[ease/libraries: 14/14] Merge branch 'master' into libraries
- From: Nate Stedman <natesm src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [ease/libraries: 14/14] Merge branch 'master' into libraries
- Date: Tue, 27 Jul 2010 03:34:05 +0000 (UTC)
commit 4dab19eb7fd75acdfd4796734dcfb1da0d9524fa
Merge: f9298fe 89ce738
Author: Nate Stedman <natesm gmail com>
Date: Mon Jul 26 23:33:33 2010 -0400
Merge branch 'master' into libraries
Conflicts:
Makefile.am
data/themes/build.sh
libease/ease-slide-pane.vala
libease/ease-transition-pane.vala
src/ease-inspector-slide-pane.vala
src/ease-inspector-transition-pane.vala
src/ease-slide-pane.vala
src/ease-transition-pane.vala
Makefile.am | 35 +-
configure.ac | 7 +-
data/Makefile.am | 39 +-
data/themes/build.sh | 11 -
data/ui/editor-window.ui | 35 -
data/ui/inspector-element-image.ui | 56 +
data/ui/inspector-element-none.ui | 55 +
data/ui/inspector-element-text.ui | 124 +
data/ui/inspector-slide.ui | 17 +-
ease-0.1.pc.in => ease-core-0.3.pc.in | 0
{libease => ease-core}/Makefile.am | 49 +-
ease-core/ease-0.1.vapi | 747 ++++
ease-core/ease-about-dialog.c | 973 ++++++
{libease => ease-core}/ease-about-dialog.vala | 0
ease-core/ease-actor.c | 336 ++
{libease => ease-core}/ease-actor.vala | 0
ease-core/ease-animated-zoom-slider.c | 226 ++
.../ease-animated-zoom-slider.vala | 0
ease-core/ease-close-confirm-dialog.c | 277 ++
.../ease-close-confirm-dialog.vala | 0
ease-core/ease-clutter-iterables.c | 496 +++
{libease => ease-core}/ease-clutter-iterables.vala | 0
ease-core/ease-color.c | 815 +++++
{libease => ease-core}/ease-color.vala | 0
ease-core/ease-core-0.1.vapi | 747 ++++
ease-core/ease-core-0.3.vapi | 747 ++++
ease-core/ease-dialogs.c | 176 +
{libease => ease-core}/ease-dialogs.vala | 0
ease-core/ease-document.c | 1677 +++++++++
{libease => ease-core}/ease-document.vala | 6 +-
ease-core/ease-editor-embed.c | 1971 +++++++++++
{libease => ease-core}/ease-editor-embed.vala | 19 +
ease-core/ease-editor-window.c | 1961 +++++++++++
{libease => ease-core}/ease-editor-window.vala | 28 +-
ease-core/ease-element.c | 820 +++++
{libease => ease-core}/ease-element.vala | 23 +-
ease-core/ease-enums.c | 102 +
{libease => ease-core}/ease-enums.vala | 0
ease-core/ease-gradient.c | 1096 ++++++
{libease => ease-core}/ease-gradient.vala | 26 +-
ease-core/ease-handle.c | 489 +++
{libease => ease-core}/ease-handle.vala | 0
ease-core/ease-html-exporter.c | 434 +++
{libease => ease-core}/ease-html-exporter.vala | 0
ease-core/ease-image-actor.c | 322 ++
{libease => ease-core}/ease-image-actor.vala | 4 +
ease-core/ease-image-element.c | 669 ++++
ease-core/ease-image-element.vala | 126 +
ease-core/ease-inspector-element-pane.c | 315 ++
ease-core/ease-inspector-element-pane.vala | 68 +
ease-core/ease-inspector-pane.c | 245 ++
{libease => ease-core}/ease-inspector-pane.vala | 0
ease-core/ease-inspector-slide-pane.c | 1146 ++++++
.../ease-inspector-slide-pane.vala | 25 +-
ease-core/ease-inspector-transition-pane.c | 1311 +++++++
.../ease-inspector-transition-pane.vala | 4 +-
ease-core/ease-inspector-window.c | 232 ++
{libease => ease-core}/ease-inspector-window.vala | 0
ease-core/ease-inspector.c | 319 ++
{libease => ease-core}/ease-inspector.vala | 14 +-
ease-core/ease-iterables.c | 460 +++
{libease => ease-core}/ease-iterables.vala | 0
ease-core/ease-main.c | 672 ++++
{libease => ease-core}/ease-main.vala | 0
ease-core/ease-media-element.c | 361 ++
{libease => ease-core}/ease-media-element.vala | 7 +
ease-core/ease-player.c | 919 +++++
{libease => ease-core}/ease-player.vala | 1 +
ease-core/ease-scrollable-embed.c | 544 +++
{libease => ease-core}/ease-scrollable-embed.vala | 0
ease-core/ease-selection-rectangle.c | 249 ++
.../ease-selection-rectangle.vala | 0
ease-core/ease-slide-actor.c | 3670 ++++++++++++++++++++
{libease => ease-core}/ease-slide-actor.vala | 26 +-
ease-core/ease-slide-button-panel.c | 754 ++++
.../ease-slide-button-panel.vala | 45 +-
ease-core/ease-slide.c | 1978 +++++++++++
{libease => ease-core}/ease-slide.vala | 7 +-
ease-core/ease-temp.c | 683 ++++
{libease => ease-core}/ease-temp.vala | 0
ease-core/ease-text-actor.c | 758 ++++
{libease => ease-core}/ease-text-actor.vala | 52 +-
ease-core/ease-text-element.c | 1787 ++++++++++
{libease => ease-core}/ease-text-element.vala | 116 +-
ease-core/ease-theme.c | 1456 ++++++++
{libease => ease-core}/ease-theme.vala | 21 +-
ease-core/ease-transformations.c | 62 +
{libease => ease-core}/ease-transformations.vala | 0
ease-core/ease-transitions.c | 1044 ++++++
{libease => ease-core}/ease-transitions.vala | 0
ease-core/ease-undo-action.c | 527 +++
{libease => ease-core}/ease-undo-action.vala | 1 +
ease-core/ease-undo-actions-element.c | 311 ++
.../ease-undo-actions-element.vala | 0
ease-core/ease-undo-actions-slide.c | 313 ++
.../ease-undo-actions-slide.vala | 0
ease-core/ease-undo-controller.c | 232 ++
{libease => ease-core}/ease-undo-controller.vala | 0
ease-core/ease-undo-item.c | 123 +
{libease => ease-core}/ease-undo-item.vala | 5 +
ease-core/ease-undo-source.c | 122 +
{libease => ease-core}/ease-undo-source.vala | 26 +
ease-core/ease-utilities.c | 952 +++++
{libease => ease-core}/ease-utilities.vala | 0
ease-core/ease-welcome-actor.c | 578 +++
{libease => ease-core}/ease-welcome-actor.vala | 0
ease-core/ease-welcome-window.c | 1217 +++++++
{libease => ease-core}/ease-welcome-window.vala | 0
ease-core/ease-zoom-slider.c | 588 ++++
{libease => ease-core}/ease-zoom-slider.vala | 0
libease/ease-image-element.vala | 80 -
po/LINGUAS | 1 +
po/sv.po | 27 +
src/Makefile.am | 18 -
114 files changed, 39935 insertions(+), 278 deletions(-)
---
diff --cc Makefile.am
index fdb0a93,81a15e8..198718a
--- a/Makefile.am
+++ b/Makefile.am
@@@ -1,17 -1,93 +1,38 @@@
NULL =
- SUBDIRS = po data libease src
-INCLUDES =
++SUBDIRS = po data ease-core
++
++bin_PROGRAMS = ease
++
++# source files
++ease_SOURCES = src/main.vala
+
++# compiler flags
++ease_VALAFLAGS = \
++ --pkg ease-core-0.3 \
++ $(EASE_PACKAGES) \
++ --vapidir ./ease-core
++
++ease_LDADD = \
++ ./ease-core/libease-core-0.3.la \
++ $(EASE_LIBS) \
++ $(NULL)
++
+INCLUDES = \
-include config.h \
$(EASE_CFLAGS)
-bin_PROGRAMS = ease
-
-EASE_CFLAGS += -w
++EASE_CFLAGS += -w -I./ease-core/
+
AM_CPPFLAGS = \
$(EASE_CFLAGS) \
-include $(CONFIG_HEADER) \
-O0 \
$(NULL)
-ease_SOURCES = \
- src/ease-about-dialog.vala \
- src/ease-actor.vala \
- src/ease-animated-zoom-slider.vala \
- src/ease-close-confirm-dialog.vala \
- src/ease-clutter-iterables.vala \
- src/ease-color.vala \
- src/ease-dialogs.vala \
- src/ease-document.vala \
- src/ease-editor-embed.vala \
- src/ease-editor-window.vala \
- src/ease-element.vala \
- src/ease-enums.vala \
- src/ease-gradient.vala \
- src/ease-handle.vala \
- src/ease-html-exporter.vala \
- src/ease-image-actor.vala \
- src/ease-image-element.vala \
- src/ease-inspector-element-pane.vala \
- src/ease-inspector-pane.vala \
- src/ease-inspector-slide-pane.vala \
- src/ease-inspector-transition-pane.vala \
- src/ease-inspector-window.vala \
- src/ease-inspector.vala \
- src/ease-iterables.vala \
- src/ease-media-element.vala \
- src/ease-player.vala \
- src/ease-scrollable-embed.vala \
- src/ease-selection-rectangle.vala \
- src/ease-slide-actor.vala \
- src/ease-slide-button-panel.vala \
- src/ease-slide.vala \
- src/ease-temp.vala \
- src/ease-text-actor.vala \
- src/ease-text-element.vala \
- src/ease-theme.vala \
- src/ease-transformations.vala \
- src/ease-transitions.vala \
- src/ease-undo-action.vala \
- src/ease-undo-actions-element.vala \
- src/ease-undo-actions-slide.vala \
- src/ease-undo-controller.vala \
- src/ease-undo-item.vala \
- src/ease-undo-source.vala \
- src/ease-utilities.vala \
- src/ease-welcome-actor.vala \
- src/ease-welcome-window.vala \
- src/ease-zoom-slider.vala \
- src/main.vala \
- $(NULL)
-
-# ease_VALAFLAGS = $(EASE_PACKAGES)
-VALAFLAGS = \
- --pkg glib-2.0 \
- --pkg gtk+-2.0 \
- --pkg clutter-1.0 \
- --pkg gdk-2.0 \
- --pkg gee-1.0 \
- --pkg clutter-gtk-0.10 \
- --pkg cogl-1.0 \
- --pkg gio-2.0 \
- --pkg json-glib-1.0\
- --pkg libarchive\
- --pkg gmodule-2.0\
- -g \
- $(NULL)
-
-SUBDIRS = po data
-
-ease_LDADD = \
- $(EASE_LIBS) \
- -lm \
- $(NULL)
++CLEANFILES = src/main.c
+
++# distribution
EXTRA_DIST = data/ease.desktop.in.in \
$(NULL)
@@@ -20,23 -96,11 +41,19 @@@ DISTCLEANFILES = data/ease.desktop
ACLOCAL_AMFLAGS = -I m4
-doc: src/*.vala
+pkgconfigdir = $(libdir)/pkgconfig
- pkgconfig_DATA = ease-0.1.pc
++pkgconfig_DATA = ease-core-0.3.pc
+
- doc: libease/*.vala
++doc: ease-core/*.vala
rm -rf doc
- valadoc --internal --private --pkg "json-glib-1.0" --pkg "gee-1.0" --pkg "clutter-gtk-0.10" --pkg "libarchive" --directory=./doc --basedir=src ./src/*.vala
+
+ valadoc \
+ --internal \
+ $(EASE_PACKAGES) \
- --directory=./doc --basedir=src ./libease/*.vala
++ --directory=./doc --basedir=src ./ease-core/*.vala
+
gnome-open doc/doc/Ease.html
- archive: data/themes/* examples/*
+ archive: examples/*
sh examples/build.sh
- sh data/themes/build.sh
-
- .PHONY: archive
- noinst_PROGRAMS = archive
diff --cc configure.ac
index 3cead0c,295984e..11d28af
--- a/configure.ac
+++ b/configure.ac
@@@ -1,14 -1,8 +1,13 @@@
- AC_INIT([Ease], [0.1], [https://bugzilla.gnome.org/enter_bug.cgi?product=ease], [ease], [http://live.gnome.org/Ease])
-AC_INIT([Ease], [0.2], [https://bugzilla.gnome.org/enter_bug.cgi?product=ease], [ease], [http://live.gnome.org/Ease])
++AC_INIT([Ease], [0.3], [https://bugzilla.gnome.org/enter_bug.cgi?product=ease], [ease], [http://live.gnome.org/Ease])
AC_PREREQ([2.59])
-AC_CONFIG_FILES([Makefile po/Makefile.in data/Makefile])
+AC_CONFIG_FILES([Makefile
+ po/Makefile.in
+ data/Makefile
- libease/Makefile
- src/Makefile
- ease-0.1.pc])
++ ease-core/Makefile
++ ease-core-0.3.pc])
+
AC_CONFIG_SRCDIR([Makefile.am])
AC_CONFIG_HEADERS([config.h])
diff --cc ease-core-0.3.pc.in
index 15582f5,0000000..15582f5
mode 100644,000000..100644
--- a/ease-core-0.3.pc.in
+++ b/ease-core-0.3.pc.in
diff --cc ease-core/Makefile.am
index 1224635,0000000..da2d68a
mode 100644,000000..100644
--- a/ease-core/Makefile.am
+++ b/ease-core/Makefile.am
@@@ -1,93 -1,0 +1,100 @@@
- lib_LTLIBRARIES = libease-0.1.la
++lib_LTLIBRARIES = libease-core-0.3.la
+
+INCLUDES = \
+ $(EASE_CFLAGS)
+
++EASE_CFLAGS += -w
++
+AM_CPPFLAGS = \
+ $(EASE_CFLAGS) \
+ -include $(CONFIG_HEADER) \
+ $(NULL)
+
+# source files
- libease_0_1_la_SOURCES = \
++libease_core_0_3_la_SOURCES = \
+ ease-about-dialog.vala \
+ ease-actor.vala \
+ ease-animated-zoom-slider.vala \
+ ease-close-confirm-dialog.vala \
+ ease-clutter-iterables.vala \
+ ease-color.vala \
+ ease-dialogs.vala \
+ ease-document.vala \
+ ease-editor-embed.vala \
+ ease-editor-window.vala \
+ ease-element.vala \
+ ease-enums.vala \
+ ease-gradient.vala \
+ ease-handle.vala \
+ ease-html-exporter.vala \
+ ease-image-actor.vala \
+ ease-image-element.vala \
++ ease-inspector-element-pane.vala \
+ ease-inspector-pane.vala \
- ease-inspector.vala \
++ ease-inspector-slide-pane.vala \
++ ease-inspector-transition-pane.vala \
+ ease-inspector-window.vala \
++ ease-inspector.vala \
+ ease-iterables.vala \
- ease-main.vala \
+ ease-media-element.vala \
+ ease-player.vala \
+ ease-scrollable-embed.vala \
+ ease-selection-rectangle.vala \
+ ease-slide-actor.vala \
+ ease-slide-button-panel.vala \
- ease-slide-pane.vala \
+ ease-slide.vala \
+ ease-temp.vala \
+ ease-text-actor.vala \
+ ease-text-element.vala \
+ ease-theme.vala \
+ ease-transformations.vala \
- ease-transition-pane.vala \
+ ease-transitions.vala \
+ ease-undo-action.vala \
+ ease-undo-actions-element.vala \
+ ease-undo-actions-slide.vala \
++ ease-undo-controller.vala \
+ ease-undo-item.vala \
+ ease-undo-source.vala \
- ease-undo-controller.vala \
+ ease-utilities.vala \
+ ease-welcome-actor.vala \
+ ease-welcome-window.vala \
+ ease-zoom-slider.vala \
++ ease-main.vala \
+ $(NULL)
+
+# compiler flags
- libease_0_1_la_VALAFLAGS = \
++libease_core_0_3_la_VALAFLAGS = \
+ $(EASE_PACKAGES) \
- --vapi=ease-0.1.vapi \
- --header=libease.h \
++ --vapi=ease-core-0.3.vapi \
++ --header=libease-core.h \
+ --thread \
- --library Ease-0.1 \
- --gir=Ease-0.1.gir \
++ --library EaseCore-0.3 \
++ --gir=EaseCore-0.3.gir \
+ -g \
+ $(NULL)
+
- libease_0_1_la_CFLAGS = $(EASE_CFLAGS)
- libease_0_1_la_LDFLAGS = $(EASE_LDFLAGS)
++libease_core_0_3_la_CFLAGS = $(EASE_CFLAGS)
++libease_core_0_3_la_LDFLAGS = $(EASE_LDFLAGS)
+
+# build typelib
+
+# header installation
- libease_includedir=$(includedir)/ease-0.1/
- libease_include_HEADERS = libease.h
++libease_includedir=$(includedir)/ease-0.3/
++libease_include_HEADERS = libease-core.h
+
+# vapi installation
+vapidir = $(datadir)/vala/vapi
- vapi_DATA = ease-0.1.vapi
++vapi_DATA = ease-core-0.3.vapi
+
+# gir installation
+girdir = $(datadir)/gir-1.0
- gir_DATA = Ease-0.1.gir
- EXTRA_DIST = Ease-0.1.gir
++gir_DATA = EaseCore-0.3.gir
++EXTRA_DIST = EaseCore-0.3.gir
+
- # remove generated c files on `make clean`
- CLEANFILES = $(subst .vala,.c,$(libease_0_1_la_SOURCES))
++# remove generated files on `make clean`
++CLEANFILES = \
++ $(subst .vala,.c,$(libease_core_0_3_la_SOURCES)) \
++ ease-core-0.3.vapi \
++ EaseCore-0.3.gir \
++ libease-core.h
+
diff --cc ease-core/ease-0.1.vapi
index 0000000,0000000..bcfb542
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-0.1.vapi
@@@ -1,0 -1,0 +1,747 @@@
++/* ease-0.1.vapi generated by valac, do not modify. */
++
++[CCode (cprefix = "Ease", lower_case_cprefix = "ease_", gir_namespace = "Ease", gir_version = "0.1")]
++namespace Ease {
++ [CCode (cprefix = "EaseIterable", lower_case_cprefix = "ease_iterable_")]
++ namespace Iterable {
++ [CCode (cheader_filename = "libease.h")]
++ public class ListStore : Gtk.ListStore, Ease.Iterable.TreeModel {
++ public ListStore (GLib.Type[] types);
++ public int size { get; }
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public interface TreeModel : Gtk.TreeModel {
++ [CCode (ref_function = "ease_iterable_tree_model_iterator_ref", unref_function = "ease_iterable_tree_model_iterator_unref", cheader_filename = "libease.h")]
++ public class Iterator {
++ public Iterator (Ease.Iterable.TreeModel self);
++ public Gtk.TreeIter @get ();
++ public bool next ();
++ }
++ public Ease.Iterable.TreeModel.Iterator iterator ();
++ }
++ }
++ [CCode (cprefix = "EaseTransformations", lower_case_cprefix = "ease_transformations_")]
++ namespace Transformations {
++ [CCode (cheader_filename = "libease.h")]
++ public static Gdk.Color clutter_color_to_gdk_color (Clutter.Color color);
++ [CCode (cheader_filename = "libease.h")]
++ public static Clutter.Color gdk_color_to_clutter_color (Gdk.Color color);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class AboutDialog : Gtk.AboutDialog {
++ public AboutDialog ();
++ public static void show_about (Gtk.Widget sender);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public abstract class Actor : Clutter.Group {
++ protected Clutter.Actor contents;
++ public Ease.ActorContext context;
++ public weak Ease.Element element;
++ public bool is_background;
++ public Actor (Ease.Element e, Ease.ActorContext c);
++ public virtual void edit (Ease.EditorEmbed sender);
++ public virtual void end_edit (Ease.EditorEmbed sender);
++ public void reposition ();
++ public void resize (float w_change, float h_change, bool proportional);
++ public void translate (float x_change, float y_change);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class AnimatedZoomSlider : Ease.ZoomSlider, Clutter.Animatable {
++ public AnimatedZoomSlider (Gtk.Adjustment adjustment, int[] button_values);
++ protected override void change_zoom (double value);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class CloseConfirmDialog : Gtk.Dialog {
++ public CloseConfirmDialog (string filename, int seconds);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class ClutterIterableGroup : Clutter.Group, Ease.ClutterIterableContainer {
++ public ClutterIterableGroup ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class ClutterIterableStage : Clutter.Stage, Ease.ClutterIterableContainer {
++ public ClutterIterableStage ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class Color : GLib.Object {
++ public Color ();
++ public Ease.Color copy ();
++ public Color.from_clutter (Clutter.Color color);
++ public Color.from_gdk (Gdk.Color color);
++ public Color.from_string (string str);
++ public Color.rgb (double r, double g, double b);
++ public Color.rgba (double r, double g, double b, double a);
++ public void set_cairo (Cairo.Context cr);
++ public string to_string ();
++ public Ease.UndoAction undo_action ();
++ public double alpha { get; set; }
++ public static Ease.Color black { owned get; }
++ public double blue { get; set; }
++ public Clutter.Color clutter { get; set; }
++ public Gdk.Color gdk { get; set; }
++ public double green { get; set; }
++ public double red { get; set; }
++ public static Ease.Color white { owned get; }
++ public signal void changed (Ease.Color self);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class Document : GLib.Object, Ease.UndoSource {
++ public Ease.Iterable.ListStore slides;
++ public const int COL_PIXBUF;
++ public const int COL_SLIDE;
++ public const string DEFAULT_SLIDE;
++ public const string THEME_PATH;
++ public Document ();
++ public string add_media_file (string file) throws GLib.Error;
++ public void add_slide (int index, Ease.Slide s);
++ public void append_slide (Ease.Slide s);
++ public void cairo_render (Cairo.Surface surface) throws GLib.Error;
++ public void export_as_html (Gtk.Window window);
++ public void export_as_pdf (Gtk.Window win);
++ public void export_as_postscript (Gtk.Window win);
++ public Document.from_saved (string file_path) throws GLib.Error;
++ public Document.from_theme (Ease.Theme doc_theme, int w, int h) throws GLib.Error;
++ public Ease.Slide get_slide (int index);
++ public bool has_next_slide (Ease.Slide slide);
++ public int index_of (Ease.Slide slide);
++ public Ease.Slide remove_slide (Ease.Slide slide);
++ public Ease.Slide? slide_by_title (string title);
++ public void to_json () throws GLib.Error;
++ public float aspect { get; }
++ public string filename { get; set; }
++ public int height { get; set; }
++ public int length { get; }
++ public string path { get; set; }
++ public Ease.Theme theme { get; set; }
++ public int width { get; set; }
++ public signal void slide_added (Ease.Slide slide, int index);
++ public signal void slide_deleted (Ease.Slide slide, int index);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class EditorEmbed : Ease.ScrollableEmbed, Ease.UndoSource {
++ public Ease.SlideActor slide_actor;
++ public EditorEmbed (Ease.Document d, Ease.EditorWindow w);
++ public void connect_keys ();
++ public void disconnect_keys ();
++ public void on_ease_actor_added (Ease.Actor actor);
++ public void on_ease_actor_removed (Ease.Actor actor);
++ public void on_element_removed (Ease.Slide slide, Ease.Element element, int index);
++ public bool on_key_press_event (Gtk.Widget self, Gdk.EventKey event);
++ public void recreate_slide ();
++ public void reposition_group ();
++ public void select_element (Ease.Element e);
++ public void set_element_color (Clutter.Color color);
++ public void set_slide (Ease.Slide slide);
++ public Ease.Actor selected { get; set; }
++ public float zoom { get; set; }
++ public signal void element_deselected (Ease.Element? deselected);
++ public signal void element_selected (Ease.Element selected);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class EditorWindow : Gtk.Window {
++ public Ease.Document document;
++ public Ease.EditorEmbed embed;
++ public Ease.Slide slide;
++ public Ease.SlideButtonPanel slide_button_panel;
++ public Ease.ZoomSlider zoom_slider;
++ public EditorWindow (Ease.Document doc);
++ public void add_undo_action (Ease.UndoItem action);
++ [CCode (instance_pos = -1)]
++ public void export_as_html (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void export_as_pdf (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void export_as_postscript (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void insert_image (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void insert_text (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void insert_video (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void inspector_clicked_handler (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void new_slide_handler (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_delete (Gtk.Widget sender);
++ public void on_new_slide_menu (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_quit (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void play_handler (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void redo_handler (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void remove_slide (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public bool save_document (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void select_font (Gtk.Widget? sender);
++ public void set_slide (int index);
++ [CCode (instance_pos = -1)]
++ public void show_color_dialog (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void undo_handler (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void zoom_in (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void zoom_out (Gtk.Widget sender);
++ public bool slides_shown { get; set; }
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public abstract class Element : GLib.Object, Ease.UndoSource {
++ public Element ();
++ public abstract Ease.Actor actor (Ease.ActorContext c);
++ public abstract void cairo_render (Cairo.Context context) throws GLib.Error;
++ public Element.from_json (Json.Object obj);
++ public virtual Clutter.Color? get_color ();
++ public abstract Gtk.Widget inspector_widget ();
++ public virtual bool set_color (Clutter.Color c);
++ public virtual void to_html (ref string html, Ease.HTMLExporter exporter, double amount);
++ public virtual Json.Object to_json ();
++ public virtual GLib.List<Gtk.ToolItem>? tool_items ();
++ public Element.with_owner (Ease.Slide owner);
++ protected abstract void write_html (ref string html, Ease.HTMLExporter exporter);
++ public Ease.Document document { get; }
++ public string element_type { get; set; }
++ public bool has_been_edited { get; set; }
++ public float height { get; set; }
++ public string identifier { get; set; }
++ public Ease.Slide parent { get; set; }
++ public float width { get; set; }
++ public float x { get; set; }
++ public float y { get; set; }
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class ElementAddUndoAction : Ease.UndoItem {
++ public ElementAddUndoAction (Ease.Element e);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class ElementRemoveUndoAction : Ease.UndoItem {
++ public ElementRemoveUndoAction (Ease.Element e);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class Gradient : GLib.Object {
++ public Gradient (Ease.Color start_color, Ease.Color end_color);
++ public void cairo_render_rect (Cairo.Context cr, int width, int height);
++ public Ease.Gradient copy ();
++ public void flip ();
++ public Gradient.from_string (string str);
++ public Gradient.mirrored (Ease.Color start_color, Ease.Color end_color);
++ public Gradient.radial (Ease.Color start_color, Ease.Color end_color);
++ public string to_string ();
++ public double angle { get; set; }
++ public static Ease.Gradient default_background { owned get; }
++ public Ease.Color end { get; set; }
++ public Ease.GradientType mode { get; set; }
++ public Ease.Color start { get; set; }
++ public signal void changed (Ease.Gradient self);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class HTMLExporter : GLib.Object {
++ public const string HEADER;
++ public HTMLExporter ();
++ public void add_progress (double amount);
++ public void copy_file (string end_path, string base_path);
++ public void finish ();
++ public bool request_path (Gtk.Window win);
++ public string basename { owned get; }
++ public string path { get; set; }
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class Handle : Clutter.CairoTexture {
++ public Handle (Ease.HandlePosition pos);
++ public void drag (float change_x, float change_y, Ease.Actor target, bool prop);
++ public void drag_from_center (float change_x, float change_y, Ease.Actor target, bool prop);
++ public void flip (bool f);
++ public void reposition (Clutter.Actor selection);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class ImageActor : Ease.Actor {
++ public ImageActor (Ease.ImageElement e, Ease.ActorContext c);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class ImageElement : Ease.MediaElement {
++ public ImageElement ();
++ public override Ease.Actor actor (Ease.ActorContext c);
++ public override void cairo_render (Cairo.Context context) throws GLib.Error;
++ public ImageElement.from_json (Json.Object obj);
++ public override Gtk.Widget inspector_widget ();
++ public override void write_html (ref string html, Ease.HTMLExporter exporter);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class Inspector : Gtk.Notebook, Ease.UndoSource {
++ public Inspector ();
++ public Ease.Slide slide { get; set; }
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public abstract class InspectorPane : Gtk.VBox, Ease.UndoSource {
++ public InspectorPane ();
++ protected virtual void slide_updated ();
++ public Ease.Slide slide { get; set; }
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class InspectorSlidePane : Ease.InspectorPane {
++ public InspectorSlidePane ();
++ [CCode (instance_pos = -1)]
++ public void on_background_changed (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_color_set (Gtk.ColorButton? sender);
++ [CCode (instance_pos = -1)]
++ public void on_file_set (Gtk.FileChooserButton? sender);
++ [CCode (instance_pos = -1)]
++ public void on_gradient_type_changed (Gtk.ComboBox? sender);
++ [CCode (instance_pos = -1)]
++ public void on_reverse_gradient (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_set_angle (Gtk.Widget? sender);
++ protected override void slide_updated ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class InspectorTransitionPane : Ease.InspectorPane {
++ public Gtk.ComboBox effect;
++ public Gtk.ComboBox variant;
++ public InspectorTransitionPane ();
++ protected override void slide_updated ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class InspectorWindow : Gtk.Window {
++ public InspectorWindow ();
++ public static void toggle ();
++ public static Ease.Slide slide { get; set; }
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class Main : GLib.Object {
++ public static bool presentation_windowed;
++ public Main ();
++ public static void add_window (Ease.EditorWindow win);
++ public static int main (string[] args);
++ public static void open_file (string path);
++ public static void remove_welcome ();
++ public static void remove_window (Ease.EditorWindow win);
++ public static void show_welcome ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public abstract class MediaElement : Ease.Element {
++ public MediaElement ();
++ public MediaElement.from_json (Json.Object obj);
++ public override Json.Object to_json ();
++ public string filename { get; set; }
++ public string full_filename { owned get; }
++ public string source_filename { get; set; }
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class OpenDialog : GLib.Object {
++ public OpenDialog ();
++ public static void run ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class Player : GLib.Object {
++ public Player (Ease.Document doc);
++ public void advance ();
++ public void on_button_press (Clutter.ButtonEvent event);
++ public void on_button_release (Clutter.ButtonEvent event);
++ public void on_key_press (Clutter.KeyEvent event);
++ public void on_motion (Clutter.MotionEvent event);
++ public Ease.Document document { get; set; }
++ public int slide_index { get; set; }
++ public Clutter.Stage stage { get; set; }
++ public signal void complete ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class ScrollableEmbed : Gtk.HBox {
++ public ScrollableEmbed (bool horizontal, bool has_frame);
++ public Clutter.Stage get_stage ();
++ public void key_focus ();
++ public Clutter.Group contents { get; set; }
++ public bool has_horizontal { get; set; }
++ public float height { get; }
++ public float width { get; }
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class SelectionRectangle : Clutter.Group {
++ public SelectionRectangle ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class Slide : GLib.Object, Ease.UndoSource {
++ public Gee.ArrayList<Ease.Element> elements;
++ public const string IMAGE_TYPE;
++ public Slide ();
++ public void add (Ease.Element e);
++ public void add_element (int index, Ease.Element e);
++ public void cairo_render (Cairo.Context context) throws GLib.Error;
++ public void cairo_render_background (Cairo.Context cr, int w, int h) throws GLib.Error;
++ public void cairo_render_sized (Cairo.Context context, int w, int h) throws GLib.Error;
++ public Ease.Element element_at (int i);
++ public int index_of (Ease.Element e);
++ public void remove_at (int index);
++ public void remove_element (Ease.Element e);
++ public void to_html (ref string html, Ease.HTMLExporter exporter, double amount, int index);
++ public Slide.with_owner (Ease.Document owner);
++ public double advance_delay { get; set; }
++ public bool automatically_advance { get; set; }
++ public string background_abs { owned get; }
++ public Ease.Color background_color { get; set; }
++ public Ease.Gradient background_gradient { get; set; }
++ public string background_image { get; set; }
++ public string background_image_source { get; set; }
++ public Ease.BackgroundType background_type { get; set; }
++ public int count { get; }
++ public Ease.Slide? next { owned get; }
++ public Ease.Document parent { get; set; }
++ public Ease.Slide? previous { owned get; }
++ public Ease.Theme theme { get; set; }
++ public string title { get; set; }
++ public Ease.Transition transition { get; set; }
++ public uint transition_msecs { get; set; }
++ public double transition_time { get; set; }
++ public Ease.TransitionVariant variant { get; set; }
++ public signal void background_changed (Ease.Slide self);
++ public signal void changed (Ease.Slide self);
++ public signal void element_added (Ease.Slide self, Ease.Element element, int index);
++ public signal void element_removed (Ease.Slide self, Ease.Element element, int index);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class SlideActor : Clutter.Group {
++ public Clutter.CairoTexture background;
++ public Ease.ClutterIterableGroup contents;
++ public Ease.ActorContext context;
++ public const int EASE_DROP;
++ public const int EASE_PIVOT;
++ public const int EASE_SLIDE;
++ public const float FLIP_DEPTH;
++ public const float PANEL_SCALE;
++ public SlideActor ();
++ public SlideActor.blank (Ease.Document document, Clutter.Color color);
++ public SlideActor.from_slide (Ease.Document document, Ease.Slide s, bool clip, Ease.ActorContext ctx);
++ public void on_element_added (Ease.Slide slide, Ease.Element element, int index);
++ public void on_element_removed (Ease.Slide slide, Ease.Element element, int index);
++ public void relayout ();
++ public void reset (Clutter.Group container);
++ public void stack (Clutter.Actor container);
++ public void transition (Ease.SlideActor new_slide, Clutter.Group container);
++ public void unstack (Ease.SlideActor other, Clutter.Actor container);
++ public SlideActor.with_dimensions (float w, float h, Ease.Slide s, bool clip, Ease.ActorContext ctx);
++ public Clutter.Timeline animation_time { get; set; }
++ public Ease.Slide slide { get; set; }
++ public signal void ease_actor_added (Ease.Actor actor);
++ public signal void ease_actor_removed (Ease.Actor actor);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class SlideAddUndoAction : Ease.UndoItem {
++ public SlideAddUndoAction (Ease.Slide s);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class SlideButtonPanel : Gtk.ScrolledWindow {
++ public SlideButtonPanel (Ease.Document d, Ease.EditorWindow win);
++ public void select_slide (Ease.Slide slide);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class SlideRemoveUndoAction : Ease.UndoItem {
++ public SlideRemoveUndoAction (Ease.Slide s);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class Temp : GLib.Object {
++ public const string IMG_DIR;
++ public const string TEMP_DIR;
++ public const string THEME_DIR;
++ public const string UI_DIR;
++ public Temp ();
++ public static void clean ();
++ public static bool exists (int dir, string tmp);
++ public static string request () throws GLib.Error;
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class TextActor : Ease.Actor {
++ public TextActor (Ease.TextElement e, Ease.ActorContext c);
++ public override void edit (Ease.EditorEmbed sender);
++ public override void end_edit (Ease.EditorEmbed sender);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class TextElement : Ease.Element {
++ public TextElement ();
++ public override Ease.Actor actor (Ease.ActorContext c);
++ public override void cairo_render (Cairo.Context context) throws GLib.Error;
++ public TextElement.from_json (Json.Object obj);
++ public override Clutter.Color? get_color ();
++ public override Gtk.Widget inspector_widget ();
++ [CCode (instance_pos = -1)]
++ public void on_inspector_alignment (Gtk.Widget sender);
++ public override bool set_color (Clutter.Color c);
++ public void text_align_from_string (string str);
++ public string text_align_to_string ();
++ public void text_size_from_string (string str);
++ public string text_size_to_string ();
++ public void text_style_from_string (string str);
++ public string text_style_to_string ();
++ public void text_variant_from_string (string str);
++ public string text_variant_to_string ();
++ public void text_weight_from_string (string str);
++ public string text_weight_to_string ();
++ public override Json.Object to_json ();
++ protected override void write_html (ref string html, Ease.HTMLExporter exporter);
++ public Ease.Color color { get; set; }
++ public Pango.FontDescription font_description { owned get; set; }
++ public string text { get; set; }
++ public Pango.Alignment text_align { get; set; }
++ public string text_font { get; set; }
++ public int text_size { get; set; }
++ public Pango.Style text_style { get; set; }
++ public Pango.Variant text_variant { get; set; }
++ public int text_weight { get; set; }
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class Theme : GLib.Object {
++ public string title;
++ public const string BACKGROUND_COLOR;
++ public const string BACKGROUND_GRADIENT;
++ public const string BACKGROUND_IMAGE;
++ public const string CONTENT;
++ public const string CONTENT_DUAL;
++ public const string CONTENT_DUAL_HEADER;
++ public const string CONTENT_HEADER;
++ public const string CONTENT_MEDIA;
++ public const string CUSTOM_MEDIA;
++ public const string ELEMENT_TYPE;
++ public const string E_IDENTIFIER;
++ public const string GRAD_LINEAR;
++ public const string GRAD_LINEAR_MIRRORED;
++ public const string GRAD_RADIAL;
++ public const string HAS_BEEN_EDITED;
++ public const string HEIGHT;
++ public const string JSON_PATH;
++ public const string[] MASTER_SLIDES;
++ public const string MEDIA;
++ public const string MEDIA_FILENAME;
++ public const string MEDIA_HEADER;
++ public const string MEDIA_SOURCE_FILENAME;
++ public const string PAD_BOTTOM;
++ public const string PAD_LEFT;
++ public const string PAD_RIGHT;
++ public const string PAD_TOP;
++ public const string S_IDENTIFIER;
++ public const string TEXT_ALIGN;
++ public const string TEXT_COLOR;
++ public const string TEXT_FONT;
++ public const string TEXT_SIZE;
++ public const string TEXT_STYLE;
++ public const string TEXT_TEXT;
++ public const string TEXT_VARIANT;
++ public const string TEXT_WEIGHT;
++ public const string TITLE;
++ public const string WIDTH;
++ public const string X;
++ public const string Y;
++ public Theme (string dir_path);
++ public void copy_media (string target) throws GLib.Error;
++ public Ease.Theme copy_to_path (string copy_to) throws GLib.Error;
++ public Ease.TextElement create_custom_text ();
++ public Ease.Slide? create_slide (string master, int width, int height);
++ public Theme.json (string json_path);
++ public static string master_description (string master);
++ public static string master_from_description (string desc);
++ public static string master_mnemonic_description (string master);
++ public string path { get; set; }
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class UndoAction : Ease.UndoItem {
++ public UndoAction (GLib.Object obj, string prop);
++ public void add (GLib.Object obj, string prop);
++ public override Ease.UndoItem apply ();
++ public void combine (Ease.UndoAction action);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class UndoController : GLib.Object {
++ public UndoController ();
++ public void add_action (Ease.UndoItem action);
++ public bool can_redo ();
++ public bool can_undo ();
++ public void clear_redo ();
++ public void redo ();
++ public void undo ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public abstract class UndoItem : GLib.Object {
++ public UndoItem ();
++ public abstract Ease.UndoItem apply ();
++ public signal void applied (Ease.UndoAction sender);
++ public signal void pre_apply (Ease.UndoAction sender);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class WelcomeActor : Clutter.Group {
++ public WelcomeActor (Ease.Theme t);
++ public void fade ();
++ public void set_actor_size (float w, float h);
++ public void set_slide_size (int w, int h);
++ public void unfade ();
++ public Ease.Theme theme { get; set; }
++ public signal void double_click (Ease.WelcomeActor sender);
++ public signal void selected (Ease.WelcomeActor sender);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class WelcomeWindow : Gtk.Window {
++ public WelcomeWindow ();
++ [CCode (instance_pos = -1)]
++ public void create_new_document (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_open_pres_button_clicked (Gtk.Widget sender);
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public class ZoomSlider : Gtk.Alignment {
++ public ZoomSlider (Gtk.Adjustment adjustment, int[] button_values);
++ protected virtual void change_zoom (double value);
++ public double get_value ();
++ public void zoom_in ();
++ public void zoom_out ();
++ public bool buttons_shown { get; set; }
++ public int digits { get; set; }
++ public double sliderpos { get; set; }
++ public Gtk.PositionType value_pos { get; set; }
++ public signal void value_changed ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public interface ClutterIterableContainer : Clutter.Container {
++ [CCode (ref_function = "ease_clutter_iterable_container_iterator_ref", unref_function = "ease_clutter_iterable_container_iterator_unref", cheader_filename = "libease.h")]
++ public class Iterator {
++ public Iterator (Ease.ClutterIterableContainer self);
++ public Clutter.Actor @get ();
++ public bool next ();
++ }
++ public Ease.ClutterIterableContainer.Iterator iterator ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public interface UndoSource : GLib.Object {
++ protected void forward (Ease.UndoItem action);
++ protected void listen (Ease.UndoSource source);
++ protected void silence (Ease.UndoSource source);
++ public signal void undo (Ease.UndoItem action);
++ }
++ [CCode (cprefix = "EASE_ACTOR_CONTEXT_", cheader_filename = "libease.h")]
++ public enum ActorContext {
++ PRESENTATION,
++ EDITOR,
++ INSPECTOR
++ }
++ [CCode (cprefix = "EASE_BACKGROUND_TYPE_", cheader_filename = "libease.h")]
++ public enum BackgroundType {
++ COLOR,
++ GRADIENT,
++ IMAGE;
++ public string to_string ();
++ public static Ease.BackgroundType from_string (string str);
++ public string description ();
++ public const Ease.BackgroundType[] TYPES;
++ }
++ [CCode (cprefix = "EASE_GRADIENT_TYPE_", cheader_filename = "libease.h")]
++ public enum GradientType {
++ LINEAR,
++ LINEAR_MIRRORED,
++ RADIAL;
++ public string to_string ();
++ public static Ease.GradientType from_string (string str);
++ public string description ();
++ public static Gtk.ListStore list_store ();
++ }
++ [CCode (cprefix = "EASE_HANDLE_POSITION_", cheader_filename = "libease.h")]
++ public enum HandlePosition {
++ TOP_LEFT,
++ TOP_RIGHT,
++ TOP,
++ LEFT,
++ RIGHT,
++ BOTTOM_LEFT,
++ BOTTOM_RIGHT,
++ BOTTOM
++ }
++ [CCode (cprefix = "EASE_KEY_", cheader_filename = "libease.h")]
++ public enum Key {
++ UP,
++ DOWN,
++ LEFT,
++ RIGHT,
++ BACKSPACE,
++ DELETE
++ }
++ [CCode (cprefix = "EASE_TRANSITION_", cheader_filename = "libease.h")]
++ public enum Transition {
++ NONE,
++ FADE,
++ SLIDE,
++ DROP,
++ PIVOT,
++ FLIP,
++ REVOLVING_DOOR,
++ REVEAL,
++ FALL,
++ SLATS,
++ OPEN_DOOR,
++ EXPLODE,
++ ASSEMBLE,
++ ZOOM,
++ PANEL,
++ SPIN_CONTENTS,
++ SPRING_CONTENTS,
++ SWING_CONTENTS,
++ SLIDE_CONTENTS,
++ ZOOM_CONTENTS;
++ public static Gtk.ListStore model ();
++ public Gtk.ListStore variant_model ();
++ public static Ease.Transition from_string (string str);
++ public Ease.TransitionVariant[] variants ();
++ public string get_name ();
++ }
++ [CCode (cprefix = "EASE_TRANSITION_VARIANT_", cheader_filename = "libease.h")]
++ public enum TransitionVariant {
++ LEFT,
++ RIGHT,
++ UP,
++ DOWN,
++ BOTTOM,
++ TOP,
++ CENTER,
++ TOP_LEFT,
++ TOP_RIGHT,
++ BOTTOM_LEFT,
++ BOTTOM_RIGHT,
++ TOP_TO_BOTTOM,
++ BOTTOM_TO_TOP,
++ LEFT_TO_RIGHT,
++ RIGHT_TO_LEFT,
++ IN,
++ OUT;
++ public static Ease.TransitionVariant from_string (string str);
++ public string get_name ();
++ }
++ [CCode (cheader_filename = "libease.h")]
++ public delegate void RecursiveDirAction (string path, string full_path);
++ [CCode (cheader_filename = "libease.h")]
++ public static string? data_path (string path);
++ [CCode (cheader_filename = "libease.h")]
++ public static double dmax (double a, double b);
++ [CCode (cheader_filename = "libease.h")]
++ public static double dmin (double a, double b);
++ [CCode (cheader_filename = "libease.h")]
++ public static void error_dialog (string title, string message);
++ [CCode (cheader_filename = "libease.h")]
++ public static void recursive_copy (string from_dir, string to_dir) throws GLib.Error;
++ [CCode (cheader_filename = "libease.h")]
++ public static void recursive_delete (string path) throws GLib.Error;
++ [CCode (cheader_filename = "libease.h")]
++ public static void recursive_directory (string directory, Ease.RecursiveDirAction? directory_action, Ease.RecursiveDirAction? file_action) throws GLib.Error;
++ [CCode (cheader_filename = "libease.h")]
++ public static void recursive_directory_after (string directory, Ease.RecursiveDirAction? directory_action, Ease.RecursiveDirAction? file_action) throws GLib.Error;
++ [CCode (cheader_filename = "libease.h")]
++ public static int roundd (double num);
++ [CCode (cheader_filename = "libease.h")]
++ public static Clutter.Color theme_clutter_color (string color);
++ [CCode (cheader_filename = "libease.h")]
++ public static Gdk.Color? theme_color (string color);
++ [CCode (cheader_filename = "libease.h")]
++ public static Gtk.Window widget_window (Gtk.Widget widg);
++}
++[CCode (cheader_filename = "libease.h")]
++public static string? save_dialog (string title, Gtk.Window? modal);
diff --cc ease-core/ease-about-dialog.c
index 0000000,0000000..eab7f67
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-about-dialog.c
@@@ -1,0 -1,0 +1,973 @@@
++/* ease-about-dialog.c generated by valac, the Vala compiler
++ * generated from ease-about-dialog.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++#include <glib/gi18n-lib.h>
++
++
++#define EASE_TYPE_ABOUT_DIALOG (ease_about_dialog_get_type ())
++#define EASE_ABOUT_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ABOUT_DIALOG, EaseAboutDialog))
++#define EASE_ABOUT_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ABOUT_DIALOG, EaseAboutDialogClass))
++#define EASE_IS_ABOUT_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ABOUT_DIALOG))
++#define EASE_IS_ABOUT_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ABOUT_DIALOG))
++#define EASE_ABOUT_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ABOUT_DIALOG, EaseAboutDialogClass))
++
++typedef struct _EaseAboutDialog EaseAboutDialog;
++typedef struct _EaseAboutDialogClass EaseAboutDialogClass;
++typedef struct _EaseAboutDialogPrivate EaseAboutDialogPrivate;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++struct _EaseAboutDialog {
++ GtkAboutDialog parent_instance;
++ EaseAboutDialogPrivate * priv;
++};
++
++struct _EaseAboutDialogClass {
++ GtkAboutDialogClass parent_class;
++};
++
++
++static gpointer ease_about_dialog_parent_class = NULL;
++
++GType ease_about_dialog_get_type (void) G_GNUC_CONST;
++enum {
++ EASE_ABOUT_DIALOG_DUMMY_PROPERTY
++};
++EaseAboutDialog* ease_about_dialog_new (void);
++EaseAboutDialog* ease_about_dialog_construct (GType object_type);
++void ease_about_dialog_show_about (GtkWidget* sender);
++
++static const char* EASE_ABOUT_DIALOG_AUTHORS[3] = {"Nate Stedman <natesm gmail com>", "Stéphane Maniaci <stephane maniaci gmail com>", NULL};
++static const char* EASE_ABOUT_DIALOG_ARTISTS[2] = {"Nate Stedman <natesm gmail com>", NULL};
++
++
++#line 32 "ease-about-dialog.vala"
++void ease_about_dialog_show_about (GtkWidget* sender) {
++#line 68 "ease-about-dialog.c"
++ EaseAboutDialog* about;
++#line 32 "ease-about-dialog.vala"
++ g_return_if_fail (sender != NULL);
++#line 34 "ease-about-dialog.vala"
++ about = g_object_ref_sink (ease_about_dialog_new ());
++#line 35 "ease-about-dialog.vala"
++ gtk_dialog_run ((GtkDialog*) about);
++#line 36 "ease-about-dialog.vala"
++ gtk_object_destroy ((GtkObject*) about);
++#line 78 "ease-about-dialog.c"
++ _g_object_unref0 (about);
++}
++
++
++#line 44 "ease-about-dialog.vala"
++EaseAboutDialog* ease_about_dialog_construct (GType object_type) {
++#line 85 "ease-about-dialog.c"
++ EaseAboutDialog * self;
++ self = g_object_newv (object_type, 0, NULL);
++#line 46 "ease-about-dialog.vala"
++ gtk_about_dialog_set_program_name ((GtkAboutDialog*) self, "Ease");
++#line 48 "ease-about-dialog.vala"
++ gtk_about_dialog_set_comments ((GtkAboutDialog*) self, _ ("A presentation application for the GNOME Desktop"));
++#line 50 "ease-about-dialog.vala"
++ gtk_about_dialog_set_website ((GtkAboutDialog*) self, "http://live.gnome.org/Ease";);
++#line 52 "ease-about-dialog.vala"
++ gtk_about_dialog_set_authors ((GtkAboutDialog*) self, EASE_ABOUT_DIALOG_AUTHORS);
++#line 54 "ease-about-dialog.vala"
++ gtk_about_dialog_set_documenters ((GtkAboutDialog*) self, EASE_ABOUT_DIALOG_AUTHORS);
++#line 56 "ease-about-dialog.vala"
++ gtk_about_dialog_set_artists ((GtkAboutDialog*) self, EASE_ABOUT_DIALOG_ARTISTS);
++#line 58 "ease-about-dialog.vala"
++ gtk_about_dialog_set_translator_credits ((GtkAboutDialog*) self, _ ("Mario Bl\303\244ttermann\n" \
++"Matej Urban\304\215i\304\215\n" \
++"Jorge Gonz\303\241lez\n" \
++"St\303\251phane Maniaci"));
++#line 65 "ease-about-dialog.vala"
++ gtk_about_dialog_set_license ((GtkAboutDialog*) self, " GNU GENERAL PUBLIC LICENSE\n" \
++" Version 3, 29 June 2007\n" \
++"\n" \
++" Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>\n" \
++" Everyone is permitted to copy and distribute verbatim copies\n" \
++" of this license document, but changing it is not allowed.\n" \
++"\n" \
++" Preamble\n" \
++"\n" \
++" The GNU General Public License is a free, copyleft license for\n" \
++"software and other kinds of works.\n" \
++"\n" \
++" The licenses for most software and other practical works are designe" \
++"d\n" \
++"to take away your freedom to share and change the works. By contrast," \
++"\n" \
++"the GNU General Public License is intended to guarantee your freedom t" \
++"o\n" \
++"share and change all versions of a program--to make sure it remains fr" \
++"ee\n" \
++"software for all its users. We, the Free Software Foundation, use the" \
++"\n" \
++"GNU General Public License for most of our software; it applies also t" \
++"o\n" \
++"any other work released this way by its authors. You can apply it to\n" \
++"your programs, too.\n" \
++"\n" \
++" When we speak of free software, we are referring to freedom, not\n" \
++"price. Our General Public Licenses are designed to make sure that you" \
++"\n" \
++"have the freedom to distribute copies of free software (and charge for" \
++"\n" \
++"them if you wish), that you receive source code or can get it if you\n" \
++"want it, that you can change the software or use pieces of it in new\n" \
++"free programs, and that you know you can do these things.\n" \
++"\n" \
++" To protect your rights, we need to prevent others from denying you\n" \
++"these rights or asking you to surrender the rights. Therefore, you ha" \
++"ve\n" \
++"certain responsibilities if you distribute copies of the software, or " \
++"if\n" \
++"you modify it: responsibilities to respect the freedom of others.\n" \
++"\n" \
++" For example, if you distribute copies of such a program, whether\n" \
++"gratis or for a fee, you must pass on to the recipients the same\n" \
++"freedoms that you received. You must make sure that they, too, receiv" \
++"e\n" \
++"or can get the source code. And you must show them these terms so the" \
++"y\n" \
++"know their rights.\n" \
++"\n" \
++" Developers that use the GNU GPL protect your rights with two steps:\n" \
++"(1) assert copyright on the software, and (2) offer you this License\n" \
++"giving you legal permission to copy, distribute and/or modify it.\n" \
++"\n" \
++" For the developers' and authors' protection, the GPL clearly explain" \
++"s\n" \
++"that there is no warranty for this free software. For both users' and" \
++"\n" \
++"authors' sake, the GPL requires that modified versions be marked as\n" \
++"changed, so that their problems will not be attributed erroneously to\n" \
++"authors of previous versions.\n" \
++"\n" \
++" Some devices are designed to deny users access to install or run\n" \
++"modified versions of the software inside them, although the manufactur" \
++"er\n" \
++"can do so. This is fundamentally incompatible with the aim of\n" \
++"protecting users' freedom to change the software. The systematic\n" \
++"pattern of such abuse occurs in the area of products for individuals t" \
++"o\n" \
++"use, which is precisely where it is most unacceptable. Therefore, we\n" \
++"have designed this version of the GPL to prohibit the practice for tho" \
++"se\n" \
++"products. If such problems arise substantially in other domains, we\n" \
++"stand ready to extend this provision to those domains in future versio" \
++"ns\n" \
++"of the GPL, as needed to protect the freedom of users.\n" \
++"\n" \
++" Finally, every program is threatened constantly by software patents." \
++"\n" \
++"States should not allow patents to restrict development and use of\n" \
++"software on general-purpose computers, but in those that do, we wish t" \
++"o\n" \
++"avoid the special danger that patents applied to a free program could\n" \
++"make it effectively proprietary. To prevent this, the GPL assures tha" \
++"t\n" \
++"patents cannot be used to render the program non-free.\n" \
++"\n" \
++" The precise terms and conditions for copying, distribution and\n" \
++"modification follow.\n" \
++"\n" \
++" TERMS AND CONDITIONS\n" \
++"\n" \
++" 0. Definitions.\n" \
++"\n" \
++" \"This License\" refers to version 3 of the GNU General Public Licen" \
++"se.\n" \
++"\n" \
++" \"Copyright\" also means copyright-like laws that apply to other kin" \
++"ds of\n" \
++"works, such as semiconductor masks.\n" \
++"\n" \
++" \"The Program\" refers to any copyrightable work licensed under this" \
++"\n" \
++"License. Each licensee is addressed as \"you\". \"Licensees\" and\n" \
++"\"recipients\" may be individuals or organizations.\n" \
++"\n" \
++" To \"modify\" a work means to copy from or adapt all or part of the " \
++"work\n" \
++"in a fashion requiring copyright permission, other than the making of " \
++"an\n" \
++"exact copy. The resulting work is called a \"modified version\" of th" \
++"e\n" \
++"earlier work or a work \"based on\" the earlier work.\n" \
++"\n" \
++" A \"covered work\" means either the unmodified Program or a work bas" \
++"ed\n" \
++"on the Program.\n" \
++"\n" \
++" To \"propagate\" a work means to do anything with it that, without\n" \
++"permission, would make you directly or secondarily liable for\n" \
++"infringement under applicable copyright law, except executing it on a\n" \
++"computer or modifying a private copy. Propagation includes copying,\n" \
++"distribution (with or without modification), making available to the\n" \
++"public, and in some countries other activities as well.\n" \
++"\n" \
++" To \"convey\" a work means any kind of propagation that enables othe" \
++"r\n" \
++"parties to make or receive copies. Mere interaction with a user throu" \
++"gh\n" \
++"a computer network, with no transfer of a copy, is not conveying.\n" \
++"\n" \
++" An interactive user interface displays \"Appropriate Legal Notices\"" \
++"\n" \
++"to the extent that it includes a convenient and prominently visible\n" \
++"feature that (1) displays an appropriate copyright notice, and (2)\n" \
++"tells the user that there is no warranty for the work (except to the\n" \
++"extent that warranties are provided), that licensees may convey the\n" \
++"work under this License, and how to view a copy of this License. If\n" \
++"the interface presents a list of user commands or options, such as a\n" \
++"menu, a prominent item in the list meets this criterion.\n" \
++"\n" \
++" 1. Source Code.\n" \
++"\n" \
++" The \"source code\" for a work means the preferred form of the work\n" \
++"for making modifications to it. \"Object code\" means any non-source\n" \
++"form of a work.\n" \
++"\n" \
++" A \"Standard Interface\" means an interface that either is an offici" \
++"al\n" \
++"standard defined by a recognized standards body, or, in the case of\n" \
++"interfaces specified for a particular programming language, one that\n" \
++"is widely used among developers working in that language.\n" \
++"\n" \
++" The \"System Libraries\" of an executable work include anything, oth" \
++"er\n" \
++"than the work as a whole, that (a) is included in the normal form of\n" \
++"packaging a Major Component, but which is not part of that Major\n" \
++"Component, and (b) serves only to enable use of the work with that\n" \
++"Major Component, or to implement a Standard Interface for which an\n" \
++"implementation is available to the public in source code form. A\n" \
++"\"Major Component\", in this context, means a major essential componen" \
++"t\n" \
++"(kernel, window system, and so on) of the specific operating system\n" \
++"(if any) on which the executable work runs, or a compiler used to\n" \
++"produce the work, or an object code interpreter used to run it.\n" \
++"\n" \
++" The \"Corresponding Source\" for a work in object code form means al" \
++"l\n" \
++"the source code needed to generate, install, and (for an executable\n" \
++"work) run the object code and to modify the work, including scripts to" \
++"\n" \
++"control those activities. However, it does not include the work's\n" \
++"System Libraries, or general-purpose tools or generally available free" \
++"\n" \
++"programs which are used unmodified in performing those activities but\n" \
++"which are not part of the work. For example, Corresponding Source\n" \
++"includes interface definition files associated with source files for\n" \
++"the work, and the source code for shared libraries and dynamically\n" \
++"linked subprograms that the work is specifically designed to require,\n" \
++"such as by intimate data communication or control flow between those\n" \
++"subprograms and other parts of the work.\n" \
++"\n" \
++" The Corresponding Source need not include anything that users\n" \
++"can regenerate automatically from other parts of the Corresponding\n" \
++"Source.\n" \
++"\n" \
++" The Corresponding Source for a work in source code form is that\n" \
++"same work.\n" \
++"\n" \
++" 2. Basic Permissions.\n" \
++"\n" \
++" All rights granted under this License are granted for the term of\n" \
++"copyright on the Program, and are irrevocable provided the stated\n" \
++"conditions are met. This License explicitly affirms your unlimited\n" \
++"permission to run the unmodified Program. The output from running a\n" \
++"covered work is covered by this License only if the output, given its\n" \
++"content, constitutes a covered work. This License acknowledges your\n" \
++"rights of fair use or other equivalent, as provided by copyright law.\n" \
++"\n" \
++" You may make, run and propagate covered works that you do not\n" \
++"convey, without conditions so long as your license otherwise remains\n" \
++"in force. You may convey covered works to others for the sole purpose" \
++"\n" \
++"of having them make modifications exclusively for you, or provide you\n" \
++"with facilities for running those works, provided that you comply with" \
++"\n" \
++"the terms of this License in conveying all material for which you do\n" \
++"not control copyright. Those thus making or running the covered works" \
++"\n" \
++"for you must do so exclusively on your behalf, under your direction\n" \
++"and control, on terms that prohibit them from making any copies of\n" \
++"your copyrighted material outside their relationship with you.\n" \
++"\n" \
++" Conveying under any other circumstances is permitted solely under\n" \
++"the conditions stated below. Sublicensing is not allowed; section 10\n" \
++"makes it unnecessary.\n" \
++"\n" \
++" 3. Protecting Users' Legal Rights From Anti-Circumvention Law.\n" \
++"\n" \
++" No covered work shall be deemed part of an effective technological\n" \
++"measure under any applicable law fulfilling obligations under article\n" \
++"11 of the WIPO copyright treaty adopted on 20 December 1996, or\n" \
++"similar laws prohibiting or restricting circumvention of such\n" \
++"measures.\n" \
++"\n" \
++" When you convey a covered work, you waive any legal power to forbid\n" \
++"circumvention of technological measures to the extent such circumventi" \
++"on\n" \
++"is effected by exercising rights under this License with respect to\n" \
++"the covered work, and you disclaim any intention to limit operation or" \
++"\n" \
++"modification of the work as a means of enforcing, against the work's\n" \
++"users, your or third parties' legal rights to forbid circumvention of\n" \
++"technological measures.\n" \
++"\n" \
++" 4. Conveying Verbatim Copies.\n" \
++"\n" \
++" You may convey verbatim copies of the Program's source code as you\n" \
++"receive it, in any medium, provided that you conspicuously and\n" \
++"appropriately publish on each copy an appropriate copyright notice;\n" \
++"keep intact all notices stating that this License and any\n" \
++"non-permissive terms added in accord with section 7 apply to the code;" \
++"\n" \
++"keep intact all notices of the absence of any warranty; and give all\n" \
++"recipients a copy of this License along with the Program.\n" \
++"\n" \
++" You may charge any price or no price for each copy that you convey,\n" \
++"and you may offer support or warranty protection for a fee.\n" \
++"\n" \
++" 5. Conveying Modified Source Versions.\n" \
++"\n" \
++" You may convey a work based on the Program, or the modifications to\n" \
++"produce it from the Program, in the form of source code under the\n" \
++"terms of section 4, provided that you also meet all of these condition" \
++"s:\n" \
++"\n" \
++" a) The work must carry prominent notices stating that you modified" \
++"\n" \
++" it, and giving a relevant date.\n" \
++"\n" \
++" b) The work must carry prominent notices stating that it is\n" \
++" released under this License and any conditions added under section" \
++"\n" \
++" 7. This requirement modifies the requirement in section 4 to\n" \
++" \"keep intact all notices\".\n" \
++"\n" \
++" c) You must license the entire work, as a whole, under this\n" \
++" License to anyone who comes into possession of a copy. This\n" \
++" License will therefore apply, along with any applicable section 7\n" \
++" additional terms, to the whole of the work, and all its parts,\n" \
++" regardless of how they are packaged. This License gives no\n" \
++" permission to license the work in any other way, but it does not\n" \
++" invalidate such permission if you have separately received it.\n" \
++"\n" \
++" d) If the work has interactive user interfaces, each must display\n" \
++" Appropriate Legal Notices; however, if the Program has interactive" \
++"\n" \
++" interfaces that do not display Appropriate Legal Notices, your\n" \
++" work need not make them do so.\n" \
++"\n" \
++" A compilation of a covered work with other separate and independent\n" \
++"works, which are not by their nature extensions of the covered work,\n" \
++"and which are not combined with it such as to form a larger program,\n" \
++"in or on a volume of a storage or distribution medium, is called an\n" \
++"\"aggregate\" if the compilation and its resulting copyright are not\n" \
++"used to limit the access or legal rights of the compilation's users\n" \
++"beyond what the individual works permit. Inclusion of a covered work\n" \
++"in an aggregate does not cause this License to apply to the other\n" \
++"parts of the aggregate.\n" \
++"\n" \
++" 6. Conveying Non-Source Forms.\n" \
++"\n" \
++" You may convey a covered work in object code form under the terms\n" \
++"of sections 4 and 5, provided that you also convey the\n" \
++"machine-readable Corresponding Source under the terms of this License," \
++"\n" \
++"in one of these ways:\n" \
++"\n" \
++" a) Convey the object code in, or embodied in, a physical product\n" \
++" (including a physical distribution medium), accompanied by the\n" \
++" Corresponding Source fixed on a durable physical medium\n" \
++" customarily used for software interchange.\n" \
++"\n" \
++" b) Convey the object code in, or embodied in, a physical product\n" \
++" (including a physical distribution medium), accompanied by a\n" \
++" written offer, valid for at least three years and valid for as\n" \
++" long as you offer spare parts or customer support for that product" \
++"\n" \
++" model, to give anyone who possesses the object code either (1) a\n" \
++" copy of the Corresponding Source for all the software in the\n" \
++" product that is covered by this License, on a durable physical\n" \
++" medium customarily used for software interchange, for a price no\n" \
++" more than your reasonable cost of physically performing this\n" \
++" conveying of source, or (2) access to copy the\n" \
++" Corresponding Source from a network server at no charge.\n" \
++"\n" \
++" c) Convey individual copies of the object code with a copy of the\n" \
++" written offer to provide the Corresponding Source. This\n" \
++" alternative is allowed only occasionally and noncommercially, and\n" \
++" only if you received the object code with such an offer, in accord" \
++"\n" \
++" with subsection 6b.\n" \
++"\n" \
++" d) Convey the object code by offering access from a designated\n" \
++" place (gratis or for a charge), and offer equivalent access to the" \
++"\n" \
++" Corresponding Source in the same way through the same place at no\n" \
++" further charge. You need not require recipients to copy the\n" \
++" Corresponding Source along with the object code. If the place to\n" \
++" copy the object code is a network server, the Corresponding Source" \
++"\n" \
++" may be on a different server (operated by you or a third party)\n" \
++" that supports equivalent copying facilities, provided you maintain" \
++"\n" \
++" clear directions next to the object code saying where to find the\n" \
++" Corresponding Source. Regardless of what server hosts the\n" \
++" Corresponding Source, you remain obligated to ensure that it is\n" \
++" available for as long as needed to satisfy these requirements.\n" \
++"\n" \
++" e) Convey the object code using peer-to-peer transmission, provide" \
++"d\n" \
++" you inform other peers where the object code and Corresponding\n" \
++" Source of the work are being offered to the general public at no\n" \
++" charge under subsection 6d.\n" \
++"\n" \
++" A separable portion of the object code, whose source code is exclude" \
++"d\n" \
++"from the Corresponding Source as a System Library, need not be\n" \
++"included in conveying the object code work.\n" \
++"\n" \
++" A \"User Product\" is either (1) a \"consumer product\", which means" \
++" any\n" \
++"tangible personal property which is normally used for personal, family" \
++",\n" \
++"or household purposes, or (2) anything designed or sold for incorporat" \
++"ion\n" \
++"into a dwelling. In determining whether a product is a consumer produ" \
++"ct,\n" \
++"doubtful cases shall be resolved in favor of coverage. For a particul" \
++"ar\n" \
++"product received by a particular user, \"normally used\" refers to a\n" \
++"typical or common use of that class of product, regardless of the stat" \
++"us\n" \
++"of the particular user or of the way in which the particular user\n" \
++"actually uses, or expects or is expected to use, the product. A produ" \
++"ct\n" \
++"is a consumer product regardless of whether the product has substantia" \
++"l\n" \
++"commercial, industrial or non-consumer uses, unless such uses represen" \
++"t\n" \
++"the only significant mode of use of the product.\n" \
++"\n" \
++" \"Installation Information\" for a User Product means any methods,\n" \
++"procedures, authorization keys, or other information required to insta" \
++"ll\n" \
++"and execute modified versions of a covered work in that User Product f" \
++"rom\n" \
++"a modified version of its Corresponding Source. The information must\n" \
++"suffice to ensure that the continued functioning of the modified objec" \
++"t\n" \
++"code is in no case prevented or interfered with solely because\n" \
++"modification has been made.\n" \
++"\n" \
++" If you convey an object code work under this section in, or with, or" \
++"\n" \
++"specifically for use in, a User Product, and the conveying occurs as\n" \
++"part of a transaction in which the right of possession and use of the\n" \
++"User Product is transferred to the recipient in perpetuity or for a\n" \
++"fixed term (regardless of how the transaction is characterized), the\n" \
++"Corresponding Source conveyed under this section must be accompanied\n" \
++"by the Installation Information. But this requirement does not apply\n" \
++"if neither you nor any third party retains the ability to install\n" \
++"modified object code on the User Product (for example, the work has\n" \
++"been installed in ROM).\n" \
++"\n" \
++" The requirement to provide Installation Information does not include" \
++" a\n" \
++"requirement to continue to provide support service, warranty, or updat" \
++"es\n" \
++"for a work that has been modified or installed by the recipient, or fo" \
++"r\n" \
++"the User Product in which it has been modified or installed. Access t" \
++"o a\n" \
++"network may be denied when the modification itself materially and\n" \
++"adversely affects the operation of the network or violates the rules a" \
++"nd\n" \
++"protocols for communication across the network.\n" \
++"\n" \
++" Corresponding Source conveyed, and Installation Information provided" \
++",\n" \
++"in accord with this section must be in a format that is publicly\n" \
++"documented (and with an implementation available to the public in\n" \
++"source code form), and must require no special password or key for\n" \
++"unpacking, reading or copying.\n" \
++"\n" \
++" 7. Additional Terms.\n" \
++"\n" \
++" \"Additional permissions\" are terms that supplement the terms of th" \
++"is\n" \
++"License by making exceptions from one or more of its conditions.\n" \
++"Additional permissions that are applicable to the entire Program shall" \
++"\n" \
++"be treated as though they were included in this License, to the extent" \
++"\n" \
++"that they are valid under applicable law. If additional permissions\n" \
++"apply only to part of the Program, that part may be used separately\n" \
++"under those permissions, but the entire Program remains governed by\n" \
++"this License without regard to the additional permissions.\n" \
++"\n" \
++" When you convey a copy of a covered work, you may at your option\n" \
++"remove any additional permissions from that copy, or from any part of\n" \
++"it. (Additional permissions may be written to require their own\n" \
++"removal in certain cases when you modify the work.) You may place\n" \
++"additional permissions on material, added by you to a covered work,\n" \
++"for which you have or can give appropriate copyright permission.\n" \
++"\n" \
++" Notwithstanding any other provision of this License, for material yo" \
++"u\n" \
++"add to a covered work, you may (if authorized by the copyright holders" \
++" of\n" \
++"that material) supplement the terms of this License with terms:\n" \
++"\n" \
++" a) Disclaiming warranty or limiting liability differently from the" \
++"\n" \
++" terms of sections 15 and 16 of this License; or\n" \
++"\n" \
++" b) Requiring preservation of specified reasonable legal notices or" \
++"\n" \
++" author attributions in that material or in the Appropriate Legal\n" \
++" Notices displayed by works containing it; or\n" \
++"\n" \
++" c) Prohibiting misrepresentation of the origin of that material, o" \
++"r\n" \
++" requiring that modified versions of such material be marked in\n" \
++" reasonable ways as different from the original version; or\n" \
++"\n" \
++" d) Limiting the use for publicity purposes of names of licensors o" \
++"r\n" \
++" authors of the material; or\n" \
++"\n" \
++" e) Declining to grant rights under trademark law for use of some\n" \
++" trade names, trademarks, or service marks; or\n" \
++"\n" \
++" f) Requiring indemnification of licensors and authors of that\n" \
++" material by anyone who conveys the material (or modified versions " \
++"of\n" \
++" it) with contractual assumptions of liability to the recipient, fo" \
++"r\n" \
++" any liability that these contractual assumptions directly impose o" \
++"n\n" \
++" those licensors and authors.\n" \
++"\n" \
++" All other non-permissive additional terms are considered \"further\n" \
++"restrictions\" within the meaning of section 10. If the Program as yo" \
++"u\n" \
++"received it, or any part of it, contains a notice stating that it is\n" \
++"governed by this License along with a term that is a further\n" \
++"restriction, you may remove that term. If a license document contains" \
++"\n" \
++"a further restriction but permits relicensing or conveying under this\n" \
++"License, you may add to a covered work material governed by the terms\n" \
++"of that license document, provided that the further restriction does\n" \
++"not survive such relicensing or conveying.\n" \
++"\n" \
++" If you add terms to a covered work in accord with this section, you\n" \
++"must place, in the relevant source files, a statement of the\n" \
++"additional terms that apply to those files, or a notice indicating\n" \
++"where to find the applicable terms.\n" \
++"\n" \
++" Additional terms, permissive or non-permissive, may be stated in the" \
++"\n" \
++"form of a separately written license, or stated as exceptions;\n" \
++"the above requirements apply either way.\n" \
++"\n" \
++" 8. Termination.\n" \
++"\n" \
++" You may not propagate or modify a covered work except as expressly\n" \
++"provided under this License. Any attempt otherwise to propagate or\n" \
++"modify it is void, and will automatically terminate your rights under\n" \
++"this License (including any patent licenses granted under the third\n" \
++"paragraph of section 11).\n" \
++"\n" \
++" However, if you cease all violation of this License, then your\n" \
++"license from a particular copyright holder is reinstated (a)\n" \
++"provisionally, unless and until the copyright holder explicitly and\n" \
++"finally terminates your license, and (b) permanently, if the copyright" \
++"\n" \
++"holder fails to notify you of the violation by some reasonable means\n" \
++"prior to 60 days after the cessation.\n" \
++"\n" \
++" Moreover, your license from a particular copyright holder is\n" \
++"reinstated permanently if the copyright holder notifies you of the\n" \
++"violation by some reasonable means, this is the first time you have\n" \
++"received notice of violation of this License (for any work) from that\n" \
++"copyright holder, and you cure the violation prior to 30 days after\n" \
++"your receipt of the notice.\n" \
++"\n" \
++" Termination of your rights under this section does not terminate the" \
++"\n" \
++"licenses of parties who have received copies or rights from you under\n" \
++"this License. If your rights have been terminated and not permanently" \
++"\n" \
++"reinstated, you do not qualify to receive new licenses for the same\n" \
++"material under section 10.\n" \
++"\n" \
++" 9. Acceptance Not Required for Having Copies.\n" \
++"\n" \
++" You are not required to accept this License in order to receive or\n" \
++"run a copy of the Program. Ancillary propagation of a covered work\n" \
++"occurring solely as a consequence of using peer-to-peer transmission\n" \
++"to receive a copy likewise does not require acceptance. However,\n" \
++"nothing other than this License grants you permission to propagate or\n" \
++"modify any covered work. These actions infringe copyright if you do\n" \
++"not accept this License. Therefore, by modifying or propagating a\n" \
++"covered work, you indicate your acceptance of this License to do so.\n" \
++"\n" \
++" 10. Automatic Licensing of Downstream Recipients.\n" \
++"\n" \
++" Each time you convey a covered work, the recipient automatically\n" \
++"receives a license from the original licensors, to run, modify and\n" \
++"propagate that work, subject to this License. You are not responsible" \
++"\n" \
++"for enforcing compliance by third parties with this License.\n" \
++"\n" \
++" An \"entity transaction\" is a transaction transferring control of a" \
++"n\n" \
++"organization, or substantially all assets of one, or subdividing an\n" \
++"organization, or merging organizations. If propagation of a covered\n" \
++"work results from an entity transaction, each party to that\n" \
++"transaction who receives a copy of the work also receives whatever\n" \
++"licenses to the work the party's predecessor in interest had or could\n" \
++"give under the previous paragraph, plus a right to possession of the\n" \
++"Corresponding Source of the work from the predecessor in interest, if\n" \
++"the predecessor has it or can get it with reasonable efforts.\n" \
++"\n" \
++" You may not impose any further restrictions on the exercise of the\n" \
++"rights granted or affirmed under this License. For example, you may\n" \
++"not impose a license fee, royalty, or other charge for exercise of\n" \
++"rights granted under this License, and you may not initiate litigation" \
++"\n" \
++"(including a cross-claim or counterclaim in a lawsuit) alleging that\n" \
++"any patent claim is infringed by making, using, selling, offering for\n" \
++"sale, or importing the Program or any portion of it.\n" \
++"\n" \
++" 11. Patents.\n" \
++"\n" \
++" A \"contributor\" is a copyright holder who authorizes use under thi" \
++"s\n" \
++"License of the Program or a work on which the Program is based. The\n" \
++"work thus licensed is called the contributor's \"contributor version\"" \
++".\n" \
++"\n" \
++" A contributor's \"essential patent claims\" are all patent claims\n" \
++"owned or controlled by the contributor, whether already acquired or\n" \
++"hereafter acquired, that would be infringed by some manner, permitted\n" \
++"by this License, of making, using, or selling its contributor version," \
++"\n" \
++"but do not include claims that would be infringed only as a\n" \
++"consequence of further modification of the contributor version. For\n" \
++"purposes of this definition, \"control\" includes the right to grant\n" \
++"patent sublicenses in a manner consistent with the requirements of\n" \
++"this License.\n" \
++"\n" \
++" Each contributor grants you a non-exclusive, worldwide, royalty-free" \
++"\n" \
++"patent license under the contributor's essential patent claims, to\n" \
++"make, use, sell, offer for sale, import and otherwise run, modify and\n" \
++"propagate the contents of its contributor version.\n" \
++"\n" \
++" In the following three paragraphs, a \"patent license\" is any expre" \
++"ss\n" \
++"agreement or commitment, however denominated, not to enforce a patent\n" \
++"(such as an express permission to practice a patent or covenant not to" \
++"\n" \
++"sue for patent infringement). To \"grant\" such a patent license to a" \
++"\n" \
++"party means to make such an agreement or commitment not to enforce a\n" \
++"patent against the party.\n" \
++"\n" \
++" If you convey a covered work, knowingly relying on a patent license," \
++"\n" \
++"and the Corresponding Source of the work is not available for anyone\n" \
++"to copy, free of charge and under the terms of this License, through a" \
++"\n" \
++"publicly available network server or other readily accessible means,\n" \
++"then you must either (1) cause the Corresponding Source to be so\n" \
++"available, or (2) arrange to deprive yourself of the benefit of the\n" \
++"patent license for this particular work, or (3) arrange, in a manner\n" \
++"consistent with the requirements of this License, to extend the patent" \
++"\n" \
++"license to downstream recipients. \"Knowingly relying\" means you hav" \
++"e\n" \
++"actual knowledge that, but for the patent license, your conveying the\n" \
++"covered work in a country, or your recipient's use of the covered work" \
++"\n" \
++"in a country, would infringe one or more identifiable patents in that\n" \
++"country that you have reason to believe are valid.\n" \
++"\n" \
++" If, pursuant to or in connection with a single transaction or\n" \
++"arrangement, you convey, or propagate by procuring conveyance of, a\n" \
++"covered work, and grant a patent license to some of the parties\n" \
++"receiving the covered work authorizing them to use, propagate, modify\n" \
++"or convey a specific copy of the covered work, then the patent license" \
++"\n" \
++"you grant is automatically extended to all recipients of the covered\n" \
++"work and works based on it.\n" \
++"\n" \
++" A patent license is \"discriminatory\" if it does not include within" \
++"\n" \
++"the scope of its coverage, prohibits the exercise of, or is\n" \
++"conditioned on the non-exercise of one or more of the rights that are\n" \
++"specifically granted under this License. You may not convey a covered" \
++"\n" \
++"work if you are a party to an arrangement with a third party that is\n" \
++"in the business of distributing software, under which you make payment" \
++"\n" \
++"to the third party based on the extent of your activity of conveying\n" \
++"the work, and under which the third party grants, to any of the\n" \
++"parties who would receive the covered work from you, a discriminatory\n" \
++"patent license (a) in connection with copies of the covered work\n" \
++"conveyed by you (or copies made from those copies), or (b) primarily\n" \
++"for and in connection with specific products or compilations that\n" \
++"contain the covered work, unless you entered into that arrangement,\n" \
++"or that patent license was granted, prior to 28 March 2007.\n" \
++"\n" \
++" Nothing in this License shall be construed as excluding or limiting\n" \
++"any implied license or other defenses to infringement that may\n" \
++"otherwise be available to you under applicable patent law.\n" \
++"\n" \
++" 12. No Surrender of Others' Freedom.\n" \
++"\n" \
++" If conditions are imposed on you (whether by court order, agreement " \
++"or\n" \
++"otherwise) that contradict the conditions of this License, they do not" \
++"\n" \
++"excuse you from the conditions of this License. If you cannot convey " \
++"a\n" \
++"covered work so as to satisfy simultaneously your obligations under th" \
++"is\n" \
++"License and any other pertinent obligations, then as a consequence you" \
++" may\n" \
++"not convey it at all. For example, if you agree to terms that obligat" \
++"e you\n" \
++"to collect a royalty for further conveying from those to whom you conv" \
++"ey\n" \
++"the Program, the only way you could satisfy both those terms and this\n" \
++"License would be to refrain entirely from conveying the Program.\n" \
++"\n" \
++" 13. Use with the GNU Affero General Public License.\n" \
++"\n" \
++" Notwithstanding any other provision of this License, you have\n" \
++"permission to link or combine any covered work with a work licensed\n" \
++"under version 3 of the GNU Affero General Public License into a single" \
++"\n" \
++"combined work, and to convey the resulting work. The terms of this\n" \
++"License will continue to apply to the part which is the covered work,\n" \
++"but the special requirements of the GNU Affero General Public License," \
++"\n" \
++"section 13, concerning interaction through a network will apply to the" \
++"\n" \
++"combination as such.\n" \
++"\n" \
++" 14. Revised Versions of this License.\n" \
++"\n" \
++" The Free Software Foundation may publish revised and/or new versions" \
++" of\n" \
++"the GNU General Public License from time to time. Such new versions w" \
++"ill\n" \
++"be similar in spirit to the present version, but may differ in detail " \
++"to\n" \
++"address new problems or concerns.\n" \
++"\n" \
++" Each version is given a distinguishing version number. If the\n" \
++"Program specifies that a certain numbered version of the GNU General\n" \
++"Public License \"or any later version\" applies to it, you have the\n" \
++"option of following the terms and conditions either of that numbered\n" \
++"version or of any later version published by the Free Software\n" \
++"Foundation. If the Program does not specify a version number of the\n" \
++"GNU General Public License, you may choose any version ever published\n" \
++"by the Free Software Foundation.\n" \
++"\n" \
++" If the Program specifies that a proxy can decide which future\n" \
++"versions of the GNU General Public License can be used, that proxy's\n" \
++"public statement of acceptance of a version permanently authorizes you" \
++"\n" \
++"to choose that version for the Program.\n" \
++"\n" \
++" Later license versions may give you additional or different\n" \
++"permissions. However, no additional obligations are imposed on any\n" \
++"author or copyright holder as a result of your choosing to follow a\n" \
++"later version.\n" \
++"\n" \
++" 15. Disclaimer of Warranty.\n" \
++"\n" \
++" THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY\n" \
++"APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT" \
++"\n" \
++"HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WAR" \
++"RANTY\n" \
++"OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED T" \
++"O,\n" \
++"THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR" \
++"\n" \
++"PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PRO" \
++"GRAM\n" \
++"IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST " \
++"OF\n" \
++"ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n" \
++"\n" \
++" 16. Limitation of Liability.\n" \
++"\n" \
++" IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITIN" \
++"G\n" \
++"WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONV" \
++"EYS\n" \
++"THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDIN" \
++"G ANY\n" \
++"GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF T" \
++"HE\n" \
++"USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS" \
++" OF\n" \
++"DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR T" \
++"HIRD\n" \
++"PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS" \
++"),\n" \
++"EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY" \
++" OF\n" \
++"SUCH DAMAGES.\n" \
++"\n" \
++" 17. Interpretation of Sections 15 and 16.\n" \
++"\n" \
++" If the disclaimer of warranty and limitation of liability provided\n" \
++"above cannot be given local legal effect according to their terms,\n" \
++"reviewing courts shall apply local law that most closely approximates\n" \
++"an absolute waiver of all civil liability in connection with the\n" \
++"Program, unless a warranty or assumption of liability accompanies a\n" \
++"copy of the Program in return for a fee.\n" \
++"\n" \
++" END OF TERMS AND CONDITIONS\n" \
++"\n" \
++" How to Apply These Terms to Your New Programs\n" \
++"\n" \
++" If you develop a new program, and you want it to be of the greatest\n" \
++"possible use to the public, the best way to achieve this is to make it" \
++"\n" \
++"free software which everyone can redistribute and change under these t" \
++"erms.\n" \
++"\n" \
++" To do so, attach the following notices to the program. It is safest" \
++"\n" \
++"to attach them to the start of each source file to most effectively\n" \
++"state the exclusion of warranty; and each file should have at least\n" \
++"the \"copyright\" line and a pointer to where the full notice is found" \
++".\n" \
++"\n" \
++" <one line to give the program's name and a brief idea of what it d" \
++"oes.>\n" \
++" Copyright (C) <year> <name of author>\n" \
++"\n" \
++" This program is free software: you can redistribute it and/or modi" \
++"fy\n" \
++" it under the terms of the GNU General Public License as published " \
++"by\n" \
++" the Free Software Foundation, either version 3 of the License, or\n" \
++" (at your option) any later version.\n" \
++"\n" \
++" This program is distributed in the hope that it will be useful,\n" \
++" but WITHOUT ANY WARRANTY; without even the implied warranty of\n" \
++" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" \
++" GNU General Public License for more details.\n" \
++"\n" \
++" You should have received a copy of the GNU General Public License\n" \
++" along with this program. If not, see <http://www.gnu.org/licenses"; \
++"/>.\n" \
++"\n" \
++"Also add information on how to contact you by electronic and paper mai" \
++"l.\n" \
++"\n" \
++" If the program does terminal interaction, make it output a short\n" \
++"notice like this when it starts in an interactive mode:\n" \
++"\n" \
++" <program> Copyright (C) <year> <name of author>\n" \
++" This program comes with ABSOLUTELY NO WARRANTY; for details type `" \
++"show w'.\n" \
++" This is free software, and you are welcome to redistribute it\n" \
++" under certain conditions; type `show c' for details.\n" \
++"\n" \
++"The hypothetical commands `show w' and `show c' should show the approp" \
++"riate\n" \
++"parts of the General Public License. Of course, your program's comman" \
++"ds\n" \
++"might be different; for a GUI interface, you would use an \"about box\"" \
++".\n" \
++"\n" \
++" You should also get your employer (if you work as a programmer) or s" \
++"chool,\n" \
++"if any, to sign a \"copyright disclaimer\" for the program, if necessa" \
++"ry.\n" \
++"For more information on this, and how to apply and follow the GNU GPL," \
++" see\n" \
++"<http://www.gnu.org/licenses/>.\n" \
++"\n" \
++" The GNU General Public License does not permit incorporating your pr" \
++"ogram\n" \
++"into proprietary programs. If your program is a subroutine library, y" \
++"ou\n" \
++"may consider it more useful to permit linking proprietary applications" \
++" with\n" \
++"the library. If this is what you want to do, use the GNU Lesser Gener" \
++"al\n" \
++"Public License instead of this License. But first, please read\n" \
++"<http://www.gnu.org/philosophy/why-not-lgpl.html>.\n");
++#line 104 "ease-about-dialog.c"
++ return self;
++}
++
++
++#line 44 "ease-about-dialog.vala"
++EaseAboutDialog* ease_about_dialog_new (void) {
++#line 44 "ease-about-dialog.vala"
++ return ease_about_dialog_construct (EASE_TYPE_ABOUT_DIALOG);
++#line 113 "ease-about-dialog.c"
++}
++
++
++static void ease_about_dialog_class_init (EaseAboutDialogClass * klass) {
++ ease_about_dialog_parent_class = g_type_class_peek_parent (klass);
++}
++
++
++static void ease_about_dialog_instance_init (EaseAboutDialog * self) {
++}
++
++
++GType ease_about_dialog_get_type (void) {
++ static volatile gsize ease_about_dialog_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_about_dialog_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseAboutDialogClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_about_dialog_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseAboutDialog), 0, (GInstanceInitFunc) ease_about_dialog_instance_init, NULL };
++ GType ease_about_dialog_type_id;
++ ease_about_dialog_type_id = g_type_register_static (GTK_TYPE_ABOUT_DIALOG, "EaseAboutDialog", &g_define_type_info, 0);
++ g_once_init_leave (&ease_about_dialog_type_id__volatile, ease_about_dialog_type_id);
++ }
++ return ease_about_dialog_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-actor.c
index 0000000,0000000..8592209
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-actor.c
@@@ -1,0 -1,0 +1,336 @@@
++/* ease-actor.c generated by valac, the Vala compiler
++ * generated from ease-actor.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <clutter/clutter.h>
++#include <gtk/gtk.h>
++#include <float.h>
++#include <math.h>
++
++
++#define EASE_TYPE_ACTOR (ease_actor_get_type ())
++#define EASE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ACTOR, EaseActor))
++#define EASE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ACTOR, EaseActorClass))
++#define EASE_IS_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ACTOR))
++#define EASE_IS_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ACTOR))
++#define EASE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ACTOR, EaseActorClass))
++
++typedef struct _EaseActor EaseActor;
++typedef struct _EaseActorClass EaseActorClass;
++typedef struct _EaseActorPrivate EaseActorPrivate;
++
++#define EASE_TYPE_SCROLLABLE_EMBED (ease_scrollable_embed_get_type ())
++#define EASE_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbed))
++#define EASE_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++#define EASE_IS_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_IS_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_SCROLLABLE_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++
++typedef struct _EaseScrollableEmbed EaseScrollableEmbed;
++typedef struct _EaseScrollableEmbedClass EaseScrollableEmbedClass;
++
++#define EASE_TYPE_EDITOR_EMBED (ease_editor_embed_get_type ())
++#define EASE_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbed))
++#define EASE_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++#define EASE_IS_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_EMBED))
++#define EASE_IS_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_EMBED))
++#define EASE_EDITOR_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++
++typedef struct _EaseEditorEmbed EaseEditorEmbed;
++typedef struct _EaseEditorEmbedClass EaseEditorEmbedClass;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++struct _EaseActor {
++ ClutterGroup parent_instance;
++ EaseActorPrivate * priv;
++ ClutterActor* contents;
++ EaseElement* element;
++ EaseActorContext context;
++ gboolean is_background;
++};
++
++struct _EaseActorClass {
++ ClutterGroupClass parent_class;
++ void (*edit) (EaseActor* self, EaseEditorEmbed* sender);
++ void (*end_edit) (EaseActor* self, EaseEditorEmbed* sender);
++};
++
++struct _EaseActorPrivate {
++ ClutterRectangle* editor_rect;
++};
++
++
++static gpointer ease_actor_parent_class = NULL;
++
++GType ease_actor_get_type (void) G_GNUC_CONST;
++GType ease_scrollable_embed_get_type (void) G_GNUC_CONST;
++GType ease_editor_embed_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++#define EASE_ACTOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_ACTOR, EaseActorPrivate))
++enum {
++ EASE_ACTOR_DUMMY_PROPERTY
++};
++#define EASE_ACTOR_RECT_WIDTH ((guint) 1)
++float ease_element_get_width (EaseElement* self);
++float ease_element_get_height (EaseElement* self);
++EaseActor* ease_actor_construct (GType object_type, EaseElement* e, EaseActorContext c);
++float ease_element_get_x (EaseElement* self);
++float ease_element_get_y (EaseElement* self);
++void ease_actor_reposition (EaseActor* self);
++void ease_element_set_x (EaseElement* self, float value);
++void ease_element_set_y (EaseElement* self, float value);
++void ease_actor_translate (EaseActor* self, float x_change, float y_change);
++void ease_element_set_width (EaseElement* self, float value);
++void ease_element_set_height (EaseElement* self, float value);
++void ease_actor_resize (EaseActor* self, float w_change, float h_change, gboolean proportional);
++void ease_actor_edit (EaseActor* self, EaseEditorEmbed* sender);
++static void ease_actor_real_edit (EaseActor* self, EaseEditorEmbed* sender);
++void ease_actor_end_edit (EaseActor* self, EaseEditorEmbed* sender);
++static void ease_actor_real_end_edit (EaseActor* self, EaseEditorEmbed* sender);
++static void ease_actor_finalize (GObject* obj);
++
++static const ClutterColor EASE_ACTOR_RECT_COLOR = {(guchar) 0, (guchar) 0, (guchar) 0, (guchar) 0};
++static const ClutterColor EASE_ACTOR_RECT_BORDER = {(guchar) 100, (guchar) 100, (guchar) 100, (guchar) 255};
++
++
++#line 75 "ease-actor.vala"
++EaseActor* ease_actor_construct (GType object_type, EaseElement* e, EaseActorContext c) {
++#line 136 "ease-actor.c"
++ EaseActor * self;
++#line 75 "ease-actor.vala"
++ g_return_val_if_fail (e != NULL, NULL);
++#line 140 "ease-actor.c"
++ self = g_object_newv (object_type, 0, NULL);
++#line 77 "ease-actor.vala"
++ self->element = e;
++#line 78 "ease-actor.vala"
++ self->context = c;
++#line 79 "ease-actor.vala"
++ self->is_background = FALSE;
++#line 82 "ease-actor.vala"
++ if (c == EASE_ACTOR_CONTEXT_EDITOR) {
++#line 150 "ease-actor.c"
++ ClutterRectangle* _tmp0_;
++ ClutterColor _tmp1_;
++#line 84 "ease-actor.vala"
++ self->priv->editor_rect = (_tmp0_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new_with_color (&EASE_ACTOR_RECT_COLOR)), _g_object_unref0 (self->priv->editor_rect), _tmp0_);
++#line 85 "ease-actor.vala"
++ clutter_rectangle_set_border_color (self->priv->editor_rect, (_tmp1_ = EASE_ACTOR_RECT_BORDER, &_tmp1_));
++#line 86 "ease-actor.vala"
++ clutter_rectangle_set_border_width (self->priv->editor_rect, EASE_ACTOR_RECT_WIDTH);
++#line 87 "ease-actor.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->editor_rect, ease_element_get_width (e));
++#line 88 "ease-actor.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->editor_rect, ease_element_get_height (e));
++#line 89 "ease-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) self->priv->editor_rect);
++#line 165 "ease-actor.c"
++ }
++ return self;
++}
++
++
++#line 98 "ease-actor.vala"
++void ease_actor_reposition (EaseActor* self) {
++#line 98 "ease-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 100 "ease-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) self, ease_element_get_x (self->element));
++#line 101 "ease-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) self, ease_element_get_y (self->element));
++#line 102 "ease-actor.vala"
++ clutter_actor_set_width ((ClutterActor*) self, ease_element_get_width (self->element));
++#line 103 "ease-actor.vala"
++ clutter_actor_set_height ((ClutterActor*) self, ease_element_get_height (self->element));
++#line 104 "ease-actor.vala"
++ clutter_actor_set_width (self->contents, clutter_actor_get_width ((ClutterActor*) self));
++#line 105 "ease-actor.vala"
++ clutter_actor_set_height (self->contents, clutter_actor_get_height ((ClutterActor*) self));
++#line 107 "ease-actor.vala"
++ if (self->priv->editor_rect != NULL) {
++#line 109 "ease-actor.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->editor_rect, clutter_actor_get_width ((ClutterActor*) self));
++#line 110 "ease-actor.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->editor_rect, clutter_actor_get_height ((ClutterActor*) self));
++#line 193 "ease-actor.c"
++ }
++}
++
++
++#line 122 "ease-actor.vala"
++void ease_actor_translate (EaseActor* self, float x_change, float y_change) {
++#line 122 "ease-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 124 "ease-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) self, clutter_actor_get_x ((ClutterActor*) self) + x_change);
++#line 125 "ease-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) self, clutter_actor_get_y ((ClutterActor*) self) + y_change);
++#line 127 "ease-actor.vala"
++ ease_element_set_x (self->element, clutter_actor_get_x ((ClutterActor*) self));
++#line 128 "ease-actor.vala"
++ ease_element_set_y (self->element, clutter_actor_get_y ((ClutterActor*) self));
++#line 210 "ease-actor.c"
++}
++
++
++#line 140 "ease-actor.vala"
++void ease_actor_resize (EaseActor* self, float w_change, float h_change, gboolean proportional) {
++#line 140 "ease-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 142 "ease-actor.vala"
++ if (proportional) {
++#line 144 "ease-actor.vala"
++ if ((w_change / h_change) > (clutter_actor_get_width ((ClutterActor*) self) / clutter_actor_get_height ((ClutterActor*) self))) {
++#line 146 "ease-actor.vala"
++ w_change = h_change * (clutter_actor_get_width ((ClutterActor*) self) / clutter_actor_get_height ((ClutterActor*) self));
++#line 224 "ease-actor.c"
++ } else {
++#line 148 "ease-actor.vala"
++ if ((w_change / h_change) < (clutter_actor_get_width ((ClutterActor*) self) / clutter_actor_get_height ((ClutterActor*) self))) {
++#line 150 "ease-actor.vala"
++ h_change = w_change * (clutter_actor_get_height ((ClutterActor*) self) / clutter_actor_get_width ((ClutterActor*) self));
++#line 230 "ease-actor.c"
++ }
++ }
++ }
++#line 154 "ease-actor.vala"
++ if ((clutter_actor_get_width ((ClutterActor*) self) + w_change) > 1) {
++#line 156 "ease-actor.vala"
++ clutter_actor_set_width ((ClutterActor*) self, clutter_actor_get_width ((ClutterActor*) self) + w_change);
++#line 157 "ease-actor.vala"
++ clutter_actor_set_width (self->contents, clutter_actor_get_width (self->contents) + w_change);
++#line 240 "ease-actor.c"
++ }
++#line 159 "ease-actor.vala"
++ if ((clutter_actor_get_height ((ClutterActor*) self) + h_change) > 1) {
++#line 161 "ease-actor.vala"
++ clutter_actor_set_height ((ClutterActor*) self, clutter_actor_get_height ((ClutterActor*) self) + h_change);
++#line 162 "ease-actor.vala"
++ clutter_actor_set_height (self->contents, clutter_actor_get_height (self->contents) + h_change);
++#line 248 "ease-actor.c"
++ }
++#line 165 "ease-actor.vala"
++ ease_element_set_width (self->element, clutter_actor_get_width ((ClutterActor*) self));
++#line 166 "ease-actor.vala"
++ ease_element_set_height (self->element, clutter_actor_get_height ((ClutterActor*) self));
++#line 168 "ease-actor.vala"
++ if (self->priv->editor_rect != NULL) {
++#line 170 "ease-actor.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->editor_rect, clutter_actor_get_width ((ClutterActor*) self));
++#line 171 "ease-actor.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->editor_rect, clutter_actor_get_height ((ClutterActor*) self));
++#line 260 "ease-actor.c"
++ }
++}
++
++
++#line 180 "ease-actor.vala"
++static void ease_actor_real_edit (EaseActor* self, EaseEditorEmbed* sender) {
++#line 180 "ease-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 180 "ease-actor.vala"
++ g_return_if_fail (sender != NULL);
++#line 271 "ease-actor.c"
++}
++
++
++#line 180 "ease-actor.vala"
++void ease_actor_edit (EaseActor* self, EaseEditorEmbed* sender) {
++#line 180 "ease-actor.vala"
++ EASE_ACTOR_GET_CLASS (self)->edit (self, sender);
++#line 279 "ease-actor.c"
++}
++
++
++#line 188 "ease-actor.vala"
++static void ease_actor_real_end_edit (EaseActor* self, EaseEditorEmbed* sender) {
++#line 188 "ease-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 188 "ease-actor.vala"
++ g_return_if_fail (sender != NULL);
++#line 289 "ease-actor.c"
++}
++
++
++#line 188 "ease-actor.vala"
++void ease_actor_end_edit (EaseActor* self, EaseEditorEmbed* sender) {
++#line 188 "ease-actor.vala"
++ EASE_ACTOR_GET_CLASS (self)->end_edit (self, sender);
++#line 297 "ease-actor.c"
++}
++
++
++static void ease_actor_class_init (EaseActorClass * klass) {
++ ease_actor_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseActorPrivate));
++ EASE_ACTOR_CLASS (klass)->edit = ease_actor_real_edit;
++ EASE_ACTOR_CLASS (klass)->end_edit = ease_actor_real_end_edit;
++ G_OBJECT_CLASS (klass)->finalize = ease_actor_finalize;
++}
++
++
++static void ease_actor_instance_init (EaseActor * self) {
++ self->priv = EASE_ACTOR_GET_PRIVATE (self);
++}
++
++
++static void ease_actor_finalize (GObject* obj) {
++ EaseActor * self;
++ self = EASE_ACTOR (obj);
++ _g_object_unref0 (self->contents);
++ _g_object_unref0 (self->priv->editor_rect);
++ G_OBJECT_CLASS (ease_actor_parent_class)->finalize (obj);
++}
++
++
++GType ease_actor_get_type (void) {
++ static volatile gsize ease_actor_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_actor_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseActorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_actor_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseActor), 0, (GInstanceInitFunc) ease_actor_instance_init, NULL };
++ GType ease_actor_type_id;
++ ease_actor_type_id = g_type_register_static (CLUTTER_TYPE_GROUP, "EaseActor", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
++ g_once_init_leave (&ease_actor_type_id__volatile, ease_actor_type_id);
++ }
++ return ease_actor_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-animated-zoom-slider.c
index 0000000,0000000..0e20f87
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-animated-zoom-slider.c
@@@ -1,0 -1,0 +1,226 @@@
++/* ease-animated-zoom-slider.c generated by valac, the Vala compiler
++ * generated from ease-animated-zoom-slider.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <float.h>
++#include <math.h>
++#include <clutter/clutter.h>
++#include <stdlib.h>
++#include <string.h>
++
++
++#define EASE_TYPE_ZOOM_SLIDER (ease_zoom_slider_get_type ())
++#define EASE_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ZOOM_SLIDER, EaseZoomSlider))
++#define EASE_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ZOOM_SLIDER, EaseZoomSliderClass))
++#define EASE_IS_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ZOOM_SLIDER))
++#define EASE_IS_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ZOOM_SLIDER))
++#define EASE_ZOOM_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ZOOM_SLIDER, EaseZoomSliderClass))
++
++typedef struct _EaseZoomSlider EaseZoomSlider;
++typedef struct _EaseZoomSliderClass EaseZoomSliderClass;
++typedef struct _EaseZoomSliderPrivate EaseZoomSliderPrivate;
++
++#define EASE_TYPE_ANIMATED_ZOOM_SLIDER (ease_animated_zoom_slider_get_type ())
++#define EASE_ANIMATED_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ANIMATED_ZOOM_SLIDER, EaseAnimatedZoomSlider))
++#define EASE_ANIMATED_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ANIMATED_ZOOM_SLIDER, EaseAnimatedZoomSliderClass))
++#define EASE_IS_ANIMATED_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ANIMATED_ZOOM_SLIDER))
++#define EASE_IS_ANIMATED_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ANIMATED_ZOOM_SLIDER))
++#define EASE_ANIMATED_ZOOM_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ANIMATED_ZOOM_SLIDER, EaseAnimatedZoomSliderClass))
++
++typedef struct _EaseAnimatedZoomSlider EaseAnimatedZoomSlider;
++typedef struct _EaseAnimatedZoomSliderClass EaseAnimatedZoomSliderClass;
++typedef struct _EaseAnimatedZoomSliderPrivate EaseAnimatedZoomSliderPrivate;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++struct _EaseZoomSlider {
++ GtkAlignment parent_instance;
++ EaseZoomSliderPrivate * priv;
++};
++
++struct _EaseZoomSliderClass {
++ GtkAlignmentClass parent_class;
++ void (*change_zoom) (EaseZoomSlider* self, double value);
++};
++
++struct _EaseAnimatedZoomSlider {
++ EaseZoomSlider parent_instance;
++ EaseAnimatedZoomSliderPrivate * priv;
++};
++
++struct _EaseAnimatedZoomSliderClass {
++ EaseZoomSliderClass parent_class;
++};
++
++struct _EaseAnimatedZoomSliderPrivate {
++ ClutterAnimation* zoom_anim;
++};
++
++
++static gpointer ease_animated_zoom_slider_parent_class = NULL;
++static ClutterAnimatableIface* ease_animated_zoom_slider_clutter_animatable_parent_iface = NULL;
++
++GType ease_zoom_slider_get_type (void) G_GNUC_CONST;
++GType ease_animated_zoom_slider_get_type (void) G_GNUC_CONST;
++#define EASE_ANIMATED_ZOOM_SLIDER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_ANIMATED_ZOOM_SLIDER, EaseAnimatedZoomSliderPrivate))
++enum {
++ EASE_ANIMATED_ZOOM_SLIDER_DUMMY_PROPERTY
++};
++#define EASE_ANIMATED_ZOOM_SLIDER_ZOOM_TIME 100
++#define EASE_ANIMATED_ZOOM_SLIDER_ZOOM_MODE ((gint) CLUTTER_EASE_IN_OUT_SINE)
++EaseZoomSlider* ease_zoom_slider_new (GtkAdjustment* adjustment, gint* button_values, int button_values_length1);
++EaseZoomSlider* ease_zoom_slider_construct (GType object_type, GtkAdjustment* adjustment, gint* button_values, int button_values_length1);
++EaseAnimatedZoomSlider* ease_animated_zoom_slider_new (GtkAdjustment* adjustment, gint* button_values, int button_values_length1);
++EaseAnimatedZoomSlider* ease_animated_zoom_slider_construct (GType object_type, GtkAdjustment* adjustment, gint* button_values, int button_values_length1);
++static void ease_animated_zoom_slider_real_change_zoom (EaseZoomSlider* base, double value);
++static gboolean ease_animated_zoom_slider_real_animate_property (ClutterAnimatable* base, ClutterAnimation* animation, const char* property_name, GValue* initial_value, GValue* final_value, double progress, GValue* value);
++static void ease_animated_zoom_slider_finalize (GObject* obj);
++static int _vala_strcmp0 (const char * str1, const char * str2);
++
++
++
++#line 37 "ease-animated-zoom-slider.vala"
++EaseAnimatedZoomSlider* ease_animated_zoom_slider_construct (GType object_type, GtkAdjustment* adjustment, gint* button_values, int button_values_length1) {
++#line 103 "ease-animated-zoom-slider.c"
++ EaseAnimatedZoomSlider * self;
++#line 37 "ease-animated-zoom-slider.vala"
++ g_return_val_if_fail (adjustment != NULL, NULL);
++#line 39 "ease-animated-zoom-slider.vala"
++ self = (EaseAnimatedZoomSlider*) ease_zoom_slider_construct (object_type, adjustment, button_values, button_values_length1);
++#line 109 "ease-animated-zoom-slider.c"
++ return self;
++}
++
++
++#line 37 "ease-animated-zoom-slider.vala"
++EaseAnimatedZoomSlider* ease_animated_zoom_slider_new (GtkAdjustment* adjustment, gint* button_values, int button_values_length1) {
++#line 37 "ease-animated-zoom-slider.vala"
++ return ease_animated_zoom_slider_construct (EASE_TYPE_ANIMATED_ZOOM_SLIDER, adjustment, button_values, button_values_length1);
++#line 118 "ease-animated-zoom-slider.c"
++}
++
++
++#line 42 "ease-animated-zoom-slider.vala"
++static void ease_animated_zoom_slider_real_change_zoom (EaseZoomSlider* base, double value) {
++#line 124 "ease-animated-zoom-slider.c"
++ EaseAnimatedZoomSlider * self;
++ ClutterAnimation* _tmp0_;
++ GValue _tmp2_;
++ GValue _tmp1_ = {0};
++ self = (EaseAnimatedZoomSlider*) base;
++#line 44 "ease-animated-zoom-slider.vala"
++ self->priv->zoom_anim = (_tmp0_ = clutter_animation_new (), _g_object_unref0 (self->priv->zoom_anim), _tmp0_);
++#line 45 "ease-animated-zoom-slider.vala"
++ clutter_animation_set_object (self->priv->zoom_anim, (GObject*) self);
++#line 46 "ease-animated-zoom-slider.vala"
++ clutter_animation_bind (self->priv->zoom_anim, "sliderpos", (_tmp2_ = (g_value_init (&_tmp1_, G_TYPE_DOUBLE), g_value_set_double (&_tmp1_, value), _tmp1_), &_tmp2_));
++#line 47 "ease-animated-zoom-slider.vala"
++ clutter_animation_set_duration (self->priv->zoom_anim, (guint) EASE_ANIMATED_ZOOM_SLIDER_ZOOM_TIME);
++#line 48 "ease-animated-zoom-slider.vala"
++ clutter_animation_set_mode (self->priv->zoom_anim, (gulong) EASE_ANIMATED_ZOOM_SLIDER_ZOOM_MODE);
++#line 49 "ease-animated-zoom-slider.vala"
++ clutter_timeline_start (clutter_animation_get_timeline (self->priv->zoom_anim));
++#line 142 "ease-animated-zoom-slider.c"
++}
++
++
++#line 52 "ease-animated-zoom-slider.vala"
++static gboolean ease_animated_zoom_slider_real_animate_property (ClutterAnimatable* base, ClutterAnimation* animation, const char* property_name, GValue* initial_value, GValue* final_value, double progress, GValue* value) {
++#line 148 "ease-animated-zoom-slider.c"
++ EaseAnimatedZoomSlider * self;
++ gboolean result = FALSE;
++ self = (EaseAnimatedZoomSlider*) base;
++#line 52 "ease-animated-zoom-slider.vala"
++ g_return_val_if_fail (animation != NULL, FALSE);
++#line 52 "ease-animated-zoom-slider.vala"
++ g_return_val_if_fail (property_name != NULL, FALSE);
++#line 59 "ease-animated-zoom-slider.vala"
++ if (_vala_strcmp0 (property_name, "sliderpos") != 0) {
++#line 158 "ease-animated-zoom-slider.c"
++ result = FALSE;
++#line 59 "ease-animated-zoom-slider.vala"
++ return result;
++#line 162 "ease-animated-zoom-slider.c"
++ }
++#line 61 "ease-animated-zoom-slider.vala"
++ g_value_set_double (value, (g_value_get_double (initial_value) * (1 - progress)) + (g_value_get_double (final_value) * progress));
++#line 166 "ease-animated-zoom-slider.c"
++ result = TRUE;
++#line 63 "ease-animated-zoom-slider.vala"
++ return result;
++#line 170 "ease-animated-zoom-slider.c"
++}
++
++
++static void ease_animated_zoom_slider_class_init (EaseAnimatedZoomSliderClass * klass) {
++ ease_animated_zoom_slider_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseAnimatedZoomSliderPrivate));
++ EASE_ZOOM_SLIDER_CLASS (klass)->change_zoom = ease_animated_zoom_slider_real_change_zoom;
++ G_OBJECT_CLASS (klass)->finalize = ease_animated_zoom_slider_finalize;
++}
++
++
++static void ease_animated_zoom_slider_clutter_animatable_interface_init (ClutterAnimatableIface * iface) {
++ ease_animated_zoom_slider_clutter_animatable_parent_iface = g_type_interface_peek_parent (iface);
++ iface->animate_property = ease_animated_zoom_slider_real_animate_property;
++}
++
++
++static void ease_animated_zoom_slider_instance_init (EaseAnimatedZoomSlider * self) {
++ self->priv = EASE_ANIMATED_ZOOM_SLIDER_GET_PRIVATE (self);
++}
++
++
++static void ease_animated_zoom_slider_finalize (GObject* obj) {
++ EaseAnimatedZoomSlider * self;
++ self = EASE_ANIMATED_ZOOM_SLIDER (obj);
++ _g_object_unref0 (self->priv->zoom_anim);
++ G_OBJECT_CLASS (ease_animated_zoom_slider_parent_class)->finalize (obj);
++}
++
++
++GType ease_animated_zoom_slider_get_type (void) {
++ static volatile gsize ease_animated_zoom_slider_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_animated_zoom_slider_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseAnimatedZoomSliderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_animated_zoom_slider_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseAnimatedZoomSlider), 0, (GInstanceInitFunc) ease_animated_zoom_slider_instance_init, NULL };
++ static const GInterfaceInfo clutter_animatable_info = { (GInterfaceInitFunc) ease_animated_zoom_slider_clutter_animatable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
++ GType ease_animated_zoom_slider_type_id;
++ ease_animated_zoom_slider_type_id = g_type_register_static (EASE_TYPE_ZOOM_SLIDER, "EaseAnimatedZoomSlider", &g_define_type_info, 0);
++ g_type_add_interface_static (ease_animated_zoom_slider_type_id, CLUTTER_TYPE_ANIMATABLE, &clutter_animatable_info);
++ g_once_init_leave (&ease_animated_zoom_slider_type_id__volatile, ease_animated_zoom_slider_type_id);
++ }
++ return ease_animated_zoom_slider_type_id__volatile;
++}
++
++
++static int _vala_strcmp0 (const char * str1, const char * str2) {
++ if (str1 == NULL) {
++ return -(str1 != str2);
++ }
++ if (str2 == NULL) {
++ return str1 != str2;
++ }
++ return strcmp (str1, str2);
++}
++
++
++
++
diff --cc ease-core/ease-close-confirm-dialog.c
index 0000000,0000000..c66bea1
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-close-confirm-dialog.c
@@@ -1,0 -1,0 +1,277 @@@
++/* ease-close-confirm-dialog.c generated by valac, the Vala compiler
++ * generated from ease-close-confirm-dialog.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++#include <glib/gi18n-lib.h>
++#include <float.h>
++#include <math.h>
++
++
++#define EASE_TYPE_CLOSE_CONFIRM_DIALOG (ease_close_confirm_dialog_get_type ())
++#define EASE_CLOSE_CONFIRM_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_CLOSE_CONFIRM_DIALOG, EaseCloseConfirmDialog))
++#define EASE_CLOSE_CONFIRM_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_CLOSE_CONFIRM_DIALOG, EaseCloseConfirmDialogClass))
++#define EASE_IS_CLOSE_CONFIRM_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_CLOSE_CONFIRM_DIALOG))
++#define EASE_IS_CLOSE_CONFIRM_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_CLOSE_CONFIRM_DIALOG))
++#define EASE_CLOSE_CONFIRM_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_CLOSE_CONFIRM_DIALOG, EaseCloseConfirmDialogClass))
++
++typedef struct _EaseCloseConfirmDialog EaseCloseConfirmDialog;
++typedef struct _EaseCloseConfirmDialogClass EaseCloseConfirmDialogClass;
++typedef struct _EaseCloseConfirmDialogPrivate EaseCloseConfirmDialogPrivate;
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++struct _EaseCloseConfirmDialog {
++ GtkDialog parent_instance;
++ EaseCloseConfirmDialogPrivate * priv;
++};
++
++struct _EaseCloseConfirmDialogClass {
++ GtkDialogClass parent_class;
++};
++
++
++static gpointer ease_close_confirm_dialog_parent_class = NULL;
++
++GType ease_close_confirm_dialog_get_type (void) G_GNUC_CONST;
++enum {
++ EASE_CLOSE_CONFIRM_DIALOG_DUMMY_PROPERTY
++};
++#define EASE_CLOSE_CONFIRM_DIALOG_TOP_FORMAT "<b><big>%s</big></b>"
++static char* ease_close_confirm_dialog_top_label_text (const char* filename);
++static char* ease_close_confirm_dialog_bottom_label_text (gint seconds);
++EaseCloseConfirmDialog* ease_close_confirm_dialog_new (const char* filename, gint seconds);
++EaseCloseConfirmDialog* ease_close_confirm_dialog_construct (GType object_type, const char* filename, gint seconds);
++
++
++
++#line 36 "ease-close-confirm-dialog.vala"
++EaseCloseConfirmDialog* ease_close_confirm_dialog_construct (GType object_type, const char* filename, gint seconds) {
++#line 71 "ease-close-confirm-dialog.c"
++ EaseCloseConfirmDialog * self;
++ GtkImage* image;
++ GtkLabel* top_label;
++ char* _tmp1_;
++ char* _tmp0_;
++ char* _tmp2_;
++ GtkLabel* _tmp3_;
++ GtkLabel* bottom_label;
++ GtkVBox* vbox;
++ GtkHBox* hbox;
++ GtkWidget* _tmp4_;
++#line 36 "ease-close-confirm-dialog.vala"
++ g_return_val_if_fail (filename != NULL, NULL);
++#line 85 "ease-close-confirm-dialog.c"
++ self = g_object_newv (object_type, 0, NULL);
++#line 38 "ease-close-confirm-dialog.vala"
++ gtk_window_set_title ((GtkWindow*) self, _ ("Save before closing?"));
++#line 39 "ease-close-confirm-dialog.vala"
++ gtk_dialog_set_has_separator ((GtkDialog*) self, FALSE);
++#line 42 "ease-close-confirm-dialog.vala"
++ image = g_object_ref_sink ((GtkImage*) gtk_image_new_from_stock ("gtk-dialog-warning", GTK_ICON_SIZE_DIALOG));
++#line 44 "ease-close-confirm-dialog.vala"
++ gtk_misc_set_alignment ((GtkMisc*) image, 0.5f, (float) 0);
++#line 47 "ease-close-confirm-dialog.vala"
++ top_label = g_object_ref_sink ((GtkLabel*) gtk_label_new (""));
++#line 48 "ease-close-confirm-dialog.vala"
++ g_object_set (top_label, "wrap", TRUE, NULL);
++#line 49 "ease-close-confirm-dialog.vala"
++ gtk_label_set_use_markup (top_label, TRUE);
++#line 50 "ease-close-confirm-dialog.vala"
++ gtk_misc_set_alignment ((GtkMisc*) top_label, (float) 0, 0.5f);
++#line 51 "ease-close-confirm-dialog.vala"
++ gtk_label_set_selectable (top_label, TRUE);
++#line 52 "ease-close-confirm-dialog.vala"
++ g_object_set ((GtkWidget*) top_label, "can-focus", FALSE, NULL);
++#line 53 "ease-close-confirm-dialog.vala"
++ gtk_label_set_markup (top_label, _tmp1_ = g_strdup_printf (EASE_CLOSE_CONFIRM_DIALOG_TOP_FORMAT, _tmp0_ = ease_close_confirm_dialog_top_label_text (filename)));
++#line 109 "ease-close-confirm-dialog.c"
++ _g_free0 (_tmp1_);
++ _g_free0 (_tmp0_);
++#line 56 "ease-close-confirm-dialog.vala"
++ bottom_label = (_tmp3_ = g_object_ref_sink ((GtkLabel*) gtk_label_new (_tmp2_ = ease_close_confirm_dialog_bottom_label_text (seconds))), _g_free0 (_tmp2_), _tmp3_);
++#line 57 "ease-close-confirm-dialog.vala"
++ g_object_set (bottom_label, "wrap", TRUE, NULL);
++#line 58 "ease-close-confirm-dialog.vala"
++ gtk_misc_set_alignment ((GtkMisc*) bottom_label, (float) 0, 0.5f);
++#line 59 "ease-close-confirm-dialog.vala"
++ gtk_label_set_selectable (bottom_label, TRUE);
++#line 60 "ease-close-confirm-dialog.vala"
++ g_object_set ((GtkWidget*) bottom_label, "can-focus", FALSE, NULL);
++#line 63 "ease-close-confirm-dialog.vala"
++ vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 12));
++#line 64 "ease-close-confirm-dialog.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) top_label, FALSE, FALSE, (guint) 0);
++#line 65 "ease-close-confirm-dialog.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) bottom_label, FALSE, FALSE, (guint) 0);
++#line 68 "ease-close-confirm-dialog.vala"
++ hbox = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 12));
++#line 69 "ease-close-confirm-dialog.vala"
++ gtk_container_set_border_width ((GtkContainer*) hbox, (guint) 5);
++#line 70 "ease-close-confirm-dialog.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) image, FALSE, FALSE, (guint) 0);
++#line 71 "ease-close-confirm-dialog.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) vbox, TRUE, TRUE, (guint) 0);
++#line 73 "ease-close-confirm-dialog.vala"
++ gtk_box_pack_start ((_tmp4_ = gtk_dialog_get_content_area ((GtkDialog*) self), GTK_IS_BOX (_tmp4_) ? ((GtkBox*) _tmp4_) : NULL), (GtkWidget*) hbox, TRUE, TRUE, (guint) 0);
++#line 74 "ease-close-confirm-dialog.vala"
++ gtk_widget_show_all ((GtkWidget*) hbox);
++#line 77 "ease-close-confirm-dialog.vala"
++ gtk_dialog_add_buttons ((GtkDialog*) self, _ ("Close _without Saving"), GTK_RESPONSE_NO, "gtk-cancel", GTK_RESPONSE_CANCEL, "gtk-save", GTK_RESPONSE_YES, NULL);
++#line 81 "ease-close-confirm-dialog.vala"
++ gtk_dialog_set_default_response ((GtkDialog*) self, (gint) GTK_RESPONSE_YES);
++#line 144 "ease-close-confirm-dialog.c"
++ _g_object_unref0 (image);
++ _g_object_unref0 (top_label);
++ _g_object_unref0 (bottom_label);
++ _g_object_unref0 (vbox);
++ _g_object_unref0 (hbox);
++ return self;
++}
++
++
++#line 36 "ease-close-confirm-dialog.vala"
++EaseCloseConfirmDialog* ease_close_confirm_dialog_new (const char* filename, gint seconds) {
++#line 36 "ease-close-confirm-dialog.vala"
++ return ease_close_confirm_dialog_construct (EASE_TYPE_CLOSE_CONFIRM_DIALOG, filename, seconds);
++#line 158 "ease-close-confirm-dialog.c"
++}
++
++
++#line 90 "ease-close-confirm-dialog.vala"
++static char* ease_close_confirm_dialog_bottom_label_text (gint seconds) {
++#line 164 "ease-close-confirm-dialog.c"
++ char* result = NULL;
++ gint hours;
++#line 92 "ease-close-confirm-dialog.vala"
++ seconds = MAX (1, seconds);
++#line 94 "ease-close-confirm-dialog.vala"
++ if (seconds < 55) {
++#line 171 "ease-close-confirm-dialog.c"
++ result = g_strdup_printf (ngettext ("If you don't save, changes from the last second will be permanently lo" \
++"st.", "If you don't save, changes from the last %i seconds will be permanentl" \
++"y lost.", (gulong) seconds), seconds);
++#line 96 "ease-close-confirm-dialog.vala"
++ return result;
++#line 175 "ease-close-confirm-dialog.c"
++ }
++#line 98 "ease-close-confirm-dialog.vala"
++ if (seconds < 75) {
++#line 179 "ease-close-confirm-dialog.c"
++ result = g_strdup (_ ("If you don't save, changes from the last minute will be permanently lo" \
++"st."));
++#line 100 "ease-close-confirm-dialog.vala"
++ return result;
++#line 183 "ease-close-confirm-dialog.c"
++ }
++#line 102 "ease-close-confirm-dialog.vala"
++ if (seconds < 110) {
++#line 187 "ease-close-confirm-dialog.c"
++ result = g_strdup_printf (ngettext ("If you don't save, changes from the last minute and %i second will be " \
++"permanently lost.", "If you don't save, changes from the last minute and %i seconds will be" \
++" permanently lost.", (gulong) (seconds - 60)), seconds - 60);
++#line 104 "ease-close-confirm-dialog.vala"
++ return result;
++#line 191 "ease-close-confirm-dialog.c"
++ }
++#line 106 "ease-close-confirm-dialog.vala"
++ if (seconds < 3600) {
++#line 195 "ease-close-confirm-dialog.c"
++ result = g_strdup_printf (ngettext ("If you don't save, changes from the last %i minute will be permanently" \
++" lost.", "If you don't save, changes from the last %i minutes will be permanentl" \
++"y lost.", (gulong) (seconds / 60)), seconds / 60);
++#line 108 "ease-close-confirm-dialog.vala"
++ return result;
++#line 199 "ease-close-confirm-dialog.c"
++ }
++#line 110 "ease-close-confirm-dialog.vala"
++ if (seconds < 7200) {
++#line 203 "ease-close-confirm-dialog.c"
++ gint minutes;
++#line 112 "ease-close-confirm-dialog.vala"
++ minutes = (seconds - 3600) / 60;
++#line 113 "ease-close-confirm-dialog.vala"
++ if (minutes < 5) {
++#line 209 "ease-close-confirm-dialog.c"
++ result = g_strdup (_ ("If you don't save, changes from the last hour will be permanently lost" \
++"."));
++#line 115 "ease-close-confirm-dialog.vala"
++ return result;
++#line 213 "ease-close-confirm-dialog.c"
++ }
++ result = g_strdup_printf (ngettext ("If you don't save, changes from the last hour and %i minute will be pe" \
++"rmanently lost.", "If you don't save, changes from the last hour and %i minutes will be p" \
++"ermanently lost.", (gulong) minutes), minutes);
++#line 117 "ease-close-confirm-dialog.vala"
++ return result;
++#line 218 "ease-close-confirm-dialog.c"
++ }
++#line 120 "ease-close-confirm-dialog.vala"
++ hours = seconds / 3600;
++#line 222 "ease-close-confirm-dialog.c"
++ result = g_strdup_printf (ngettext ("If you don't save, changes from the last %i hour will be permanently l" \
++"ost.", "If you don't save, changes from the last %i hours will be permanently " \
++"lost.", (gulong) hours), hours);
++#line 121 "ease-close-confirm-dialog.vala"
++ return result;
++#line 226 "ease-close-confirm-dialog.c"
++}
++
++
++#line 130 "ease-close-confirm-dialog.vala"
++static char* ease_close_confirm_dialog_top_label_text (const char* filename) {
++#line 232 "ease-close-confirm-dialog.c"
++ char* result = NULL;
++#line 130 "ease-close-confirm-dialog.vala"
++ g_return_val_if_fail (filename != NULL, NULL);
++#line 236 "ease-close-confirm-dialog.c"
++ result = g_strdup_printf (_ ("Save changes to \"%s\" before closing?"), filename);
++#line 132 "ease-close-confirm-dialog.vala"
++ return result;
++#line 240 "ease-close-confirm-dialog.c"
++}
++
++
++static void ease_close_confirm_dialog_class_init (EaseCloseConfirmDialogClass * klass) {
++ ease_close_confirm_dialog_parent_class = g_type_class_peek_parent (klass);
++}
++
++
++static void ease_close_confirm_dialog_instance_init (EaseCloseConfirmDialog * self) {
++}
++
++
++GType ease_close_confirm_dialog_get_type (void) {
++ static volatile gsize ease_close_confirm_dialog_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_close_confirm_dialog_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseCloseConfirmDialogClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_close_confirm_dialog_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseCloseConfirmDialog), 0, (GInstanceInitFunc) ease_close_confirm_dialog_instance_init, NULL };
++ GType ease_close_confirm_dialog_type_id;
++ ease_close_confirm_dialog_type_id = g_type_register_static (GTK_TYPE_DIALOG, "EaseCloseConfirmDialog", &g_define_type_info, 0);
++ g_once_init_leave (&ease_close_confirm_dialog_type_id__volatile, ease_close_confirm_dialog_type_id);
++ }
++ return ease_close_confirm_dialog_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-clutter-iterables.c
index 0000000,0000000..ab255ab
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-clutter-iterables.c
@@@ -1,0 -1,0 +1,496 @@@
++/* ease-clutter-iterables.c generated by valac, the Vala compiler
++ * generated from ease-clutter-iterables.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <clutter/clutter.h>
++#include <gobject/gvaluecollector.h>
++
++
++#define EASE_TYPE_CLUTTER_ITERABLE_CONTAINER (ease_clutter_iterable_container_get_type ())
++#define EASE_CLUTTER_ITERABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_CLUTTER_ITERABLE_CONTAINER, EaseClutterIterableContainer))
++#define EASE_IS_CLUTTER_ITERABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_CLUTTER_ITERABLE_CONTAINER))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_CLUTTER_ITERABLE_CONTAINER, EaseClutterIterableContainerIface))
++
++typedef struct _EaseClutterIterableContainer EaseClutterIterableContainer;
++typedef struct _EaseClutterIterableContainerIface EaseClutterIterableContainerIface;
++
++#define EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR (ease_clutter_iterable_container_iterator_get_type ())
++#define EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR, EaseClutterIterableContainerIterator))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR, EaseClutterIterableContainerIteratorClass))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR, EaseClutterIterableContainerIteratorClass))
++
++typedef struct _EaseClutterIterableContainerIterator EaseClutterIterableContainerIterator;
++typedef struct _EaseClutterIterableContainerIteratorClass EaseClutterIterableContainerIteratorClass;
++typedef struct _EaseClutterIterableContainerIteratorPrivate EaseClutterIterableContainerIteratorPrivate;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++typedef struct _EaseClutterIterableContainerParamSpecIterator EaseClutterIterableContainerParamSpecIterator;
++
++#define EASE_TYPE_CLUTTER_ITERABLE_GROUP (ease_clutter_iterable_group_get_type ())
++#define EASE_CLUTTER_ITERABLE_GROUP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_CLUTTER_ITERABLE_GROUP, EaseClutterIterableGroup))
++#define EASE_CLUTTER_ITERABLE_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_CLUTTER_ITERABLE_GROUP, EaseClutterIterableGroupClass))
++#define EASE_IS_CLUTTER_ITERABLE_GROUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_CLUTTER_ITERABLE_GROUP))
++#define EASE_IS_CLUTTER_ITERABLE_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_CLUTTER_ITERABLE_GROUP))
++#define EASE_CLUTTER_ITERABLE_GROUP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_CLUTTER_ITERABLE_GROUP, EaseClutterIterableGroupClass))
++
++typedef struct _EaseClutterIterableGroup EaseClutterIterableGroup;
++typedef struct _EaseClutterIterableGroupClass EaseClutterIterableGroupClass;
++typedef struct _EaseClutterIterableGroupPrivate EaseClutterIterableGroupPrivate;
++
++#define EASE_TYPE_CLUTTER_ITERABLE_STAGE (ease_clutter_iterable_stage_get_type ())
++#define EASE_CLUTTER_ITERABLE_STAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_CLUTTER_ITERABLE_STAGE, EaseClutterIterableStage))
++#define EASE_CLUTTER_ITERABLE_STAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_CLUTTER_ITERABLE_STAGE, EaseClutterIterableStageClass))
++#define EASE_IS_CLUTTER_ITERABLE_STAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_CLUTTER_ITERABLE_STAGE))
++#define EASE_IS_CLUTTER_ITERABLE_STAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_CLUTTER_ITERABLE_STAGE))
++#define EASE_CLUTTER_ITERABLE_STAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_CLUTTER_ITERABLE_STAGE, EaseClutterIterableStageClass))
++
++typedef struct _EaseClutterIterableStage EaseClutterIterableStage;
++typedef struct _EaseClutterIterableStageClass EaseClutterIterableStageClass;
++typedef struct _EaseClutterIterableStagePrivate EaseClutterIterableStagePrivate;
++
++struct _EaseClutterIterableContainerIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseClutterIterableContainerIterator {
++ GTypeInstance parent_instance;
++ volatile int ref_count;
++ EaseClutterIterableContainerIteratorPrivate * priv;
++};
++
++struct _EaseClutterIterableContainerIteratorClass {
++ GTypeClass parent_class;
++ void (*finalize) (EaseClutterIterableContainerIterator *self);
++};
++
++struct _EaseClutterIterableContainerIteratorPrivate {
++ GList* itr;
++};
++
++struct _EaseClutterIterableContainerParamSpecIterator {
++ GParamSpec parent_instance;
++};
++
++struct _EaseClutterIterableGroup {
++ ClutterGroup parent_instance;
++ EaseClutterIterableGroupPrivate * priv;
++};
++
++struct _EaseClutterIterableGroupClass {
++ ClutterGroupClass parent_class;
++};
++
++struct _EaseClutterIterableStage {
++ ClutterStage parent_instance;
++ EaseClutterIterableStagePrivate * priv;
++};
++
++struct _EaseClutterIterableStageClass {
++ ClutterStageClass parent_class;
++};
++
++
++static gpointer ease_clutter_iterable_container_iterator_parent_class = NULL;
++static gpointer ease_clutter_iterable_group_parent_class = NULL;
++static EaseClutterIterableContainerIface* ease_clutter_iterable_group_ease_clutter_iterable_container_parent_iface = NULL;
++static gpointer ease_clutter_iterable_stage_parent_class = NULL;
++static EaseClutterIterableContainerIface* ease_clutter_iterable_stage_ease_clutter_iterable_container_parent_iface = NULL;
++
++GType ease_clutter_iterable_container_get_type (void) G_GNUC_CONST;
++EaseClutterIterableContainerIterator* ease_clutter_iterable_container_iterator_new (EaseClutterIterableContainer* _self_);
++EaseClutterIterableContainerIterator* ease_clutter_iterable_container_iterator_construct (GType object_type, EaseClutterIterableContainer* _self_);
++gpointer ease_clutter_iterable_container_iterator_ref (gpointer instance);
++void ease_clutter_iterable_container_iterator_unref (gpointer instance);
++GParamSpec* ease_clutter_iterable_container_param_spec_iterator (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
++void ease_clutter_iterable_container_value_set_iterator (GValue* value, gpointer v_object);
++void ease_clutter_iterable_container_value_take_iterator (GValue* value, gpointer v_object);
++gpointer ease_clutter_iterable_container_value_get_iterator (const GValue* value);
++GType ease_clutter_iterable_container_iterator_get_type (void) G_GNUC_CONST;
++EaseClutterIterableContainerIterator* ease_clutter_iterable_container_iterator (EaseClutterIterableContainer* self);
++#define EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR, EaseClutterIterableContainerIteratorPrivate))
++enum {
++ EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR_DUMMY_PROPERTY
++};
++gboolean ease_clutter_iterable_container_iterator_next (EaseClutterIterableContainerIterator* self);
++ClutterActor* ease_clutter_iterable_container_iterator_get (EaseClutterIterableContainerIterator* self);
++static void ease_clutter_iterable_container_iterator_finalize (EaseClutterIterableContainerIterator* obj);
++GType ease_clutter_iterable_group_get_type (void) G_GNUC_CONST;
++enum {
++ EASE_CLUTTER_ITERABLE_GROUP_DUMMY_PROPERTY
++};
++EaseClutterIterableGroup* ease_clutter_iterable_group_new (void);
++EaseClutterIterableGroup* ease_clutter_iterable_group_construct (GType object_type);
++GType ease_clutter_iterable_stage_get_type (void) G_GNUC_CONST;
++enum {
++ EASE_CLUTTER_ITERABLE_STAGE_DUMMY_PROPERTY
++};
++EaseClutterIterableStage* ease_clutter_iterable_stage_new (void);
++EaseClutterIterableStage* ease_clutter_iterable_stage_construct (GType object_type);
++
++
++
++#line 23 "ease-clutter-iterables.vala"
++EaseClutterIterableContainerIterator* ease_clutter_iterable_container_iterator (EaseClutterIterableContainer* self) {
++#line 154 "ease-clutter-iterables.c"
++ EaseClutterIterableContainerIterator* result = NULL;
++ result = ease_clutter_iterable_container_iterator_new (self);
++#line 25 "ease-clutter-iterables.vala"
++ return result;
++#line 159 "ease-clutter-iterables.c"
++}
++
++
++#line 32 "ease-clutter-iterables.vala"
++EaseClutterIterableContainerIterator* ease_clutter_iterable_container_iterator_construct (GType object_type, EaseClutterIterableContainer* _self_) {
++#line 165 "ease-clutter-iterables.c"
++ EaseClutterIterableContainerIterator* self;
++#line 32 "ease-clutter-iterables.vala"
++ g_return_val_if_fail (_self_ != NULL, NULL);
++#line 169 "ease-clutter-iterables.c"
++ self = (EaseClutterIterableContainerIterator*) g_type_create_instance (object_type);
++#line 34 "ease-clutter-iterables.vala"
++ self->priv->itr = clutter_container_get_children ((ClutterContainer*) _self_);
++#line 173 "ease-clutter-iterables.c"
++ return self;
++}
++
++
++#line 32 "ease-clutter-iterables.vala"
++EaseClutterIterableContainerIterator* ease_clutter_iterable_container_iterator_new (EaseClutterIterableContainer* _self_) {
++#line 32 "ease-clutter-iterables.vala"
++ return ease_clutter_iterable_container_iterator_construct (EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR, _self_);
++#line 182 "ease-clutter-iterables.c"
++}
++
++
++#line 37 "ease-clutter-iterables.vala"
++gboolean ease_clutter_iterable_container_iterator_next (EaseClutterIterableContainerIterator* self) {
++#line 188 "ease-clutter-iterables.c"
++ gboolean result = FALSE;
++#line 37 "ease-clutter-iterables.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 192 "ease-clutter-iterables.c"
++ result = self->priv->itr != NULL;
++#line 39 "ease-clutter-iterables.vala"
++ return result;
++#line 196 "ease-clutter-iterables.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 42 "ease-clutter-iterables.vala"
++ClutterActor* ease_clutter_iterable_container_iterator_get (EaseClutterIterableContainerIterator* self) {
++#line 207 "ease-clutter-iterables.c"
++ ClutterActor* result = NULL;
++ ClutterActor* actor;
++#line 42 "ease-clutter-iterables.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 44 "ease-clutter-iterables.vala"
++ actor = _g_object_ref0 (CLUTTER_ACTOR ((ClutterActor*) self->priv->itr->data));
++#line 45 "ease-clutter-iterables.vala"
++ self->priv->itr = self->priv->itr->next;
++#line 216 "ease-clutter-iterables.c"
++ result = actor;
++#line 46 "ease-clutter-iterables.vala"
++ return result;
++#line 220 "ease-clutter-iterables.c"
++}
++
++
++static void ease_clutter_iterable_container_value_iterator_init (GValue* value) {
++ value->data[0].v_pointer = NULL;
++}
++
++
++static void ease_clutter_iterable_container_value_iterator_free_value (GValue* value) {
++ if (value->data[0].v_pointer) {
++ ease_clutter_iterable_container_iterator_unref (value->data[0].v_pointer);
++ }
++}
++
++
++static void ease_clutter_iterable_container_value_iterator_copy_value (const GValue* src_value, GValue* dest_value) {
++ if (src_value->data[0].v_pointer) {
++ dest_value->data[0].v_pointer = ease_clutter_iterable_container_iterator_ref (src_value->data[0].v_pointer);
++ } else {
++ dest_value->data[0].v_pointer = NULL;
++ }
++}
++
++
++static gpointer ease_clutter_iterable_container_value_iterator_peek_pointer (const GValue* value) {
++ return value->data[0].v_pointer;
++}
++
++
++static gchar* ease_clutter_iterable_container_value_iterator_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
++ if (collect_values[0].v_pointer) {
++ EaseClutterIterableContainerIterator* object;
++ object = collect_values[0].v_pointer;
++ if (object->parent_instance.g_class == NULL) {
++ return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
++ } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
++ return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
++ }
++ value->data[0].v_pointer = ease_clutter_iterable_container_iterator_ref (object);
++ } else {
++ value->data[0].v_pointer = NULL;
++ }
++ return NULL;
++}
++
++
++static gchar* ease_clutter_iterable_container_value_iterator_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
++ EaseClutterIterableContainerIterator** object_p;
++ object_p = collect_values[0].v_pointer;
++ if (!object_p) {
++ return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
++ }
++ if (!value->data[0].v_pointer) {
++ *object_p = NULL;
++ } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
++ *object_p = value->data[0].v_pointer;
++ } else {
++ *object_p = ease_clutter_iterable_container_iterator_ref (value->data[0].v_pointer);
++ }
++ return NULL;
++}
++
++
++GParamSpec* ease_clutter_iterable_container_param_spec_iterator (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
++ EaseClutterIterableContainerParamSpecIterator* spec;
++ g_return_val_if_fail (g_type_is_a (object_type, EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR), NULL);
++ spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
++ G_PARAM_SPEC (spec)->value_type = object_type;
++ return G_PARAM_SPEC (spec);
++}
++
++
++gpointer ease_clutter_iterable_container_value_get_iterator (const GValue* value) {
++ g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR), NULL);
++ return value->data[0].v_pointer;
++}
++
++
++void ease_clutter_iterable_container_value_set_iterator (GValue* value, gpointer v_object) {
++ EaseClutterIterableContainerIterator* old;
++ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR));
++ old = value->data[0].v_pointer;
++ if (v_object) {
++ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR));
++ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
++ value->data[0].v_pointer = v_object;
++ ease_clutter_iterable_container_iterator_ref (value->data[0].v_pointer);
++ } else {
++ value->data[0].v_pointer = NULL;
++ }
++ if (old) {
++ ease_clutter_iterable_container_iterator_unref (old);
++ }
++}
++
++
++void ease_clutter_iterable_container_value_take_iterator (GValue* value, gpointer v_object) {
++ EaseClutterIterableContainerIterator* old;
++ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR));
++ old = value->data[0].v_pointer;
++ if (v_object) {
++ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR));
++ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
++ value->data[0].v_pointer = v_object;
++ } else {
++ value->data[0].v_pointer = NULL;
++ }
++ if (old) {
++ ease_clutter_iterable_container_iterator_unref (old);
++ }
++}
++
++
++static void ease_clutter_iterable_container_iterator_class_init (EaseClutterIterableContainerIteratorClass * klass) {
++ ease_clutter_iterable_container_iterator_parent_class = g_type_class_peek_parent (klass);
++ EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR_CLASS (klass)->finalize = ease_clutter_iterable_container_iterator_finalize;
++ g_type_class_add_private (klass, sizeof (EaseClutterIterableContainerIteratorPrivate));
++}
++
++
++static void ease_clutter_iterable_container_iterator_instance_init (EaseClutterIterableContainerIterator * self) {
++ self->priv = EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR_GET_PRIVATE (self);
++ self->ref_count = 1;
++}
++
++
++static void ease_clutter_iterable_container_iterator_finalize (EaseClutterIterableContainerIterator* obj) {
++ EaseClutterIterableContainerIterator * self;
++ self = EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR (obj);
++}
++
++
++GType ease_clutter_iterable_container_iterator_get_type (void) {
++ static volatile gsize ease_clutter_iterable_container_iterator_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_clutter_iterable_container_iterator_type_id__volatile)) {
++ static const GTypeValueTable g_define_type_value_table = { ease_clutter_iterable_container_value_iterator_init, ease_clutter_iterable_container_value_iterator_free_value, ease_clutter_iterable_container_value_iterator_copy_value, ease_clutter_iterable_container_value_iterator_peek_pointer, "p", ease_clutter_iterable_container_value_iterator_collect_value, "p", ease_clutter_iterable_container_value_iterator_lcopy_value };
++ static const GTypeInfo g_define_type_info = { sizeof (EaseClutterIterableContainerIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_clutter_iterable_container_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseClutterIterableContainerIterator), 0, (GInstanceInitFunc) ease_clutter_iterable_container_iterator_instance_init, &g_define_type_value_table };
++ static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
++ GType ease_clutter_iterable_container_iterator_type_id;
++ ease_clutter_iterable_container_iterator_type_id = g_type_register_fundamental (g_type_fundamental_next (), "EaseClutterIterableContainerIterator", &g_define_type_info, &g_define_type_fundamental_info, 0);
++ g_once_init_leave (&ease_clutter_iterable_container_iterator_type_id__volatile, ease_clutter_iterable_container_iterator_type_id);
++ }
++ return ease_clutter_iterable_container_iterator_type_id__volatile;
++}
++
++
++gpointer ease_clutter_iterable_container_iterator_ref (gpointer instance) {
++ EaseClutterIterableContainerIterator* self;
++ self = instance;
++ g_atomic_int_inc (&self->ref_count);
++ return instance;
++}
++
++
++void ease_clutter_iterable_container_iterator_unref (gpointer instance) {
++ EaseClutterIterableContainerIterator* self;
++ self = instance;
++ if (g_atomic_int_dec_and_test (&self->ref_count)) {
++ EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR_GET_CLASS (self)->finalize (self);
++ g_type_free_instance ((GTypeInstance *) self);
++ }
++}
++
++
++static void ease_clutter_iterable_container_base_init (EaseClutterIterableContainerIface * iface) {
++ static gboolean initialized = FALSE;
++ if (!initialized) {
++ initialized = TRUE;
++ }
++}
++
++
++GType ease_clutter_iterable_container_get_type (void) {
++ static volatile gsize ease_clutter_iterable_container_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_clutter_iterable_container_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseClutterIterableContainerIface), (GBaseInitFunc) ease_clutter_iterable_container_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
++ GType ease_clutter_iterable_container_type_id;
++ ease_clutter_iterable_container_type_id = g_type_register_static (G_TYPE_INTERFACE, "EaseClutterIterableContainer", &g_define_type_info, 0);
++ g_type_interface_add_prerequisite (ease_clutter_iterable_container_type_id, CLUTTER_TYPE_CONTAINER);
++ g_once_init_leave (&ease_clutter_iterable_container_type_id__volatile, ease_clutter_iterable_container_type_id);
++ }
++ return ease_clutter_iterable_container_type_id__volatile;
++}
++
++
++#line 54 "ease-clutter-iterables.vala"
++EaseClutterIterableGroup* ease_clutter_iterable_group_construct (GType object_type) {
++#line 408 "ease-clutter-iterables.c"
++ EaseClutterIterableGroup * self;
++ self = g_object_newv (object_type, 0, NULL);
++ return self;
++}
++
++
++#line 54 "ease-clutter-iterables.vala"
++EaseClutterIterableGroup* ease_clutter_iterable_group_new (void) {
++#line 54 "ease-clutter-iterables.vala"
++ return ease_clutter_iterable_group_construct (EASE_TYPE_CLUTTER_ITERABLE_GROUP);
++#line 419 "ease-clutter-iterables.c"
++}
++
++
++static void ease_clutter_iterable_group_class_init (EaseClutterIterableGroupClass * klass) {
++ ease_clutter_iterable_group_parent_class = g_type_class_peek_parent (klass);
++}
++
++
++static void ease_clutter_iterable_group_ease_clutter_iterable_container_interface_init (EaseClutterIterableContainerIface * iface) {
++ ease_clutter_iterable_group_ease_clutter_iterable_container_parent_iface = g_type_interface_peek_parent (iface);
++}
++
++
++static void ease_clutter_iterable_group_instance_init (EaseClutterIterableGroup * self) {
++}
++
++
++GType ease_clutter_iterable_group_get_type (void) {
++ static volatile gsize ease_clutter_iterable_group_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_clutter_iterable_group_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseClutterIterableGroupClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_clutter_iterable_group_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseClutterIterableGroup), 0, (GInstanceInitFunc) ease_clutter_iterable_group_instance_init, NULL };
++ static const GInterfaceInfo ease_clutter_iterable_container_info = { (GInterfaceInitFunc) ease_clutter_iterable_group_ease_clutter_iterable_container_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
++ GType ease_clutter_iterable_group_type_id;
++ ease_clutter_iterable_group_type_id = g_type_register_static (CLUTTER_TYPE_GROUP, "EaseClutterIterableGroup", &g_define_type_info, 0);
++ g_type_add_interface_static (ease_clutter_iterable_group_type_id, EASE_TYPE_CLUTTER_ITERABLE_CONTAINER, &ease_clutter_iterable_container_info);
++ g_once_init_leave (&ease_clutter_iterable_group_type_id__volatile, ease_clutter_iterable_group_type_id);
++ }
++ return ease_clutter_iterable_group_type_id__volatile;
++}
++
++
++#line 61 "ease-clutter-iterables.vala"
++EaseClutterIterableStage* ease_clutter_iterable_stage_construct (GType object_type) {
++#line 453 "ease-clutter-iterables.c"
++ EaseClutterIterableStage * self;
++ self = g_object_newv (object_type, 0, NULL);
++ return self;
++}
++
++
++#line 61 "ease-clutter-iterables.vala"
++EaseClutterIterableStage* ease_clutter_iterable_stage_new (void) {
++#line 61 "ease-clutter-iterables.vala"
++ return ease_clutter_iterable_stage_construct (EASE_TYPE_CLUTTER_ITERABLE_STAGE);
++#line 464 "ease-clutter-iterables.c"
++}
++
++
++static void ease_clutter_iterable_stage_class_init (EaseClutterIterableStageClass * klass) {
++ ease_clutter_iterable_stage_parent_class = g_type_class_peek_parent (klass);
++}
++
++
++static void ease_clutter_iterable_stage_ease_clutter_iterable_container_interface_init (EaseClutterIterableContainerIface * iface) {
++ ease_clutter_iterable_stage_ease_clutter_iterable_container_parent_iface = g_type_interface_peek_parent (iface);
++}
++
++
++static void ease_clutter_iterable_stage_instance_init (EaseClutterIterableStage * self) {
++}
++
++
++GType ease_clutter_iterable_stage_get_type (void) {
++ static volatile gsize ease_clutter_iterable_stage_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_clutter_iterable_stage_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseClutterIterableStageClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_clutter_iterable_stage_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseClutterIterableStage), 0, (GInstanceInitFunc) ease_clutter_iterable_stage_instance_init, NULL };
++ static const GInterfaceInfo ease_clutter_iterable_container_info = { (GInterfaceInitFunc) ease_clutter_iterable_stage_ease_clutter_iterable_container_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
++ GType ease_clutter_iterable_stage_type_id;
++ ease_clutter_iterable_stage_type_id = g_type_register_static (CLUTTER_TYPE_STAGE, "EaseClutterIterableStage", &g_define_type_info, 0);
++ g_type_add_interface_static (ease_clutter_iterable_stage_type_id, EASE_TYPE_CLUTTER_ITERABLE_CONTAINER, &ease_clutter_iterable_container_info);
++ g_once_init_leave (&ease_clutter_iterable_stage_type_id__volatile, ease_clutter_iterable_stage_type_id);
++ }
++ return ease_clutter_iterable_stage_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-color.c
index 0000000,0000000..45d4401
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-color.c
@@@ -1,0 -1,0 +1,815 @@@
++/* ease-color.c generated by valac, the Vala compiler
++ * generated from ease-color.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <float.h>
++#include <math.h>
++#include <stdlib.h>
++#include <string.h>
++#include <clutter/clutter.h>
++#include <gdk/gdk.h>
++#include <cairo.h>
++
++
++#define EASE_TYPE_COLOR (ease_color_get_type ())
++#define EASE_COLOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_COLOR, EaseColor))
++#define EASE_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_COLOR, EaseColorClass))
++#define EASE_IS_COLOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_COLOR))
++#define EASE_IS_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_COLOR))
++#define EASE_COLOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_COLOR, EaseColorClass))
++
++typedef struct _EaseColor EaseColor;
++typedef struct _EaseColorClass EaseColorClass;
++typedef struct _EaseColorPrivate EaseColorPrivate;
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++
++#define EASE_TYPE_UNDO_ACTION (ease_undo_action_get_type ())
++#define EASE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoAction))
++#define EASE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++#define EASE_IS_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ACTION))
++#define EASE_IS_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ACTION))
++#define EASE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++
++typedef struct _EaseUndoAction EaseUndoAction;
++typedef struct _EaseUndoActionClass EaseUndoActionClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++struct _EaseColor {
++ GObject parent_instance;
++ EaseColorPrivate * priv;
++};
++
++struct _EaseColorClass {
++ GObjectClass parent_class;
++};
++
++struct _EaseColorPrivate {
++ double red_priv;
++ double green_priv;
++ double blue_priv;
++ double alpha_priv;
++ gboolean silence_changed;
++};
++
++
++static gpointer ease_color_parent_class = NULL;
++
++GType ease_color_get_type (void) G_GNUC_CONST;
++#define EASE_COLOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_COLOR, EaseColorPrivate))
++enum {
++ EASE_COLOR_DUMMY_PROPERTY,
++ EASE_COLOR_RED,
++ EASE_COLOR_GREEN,
++ EASE_COLOR_BLUE,
++ EASE_COLOR_ALPHA,
++ EASE_COLOR_CLUTTER,
++ EASE_COLOR_GDK
++};
++#define EASE_COLOR_STR "%f%s %f%s %f%s %f"
++#define EASE_COLOR_SPLIT ","
++EaseColor* ease_color_new_rgba (double r, double g, double b, double a);
++EaseColor* ease_color_construct_rgba (GType object_type, double r, double g, double b, double a);
++EaseColor* ease_color_new_rgb (double r, double g, double b);
++EaseColor* ease_color_construct_rgb (GType object_type, double r, double g, double b);
++void ease_color_set_red (EaseColor* self, double value);
++void ease_color_set_green (EaseColor* self, double value);
++void ease_color_set_blue (EaseColor* self, double value);
++void ease_color_set_alpha (EaseColor* self, double value);
++void ease_color_set_clutter (EaseColor* self, ClutterColor* value);
++EaseColor* ease_color_new_from_clutter (ClutterColor* color);
++EaseColor* ease_color_construct_from_clutter (GType object_type, ClutterColor* color);
++void ease_color_set_gdk (EaseColor* self, GdkColor* value);
++EaseColor* ease_color_new_from_gdk (GdkColor* color);
++EaseColor* ease_color_construct_from_gdk (GType object_type, GdkColor* color);
++EaseColor* ease_color_new_from_string (const char* str);
++EaseColor* ease_color_construct_from_string (GType object_type, const char* str);
++double ease_color_get_red (EaseColor* self);
++double ease_color_get_green (EaseColor* self);
++double ease_color_get_blue (EaseColor* self);
++double ease_color_get_alpha (EaseColor* self);
++char* ease_color_to_string (EaseColor* self);
++EaseColor* ease_color_copy (EaseColor* self);
++void ease_color_set_cairo (EaseColor* self, cairo_t* cr);
++EaseUndoAction* ease_undo_action_new (GObject* obj, const char* prop);
++EaseUndoAction* ease_undo_action_construct (GType object_type, GObject* obj, const char* prop);
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++GType ease_undo_action_get_type (void) G_GNUC_CONST;
++void ease_undo_action_add (EaseUndoAction* self, GObject* obj, const char* prop);
++EaseUndoAction* ease_color_undo_action (EaseColor* self);
++EaseColor* ease_color_new (void);
++EaseColor* ease_color_construct (GType object_type);
++EaseColor* ease_color_get_white (void);
++EaseColor* ease_color_get_black (void);
++void ease_color_get_clutter (EaseColor* self, ClutterColor* result);
++void ease_color_get_gdk (EaseColor* self, GdkColor* result);
++static void ease_color_finalize (GObject* obj);
++static void ease_color_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_color_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
++static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
++static gint _vala_array_length (gpointer array);
++
++
++
++#line 206 "ease-color.vala"
++EaseColor* ease_color_construct_rgb (GType object_type, double r, double g, double b) {
++#line 147 "ease-color.c"
++ EaseColor * self;
++#line 208 "ease-color.vala"
++ self = (EaseColor*) ease_color_construct_rgba (object_type, r, g, b, (double) 1);
++#line 151 "ease-color.c"
++ return self;
++}
++
++
++#line 206 "ease-color.vala"
++EaseColor* ease_color_new_rgb (double r, double g, double b) {
++#line 206 "ease-color.vala"
++ return ease_color_construct_rgb (EASE_TYPE_COLOR, r, g, b);
++#line 160 "ease-color.c"
++}
++
++
++#line 219 "ease-color.vala"
++EaseColor* ease_color_construct_rgba (GType object_type, double r, double g, double b, double a) {
++#line 166 "ease-color.c"
++ EaseColor * self;
++#line 219 "ease-color.vala"
++ self = (EaseColor*) g_object_new (object_type, NULL);
++#line 221 "ease-color.vala"
++ ease_color_set_red (self, r);
++#line 222 "ease-color.vala"
++ ease_color_set_green (self, g);
++#line 223 "ease-color.vala"
++ ease_color_set_blue (self, b);
++#line 224 "ease-color.vala"
++ ease_color_set_alpha (self, a);
++#line 178 "ease-color.c"
++ return self;
++}
++
++
++#line 219 "ease-color.vala"
++EaseColor* ease_color_new_rgba (double r, double g, double b, double a) {
++#line 219 "ease-color.vala"
++ return ease_color_construct_rgba (EASE_TYPE_COLOR, r, g, b, a);
++#line 187 "ease-color.c"
++}
++
++
++#line 232 "ease-color.vala"
++EaseColor* ease_color_construct_from_clutter (GType object_type, ClutterColor* color) {
++#line 193 "ease-color.c"
++ EaseColor * self;
++#line 232 "ease-color.vala"
++ self = (EaseColor*) g_object_new (object_type, NULL);
++#line 234 "ease-color.vala"
++ ease_color_set_clutter (self, color);
++#line 199 "ease-color.c"
++ return self;
++}
++
++
++#line 232 "ease-color.vala"
++EaseColor* ease_color_new_from_clutter (ClutterColor* color) {
++#line 232 "ease-color.vala"
++ return ease_color_construct_from_clutter (EASE_TYPE_COLOR, color);
++#line 208 "ease-color.c"
++}
++
++
++#line 242 "ease-color.vala"
++EaseColor* ease_color_construct_from_gdk (GType object_type, GdkColor* color) {
++#line 214 "ease-color.c"
++ EaseColor * self;
++#line 242 "ease-color.vala"
++ self = (EaseColor*) g_object_new (object_type, NULL);
++#line 244 "ease-color.vala"
++ ease_color_set_gdk (self, color);
++#line 220 "ease-color.c"
++ return self;
++}
++
++
++#line 242 "ease-color.vala"
++EaseColor* ease_color_new_from_gdk (GdkColor* color) {
++#line 242 "ease-color.vala"
++ return ease_color_construct_from_gdk (EASE_TYPE_COLOR, color);
++#line 229 "ease-color.c"
++}
++
++
++#line 1156 "glib-2.0.vapi"
++static char* string_replace (const char* self, const char* old, const char* replacement) {
++#line 235 "ease-color.c"
++ char* result = NULL;
++ GError * _inner_error_;
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (old != NULL, NULL);
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (replacement != NULL, NULL);
++#line 244 "ease-color.c"
++ _inner_error_ = NULL;
++ {
++ char* _tmp0_;
++ GRegex* _tmp1_;
++ GRegex* regex;
++ char* _tmp2_;
++#line 1158 "glib-2.0.vapi"
++ regex = (_tmp1_ = g_regex_new (_tmp0_ = g_regex_escape_string (old, -1), 0, 0, &_inner_error_), _g_free0 (_tmp0_), _tmp1_);
++#line 253 "ease-color.c"
++ if (_inner_error_ != NULL) {
++ if (_inner_error_->domain == G_REGEX_ERROR) {
++ goto __catch0_g_regex_error;
++ }
++ g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++#line 1159 "glib-2.0.vapi"
++ _tmp2_ = g_regex_replace_literal (regex, self, (gssize) (-1), 0, replacement, 0, &_inner_error_);
++#line 264 "ease-color.c"
++ if (_inner_error_ != NULL) {
++ _g_regex_unref0 (regex);
++ if (_inner_error_->domain == G_REGEX_ERROR) {
++ goto __catch0_g_regex_error;
++ }
++ _g_regex_unref0 (regex);
++ g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++ result = _tmp2_;
++ _g_regex_unref0 (regex);
++#line 1159 "glib-2.0.vapi"
++ return result;
++#line 279 "ease-color.c"
++ }
++ goto __finally0;
++ __catch0_g_regex_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 1161 "glib-2.0.vapi"
++ g_assert_not_reached ();
++#line 290 "ease-color.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally0:
++ if (_inner_error_ != NULL) {
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++}
++
++
++#line 252 "ease-color.vala"
++EaseColor* ease_color_construct_from_string (GType object_type, const char* str) {
++#line 305 "ease-color.c"
++ EaseColor * self;
++ char** _tmp3_;
++ gint _split_size_;
++ gint split_length1;
++ char** _tmp1_;
++ char* _tmp0_;
++ char** _tmp2_;
++ char** split;
++#line 252 "ease-color.vala"
++ g_return_val_if_fail (str != NULL, NULL);
++#line 252 "ease-color.vala"
++ self = (EaseColor*) g_object_new (object_type, NULL);
++#line 318 "ease-color.c"
++ split = (_tmp3_ = (_tmp2_ = _tmp1_ = g_strsplit (_tmp0_ = string_replace (str, " ", ""), EASE_COLOR_SPLIT, 0), _g_free0 (_tmp0_), _tmp2_), split_length1 = _vala_array_length (_tmp1_), _split_size_ = split_length1, _tmp3_);
++#line 255 "ease-color.vala"
++ ease_color_set_red (self, g_ascii_strtod (split[0], NULL));
++#line 256 "ease-color.vala"
++ ease_color_set_green (self, g_ascii_strtod (split[1], NULL));
++#line 257 "ease-color.vala"
++ ease_color_set_blue (self, g_ascii_strtod (split[2], NULL));
++#line 260 "ease-color.vala"
++ if (split_length1 > 3) {
++#line 260 "ease-color.vala"
++ ease_color_set_alpha (self, g_ascii_strtod (split[3], NULL));
++#line 330 "ease-color.c"
++ } else {
++#line 261 "ease-color.vala"
++ ease_color_set_alpha (self, (double) 1);
++#line 334 "ease-color.c"
++ }
++ split = (_vala_array_free (split, split_length1, (GDestroyNotify) g_free), NULL);
++ return self;
++}
++
++
++#line 252 "ease-color.vala"
++EaseColor* ease_color_new_from_string (const char* str) {
++#line 252 "ease-color.vala"
++ return ease_color_construct_from_string (EASE_TYPE_COLOR, str);
++#line 345 "ease-color.c"
++}
++
++
++#line 267 "ease-color.vala"
++char* ease_color_to_string (EaseColor* self) {
++#line 351 "ease-color.c"
++ char* result = NULL;
++#line 267 "ease-color.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 355 "ease-color.c"
++ result = g_strdup_printf (EASE_COLOR_STR, ease_color_get_red (self), EASE_COLOR_SPLIT, ease_color_get_green (self), EASE_COLOR_SPLIT, ease_color_get_blue (self), EASE_COLOR_SPLIT, ease_color_get_alpha (self));
++#line 269 "ease-color.vala"
++ return result;
++#line 359 "ease-color.c"
++}
++
++
++#line 275 "ease-color.vala"
++EaseColor* ease_color_copy (EaseColor* self) {
++#line 365 "ease-color.c"
++ EaseColor* result = NULL;
++#line 275 "ease-color.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 369 "ease-color.c"
++ result = ease_color_new_rgba (ease_color_get_red (self), ease_color_get_green (self), ease_color_get_blue (self), ease_color_get_alpha (self));
++#line 277 "ease-color.vala"
++ return result;
++#line 373 "ease-color.c"
++}
++
++
++#line 285 "ease-color.vala"
++void ease_color_set_cairo (EaseColor* self, cairo_t* cr) {
++#line 285 "ease-color.vala"
++ g_return_if_fail (self != NULL);
++#line 285 "ease-color.vala"
++ g_return_if_fail (cr != NULL);
++#line 287 "ease-color.vala"
++ cairo_set_source_rgba (cr, ease_color_get_red (self), ease_color_get_green (self), ease_color_get_blue (self), ease_color_get_alpha (self));
++#line 385 "ease-color.c"
++}
++
++
++#line 294 "ease-color.vala"
++EaseUndoAction* ease_color_undo_action (EaseColor* self) {
++#line 391 "ease-color.c"
++ EaseUndoAction* result = NULL;
++ EaseUndoAction* action;
++#line 294 "ease-color.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 296 "ease-color.vala"
++ action = ease_undo_action_new ((GObject*) self, "red");
++#line 297 "ease-color.vala"
++ ease_undo_action_add (action, (GObject*) self, "green");
++#line 298 "ease-color.vala"
++ ease_undo_action_add (action, (GObject*) self, "blue");
++#line 299 "ease-color.vala"
++ ease_undo_action_add (action, (GObject*) self, "alpha");
++#line 404 "ease-color.c"
++ result = action;
++#line 301 "ease-color.vala"
++ return result;
++#line 408 "ease-color.c"
++}
++
++
++#line 21 "ease-color.vala"
++EaseColor* ease_color_construct (GType object_type) {
++#line 414 "ease-color.c"
++ EaseColor * self;
++#line 21 "ease-color.vala"
++ self = (EaseColor*) g_object_new (object_type, NULL);
++#line 418 "ease-color.c"
++ return self;
++}
++
++
++#line 21 "ease-color.vala"
++EaseColor* ease_color_new (void) {
++#line 21 "ease-color.vala"
++ return ease_color_construct (EASE_TYPE_COLOR);
++#line 427 "ease-color.c"
++}
++
++
++EaseColor* ease_color_get_white (void) {
++ EaseColor* result;
++ result = ease_color_new_rgb ((double) 1, (double) 1, (double) 1);
++#line 38 "ease-color.vala"
++ return result;
++#line 436 "ease-color.c"
++}
++
++
++EaseColor* ease_color_get_black (void) {
++ EaseColor* result;
++ result = ease_color_new_rgb ((double) 0, (double) 0, (double) 0);
++#line 46 "ease-color.vala"
++ return result;
++#line 445 "ease-color.c"
++}
++
++
++double ease_color_get_red (EaseColor* self) {
++ double result;
++ g_return_val_if_fail (self != NULL, 0.0);
++ result = self->priv->red_priv;
++#line 54 "ease-color.vala"
++ return result;
++#line 455 "ease-color.c"
++}
++
++
++void ease_color_set_red (EaseColor* self, double value) {
++ g_return_if_fail (self != NULL);
++#line 57 "ease-color.vala"
++ if (value < 0) {
++#line 59 "ease-color.vala"
++ g_warning ("ease-color.vala:59: red value must be >= 0, %f is not", value);
++#line 60 "ease-color.vala"
++ self->priv->red_priv = (double) 0;
++#line 467 "ease-color.c"
++ } else {
++#line 62 "ease-color.vala"
++ if (value > 1) {
++#line 64 "ease-color.vala"
++ g_warning ("ease-color.vala:64: red value must be <= 0, %f is not", value);
++#line 65 "ease-color.vala"
++ self->priv->red_priv = (double) 1;
++#line 475 "ease-color.c"
++ } else {
++#line 67 "ease-color.vala"
++ self->priv->red_priv = value;
++#line 479 "ease-color.c"
++ }
++ }
++#line 68 "ease-color.vala"
++ if (!self->priv->silence_changed) {
++#line 68 "ease-color.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 486 "ease-color.c"
++ }
++ g_object_notify ((GObject *) self, "red");
++}
++
++
++double ease_color_get_green (EaseColor* self) {
++ double result;
++ g_return_val_if_fail (self != NULL, 0.0);
++ result = self->priv->green_priv;
++#line 78 "ease-color.vala"
++ return result;
++#line 498 "ease-color.c"
++}
++
++
++void ease_color_set_green (EaseColor* self, double value) {
++ g_return_if_fail (self != NULL);
++#line 81 "ease-color.vala"
++ if (value < 0) {
++#line 83 "ease-color.vala"
++ g_warning ("ease-color.vala:83: green value must be >= 0, %f is not", value);
++#line 84 "ease-color.vala"
++ self->priv->green_priv = (double) 0;
++#line 510 "ease-color.c"
++ } else {
++#line 86 "ease-color.vala"
++ if (value > 1) {
++#line 88 "ease-color.vala"
++ g_warning ("ease-color.vala:88: green value must be <= 0, %f is not", value);
++#line 89 "ease-color.vala"
++ self->priv->green_priv = (double) 1;
++#line 518 "ease-color.c"
++ } else {
++#line 91 "ease-color.vala"
++ self->priv->green_priv = value;
++#line 522 "ease-color.c"
++ }
++ }
++#line 92 "ease-color.vala"
++ if (!self->priv->silence_changed) {
++#line 92 "ease-color.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 529 "ease-color.c"
++ }
++ g_object_notify ((GObject *) self, "green");
++}
++
++
++double ease_color_get_blue (EaseColor* self) {
++ double result;
++ g_return_val_if_fail (self != NULL, 0.0);
++ result = self->priv->blue_priv;
++#line 102 "ease-color.vala"
++ return result;
++#line 541 "ease-color.c"
++}
++
++
++void ease_color_set_blue (EaseColor* self, double value) {
++ g_return_if_fail (self != NULL);
++#line 105 "ease-color.vala"
++ if (value < 0) {
++#line 107 "ease-color.vala"
++ g_warning ("ease-color.vala:107: blue value must be >= 0, %f is not", value);
++#line 108 "ease-color.vala"
++ self->priv->blue_priv = (double) 0;
++#line 553 "ease-color.c"
++ } else {
++#line 110 "ease-color.vala"
++ if (value > 1) {
++#line 112 "ease-color.vala"
++ g_warning ("ease-color.vala:112: blue value must be <= 0, %f is not", value);
++#line 113 "ease-color.vala"
++ self->priv->blue_priv = (double) 1;
++#line 561 "ease-color.c"
++ } else {
++#line 115 "ease-color.vala"
++ self->priv->blue_priv = value;
++#line 565 "ease-color.c"
++ }
++ }
++#line 116 "ease-color.vala"
++ if (!self->priv->silence_changed) {
++#line 116 "ease-color.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 572 "ease-color.c"
++ }
++ g_object_notify ((GObject *) self, "blue");
++}
++
++
++double ease_color_get_alpha (EaseColor* self) {
++ double result;
++ g_return_val_if_fail (self != NULL, 0.0);
++ result = self->priv->alpha_priv;
++#line 126 "ease-color.vala"
++ return result;
++#line 584 "ease-color.c"
++}
++
++
++void ease_color_set_alpha (EaseColor* self, double value) {
++ g_return_if_fail (self != NULL);
++#line 129 "ease-color.vala"
++ if (value < 0) {
++#line 131 "ease-color.vala"
++ g_warning ("ease-color.vala:131: alpha value must be >= 0, %f is not", value);
++#line 132 "ease-color.vala"
++ self->priv->alpha_priv = (double) 0;
++#line 596 "ease-color.c"
++ } else {
++#line 134 "ease-color.vala"
++ if (value > 1) {
++#line 136 "ease-color.vala"
++ g_warning ("ease-color.vala:136: alpha value must be <= 0, %f is not", value);
++#line 137 "ease-color.vala"
++ self->priv->alpha_priv = (double) 1;
++#line 604 "ease-color.c"
++ } else {
++#line 139 "ease-color.vala"
++ self->priv->alpha_priv = value;
++#line 608 "ease-color.c"
++ }
++ }
++#line 140 "ease-color.vala"
++ if (!self->priv->silence_changed) {
++#line 140 "ease-color.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 615 "ease-color.c"
++ }
++ g_object_notify ((GObject *) self, "alpha");
++}
++
++
++void ease_color_get_clutter (EaseColor* self, ClutterColor* result) {
++ ClutterColor _tmp0_ = {0};
++ g_return_if_fail (self != NULL);
++ *result = (_tmp0_.red = (guchar) (255 * ease_color_get_red (self)), _tmp0_.green = (guchar) (255 * ease_color_get_green (self)), _tmp0_.blue = (guchar) (255 * ease_color_get_blue (self)), _tmp0_.alpha = (guchar) (255 * ease_color_get_alpha (self)), _tmp0_);
++#line 153 "ease-color.vala"
++ return;
++#line 627 "ease-color.c"
++}
++
++
++void ease_color_set_clutter (EaseColor* self, ClutterColor* value) {
++ g_return_if_fail (self != NULL);
++#line 160 "ease-color.vala"
++ self->priv->silence_changed = TRUE;
++#line 161 "ease-color.vala"
++ ease_color_set_red (self, (double) ((*value).red / 255.f));
++#line 162 "ease-color.vala"
++ ease_color_set_green (self, (double) ((*value).green / 255.f));
++#line 163 "ease-color.vala"
++ ease_color_set_blue (self, (double) ((*value).blue / 255.f));
++#line 164 "ease-color.vala"
++ ease_color_set_alpha (self, (double) ((*value).alpha / 255.f));
++#line 165 "ease-color.vala"
++ self->priv->silence_changed = FALSE;
++#line 166 "ease-color.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 647 "ease-color.c"
++ g_object_notify ((GObject *) self, "clutter");
++}
++
++
++void ease_color_get_gdk (EaseColor* self, GdkColor* result) {
++ GdkColor _tmp0_ = {0};
++ g_return_if_fail (self != NULL);
++ *result = (_tmp0_.pixel = (guint32) 0, _tmp0_.red = (guint16) (65535 * ease_color_get_red (self)), _tmp0_.green = (guint16) (65535 * ease_color_get_green (self)), _tmp0_.blue = (guint16) (65535 * ease_color_get_blue (self)), _tmp0_);
++#line 180 "ease-color.vala"
++ return;
++#line 658 "ease-color.c"
++}
++
++
++void ease_color_set_gdk (EaseColor* self, GdkColor* value) {
++ g_return_if_fail (self != NULL);
++#line 187 "ease-color.vala"
++ self->priv->silence_changed = TRUE;
++#line 188 "ease-color.vala"
++ ease_color_set_red (self, (double) ((*value).red / 65535.f));
++#line 189 "ease-color.vala"
++ ease_color_set_green (self, (double) ((*value).green / 65535.f));
++#line 190 "ease-color.vala"
++ ease_color_set_blue (self, (double) ((*value).blue / 65535.f));
++#line 191 "ease-color.vala"
++ ease_color_set_alpha (self, (double) 1);
++#line 192 "ease-color.vala"
++ self->priv->silence_changed = FALSE;
++#line 193 "ease-color.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 678 "ease-color.c"
++ g_object_notify ((GObject *) self, "gdk");
++}
++
++
++static void ease_color_class_init (EaseColorClass * klass) {
++ ease_color_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseColorPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_color_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_color_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_color_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_COLOR_RED, g_param_spec_double ("red", "red", "red", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_COLOR_GREEN, g_param_spec_double ("green", "green", "green", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_COLOR_BLUE, g_param_spec_double ("blue", "blue", "blue", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_COLOR_ALPHA, g_param_spec_double ("alpha", "alpha", "alpha", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_COLOR_CLUTTER, g_param_spec_boxed ("clutter", "clutter", "clutter", CLUTTER_TYPE_COLOR, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_COLOR_GDK, g_param_spec_boxed ("gdk", "gdk", "gdk", GDK_TYPE_COLOR, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_signal_new ("changed", EASE_TYPE_COLOR, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_COLOR);
++}
++
++
++static void ease_color_instance_init (EaseColor * self) {
++ self->priv = EASE_COLOR_GET_PRIVATE (self);
++}
++
++
++static void ease_color_finalize (GObject* obj) {
++ EaseColor * self;
++ self = EASE_COLOR (obj);
++ G_OBJECT_CLASS (ease_color_parent_class)->finalize (obj);
++}
++
++
++GType ease_color_get_type (void) {
++ static volatile gsize ease_color_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_color_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseColorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_color_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseColor), 0, (GInstanceInitFunc) ease_color_instance_init, NULL };
++ GType ease_color_type_id;
++ ease_color_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseColor", &g_define_type_info, 0);
++ g_once_init_leave (&ease_color_type_id__volatile, ease_color_type_id);
++ }
++ return ease_color_type_id__volatile;
++}
++
++
++static void ease_color_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseColor * self;
++ ClutterColor boxed0;
++ GdkColor boxed1;
++ self = EASE_COLOR (object);
++ switch (property_id) {
++ case EASE_COLOR_RED:
++ g_value_set_double (value, ease_color_get_red (self));
++ break;
++ case EASE_COLOR_GREEN:
++ g_value_set_double (value, ease_color_get_green (self));
++ break;
++ case EASE_COLOR_BLUE:
++ g_value_set_double (value, ease_color_get_blue (self));
++ break;
++ case EASE_COLOR_ALPHA:
++ g_value_set_double (value, ease_color_get_alpha (self));
++ break;
++ case EASE_COLOR_CLUTTER:
++ ease_color_get_clutter (self, &boxed0);
++ g_value_set_boxed (value, &boxed0);
++ break;
++ case EASE_COLOR_GDK:
++ ease_color_get_gdk (self, &boxed1);
++ g_value_set_boxed (value, &boxed1);
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_color_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseColor * self;
++ self = EASE_COLOR (object);
++ switch (property_id) {
++ case EASE_COLOR_RED:
++ ease_color_set_red (self, g_value_get_double (value));
++ break;
++ case EASE_COLOR_GREEN:
++ ease_color_set_green (self, g_value_get_double (value));
++ break;
++ case EASE_COLOR_BLUE:
++ ease_color_set_blue (self, g_value_get_double (value));
++ break;
++ case EASE_COLOR_ALPHA:
++ ease_color_set_alpha (self, g_value_get_double (value));
++ break;
++ case EASE_COLOR_CLUTTER:
++ ease_color_set_clutter (self, g_value_get_boxed (value));
++ break;
++ case EASE_COLOR_GDK:
++ ease_color_set_gdk (self, g_value_get_boxed (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
++ if ((array != NULL) && (destroy_func != NULL)) {
++ int 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, gint array_length, GDestroyNotify destroy_func) {
++ _vala_array_destroy (array, array_length, destroy_func);
++ g_free (array);
++}
++
++
++static gint _vala_array_length (gpointer array) {
++ int length;
++ length = 0;
++ if (array) {
++ while (((gpointer*) array)[length]) {
++ length++;
++ }
++ }
++ return length;
++}
++
++
++
++
diff --cc ease-core/ease-core-0.1.vapi
index 0000000,0000000..bbf21d2
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-core-0.1.vapi
@@@ -1,0 -1,0 +1,747 @@@
++/* ease-core-0.1.vapi generated by valac, do not modify. */
++
++[CCode (cprefix = "Ease", lower_case_cprefix = "ease_", gir_namespace = "EaseCore", gir_version = "0.1")]
++namespace Ease {
++ [CCode (cprefix = "EaseIterable", lower_case_cprefix = "ease_iterable_")]
++ namespace Iterable {
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ListStore : Gtk.ListStore, Ease.Iterable.TreeModel {
++ public ListStore (GLib.Type[] types);
++ public int size { get; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public interface TreeModel : Gtk.TreeModel {
++ [CCode (ref_function = "ease_iterable_tree_model_iterator_ref", unref_function = "ease_iterable_tree_model_iterator_unref", cheader_filename = "libease-core.h")]
++ public class Iterator {
++ public Iterator (Ease.Iterable.TreeModel self);
++ public Gtk.TreeIter @get ();
++ public bool next ();
++ }
++ public Ease.Iterable.TreeModel.Iterator iterator ();
++ }
++ }
++ [CCode (cprefix = "EaseTransformations", lower_case_cprefix = "ease_transformations_")]
++ namespace Transformations {
++ [CCode (cheader_filename = "libease-core.h")]
++ public static Gdk.Color clutter_color_to_gdk_color (Clutter.Color color);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static Clutter.Color gdk_color_to_clutter_color (Gdk.Color color);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class AboutDialog : Gtk.AboutDialog {
++ public AboutDialog ();
++ public static void show_about (Gtk.Widget sender);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public abstract class Actor : Clutter.Group {
++ protected Clutter.Actor contents;
++ public Ease.ActorContext context;
++ public weak Ease.Element element;
++ public bool is_background;
++ public Actor (Ease.Element e, Ease.ActorContext c);
++ public virtual void edit (Ease.EditorEmbed sender);
++ public virtual void end_edit (Ease.EditorEmbed sender);
++ public void reposition ();
++ public void resize (float w_change, float h_change, bool proportional);
++ public void translate (float x_change, float y_change);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class AnimatedZoomSlider : Ease.ZoomSlider, Clutter.Animatable {
++ public AnimatedZoomSlider (Gtk.Adjustment adjustment, int[] button_values);
++ protected override void change_zoom (double value);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class CloseConfirmDialog : Gtk.Dialog {
++ public CloseConfirmDialog (string filename, int seconds);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ClutterIterableGroup : Clutter.Group, Ease.ClutterIterableContainer {
++ public ClutterIterableGroup ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ClutterIterableStage : Clutter.Stage, Ease.ClutterIterableContainer {
++ public ClutterIterableStage ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Color : GLib.Object {
++ public Color ();
++ public Ease.Color copy ();
++ public Color.from_clutter (Clutter.Color color);
++ public Color.from_gdk (Gdk.Color color);
++ public Color.from_string (string str);
++ public Color.rgb (double r, double g, double b);
++ public Color.rgba (double r, double g, double b, double a);
++ public void set_cairo (Cairo.Context cr);
++ public string to_string ();
++ public Ease.UndoAction undo_action ();
++ public double alpha { get; set; }
++ public static Ease.Color black { owned get; }
++ public double blue { get; set; }
++ public Clutter.Color clutter { get; set; }
++ public Gdk.Color gdk { get; set; }
++ public double green { get; set; }
++ public double red { get; set; }
++ public static Ease.Color white { owned get; }
++ public signal void changed (Ease.Color self);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Document : GLib.Object, Ease.UndoSource {
++ public Ease.Iterable.ListStore slides;
++ public const int COL_PIXBUF;
++ public const int COL_SLIDE;
++ public const string DEFAULT_SLIDE;
++ public const string THEME_PATH;
++ public Document ();
++ public string add_media_file (string file) throws GLib.Error;
++ public void add_slide (int index, Ease.Slide s);
++ public void append_slide (Ease.Slide s);
++ public void cairo_render (Cairo.Surface surface) throws GLib.Error;
++ public void export_as_html (Gtk.Window window);
++ public void export_as_pdf (Gtk.Window win);
++ public void export_as_postscript (Gtk.Window win);
++ public Document.from_saved (string file_path) throws GLib.Error;
++ public Document.from_theme (Ease.Theme doc_theme, int w, int h) throws GLib.Error;
++ public Ease.Slide get_slide (int index);
++ public bool has_next_slide (Ease.Slide slide);
++ public int index_of (Ease.Slide slide);
++ public Ease.Slide remove_slide (Ease.Slide slide);
++ public Ease.Slide? slide_by_title (string title);
++ public void to_json () throws GLib.Error;
++ public float aspect { get; }
++ public string filename { get; set; }
++ public int height { get; set; }
++ public int length { get; }
++ public string path { get; set; }
++ public Ease.Theme theme { get; set; }
++ public int width { get; set; }
++ public signal void slide_added (Ease.Slide slide, int index);
++ public signal void slide_deleted (Ease.Slide slide, int index);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class EditorEmbed : Ease.ScrollableEmbed, Ease.UndoSource {
++ public Ease.SlideActor slide_actor;
++ public EditorEmbed (Ease.Document d, Ease.EditorWindow w);
++ public void connect_keys ();
++ public void disconnect_keys ();
++ public void on_ease_actor_added (Ease.Actor actor);
++ public void on_ease_actor_removed (Ease.Actor actor);
++ public void on_element_removed (Ease.Slide slide, Ease.Element element, int index);
++ public bool on_key_press_event (Gtk.Widget self, Gdk.EventKey event);
++ public void recreate_slide ();
++ public void reposition_group ();
++ public void select_element (Ease.Element e);
++ public void set_element_color (Clutter.Color color);
++ public void set_slide (Ease.Slide slide);
++ public Ease.Actor selected { get; set; }
++ public float zoom { get; set; }
++ public signal void element_deselected (Ease.Element? deselected);
++ public signal void element_selected (Ease.Element selected);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class EditorWindow : Gtk.Window {
++ public Ease.Document document;
++ public Ease.EditorEmbed embed;
++ public Ease.Slide slide;
++ public Ease.SlideButtonPanel slide_button_panel;
++ public Ease.ZoomSlider zoom_slider;
++ public EditorWindow (Ease.Document doc);
++ public void add_undo_action (Ease.UndoItem action);
++ [CCode (instance_pos = -1)]
++ public void export_as_html (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void export_as_pdf (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void export_as_postscript (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void insert_image (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void insert_text (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void insert_video (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void inspector_clicked_handler (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void new_slide_handler (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_delete (Gtk.Widget sender);
++ public void on_new_slide_menu (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_quit (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void play_handler (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void redo_handler (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void remove_slide (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public bool save_document (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void select_font (Gtk.Widget? sender);
++ public void set_slide (int index);
++ [CCode (instance_pos = -1)]
++ public void show_color_dialog (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void undo_handler (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void zoom_in (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void zoom_out (Gtk.Widget sender);
++ public bool slides_shown { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public abstract class Element : GLib.Object, Ease.UndoSource {
++ public Element ();
++ public abstract Ease.Actor actor (Ease.ActorContext c);
++ public abstract void cairo_render (Cairo.Context context) throws GLib.Error;
++ public Element.from_json (Json.Object obj);
++ public virtual Clutter.Color? get_color ();
++ public abstract Gtk.Widget inspector_widget ();
++ public virtual bool set_color (Clutter.Color c);
++ public virtual void to_html (ref string html, Ease.HTMLExporter exporter, double amount);
++ public virtual Json.Object to_json ();
++ public virtual GLib.List<Gtk.ToolItem>? tool_items ();
++ public Element.with_owner (Ease.Slide owner);
++ protected abstract void write_html (ref string html, Ease.HTMLExporter exporter);
++ public Ease.Document document { get; }
++ public string element_type { get; set; }
++ public bool has_been_edited { get; set; }
++ public float height { get; set; }
++ public string identifier { get; set; }
++ public Ease.Slide parent { get; set; }
++ public float width { get; set; }
++ public float x { get; set; }
++ public float y { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ElementAddUndoAction : Ease.UndoItem {
++ public ElementAddUndoAction (Ease.Element e);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ElementRemoveUndoAction : Ease.UndoItem {
++ public ElementRemoveUndoAction (Ease.Element e);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Gradient : GLib.Object {
++ public Gradient (Ease.Color start_color, Ease.Color end_color);
++ public void cairo_render_rect (Cairo.Context cr, int width, int height);
++ public Ease.Gradient copy ();
++ public void flip ();
++ public Gradient.from_string (string str);
++ public Gradient.mirrored (Ease.Color start_color, Ease.Color end_color);
++ public Gradient.radial (Ease.Color start_color, Ease.Color end_color);
++ public string to_string ();
++ public double angle { get; set; }
++ public static Ease.Gradient default_background { owned get; }
++ public Ease.Color end { get; set; }
++ public Ease.GradientType mode { get; set; }
++ public Ease.Color start { get; set; }
++ public signal void changed (Ease.Gradient self);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class HTMLExporter : GLib.Object {
++ public const string HEADER;
++ public HTMLExporter ();
++ public void add_progress (double amount);
++ public void copy_file (string end_path, string base_path);
++ public void finish ();
++ public bool request_path (Gtk.Window win);
++ public string basename { owned get; }
++ public string path { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Handle : Clutter.CairoTexture {
++ public Handle (Ease.HandlePosition pos);
++ public void drag (float change_x, float change_y, Ease.Actor target, bool prop);
++ public void drag_from_center (float change_x, float change_y, Ease.Actor target, bool prop);
++ public void flip (bool f);
++ public void reposition (Clutter.Actor selection);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ImageActor : Ease.Actor {
++ public ImageActor (Ease.ImageElement e, Ease.ActorContext c);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ImageElement : Ease.MediaElement {
++ public ImageElement ();
++ public override Ease.Actor actor (Ease.ActorContext c);
++ public override void cairo_render (Cairo.Context context) throws GLib.Error;
++ public ImageElement.from_json (Json.Object obj);
++ public override Gtk.Widget inspector_widget ();
++ public override void write_html (ref string html, Ease.HTMLExporter exporter);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Inspector : Gtk.Notebook, Ease.UndoSource {
++ public Inspector ();
++ public Ease.Slide slide { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public abstract class InspectorPane : Gtk.VBox, Ease.UndoSource {
++ public InspectorPane ();
++ protected virtual void slide_updated ();
++ public Ease.Slide slide { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class InspectorSlidePane : Ease.InspectorPane {
++ public InspectorSlidePane ();
++ [CCode (instance_pos = -1)]
++ public void on_background_changed (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_color_set (Gtk.ColorButton? sender);
++ [CCode (instance_pos = -1)]
++ public void on_file_set (Gtk.FileChooserButton? sender);
++ [CCode (instance_pos = -1)]
++ public void on_gradient_type_changed (Gtk.ComboBox? sender);
++ [CCode (instance_pos = -1)]
++ public void on_reverse_gradient (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_set_angle (Gtk.Widget? sender);
++ protected override void slide_updated ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class InspectorTransitionPane : Ease.InspectorPane {
++ public Gtk.ComboBox effect;
++ public Gtk.ComboBox variant;
++ public InspectorTransitionPane ();
++ protected override void slide_updated ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class InspectorWindow : Gtk.Window {
++ public InspectorWindow ();
++ public static void toggle ();
++ public static Ease.Slide slide { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Main : GLib.Object {
++ public static bool presentation_windowed;
++ public Main ();
++ public static void add_window (Ease.EditorWindow win);
++ public static int main (string[] args);
++ public static void open_file (string path);
++ public static void remove_welcome ();
++ public static void remove_window (Ease.EditorWindow win);
++ public static void show_welcome ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public abstract class MediaElement : Ease.Element {
++ public MediaElement ();
++ public MediaElement.from_json (Json.Object obj);
++ public override Json.Object to_json ();
++ public string filename { get; set; }
++ public string full_filename { owned get; }
++ public string source_filename { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class OpenDialog : GLib.Object {
++ public OpenDialog ();
++ public static void run ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Player : GLib.Object {
++ public Player (Ease.Document doc);
++ public void advance ();
++ public void on_button_press (Clutter.ButtonEvent event);
++ public void on_button_release (Clutter.ButtonEvent event);
++ public void on_key_press (Clutter.KeyEvent event);
++ public void on_motion (Clutter.MotionEvent event);
++ public Ease.Document document { get; set; }
++ public int slide_index { get; set; }
++ public Clutter.Stage stage { get; set; }
++ public signal void complete ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ScrollableEmbed : Gtk.HBox {
++ public ScrollableEmbed (bool horizontal, bool has_frame);
++ public Clutter.Stage get_stage ();
++ public void key_focus ();
++ public Clutter.Group contents { get; set; }
++ public bool has_horizontal { get; set; }
++ public float height { get; }
++ public float width { get; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class SelectionRectangle : Clutter.Group {
++ public SelectionRectangle ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Slide : GLib.Object, Ease.UndoSource {
++ public Gee.ArrayList<Ease.Element> elements;
++ public const string IMAGE_TYPE;
++ public Slide ();
++ public void add (Ease.Element e);
++ public void add_element (int index, Ease.Element e);
++ public void cairo_render (Cairo.Context context) throws GLib.Error;
++ public void cairo_render_background (Cairo.Context cr, int w, int h) throws GLib.Error;
++ public void cairo_render_sized (Cairo.Context context, int w, int h) throws GLib.Error;
++ public Ease.Element element_at (int i);
++ public int index_of (Ease.Element e);
++ public void remove_at (int index);
++ public void remove_element (Ease.Element e);
++ public void to_html (ref string html, Ease.HTMLExporter exporter, double amount, int index);
++ public Slide.with_owner (Ease.Document owner);
++ public double advance_delay { get; set; }
++ public bool automatically_advance { get; set; }
++ public string background_abs { owned get; }
++ public Ease.Color background_color { get; set; }
++ public Ease.Gradient background_gradient { get; set; }
++ public string background_image { get; set; }
++ public string background_image_source { get; set; }
++ public Ease.BackgroundType background_type { get; set; }
++ public int count { get; }
++ public Ease.Slide? next { owned get; }
++ public Ease.Document parent { get; set; }
++ public Ease.Slide? previous { owned get; }
++ public Ease.Theme theme { get; set; }
++ public string title { get; set; }
++ public Ease.Transition transition { get; set; }
++ public uint transition_msecs { get; set; }
++ public double transition_time { get; set; }
++ public Ease.TransitionVariant variant { get; set; }
++ public signal void background_changed (Ease.Slide self);
++ public signal void changed (Ease.Slide self);
++ public signal void element_added (Ease.Slide self, Ease.Element element, int index);
++ public signal void element_removed (Ease.Slide self, Ease.Element element, int index);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class SlideActor : Clutter.Group {
++ public Clutter.CairoTexture background;
++ public Ease.ClutterIterableGroup contents;
++ public Ease.ActorContext context;
++ public const int EASE_DROP;
++ public const int EASE_PIVOT;
++ public const int EASE_SLIDE;
++ public const float FLIP_DEPTH;
++ public const float PANEL_SCALE;
++ public SlideActor ();
++ public SlideActor.blank (Ease.Document document, Clutter.Color color);
++ public SlideActor.from_slide (Ease.Document document, Ease.Slide s, bool clip, Ease.ActorContext ctx);
++ public void on_element_added (Ease.Slide slide, Ease.Element element, int index);
++ public void on_element_removed (Ease.Slide slide, Ease.Element element, int index);
++ public void relayout ();
++ public void reset (Clutter.Group container);
++ public void stack (Clutter.Actor container);
++ public void transition (Ease.SlideActor new_slide, Clutter.Group container);
++ public void unstack (Ease.SlideActor other, Clutter.Actor container);
++ public SlideActor.with_dimensions (float w, float h, Ease.Slide s, bool clip, Ease.ActorContext ctx);
++ public Clutter.Timeline animation_time { get; set; }
++ public Ease.Slide slide { get; set; }
++ public signal void ease_actor_added (Ease.Actor actor);
++ public signal void ease_actor_removed (Ease.Actor actor);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class SlideAddUndoAction : Ease.UndoItem {
++ public SlideAddUndoAction (Ease.Slide s);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class SlideButtonPanel : Gtk.ScrolledWindow {
++ public SlideButtonPanel (Ease.Document d, Ease.EditorWindow win);
++ public void select_slide (Ease.Slide slide);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class SlideRemoveUndoAction : Ease.UndoItem {
++ public SlideRemoveUndoAction (Ease.Slide s);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Temp : GLib.Object {
++ public const string IMG_DIR;
++ public const string TEMP_DIR;
++ public const string THEME_DIR;
++ public const string UI_DIR;
++ public Temp ();
++ public static void clean ();
++ public static bool exists (int dir, string tmp);
++ public static string request () throws GLib.Error;
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class TextActor : Ease.Actor {
++ public TextActor (Ease.TextElement e, Ease.ActorContext c);
++ public override void edit (Ease.EditorEmbed sender);
++ public override void end_edit (Ease.EditorEmbed sender);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class TextElement : Ease.Element {
++ public TextElement ();
++ public override Ease.Actor actor (Ease.ActorContext c);
++ public override void cairo_render (Cairo.Context context) throws GLib.Error;
++ public TextElement.from_json (Json.Object obj);
++ public override Clutter.Color? get_color ();
++ public override Gtk.Widget inspector_widget ();
++ [CCode (instance_pos = -1)]
++ public void on_inspector_alignment (Gtk.Widget sender);
++ public override bool set_color (Clutter.Color c);
++ public void text_align_from_string (string str);
++ public string text_align_to_string ();
++ public void text_size_from_string (string str);
++ public string text_size_to_string ();
++ public void text_style_from_string (string str);
++ public string text_style_to_string ();
++ public void text_variant_from_string (string str);
++ public string text_variant_to_string ();
++ public void text_weight_from_string (string str);
++ public string text_weight_to_string ();
++ public override Json.Object to_json ();
++ protected override void write_html (ref string html, Ease.HTMLExporter exporter);
++ public Ease.Color color { get; set; }
++ public Pango.FontDescription font_description { owned get; set; }
++ public string text { get; set; }
++ public Pango.Alignment text_align { get; set; }
++ public string text_font { get; set; }
++ public int text_size { get; set; }
++ public Pango.Style text_style { get; set; }
++ public Pango.Variant text_variant { get; set; }
++ public int text_weight { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Theme : GLib.Object {
++ public string title;
++ public const string BACKGROUND_COLOR;
++ public const string BACKGROUND_GRADIENT;
++ public const string BACKGROUND_IMAGE;
++ public const string CONTENT;
++ public const string CONTENT_DUAL;
++ public const string CONTENT_DUAL_HEADER;
++ public const string CONTENT_HEADER;
++ public const string CONTENT_MEDIA;
++ public const string CUSTOM_MEDIA;
++ public const string ELEMENT_TYPE;
++ public const string E_IDENTIFIER;
++ public const string GRAD_LINEAR;
++ public const string GRAD_LINEAR_MIRRORED;
++ public const string GRAD_RADIAL;
++ public const string HAS_BEEN_EDITED;
++ public const string HEIGHT;
++ public const string JSON_PATH;
++ public const string[] MASTER_SLIDES;
++ public const string MEDIA;
++ public const string MEDIA_FILENAME;
++ public const string MEDIA_HEADER;
++ public const string MEDIA_SOURCE_FILENAME;
++ public const string PAD_BOTTOM;
++ public const string PAD_LEFT;
++ public const string PAD_RIGHT;
++ public const string PAD_TOP;
++ public const string S_IDENTIFIER;
++ public const string TEXT_ALIGN;
++ public const string TEXT_COLOR;
++ public const string TEXT_FONT;
++ public const string TEXT_SIZE;
++ public const string TEXT_STYLE;
++ public const string TEXT_TEXT;
++ public const string TEXT_VARIANT;
++ public const string TEXT_WEIGHT;
++ public const string TITLE;
++ public const string WIDTH;
++ public const string X;
++ public const string Y;
++ public Theme (string dir_path);
++ public void copy_media (string target) throws GLib.Error;
++ public Ease.Theme copy_to_path (string copy_to) throws GLib.Error;
++ public Ease.TextElement create_custom_text ();
++ public Ease.Slide? create_slide (string master, int width, int height);
++ public Theme.json (string json_path);
++ public static string master_description (string master);
++ public static string master_from_description (string desc);
++ public static string master_mnemonic_description (string master);
++ public string path { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class UndoAction : Ease.UndoItem {
++ public UndoAction (GLib.Object obj, string prop);
++ public void add (GLib.Object obj, string prop);
++ public override Ease.UndoItem apply ();
++ public void combine (Ease.UndoAction action);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class UndoController : GLib.Object {
++ public UndoController ();
++ public void add_action (Ease.UndoItem action);
++ public bool can_redo ();
++ public bool can_undo ();
++ public void clear_redo ();
++ public void redo ();
++ public void undo ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public abstract class UndoItem : GLib.Object {
++ public UndoItem ();
++ public abstract Ease.UndoItem apply ();
++ public signal void applied (Ease.UndoAction sender);
++ public signal void pre_apply (Ease.UndoAction sender);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class WelcomeActor : Clutter.Group {
++ public WelcomeActor (Ease.Theme t);
++ public void fade ();
++ public void set_actor_size (float w, float h);
++ public void set_slide_size (int w, int h);
++ public void unfade ();
++ public Ease.Theme theme { get; set; }
++ public signal void double_click (Ease.WelcomeActor sender);
++ public signal void selected (Ease.WelcomeActor sender);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class WelcomeWindow : Gtk.Window {
++ public WelcomeWindow ();
++ [CCode (instance_pos = -1)]
++ public void create_new_document (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_open_pres_button_clicked (Gtk.Widget sender);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ZoomSlider : Gtk.Alignment {
++ public ZoomSlider (Gtk.Adjustment adjustment, int[] button_values);
++ protected virtual void change_zoom (double value);
++ public double get_value ();
++ public void zoom_in ();
++ public void zoom_out ();
++ public bool buttons_shown { get; set; }
++ public int digits { get; set; }
++ public double sliderpos { get; set; }
++ public Gtk.PositionType value_pos { get; set; }
++ public signal void value_changed ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public interface ClutterIterableContainer : Clutter.Container {
++ [CCode (ref_function = "ease_clutter_iterable_container_iterator_ref", unref_function = "ease_clutter_iterable_container_iterator_unref", cheader_filename = "libease-core.h")]
++ public class Iterator {
++ public Iterator (Ease.ClutterIterableContainer self);
++ public Clutter.Actor @get ();
++ public bool next ();
++ }
++ public Ease.ClutterIterableContainer.Iterator iterator ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public interface UndoSource : GLib.Object {
++ protected void forward (Ease.UndoItem action);
++ protected void listen (Ease.UndoSource source);
++ protected void silence (Ease.UndoSource source);
++ public signal void undo (Ease.UndoItem action);
++ }
++ [CCode (cprefix = "EASE_ACTOR_CONTEXT_", cheader_filename = "libease-core.h")]
++ public enum ActorContext {
++ PRESENTATION,
++ EDITOR,
++ INSPECTOR
++ }
++ [CCode (cprefix = "EASE_BACKGROUND_TYPE_", cheader_filename = "libease-core.h")]
++ public enum BackgroundType {
++ COLOR,
++ GRADIENT,
++ IMAGE;
++ public string to_string ();
++ public static Ease.BackgroundType from_string (string str);
++ public string description ();
++ public const Ease.BackgroundType[] TYPES;
++ }
++ [CCode (cprefix = "EASE_GRADIENT_TYPE_", cheader_filename = "libease-core.h")]
++ public enum GradientType {
++ LINEAR,
++ LINEAR_MIRRORED,
++ RADIAL;
++ public string to_string ();
++ public static Ease.GradientType from_string (string str);
++ public string description ();
++ public static Gtk.ListStore list_store ();
++ }
++ [CCode (cprefix = "EASE_HANDLE_POSITION_", cheader_filename = "libease-core.h")]
++ public enum HandlePosition {
++ TOP_LEFT,
++ TOP_RIGHT,
++ TOP,
++ LEFT,
++ RIGHT,
++ BOTTOM_LEFT,
++ BOTTOM_RIGHT,
++ BOTTOM
++ }
++ [CCode (cprefix = "EASE_KEY_", cheader_filename = "libease-core.h")]
++ public enum Key {
++ UP,
++ DOWN,
++ LEFT,
++ RIGHT,
++ BACKSPACE,
++ DELETE
++ }
++ [CCode (cprefix = "EASE_TRANSITION_", cheader_filename = "libease-core.h")]
++ public enum Transition {
++ NONE,
++ FADE,
++ SLIDE,
++ DROP,
++ PIVOT,
++ FLIP,
++ REVOLVING_DOOR,
++ REVEAL,
++ FALL,
++ SLATS,
++ OPEN_DOOR,
++ EXPLODE,
++ ASSEMBLE,
++ ZOOM,
++ PANEL,
++ SPIN_CONTENTS,
++ SPRING_CONTENTS,
++ SWING_CONTENTS,
++ SLIDE_CONTENTS,
++ ZOOM_CONTENTS;
++ public static Gtk.ListStore model ();
++ public Gtk.ListStore variant_model ();
++ public static Ease.Transition from_string (string str);
++ public Ease.TransitionVariant[] variants ();
++ public string get_name ();
++ }
++ [CCode (cprefix = "EASE_TRANSITION_VARIANT_", cheader_filename = "libease-core.h")]
++ public enum TransitionVariant {
++ LEFT,
++ RIGHT,
++ UP,
++ DOWN,
++ BOTTOM,
++ TOP,
++ CENTER,
++ TOP_LEFT,
++ TOP_RIGHT,
++ BOTTOM_LEFT,
++ BOTTOM_RIGHT,
++ TOP_TO_BOTTOM,
++ BOTTOM_TO_TOP,
++ LEFT_TO_RIGHT,
++ RIGHT_TO_LEFT,
++ IN,
++ OUT;
++ public static Ease.TransitionVariant from_string (string str);
++ public string get_name ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public delegate void RecursiveDirAction (string path, string full_path);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static string? data_path (string path);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static double dmax (double a, double b);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static double dmin (double a, double b);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static void error_dialog (string title, string message);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static void recursive_copy (string from_dir, string to_dir) throws GLib.Error;
++ [CCode (cheader_filename = "libease-core.h")]
++ public static void recursive_delete (string path) throws GLib.Error;
++ [CCode (cheader_filename = "libease-core.h")]
++ public static void recursive_directory (string directory, Ease.RecursiveDirAction? directory_action, Ease.RecursiveDirAction? file_action) throws GLib.Error;
++ [CCode (cheader_filename = "libease-core.h")]
++ public static void recursive_directory_after (string directory, Ease.RecursiveDirAction? directory_action, Ease.RecursiveDirAction? file_action) throws GLib.Error;
++ [CCode (cheader_filename = "libease-core.h")]
++ public static int roundd (double num);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static Clutter.Color theme_clutter_color (string color);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static Gdk.Color? theme_color (string color);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static Gtk.Window widget_window (Gtk.Widget widg);
++}
++[CCode (cheader_filename = "libease-core.h")]
++public static string? save_dialog (string title, Gtk.Window? modal);
diff --cc ease-core/ease-core-0.3.vapi
index 0000000,0000000..df7237a
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-core-0.3.vapi
@@@ -1,0 -1,0 +1,747 @@@
++/* ease-core-0.3.vapi generated by valac, do not modify. */
++
++[CCode (cprefix = "Ease", lower_case_cprefix = "ease_", gir_namespace = "EaseCore", gir_version = "0.3")]
++namespace Ease {
++ [CCode (cprefix = "EaseIterable", lower_case_cprefix = "ease_iterable_")]
++ namespace Iterable {
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ListStore : Gtk.ListStore, Ease.Iterable.TreeModel {
++ public ListStore (GLib.Type[] types);
++ public int size { get; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public interface TreeModel : Gtk.TreeModel {
++ [CCode (ref_function = "ease_iterable_tree_model_iterator_ref", unref_function = "ease_iterable_tree_model_iterator_unref", cheader_filename = "libease-core.h")]
++ public class Iterator {
++ public Iterator (Ease.Iterable.TreeModel self);
++ public Gtk.TreeIter @get ();
++ public bool next ();
++ }
++ public Ease.Iterable.TreeModel.Iterator iterator ();
++ }
++ }
++ [CCode (cprefix = "EaseTransformations", lower_case_cprefix = "ease_transformations_")]
++ namespace Transformations {
++ [CCode (cheader_filename = "libease-core.h")]
++ public static Gdk.Color clutter_color_to_gdk_color (Clutter.Color color);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static Clutter.Color gdk_color_to_clutter_color (Gdk.Color color);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class AboutDialog : Gtk.AboutDialog {
++ public AboutDialog ();
++ public static void show_about (Gtk.Widget sender);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public abstract class Actor : Clutter.Group {
++ protected Clutter.Actor contents;
++ public Ease.ActorContext context;
++ public weak Ease.Element element;
++ public bool is_background;
++ public Actor (Ease.Element e, Ease.ActorContext c);
++ public virtual void edit (Ease.EditorEmbed sender);
++ public virtual void end_edit (Ease.EditorEmbed sender);
++ public void reposition ();
++ public void resize (float w_change, float h_change, bool proportional);
++ public void translate (float x_change, float y_change);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class AnimatedZoomSlider : Ease.ZoomSlider, Clutter.Animatable {
++ public AnimatedZoomSlider (Gtk.Adjustment adjustment, int[] button_values);
++ protected override void change_zoom (double value);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class CloseConfirmDialog : Gtk.Dialog {
++ public CloseConfirmDialog (string filename, int seconds);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ClutterIterableGroup : Clutter.Group, Ease.ClutterIterableContainer {
++ public ClutterIterableGroup ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ClutterIterableStage : Clutter.Stage, Ease.ClutterIterableContainer {
++ public ClutterIterableStage ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Color : GLib.Object {
++ public Color ();
++ public Ease.Color copy ();
++ public Color.from_clutter (Clutter.Color color);
++ public Color.from_gdk (Gdk.Color color);
++ public Color.from_string (string str);
++ public Color.rgb (double r, double g, double b);
++ public Color.rgba (double r, double g, double b, double a);
++ public void set_cairo (Cairo.Context cr);
++ public string to_string ();
++ public Ease.UndoAction undo_action ();
++ public double alpha { get; set; }
++ public static Ease.Color black { owned get; }
++ public double blue { get; set; }
++ public Clutter.Color clutter { get; set; }
++ public Gdk.Color gdk { get; set; }
++ public double green { get; set; }
++ public double red { get; set; }
++ public static Ease.Color white { owned get; }
++ public signal void changed (Ease.Color self);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Document : GLib.Object, Ease.UndoSource {
++ public Ease.Iterable.ListStore slides;
++ public const int COL_PIXBUF;
++ public const int COL_SLIDE;
++ public const string DEFAULT_SLIDE;
++ public const string THEME_PATH;
++ public Document ();
++ public string add_media_file (string file) throws GLib.Error;
++ public void add_slide (int index, Ease.Slide s);
++ public void append_slide (Ease.Slide s);
++ public void cairo_render (Cairo.Surface surface) throws GLib.Error;
++ public void export_as_html (Gtk.Window window);
++ public void export_as_pdf (Gtk.Window win);
++ public void export_as_postscript (Gtk.Window win);
++ public Document.from_saved (string file_path) throws GLib.Error;
++ public Document.from_theme (Ease.Theme doc_theme, int w, int h) throws GLib.Error;
++ public Ease.Slide get_slide (int index);
++ public bool has_next_slide (Ease.Slide slide);
++ public int index_of (Ease.Slide slide);
++ public Ease.Slide remove_slide (Ease.Slide slide);
++ public Ease.Slide? slide_by_title (string title);
++ public void to_json () throws GLib.Error;
++ public float aspect { get; }
++ public string filename { get; set; }
++ public int height { get; set; }
++ public int length { get; }
++ public string path { get; set; }
++ public Ease.Theme theme { get; set; }
++ public int width { get; set; }
++ public signal void slide_added (Ease.Slide slide, int index);
++ public signal void slide_deleted (Ease.Slide slide, int index);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class EditorEmbed : Ease.ScrollableEmbed, Ease.UndoSource {
++ public Ease.SlideActor slide_actor;
++ public EditorEmbed (Ease.Document d, Ease.EditorWindow w);
++ public void connect_keys ();
++ public void disconnect_keys ();
++ public void on_ease_actor_added (Ease.Actor actor);
++ public void on_ease_actor_removed (Ease.Actor actor);
++ public void on_element_removed (Ease.Slide slide, Ease.Element element, int index);
++ public bool on_key_press_event (Gtk.Widget self, Gdk.EventKey event);
++ public void recreate_slide ();
++ public void reposition_group ();
++ public void select_element (Ease.Element e);
++ public void set_element_color (Clutter.Color color);
++ public void set_slide (Ease.Slide slide);
++ public Ease.Actor selected { get; set; }
++ public float zoom { get; set; }
++ public signal void element_deselected (Ease.Element? deselected);
++ public signal void element_selected (Ease.Element selected);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class EditorWindow : Gtk.Window {
++ public Ease.Document document;
++ public Ease.EditorEmbed embed;
++ public Ease.Slide slide;
++ public Ease.SlideButtonPanel slide_button_panel;
++ public Ease.ZoomSlider zoom_slider;
++ public EditorWindow (Ease.Document doc);
++ public void add_undo_action (Ease.UndoItem action);
++ [CCode (instance_pos = -1)]
++ public void export_as_html (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void export_as_pdf (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void export_as_postscript (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void insert_image (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void insert_text (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void insert_video (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void inspector_clicked_handler (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void new_slide_handler (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_delete (Gtk.Widget sender);
++ public void on_new_slide_menu (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_quit (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void play_handler (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void redo_handler (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void remove_slide (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public bool save_document (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void select_font (Gtk.Widget? sender);
++ public void set_slide (int index);
++ [CCode (instance_pos = -1)]
++ public void show_color_dialog (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void undo_handler (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void zoom_in (Gtk.Widget sender);
++ [CCode (instance_pos = -1)]
++ public void zoom_out (Gtk.Widget sender);
++ public bool slides_shown { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public abstract class Element : GLib.Object, Ease.UndoSource {
++ public Element ();
++ public abstract Ease.Actor actor (Ease.ActorContext c);
++ public abstract void cairo_render (Cairo.Context context) throws GLib.Error;
++ public Element.from_json (Json.Object obj);
++ public virtual Clutter.Color? get_color ();
++ public abstract Gtk.Widget inspector_widget ();
++ public virtual bool set_color (Clutter.Color c);
++ public virtual void to_html (ref string html, Ease.HTMLExporter exporter, double amount);
++ public virtual Json.Object to_json ();
++ public virtual GLib.List<Gtk.ToolItem>? tool_items ();
++ public Element.with_owner (Ease.Slide owner);
++ protected abstract void write_html (ref string html, Ease.HTMLExporter exporter);
++ public Ease.Document document { get; }
++ public string element_type { get; set; }
++ public bool has_been_edited { get; set; }
++ public float height { get; set; }
++ public string identifier { get; set; }
++ public Ease.Slide parent { get; set; }
++ public float width { get; set; }
++ public float x { get; set; }
++ public float y { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ElementAddUndoAction : Ease.UndoItem {
++ public ElementAddUndoAction (Ease.Element e);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ElementRemoveUndoAction : Ease.UndoItem {
++ public ElementRemoveUndoAction (Ease.Element e);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Gradient : GLib.Object {
++ public Gradient (Ease.Color start_color, Ease.Color end_color);
++ public void cairo_render_rect (Cairo.Context cr, int width, int height);
++ public Ease.Gradient copy ();
++ public void flip ();
++ public Gradient.from_string (string str);
++ public Gradient.mirrored (Ease.Color start_color, Ease.Color end_color);
++ public Gradient.radial (Ease.Color start_color, Ease.Color end_color);
++ public string to_string ();
++ public double angle { get; set; }
++ public static Ease.Gradient default_background { owned get; }
++ public Ease.Color end { get; set; }
++ public Ease.GradientType mode { get; set; }
++ public Ease.Color start { get; set; }
++ public signal void changed (Ease.Gradient self);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class HTMLExporter : GLib.Object {
++ public const string HEADER;
++ public HTMLExporter ();
++ public void add_progress (double amount);
++ public void copy_file (string end_path, string base_path);
++ public void finish ();
++ public bool request_path (Gtk.Window win);
++ public string basename { owned get; }
++ public string path { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Handle : Clutter.CairoTexture {
++ public Handle (Ease.HandlePosition pos);
++ public void drag (float change_x, float change_y, Ease.Actor target, bool prop);
++ public void drag_from_center (float change_x, float change_y, Ease.Actor target, bool prop);
++ public void flip (bool f);
++ public void reposition (Clutter.Actor selection);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ImageActor : Ease.Actor {
++ public ImageActor (Ease.ImageElement e, Ease.ActorContext c);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ImageElement : Ease.MediaElement {
++ public ImageElement ();
++ public override Ease.Actor actor (Ease.ActorContext c);
++ public override void cairo_render (Cairo.Context context) throws GLib.Error;
++ public ImageElement.from_json (Json.Object obj);
++ public override Gtk.Widget inspector_widget ();
++ public override void write_html (ref string html, Ease.HTMLExporter exporter);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Inspector : Gtk.Notebook, Ease.UndoSource {
++ public Inspector ();
++ public Ease.Slide slide { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public abstract class InspectorPane : Gtk.VBox, Ease.UndoSource {
++ public InspectorPane ();
++ protected virtual void slide_updated ();
++ public Ease.Slide slide { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class InspectorSlidePane : Ease.InspectorPane {
++ public InspectorSlidePane ();
++ [CCode (instance_pos = -1)]
++ public void on_background_changed (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_color_set (Gtk.ColorButton? sender);
++ [CCode (instance_pos = -1)]
++ public void on_file_set (Gtk.FileChooserButton? sender);
++ [CCode (instance_pos = -1)]
++ public void on_gradient_type_changed (Gtk.ComboBox? sender);
++ [CCode (instance_pos = -1)]
++ public void on_reverse_gradient (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_set_angle (Gtk.Widget? sender);
++ protected override void slide_updated ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class InspectorTransitionPane : Ease.InspectorPane {
++ public Gtk.ComboBox effect;
++ public Gtk.ComboBox variant;
++ public InspectorTransitionPane ();
++ protected override void slide_updated ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class InspectorWindow : Gtk.Window {
++ public InspectorWindow ();
++ public static void toggle ();
++ public static Ease.Slide slide { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Main : GLib.Object {
++ public static bool presentation_windowed;
++ public Main ();
++ public static void add_window (Ease.EditorWindow win);
++ public static int main (string[] args);
++ public static void open_file (string path);
++ public static void remove_welcome ();
++ public static void remove_window (Ease.EditorWindow win);
++ public static void show_welcome ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public abstract class MediaElement : Ease.Element {
++ public MediaElement ();
++ public MediaElement.from_json (Json.Object obj);
++ public override Json.Object to_json ();
++ public string filename { get; set; }
++ public string full_filename { owned get; }
++ public string source_filename { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class OpenDialog : GLib.Object {
++ public OpenDialog ();
++ public static void run ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Player : GLib.Object {
++ public Player (Ease.Document doc);
++ public void advance ();
++ public void on_button_press (Clutter.ButtonEvent event);
++ public void on_button_release (Clutter.ButtonEvent event);
++ public void on_key_press (Clutter.KeyEvent event);
++ public void on_motion (Clutter.MotionEvent event);
++ public Ease.Document document { get; set; }
++ public int slide_index { get; set; }
++ public Clutter.Stage stage { get; set; }
++ public signal void complete ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ScrollableEmbed : Gtk.HBox {
++ public ScrollableEmbed (bool horizontal, bool has_frame);
++ public Clutter.Stage get_stage ();
++ public void key_focus ();
++ public Clutter.Group contents { get; set; }
++ public bool has_horizontal { get; set; }
++ public float height { get; }
++ public float width { get; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class SelectionRectangle : Clutter.Group {
++ public SelectionRectangle ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Slide : GLib.Object, Ease.UndoSource {
++ public Gee.ArrayList<Ease.Element> elements;
++ public const string IMAGE_TYPE;
++ public Slide ();
++ public void add (Ease.Element e);
++ public void add_element (int index, Ease.Element e);
++ public void cairo_render (Cairo.Context context) throws GLib.Error;
++ public void cairo_render_background (Cairo.Context cr, int w, int h) throws GLib.Error;
++ public void cairo_render_sized (Cairo.Context context, int w, int h) throws GLib.Error;
++ public Ease.Element element_at (int i);
++ public int index_of (Ease.Element e);
++ public void remove_at (int index);
++ public void remove_element (Ease.Element e);
++ public void to_html (ref string html, Ease.HTMLExporter exporter, double amount, int index);
++ public Slide.with_owner (Ease.Document owner);
++ public double advance_delay { get; set; }
++ public bool automatically_advance { get; set; }
++ public string background_abs { owned get; }
++ public Ease.Color background_color { get; set; }
++ public Ease.Gradient background_gradient { get; set; }
++ public string background_image { get; set; }
++ public string background_image_source { get; set; }
++ public Ease.BackgroundType background_type { get; set; }
++ public int count { get; }
++ public Ease.Slide? next { owned get; }
++ public Ease.Document parent { get; set; }
++ public Ease.Slide? previous { owned get; }
++ public Ease.Theme theme { get; set; }
++ public string title { get; set; }
++ public Ease.Transition transition { get; set; }
++ public uint transition_msecs { get; set; }
++ public double transition_time { get; set; }
++ public Ease.TransitionVariant variant { get; set; }
++ public signal void background_changed (Ease.Slide self);
++ public signal void changed (Ease.Slide self);
++ public signal void element_added (Ease.Slide self, Ease.Element element, int index);
++ public signal void element_removed (Ease.Slide self, Ease.Element element, int index);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class SlideActor : Clutter.Group {
++ public Clutter.CairoTexture background;
++ public Ease.ClutterIterableGroup contents;
++ public Ease.ActorContext context;
++ public const int EASE_DROP;
++ public const int EASE_PIVOT;
++ public const int EASE_SLIDE;
++ public const float FLIP_DEPTH;
++ public const float PANEL_SCALE;
++ public SlideActor ();
++ public SlideActor.blank (Ease.Document document, Clutter.Color color);
++ public SlideActor.from_slide (Ease.Document document, Ease.Slide s, bool clip, Ease.ActorContext ctx);
++ public void on_element_added (Ease.Slide slide, Ease.Element element, int index);
++ public void on_element_removed (Ease.Slide slide, Ease.Element element, int index);
++ public void relayout ();
++ public void reset (Clutter.Group container);
++ public void stack (Clutter.Actor container);
++ public void transition (Ease.SlideActor new_slide, Clutter.Group container);
++ public void unstack (Ease.SlideActor other, Clutter.Actor container);
++ public SlideActor.with_dimensions (float w, float h, Ease.Slide s, bool clip, Ease.ActorContext ctx);
++ public Clutter.Timeline animation_time { get; set; }
++ public Ease.Slide slide { get; set; }
++ public signal void ease_actor_added (Ease.Actor actor);
++ public signal void ease_actor_removed (Ease.Actor actor);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class SlideAddUndoAction : Ease.UndoItem {
++ public SlideAddUndoAction (Ease.Slide s);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class SlideButtonPanel : Gtk.ScrolledWindow {
++ public SlideButtonPanel (Ease.Document d, Ease.EditorWindow win);
++ public void select_slide (Ease.Slide slide);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class SlideRemoveUndoAction : Ease.UndoItem {
++ public SlideRemoveUndoAction (Ease.Slide s);
++ public override Ease.UndoItem apply ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Temp : GLib.Object {
++ public const string IMG_DIR;
++ public const string TEMP_DIR;
++ public const string THEME_DIR;
++ public const string UI_DIR;
++ public Temp ();
++ public static void clean ();
++ public static bool exists (int dir, string tmp);
++ public static string request () throws GLib.Error;
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class TextActor : Ease.Actor {
++ public TextActor (Ease.TextElement e, Ease.ActorContext c);
++ public override void edit (Ease.EditorEmbed sender);
++ public override void end_edit (Ease.EditorEmbed sender);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class TextElement : Ease.Element {
++ public TextElement ();
++ public override Ease.Actor actor (Ease.ActorContext c);
++ public override void cairo_render (Cairo.Context context) throws GLib.Error;
++ public TextElement.from_json (Json.Object obj);
++ public override Clutter.Color? get_color ();
++ public override Gtk.Widget inspector_widget ();
++ [CCode (instance_pos = -1)]
++ public void on_inspector_alignment (Gtk.Widget sender);
++ public override bool set_color (Clutter.Color c);
++ public void text_align_from_string (string str);
++ public string text_align_to_string ();
++ public void text_size_from_string (string str);
++ public string text_size_to_string ();
++ public void text_style_from_string (string str);
++ public string text_style_to_string ();
++ public void text_variant_from_string (string str);
++ public string text_variant_to_string ();
++ public void text_weight_from_string (string str);
++ public string text_weight_to_string ();
++ public override Json.Object to_json ();
++ protected override void write_html (ref string html, Ease.HTMLExporter exporter);
++ public Ease.Color color { get; set; }
++ public Pango.FontDescription font_description { owned get; set; }
++ public string text { get; set; }
++ public Pango.Alignment text_align { get; set; }
++ public string text_font { get; set; }
++ public int text_size { get; set; }
++ public Pango.Style text_style { get; set; }
++ public Pango.Variant text_variant { get; set; }
++ public int text_weight { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class Theme : GLib.Object {
++ public string title;
++ public const string BACKGROUND_COLOR;
++ public const string BACKGROUND_GRADIENT;
++ public const string BACKGROUND_IMAGE;
++ public const string CONTENT;
++ public const string CONTENT_DUAL;
++ public const string CONTENT_DUAL_HEADER;
++ public const string CONTENT_HEADER;
++ public const string CONTENT_MEDIA;
++ public const string CUSTOM_MEDIA;
++ public const string ELEMENT_TYPE;
++ public const string E_IDENTIFIER;
++ public const string GRAD_LINEAR;
++ public const string GRAD_LINEAR_MIRRORED;
++ public const string GRAD_RADIAL;
++ public const string HAS_BEEN_EDITED;
++ public const string HEIGHT;
++ public const string JSON_PATH;
++ public const string[] MASTER_SLIDES;
++ public const string MEDIA;
++ public const string MEDIA_FILENAME;
++ public const string MEDIA_HEADER;
++ public const string MEDIA_SOURCE_FILENAME;
++ public const string PAD_BOTTOM;
++ public const string PAD_LEFT;
++ public const string PAD_RIGHT;
++ public const string PAD_TOP;
++ public const string S_IDENTIFIER;
++ public const string TEXT_ALIGN;
++ public const string TEXT_COLOR;
++ public const string TEXT_FONT;
++ public const string TEXT_SIZE;
++ public const string TEXT_STYLE;
++ public const string TEXT_TEXT;
++ public const string TEXT_VARIANT;
++ public const string TEXT_WEIGHT;
++ public const string TITLE;
++ public const string WIDTH;
++ public const string X;
++ public const string Y;
++ public Theme (string dir_path);
++ public void copy_media (string target) throws GLib.Error;
++ public Ease.Theme copy_to_path (string copy_to) throws GLib.Error;
++ public Ease.TextElement create_custom_text ();
++ public Ease.Slide? create_slide (string master, int width, int height);
++ public Theme.json (string json_path);
++ public static string master_description (string master);
++ public static string master_from_description (string desc);
++ public static string master_mnemonic_description (string master);
++ public string path { get; set; }
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class UndoAction : Ease.UndoItem {
++ public UndoAction (GLib.Object obj, string prop);
++ public void add (GLib.Object obj, string prop);
++ public override Ease.UndoItem apply ();
++ public void combine (Ease.UndoAction action);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class UndoController : GLib.Object {
++ public UndoController ();
++ public void add_action (Ease.UndoItem action);
++ public bool can_redo ();
++ public bool can_undo ();
++ public void clear_redo ();
++ public void redo ();
++ public void undo ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public abstract class UndoItem : GLib.Object {
++ public UndoItem ();
++ public abstract Ease.UndoItem apply ();
++ public signal void applied (Ease.UndoAction sender);
++ public signal void pre_apply (Ease.UndoAction sender);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class WelcomeActor : Clutter.Group {
++ public WelcomeActor (Ease.Theme t);
++ public void fade ();
++ public void set_actor_size (float w, float h);
++ public void set_slide_size (int w, int h);
++ public void unfade ();
++ public Ease.Theme theme { get; set; }
++ public signal void double_click (Ease.WelcomeActor sender);
++ public signal void selected (Ease.WelcomeActor sender);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class WelcomeWindow : Gtk.Window {
++ public WelcomeWindow ();
++ [CCode (instance_pos = -1)]
++ public void create_new_document (Gtk.Widget? sender);
++ [CCode (instance_pos = -1)]
++ public void on_open_pres_button_clicked (Gtk.Widget sender);
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public class ZoomSlider : Gtk.Alignment {
++ public ZoomSlider (Gtk.Adjustment adjustment, int[] button_values);
++ protected virtual void change_zoom (double value);
++ public double get_value ();
++ public void zoom_in ();
++ public void zoom_out ();
++ public bool buttons_shown { get; set; }
++ public int digits { get; set; }
++ public double sliderpos { get; set; }
++ public Gtk.PositionType value_pos { get; set; }
++ public signal void value_changed ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public interface ClutterIterableContainer : Clutter.Container {
++ [CCode (ref_function = "ease_clutter_iterable_container_iterator_ref", unref_function = "ease_clutter_iterable_container_iterator_unref", cheader_filename = "libease-core.h")]
++ public class Iterator {
++ public Iterator (Ease.ClutterIterableContainer self);
++ public Clutter.Actor @get ();
++ public bool next ();
++ }
++ public Ease.ClutterIterableContainer.Iterator iterator ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public interface UndoSource : GLib.Object {
++ protected void forward (Ease.UndoItem action);
++ protected void listen (Ease.UndoSource source);
++ protected void silence (Ease.UndoSource source);
++ public signal void undo (Ease.UndoItem action);
++ }
++ [CCode (cprefix = "EASE_ACTOR_CONTEXT_", cheader_filename = "libease-core.h")]
++ public enum ActorContext {
++ PRESENTATION,
++ EDITOR,
++ INSPECTOR
++ }
++ [CCode (cprefix = "EASE_BACKGROUND_TYPE_", cheader_filename = "libease-core.h")]
++ public enum BackgroundType {
++ COLOR,
++ GRADIENT,
++ IMAGE;
++ public string to_string ();
++ public static Ease.BackgroundType from_string (string str);
++ public string description ();
++ public const Ease.BackgroundType[] TYPES;
++ }
++ [CCode (cprefix = "EASE_GRADIENT_TYPE_", cheader_filename = "libease-core.h")]
++ public enum GradientType {
++ LINEAR,
++ LINEAR_MIRRORED,
++ RADIAL;
++ public string to_string ();
++ public static Ease.GradientType from_string (string str);
++ public string description ();
++ public static Gtk.ListStore list_store ();
++ }
++ [CCode (cprefix = "EASE_HANDLE_POSITION_", cheader_filename = "libease-core.h")]
++ public enum HandlePosition {
++ TOP_LEFT,
++ TOP_RIGHT,
++ TOP,
++ LEFT,
++ RIGHT,
++ BOTTOM_LEFT,
++ BOTTOM_RIGHT,
++ BOTTOM
++ }
++ [CCode (cprefix = "EASE_KEY_", cheader_filename = "libease-core.h")]
++ public enum Key {
++ UP,
++ DOWN,
++ LEFT,
++ RIGHT,
++ BACKSPACE,
++ DELETE
++ }
++ [CCode (cprefix = "EASE_TRANSITION_", cheader_filename = "libease-core.h")]
++ public enum Transition {
++ NONE,
++ FADE,
++ SLIDE,
++ DROP,
++ PIVOT,
++ FLIP,
++ REVOLVING_DOOR,
++ REVEAL,
++ FALL,
++ SLATS,
++ OPEN_DOOR,
++ EXPLODE,
++ ASSEMBLE,
++ ZOOM,
++ PANEL,
++ SPIN_CONTENTS,
++ SPRING_CONTENTS,
++ SWING_CONTENTS,
++ SLIDE_CONTENTS,
++ ZOOM_CONTENTS;
++ public static Gtk.ListStore model ();
++ public Gtk.ListStore variant_model ();
++ public static Ease.Transition from_string (string str);
++ public Ease.TransitionVariant[] variants ();
++ public string get_name ();
++ }
++ [CCode (cprefix = "EASE_TRANSITION_VARIANT_", cheader_filename = "libease-core.h")]
++ public enum TransitionVariant {
++ LEFT,
++ RIGHT,
++ UP,
++ DOWN,
++ BOTTOM,
++ TOP,
++ CENTER,
++ TOP_LEFT,
++ TOP_RIGHT,
++ BOTTOM_LEFT,
++ BOTTOM_RIGHT,
++ TOP_TO_BOTTOM,
++ BOTTOM_TO_TOP,
++ LEFT_TO_RIGHT,
++ RIGHT_TO_LEFT,
++ IN,
++ OUT;
++ public static Ease.TransitionVariant from_string (string str);
++ public string get_name ();
++ }
++ [CCode (cheader_filename = "libease-core.h")]
++ public delegate void RecursiveDirAction (string path, string full_path);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static string? data_path (string path);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static double dmax (double a, double b);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static double dmin (double a, double b);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static void error_dialog (string title, string message);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static void recursive_copy (string from_dir, string to_dir) throws GLib.Error;
++ [CCode (cheader_filename = "libease-core.h")]
++ public static void recursive_delete (string path) throws GLib.Error;
++ [CCode (cheader_filename = "libease-core.h")]
++ public static void recursive_directory (string directory, Ease.RecursiveDirAction? directory_action, Ease.RecursiveDirAction? file_action) throws GLib.Error;
++ [CCode (cheader_filename = "libease-core.h")]
++ public static void recursive_directory_after (string directory, Ease.RecursiveDirAction? directory_action, Ease.RecursiveDirAction? file_action) throws GLib.Error;
++ [CCode (cheader_filename = "libease-core.h")]
++ public static int roundd (double num);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static Clutter.Color theme_clutter_color (string color);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static Gdk.Color? theme_color (string color);
++ [CCode (cheader_filename = "libease-core.h")]
++ public static Gtk.Window widget_window (Gtk.Widget widg);
++}
++[CCode (cheader_filename = "libease-core.h")]
++public static string? save_dialog (string title, Gtk.Window? modal);
diff --cc ease-core/ease-dialogs.c
index 0000000,0000000..f45b773
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-dialogs.c
@@@ -1,0 -1,0 +1,176 @@@
++/* ease-dialogs.c generated by valac, the Vala compiler
++ * generated from ease-dialogs.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <glib/gi18n-lib.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++
++
++#define EASE_TYPE_OPEN_DIALOG (ease_open_dialog_get_type ())
++#define EASE_OPEN_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_OPEN_DIALOG, EaseOpenDialog))
++#define EASE_OPEN_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_OPEN_DIALOG, EaseOpenDialogClass))
++#define EASE_IS_OPEN_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_OPEN_DIALOG))
++#define EASE_IS_OPEN_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_OPEN_DIALOG))
++#define EASE_OPEN_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_OPEN_DIALOG, EaseOpenDialogClass))
++
++typedef struct _EaseOpenDialog EaseOpenDialog;
++typedef struct _EaseOpenDialogClass EaseOpenDialogClass;
++typedef struct _EaseOpenDialogPrivate EaseOpenDialogPrivate;
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++struct _EaseOpenDialog {
++ GObject parent_instance;
++ EaseOpenDialogPrivate * priv;
++};
++
++struct _EaseOpenDialogClass {
++ GObjectClass parent_class;
++};
++
++
++static gpointer ease_open_dialog_parent_class = NULL;
++
++GType ease_open_dialog_get_type (void) G_GNUC_CONST;
++enum {
++ EASE_OPEN_DIALOG_DUMMY_PROPERTY
++};
++void ease_main_open_file (const char* path);
++void ease_open_dialog_run (void);
++EaseOpenDialog* ease_open_dialog_new (void);
++EaseOpenDialog* ease_open_dialog_construct (GType object_type);
++char* save_dialog (const char* title, GtkWindow* modal);
++
++
++
++#line 28 "ease-dialogs.vala"
++void ease_open_dialog_run (void) {
++#line 69 "ease-dialogs.c"
++ GtkFileChooserDialog* dialog;
++ GtkFileFilter* filter;
++#line 30 "ease-dialogs.vala"
++ dialog = g_object_ref_sink ((GtkFileChooserDialog*) gtk_file_chooser_dialog_new (_ ("Open File"), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, "gtk-cancel", GTK_RESPONSE_CANCEL, "gtk-open", GTK_RESPONSE_ACCEPT, NULL));
++#line 39 "ease-dialogs.vala"
++ filter = g_object_ref_sink (gtk_file_filter_new ());
++#line 40 "ease-dialogs.vala"
++ gtk_file_filter_add_pattern (filter, "*.ease");
++#line 41 "ease-dialogs.vala"
++ gtk_file_chooser_set_filter ((GtkFileChooser*) dialog, filter);
++#line 43 "ease-dialogs.vala"
++ if (gtk_dialog_run ((GtkDialog*) dialog) == GTK_RESPONSE_ACCEPT) {
++#line 82 "ease-dialogs.c"
++ char* _tmp1_;
++ char* _tmp0_;
++#line 45 "ease-dialogs.vala"
++ ease_main_open_file (_tmp1_ = g_strconcat (_tmp0_ = gtk_file_chooser_get_filename ((GtkFileChooser*) dialog), "/", NULL));
++#line 87 "ease-dialogs.c"
++ _g_free0 (_tmp1_);
++ _g_free0 (_tmp0_);
++ }
++#line 47 "ease-dialogs.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 93 "ease-dialogs.c"
++ _g_object_unref0 (filter);
++ _g_object_unref0 (dialog);
++}
++
++
++#line 21 "ease-dialogs.vala"
++EaseOpenDialog* ease_open_dialog_construct (GType object_type) {
++#line 101 "ease-dialogs.c"
++ EaseOpenDialog * self;
++#line 21 "ease-dialogs.vala"
++ self = (EaseOpenDialog*) g_object_new (object_type, NULL);
++#line 105 "ease-dialogs.c"
++ return self;
++}
++
++
++#line 21 "ease-dialogs.vala"
++EaseOpenDialog* ease_open_dialog_new (void) {
++#line 21 "ease-dialogs.vala"
++ return ease_open_dialog_construct (EASE_TYPE_OPEN_DIALOG);
++#line 114 "ease-dialogs.c"
++}
++
++
++static void ease_open_dialog_class_init (EaseOpenDialogClass * klass) {
++ ease_open_dialog_parent_class = g_type_class_peek_parent (klass);
++}
++
++
++static void ease_open_dialog_instance_init (EaseOpenDialog * self) {
++}
++
++
++GType ease_open_dialog_get_type (void) {
++ static volatile gsize ease_open_dialog_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_open_dialog_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseOpenDialogClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_open_dialog_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseOpenDialog), 0, (GInstanceInitFunc) ease_open_dialog_instance_init, NULL };
++ GType ease_open_dialog_type_id;
++ ease_open_dialog_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseOpenDialog", &g_define_type_info, 0);
++ g_once_init_leave (&ease_open_dialog_type_id__volatile, ease_open_dialog_type_id);
++ }
++ return ease_open_dialog_type_id__volatile;
++}
++
++
++#line 58 "ease-dialogs.vala"
++char* save_dialog (const char* title, GtkWindow* modal) {
++#line 141 "ease-dialogs.c"
++ char* result = NULL;
++ GtkFileChooserDialog* dialog;
++#line 58 "ease-dialogs.vala"
++ g_return_val_if_fail (title != NULL, NULL);
++#line 60 "ease-dialogs.vala"
++ dialog = g_object_ref_sink ((GtkFileChooserDialog*) gtk_file_chooser_dialog_new (title, modal, GTK_FILE_CHOOSER_ACTION_SAVE, "gtk-save", GTK_RESPONSE_ACCEPT, "gtk-cancel", GTK_RESPONSE_CANCEL, NULL, NULL));
++#line 69 "ease-dialogs.vala"
++ if (gtk_dialog_run ((GtkDialog*) dialog) == GTK_RESPONSE_ACCEPT) {
++#line 150 "ease-dialogs.c"
++ char* path;
++#line 72 "ease-dialogs.vala"
++ path = gtk_file_chooser_get_filename ((GtkFileChooser*) dialog);
++#line 73 "ease-dialogs.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 156 "ease-dialogs.c"
++ result = path;
++ _g_object_unref0 (dialog);
++#line 74 "ease-dialogs.vala"
++ return result;
++#line 161 "ease-dialogs.c"
++ } else {
++#line 78 "ease-dialogs.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 165 "ease-dialogs.c"
++ result = NULL;
++ _g_object_unref0 (dialog);
++#line 79 "ease-dialogs.vala"
++ return result;
++#line 170 "ease-dialogs.c"
++ }
++ _g_object_unref0 (dialog);
++}
++
++
++
++
diff --cc ease-core/ease-document.c
index 0000000,0000000..60490c2
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-document.c
@@@ -1,0 -1,0 +1,1677 @@@
++/* ease-document.c generated by valac, the Vala compiler
++ * generated from ease-document.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++#include <gdk-pixbuf/gdk-pixdata.h>
++#include <json-glib/json-glib.h>
++#include <gio/gio.h>
++#include <cairo.h>
++#include <glib/gi18n-lib.h>
++#include <float.h>
++#include <math.h>
++#include <cairo-pdf.h>
++#include <cairo-ps.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++typedef struct _EaseDocumentPrivate EaseDocumentPrivate;
++
++#define EASE_ITERABLE_TYPE_LIST_STORE (ease_iterable_list_store_get_type ())
++#define EASE_ITERABLE_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStore))
++#define EASE_ITERABLE_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStoreClass))
++#define EASE_ITERABLE_IS_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_ITERABLE_TYPE_LIST_STORE))
++#define EASE_ITERABLE_IS_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_ITERABLE_TYPE_LIST_STORE))
++#define EASE_ITERABLE_LIST_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStoreClass))
++
++typedef struct _EaseIterableListStore EaseIterableListStore;
++typedef struct _EaseIterableListStoreClass EaseIterableListStoreClass;
++
++#define EASE_TYPE_THEME (ease_theme_get_type ())
++#define EASE_THEME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_THEME, EaseTheme))
++#define EASE_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_THEME, EaseThemeClass))
++#define EASE_IS_THEME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_THEME))
++#define EASE_IS_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_THEME))
++#define EASE_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_THEME, EaseThemeClass))
++
++typedef struct _EaseTheme EaseTheme;
++typedef struct _EaseThemeClass EaseThemeClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++#define _json_object_unref0(var) ((var == NULL) ? NULL : (var = (json_object_unref (var), NULL)))
++#define _json_array_unref0(var) ((var == NULL) ? NULL : (var = (json_array_unref (var), NULL)))
++
++#define EASE_ITERABLE_TYPE_TREE_MODEL (ease_iterable_tree_model_get_type ())
++#define EASE_ITERABLE_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_ITERABLE_TYPE_TREE_MODEL, EaseIterableTreeModel))
++#define EASE_ITERABLE_IS_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_ITERABLE_TYPE_TREE_MODEL))
++#define EASE_ITERABLE_TREE_MODEL_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_ITERABLE_TYPE_TREE_MODEL, EaseIterableTreeModelIface))
++
++typedef struct _EaseIterableTreeModel EaseIterableTreeModel;
++typedef struct _EaseIterableTreeModelIface EaseIterableTreeModelIface;
++
++#define EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR (ease_iterable_tree_model_iterator_get_type ())
++#define EASE_ITERABLE_TREE_MODEL_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR, EaseIterableTreeModelIterator))
++#define EASE_ITERABLE_TREE_MODEL_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR, EaseIterableTreeModelIteratorClass))
++#define EASE_ITERABLE_TREE_MODEL_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR))
++#define EASE_ITERABLE_TREE_MODEL_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR))
++#define EASE_ITERABLE_TREE_MODEL_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR, EaseIterableTreeModelIteratorClass))
++
++typedef struct _EaseIterableTreeModelIterator EaseIterableTreeModelIterator;
++typedef struct _EaseIterableTreeModelIteratorClass EaseIterableTreeModelIteratorClass;
++#define _ease_iterable_tree_model_iterator_unref0(var) ((var == NULL) ? NULL : (var = (ease_iterable_tree_model_iterator_unref (var), NULL)))
++#define _json_node_free0(var) ((var == NULL) ? NULL : (var = (json_node_free (var), NULL)))
++#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL)))
++#define _cairo_surface_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_surface_destroy (var), NULL)))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++
++#define EASE_TYPE_HTML_EXPORTER (ease_html_exporter_get_type ())
++#define EASE_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporter))
++#define EASE_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++#define EASE_IS_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_HTML_EXPORTER))
++#define EASE_IS_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_HTML_EXPORTER))
++#define EASE_HTML_EXPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++
++typedef struct _EaseHTMLExporter EaseHTMLExporter;
++typedef struct _EaseHTMLExporterClass EaseHTMLExporterClass;
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseDocument {
++ GObject parent_instance;
++ EaseDocumentPrivate * priv;
++ EaseIterableListStore* slides;
++};
++
++struct _EaseDocumentClass {
++ GObjectClass parent_class;
++};
++
++struct _EaseDocumentPrivate {
++ EaseTheme* _theme;
++ gint _width;
++ gint _height;
++ char* _filename;
++ char* _path;
++};
++
++struct _EaseIterableTreeModelIface {
++ GTypeInterface parent_iface;
++};
++
++
++static gpointer ease_document_parent_class = NULL;
++static EaseUndoSourceIface* ease_document_ease_undo_source_parent_iface = NULL;
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_document_get_type (void) G_GNUC_CONST;
++GType ease_iterable_list_store_get_type (void) G_GNUC_CONST;
++GType ease_theme_get_type (void) G_GNUC_CONST;
++#define EASE_DOCUMENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_DOCUMENT, EaseDocumentPrivate))
++enum {
++ EASE_DOCUMENT_DUMMY_PROPERTY,
++ EASE_DOCUMENT_THEME,
++ EASE_DOCUMENT_WIDTH,
++ EASE_DOCUMENT_HEIGHT,
++ EASE_DOCUMENT_ASPECT,
++ EASE_DOCUMENT_FILENAME,
++ EASE_DOCUMENT_PATH,
++ EASE_DOCUMENT_LENGTH
++};
++GType ease_slide_get_type (void) G_GNUC_CONST;
++EaseIterableListStore* ease_iterable_list_store_new (GType* types, int types_length1);
++EaseIterableListStore* ease_iterable_list_store_construct (GType object_type, GType* types, int types_length1);
++#define EASE_DOCUMENT_MEDIA_PATH "Media"
++#define EASE_DOCUMENT_JSON_FILE "Document.json"
++#define EASE_THEME_CONTENT_HEADER "content-header"
++#define EASE_DOCUMENT_DEFAULT_SLIDE EASE_THEME_CONTENT_HEADER
++#define EASE_THEME_TITLE "title"
++#define EASE_DOCUMENT_DEFAULT_FIRST EASE_THEME_TITLE
++#define EASE_DOCUMENT_THEME_PATH "Theme"
++#define EASE_DOCUMENT_MODEL_COLS 2
++#define EASE_DOCUMENT_COL_SLIDE 0
++#define EASE_DOCUMENT_COL_PIXBUF 1
++EaseDocument* ease_document_new (void);
++EaseDocument* ease_document_construct (GType object_type);
++char* ease_absolute_path (const char* path);
++void ease_document_set_filename (EaseDocument* self, const char* value);
++char* ease_temp_extract (const char* filename, GError** error);
++const char* ease_document_get_filename (EaseDocument* self);
++void ease_document_set_path (EaseDocument* self, const char* value);
++const char* ease_document_get_path (EaseDocument* self);
++void ease_document_set_width (EaseDocument* self, gint value);
++void ease_document_set_height (EaseDocument* self, gint value);
++void ease_document_append_slide (EaseDocument* self, EaseSlide* s);
++EaseSlide* ease_slide_new_from_json (JsonObject* obj);
++EaseSlide* ease_slide_construct_from_json (GType object_type, JsonObject* obj);
++#define EASE_THEME_JSON_PATH "Theme.json"
++EaseTheme* ease_theme_new_json (const char* json_path);
++EaseTheme* ease_theme_construct_json (GType object_type, const char* json_path);
++void ease_document_set_theme (EaseDocument* self, EaseTheme* value);
++void ease_theme_set_path (EaseTheme* self, const char* value);
++EaseTheme* ease_document_get_theme (EaseDocument* self);
++EaseDocument* ease_document_new_from_saved (const char* file_path, GError** error);
++EaseDocument* ease_document_construct_from_saved (GType object_type, const char* file_path, GError** error);
++char* ease_temp_request (GError** error);
++EaseTheme* ease_theme_copy_to_path (EaseTheme* self, const char* copy_to, GError** error);
++void ease_theme_copy_media (EaseTheme* self, const char* target, GError** error);
++EaseSlide* ease_theme_create_slide (EaseTheme* self, const char* master, gint width, gint height);
++gint ease_document_get_width (EaseDocument* self);
++gint ease_document_get_height (EaseDocument* self);
++void ease_slide_set_parent (EaseSlide* self, EaseDocument* value);
++EaseDocument* ease_document_new_from_theme (EaseTheme* doc_theme, gint w, gint h, GError** error);
++EaseDocument* ease_document_construct_from_theme (GType object_type, EaseTheme* doc_theme, gint w, gint h, GError** error);
++GType ease_iterable_tree_model_get_type (void) G_GNUC_CONST;
++gpointer ease_iterable_tree_model_iterator_ref (gpointer instance);
++void ease_iterable_tree_model_iterator_unref (gpointer instance);
++GParamSpec* ease_iterable_tree_model_param_spec_iterator (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
++void ease_iterable_tree_model_value_set_iterator (GValue* value, gpointer v_object);
++void ease_iterable_tree_model_value_take_iterator (GValue* value, gpointer v_object);
++gpointer ease_iterable_tree_model_value_get_iterator (const GValue* value);
++GType ease_iterable_tree_model_iterator_get_type (void) G_GNUC_CONST;
++EaseIterableTreeModelIterator* ease_iterable_tree_model_iterator (EaseIterableTreeModel* self);
++gboolean ease_iterable_tree_model_iterator_next (EaseIterableTreeModelIterator* self);
++void ease_iterable_tree_model_iterator_get (EaseIterableTreeModelIterator* self, GtkTreeIter* result);
++JsonNode* ease_slide_to_json (EaseSlide* self);
++void ease_temp_archive (const char* temp_path, const char* filename, GError** error);
++void ease_document_to_json (EaseDocument* self, GError** error);
++void ease_undo_source_listen (EaseUndoSource* self, EaseUndoSource* source);
++void ease_document_add_slide (EaseDocument* self, gint index, EaseSlide* s);
++gint ease_document_get_length (EaseDocument* self);
++void ease_undo_source_silence (EaseUndoSource* self, EaseUndoSource* source);
++EaseSlide* ease_document_remove_slide (EaseDocument* self, EaseSlide* slide);
++gboolean ease_document_has_next_slide (EaseDocument* self, EaseSlide* slide);
++gint ease_document_index_of (EaseDocument* self, EaseSlide* slide);
++EaseSlide* ease_document_get_slide (EaseDocument* self, gint index);
++const char* ease_slide_get_title (EaseSlide* self);
++EaseSlide* ease_document_slide_by_title (EaseDocument* self, const char* title);
++void ease_slide_cairo_render (EaseSlide* self, cairo_t* context, GError** error);
++void ease_document_cairo_render (EaseDocument* self, cairo_surface_t* surface, GError** error);
++char* save_dialog (const char* title, GtkWindow* modal);
++void ease_error_dialog (const char* title, const char* message);
++void ease_document_export_as_pdf (EaseDocument* self, GtkWindow* win);
++void ease_document_export_as_postscript (EaseDocument* self, GtkWindow* win);
++EaseHTMLExporter* ease_html_exporter_new (void);
++EaseHTMLExporter* ease_html_exporter_construct (GType object_type);
++GType ease_html_exporter_get_type (void) G_GNUC_CONST;
++gboolean ease_html_exporter_request_path (EaseHTMLExporter* self, GtkWindow* win);
++#define EASE_HTML_EXPORTER_HEADER "<!DOCTYPE html>\n" \
++"<html>\n" \
++"<head>\n" \
++"\t<title>Presentation</title>\n" \
++"\t\n" \
++"\t<script type=\"text/javascript\">\n" \
++"\t\tvar slide = -1;\n" \
++"\n" \
++"\t\tfunction load() {\n" \
++"\t\t\tadvance();\n" \
++"\t\t}\n" \
++"\n" \
++"\t\tfunction keydown(e) {\n" \
++"\t\t\tvar code = e.keyCode;\n" \
++"\t\t\tif (code == 32 || code == 39 || code == 13 || code == 40 || code" \
++" == 39) {\n" \
++"\t\t\t\tadvance();\n" \
++"\t\t\t}\n" \
++"\t\n" \
++"\t\t\telse if (code == 8 || code == 46 || code == 37 || code == 38) {\n" \
++"\t\t\t\tretreat();\n" \
++"\t\t\t}\n" \
++"\t\t}\n" \
++"\n" \
++"\t\tfunction advance() {\n" \
++"\t\t\tif (document.getElementById(\"slide\" + (slide + 1)) != null) {\n" \
++"\t\t\t\tif (slide >= 0) {\n" \
++"\t\t\t\t\tdocument.getElementById(\"slide\" + slide).style.display = \"" \
++"none\";\n" \
++"\t\t\t\t}\n" \
++"\t\t\t\tslide++;\n" \
++"\t\t\t\tdocument.getElementById(\"slide\" + slide).style.display = \"b" \
++"lock\";\n" \
++"\t\t\t}\n" \
++"\t\t}\n" \
++"\n" \
++"\t\tfunction retreat() {\n" \
++"\t\t\tif (slide > 0) {\n" \
++"\t\t\t\tdocument.getElementById(\"slide\" + slide).style.display = \"n" \
++"one\";\n" \
++"\t\t\t\tslide--;\n" \
++"\t\t\t\tdocument.getElementById(\"slide\" + slide).style.display = \"b" \
++"lock\";\n" \
++"\t\t\t}\n" \
++"\t\t}\n" \
++"\n" \
++"\t\tdocument.onkeydown = keydown;\n" \
++"\t</script>\n" \
++"\t\n" \
++"\t<style>\n" \
++"\t\t.slide {\n" \
++"\t\t\twidth: %ipx;\n" \
++"\t\t\theight: %ipx;\n" \
++"\t\t\tdisplay: none;\n" \
++"\t\t\toverflow: hidden;\n" \
++"\t\t\tposition: relative;\n" \
++"\t\t\tmargin: 20px auto 20px auto;\n" \
++"\t\t}\n" \
++"\t\thtml {\n" \
++"\t\t\tpadding: 0px;\n" \
++"\t\t\tmargin: 0px;\n" \
++"\t\t\tbackground-color: black;\n" \
++"\t\t}\n" \
++"\t</style>\n" \
++"</head>\n" \
++"<body onload=load()>\n"
++void ease_slide_to_html (EaseSlide* self, char** html, EaseHTMLExporter* exporter, double amount, gint index);
++gint ease_iterable_list_store_get_size (EaseIterableListStore* self);
++const char* ease_html_exporter_get_path (EaseHTMLExporter* self);
++void ease_html_exporter_finish (EaseHTMLExporter* self);
++void ease_document_export_as_html (EaseDocument* self, GtkWindow* window);
++char* ease_document_add_media_file (EaseDocument* self, const char* file, GError** error);
++float ease_document_get_aspect (EaseDocument* self);
++static void ease_document_finalize (GObject* obj);
++static void ease_document_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_document_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++static int _vala_strcmp0 (const char * str1, const char * str2);
++
++
++static void g_cclosure_user_marshal_VOID__OBJECT_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
++
++#line 121 "ease-document.vala"
++EaseDocument* ease_document_construct (GType object_type) {
++#line 264 "ease-document.c"
++ EaseDocument * self;
++#line 121 "ease-document.vala"
++ self = (EaseDocument*) g_object_new (object_type, NULL);
++#line 268 "ease-document.c"
++ return self;
++}
++
++
++#line 121 "ease-document.vala"
++EaseDocument* ease_document_new (void) {
++#line 121 "ease-document.vala"
++ return ease_document_construct (EASE_TYPE_DOCUMENT);
++#line 277 "ease-document.c"
++}
++
++
++static gpointer _json_object_ref0 (gpointer self) {
++ return self ? json_object_ref (self) : NULL;
++}
++
++
++static gpointer _json_array_ref0 (gpointer self) {
++ return self ? json_array_ref (self) : NULL;
++}
++
++
++#line 123 "ease-document.vala"
++EaseDocument* ease_document_construct_from_saved (GType object_type, const char* file_path, GError** error) {
++#line 293 "ease-document.c"
++ GError * _inner_error_;
++ EaseDocument * self;
++ char* _tmp0_;
++ char* _tmp1_;
++ char* _tmp2_;
++ JsonParser* parser;
++ char* _tmp3_;
++ JsonObject* root;
++ JsonArray* json_slides;
++ char* theme_path;
++ char* theme_full_path;
++ GFile* _tmp6_;
++ gboolean _tmp7_;
++#line 123 "ease-document.vala"
++ g_return_val_if_fail (file_path != NULL, NULL);
++#line 309 "ease-document.c"
++ _inner_error_ = NULL;
++#line 125 "ease-document.vala"
++ self = (EaseDocument*) ease_document_construct (object_type);
++#line 127 "ease-document.vala"
++ ease_document_set_filename (self, _tmp0_ = ease_absolute_path (file_path));
++#line 315 "ease-document.c"
++ _g_free0 (_tmp0_);
++#line 128 "ease-document.vala"
++ _tmp1_ = ease_temp_extract (self->priv->_filename, &_inner_error_);
++#line 319 "ease-document.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (self);
++ return NULL;
++ }
++#line 128 "ease-document.vala"
++ ease_document_set_path (self, _tmp2_ = _tmp1_);
++#line 327 "ease-document.c"
++ _g_free0 (_tmp2_);
++#line 130 "ease-document.vala"
++ parser = json_parser_new ();
++#line 133 "ease-document.vala"
++ json_parser_load_from_file (parser, _tmp3_ = g_build_filename (self->priv->_path, EASE_DOCUMENT_JSON_FILE, NULL), &_inner_error_);
++#line 333 "ease-document.c"
++ _g_free0 (_tmp3_);
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (parser);
++ _g_object_unref0 (self);
++ return NULL;
++ }
++#line 136 "ease-document.vala"
++ root = _json_object_ref0 (json_node_get_object (json_parser_get_root (parser)));
++#line 139 "ease-document.vala"
++ ease_document_set_width (self, (gint) atoi (json_object_get_string_member (root, "width")));
++#line 140 "ease-document.vala"
++ ease_document_set_height (self, (gint) atoi (json_object_get_string_member (root, "height")));
++#line 143 "ease-document.vala"
++ json_slides = _json_array_ref0 (json_object_get_array_member (root, "slides"));
++#line 349 "ease-document.c"
++ {
++ gint i;
++#line 145 "ease-document.vala"
++ i = 0;
++#line 354 "ease-document.c"
++ {
++ gboolean _tmp4_;
++#line 145 "ease-document.vala"
++ _tmp4_ = TRUE;
++#line 145 "ease-document.vala"
++ while (TRUE) {
++#line 361 "ease-document.c"
++ JsonObject* node;
++ EaseSlide* _tmp5_;
++#line 145 "ease-document.vala"
++ if (!_tmp4_) {
++#line 145 "ease-document.vala"
++ i++;
++#line 368 "ease-document.c"
++ }
++#line 145 "ease-document.vala"
++ _tmp4_ = FALSE;
++#line 145 "ease-document.vala"
++ if (!(i < json_array_get_length (json_slides))) {
++#line 145 "ease-document.vala"
++ break;
++#line 376 "ease-document.c"
++ }
++#line 147 "ease-document.vala"
++ node = _json_object_ref0 (json_array_get_object_element (json_slides, (guint) i));
++#line 148 "ease-document.vala"
++ ease_document_append_slide (self, _tmp5_ = ease_slide_new_from_json (node));
++#line 382 "ease-document.c"
++ _g_object_unref0 (_tmp5_);
++ _json_object_unref0 (node);
++ }
++ }
++ }
++#line 152 "ease-document.vala"
++ theme_path = g_build_filename (EASE_DOCUMENT_THEME_PATH, EASE_THEME_JSON_PATH, NULL);
++#line 153 "ease-document.vala"
++ theme_full_path = g_build_filename (self->priv->_path, theme_path, NULL);
++#line 155 "ease-document.vala"
++ if ((_tmp7_ = g_file_query_exists (_tmp6_ = g_file_new_for_path (theme_full_path), NULL), _g_object_unref0 (_tmp6_), _tmp7_)) {
++#line 394 "ease-document.c"
++ EaseTheme* _tmp8_;
++#line 157 "ease-document.vala"
++ ease_document_set_theme (self, _tmp8_ = ease_theme_new_json (theme_full_path));
++#line 398 "ease-document.c"
++ _g_object_unref0 (_tmp8_);
++#line 158 "ease-document.vala"
++ ease_theme_set_path (self->priv->_theme, theme_full_path);
++#line 402 "ease-document.c"
++ }
++ _g_free0 (theme_full_path);
++ _g_free0 (theme_path);
++ _json_array_unref0 (json_slides);
++ _json_object_unref0 (root);
++ _g_object_unref0 (parser);
++ return self;
++}
++
++
++#line 123 "ease-document.vala"
++EaseDocument* ease_document_new_from_saved (const char* file_path, GError** error) {
++#line 123 "ease-document.vala"
++ return ease_document_construct_from_saved (EASE_TYPE_DOCUMENT, file_path, error);
++#line 417 "ease-document.c"
++}
++
++
++#line 169 "ease-document.vala"
++EaseDocument* ease_document_construct_from_theme (GType object_type, EaseTheme* doc_theme, gint w, gint h, GError** error) {
++#line 423 "ease-document.c"
++ GError * _inner_error_;
++ EaseDocument * self;
++ char* _tmp0_;
++ char* _tmp1_;
++ char* _tmp2_;
++ EaseTheme* _tmp3_;
++ EaseTheme* _tmp4_;
++ EaseTheme* _tmp5_;
++ EaseSlide* slide;
++#line 169 "ease-document.vala"
++ g_return_val_if_fail (doc_theme != NULL, NULL);
++#line 435 "ease-document.c"
++ _inner_error_ = NULL;
++#line 169 "ease-document.vala"
++ self = (EaseDocument*) g_object_new (object_type, NULL);
++#line 172 "ease-document.vala"
++ g_assert (doc_theme != NULL);
++#line 175 "ease-document.vala"
++ ease_document_set_width (self, w);
++#line 176 "ease-document.vala"
++ ease_document_set_height (self, h);
++#line 179 "ease-document.vala"
++ _tmp0_ = ease_temp_request (&_inner_error_);
++#line 447 "ease-document.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (self);
++ return NULL;
++ }
++#line 179 "ease-document.vala"
++ ease_document_set_path (self, _tmp1_ = _tmp0_);
++#line 455 "ease-document.c"
++ _g_free0 (_tmp1_);
++#line 182 "ease-document.vala"
++ _tmp4_ = (_tmp3_ = ease_theme_copy_to_path (doc_theme, _tmp2_ = g_build_filename (self->priv->_path, EASE_DOCUMENT_THEME_PATH, NULL), &_inner_error_), _g_free0 (_tmp2_), _tmp3_);
++#line 459 "ease-document.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (self);
++ return NULL;
++ }
++#line 182 "ease-document.vala"
++ ease_document_set_theme (self, _tmp5_ = _tmp4_);
++#line 467 "ease-document.c"
++ _g_object_unref0 (_tmp5_);
++#line 185 "ease-document.vala"
++ ease_theme_copy_media (self->priv->_theme, self->priv->_path, &_inner_error_);
++#line 471 "ease-document.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (self);
++ return NULL;
++ }
++#line 188 "ease-document.vala"
++ slide = ease_theme_create_slide (self->priv->_theme, EASE_DOCUMENT_DEFAULT_FIRST, self->priv->_width, self->priv->_height);
++#line 189 "ease-document.vala"
++ ease_slide_set_parent (slide, self);
++#line 190 "ease-document.vala"
++ ease_document_append_slide (self, slide);
++#line 483 "ease-document.c"
++ _g_object_unref0 (slide);
++ return self;
++}
++
++
++#line 169 "ease-document.vala"
++EaseDocument* ease_document_new_from_theme (EaseTheme* doc_theme, gint w, gint h, GError** error) {
++#line 169 "ease-document.vala"
++ return ease_document_construct_from_theme (EASE_TYPE_DOCUMENT, doc_theme, w, h, error);
++#line 493 "ease-document.c"
++}
++
++
++#line 193 "ease-document.vala"
++void ease_document_to_json (EaseDocument* self, GError** error) {
++#line 499 "ease-document.c"
++ GError * _inner_error_;
++ JsonNode* root;
++ JsonObject* obj;
++ char* _tmp0_;
++ char* _tmp1_;
++ JsonArray* slides_json;
++ EaseSlide* s;
++ JsonGenerator* generator;
++ char* _tmp3_;
++#line 193 "ease-document.vala"
++ g_return_if_fail (self != NULL);
++#line 511 "ease-document.c"
++ _inner_error_ = NULL;
++#line 195 "ease-document.vala"
++ root = json_node_new (JSON_NODE_OBJECT);
++#line 196 "ease-document.vala"
++ obj = json_object_new ();
++#line 199 "ease-document.vala"
++ json_object_set_string_member (obj, "width", _tmp0_ = g_strdup_printf ("%i", self->priv->_width));
++#line 519 "ease-document.c"
++ _g_free0 (_tmp0_);
++#line 200 "ease-document.vala"
++ json_object_set_string_member (obj, "height", _tmp1_ = g_strdup_printf ("%i", self->priv->_height));
++#line 523 "ease-document.c"
++ _g_free0 (_tmp1_);
++#line 203 "ease-document.vala"
++ slides_json = json_array_new ();
++#line 527 "ease-document.c"
++ s = NULL;
++ {
++ EaseIterableTreeModelIterator* _itr_it;
++#line 205 "ease-document.vala"
++ _itr_it = ease_iterable_tree_model_iterator ((EaseIterableTreeModel*) self->slides);
++#line 205 "ease-document.vala"
++ while (TRUE) {
++#line 535 "ease-document.c"
++ GtkTreeIter _tmp2_ = {0};
++ GtkTreeIter itr;
++#line 205 "ease-document.vala"
++ if (!ease_iterable_tree_model_iterator_next (_itr_it)) {
++#line 205 "ease-document.vala"
++ break;
++#line 542 "ease-document.c"
++ }
++#line 205 "ease-document.vala"
++ itr = (ease_iterable_tree_model_iterator_get (_itr_it, &_tmp2_), _tmp2_);
++#line 207 "ease-document.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &s, -1);
++#line 208 "ease-document.vala"
++ json_array_add_element (slides_json, ease_slide_to_json (s));
++#line 550 "ease-document.c"
++ }
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++ }
++#line 210 "ease-document.vala"
++ json_object_set_array_member (obj, "slides", _json_array_ref0 (slides_json));
++#line 213 "ease-document.vala"
++ json_node_set_object (root, obj);
++#line 216 "ease-document.vala"
++ generator = json_generator_new ();
++#line 217 "ease-document.vala"
++ json_generator_set_root (generator, root);
++#line 218 "ease-document.vala"
++ g_object_set (generator, "pretty", TRUE, NULL);
++#line 219 "ease-document.vala"
++ json_generator_to_file (generator, _tmp3_ = g_build_filename (self->priv->_path, EASE_DOCUMENT_JSON_FILE, NULL), &_inner_error_);
++#line 566 "ease-document.c"
++ _g_free0 (_tmp3_);
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (generator);
++ _g_object_unref0 (s);
++ _json_array_unref0 (slides_json);
++ _json_object_unref0 (obj);
++ _json_node_free0 (root);
++ return;
++ }
++#line 222 "ease-document.vala"
++ ease_temp_archive (self->priv->_path, self->priv->_filename, &_inner_error_);
++#line 579 "ease-document.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (generator);
++ _g_object_unref0 (s);
++ _json_array_unref0 (slides_json);
++ _json_object_unref0 (obj);
++ _json_node_free0 (root);
++ return;
++ }
++ _g_object_unref0 (generator);
++ _g_object_unref0 (s);
++ _json_array_unref0 (slides_json);
++ _json_object_unref0 (obj);
++ _json_node_free0 (root);
++}
++
++
++#line 231 "ease-document.vala"
++void ease_document_add_slide (EaseDocument* self, gint index, EaseSlide* s) {
++#line 599 "ease-document.c"
++ GtkTreeIter itr = {0};
++#line 231 "ease-document.vala"
++ g_return_if_fail (self != NULL);
++#line 231 "ease-document.vala"
++ g_return_if_fail (s != NULL);
++#line 233 "ease-document.vala"
++ ease_slide_set_parent (s, self);
++#line 235 "ease-document.vala"
++ gtk_list_store_insert ((GtkListStore*) self->slides, &itr, index);
++#line 236 "ease-document.vala"
++ gtk_list_store_set ((GtkListStore*) self->slides, &itr, EASE_DOCUMENT_COL_SLIDE, s, -1);
++#line 237 "ease-document.vala"
++ g_signal_emit_by_name (self, "slide-added", s, index);
++#line 238 "ease-document.vala"
++ ease_undo_source_listen ((EaseUndoSource*) self, (EaseUndoSource*) s);
++#line 615 "ease-document.c"
++}
++
++
++#line 244 "ease-document.vala"
++void ease_document_append_slide (EaseDocument* self, EaseSlide* s) {
++#line 244 "ease-document.vala"
++ g_return_if_fail (self != NULL);
++#line 244 "ease-document.vala"
++ g_return_if_fail (s != NULL);
++#line 246 "ease-document.vala"
++ ease_document_add_slide (self, ease_document_get_length (self), s);
++#line 627 "ease-document.c"
++}
++
++
++#line 255 "ease-document.vala"
++EaseSlide* ease_document_remove_slide (EaseDocument* self, EaseSlide* slide) {
++#line 633 "ease-document.c"
++ EaseSlide* result = NULL;
++ EaseSlide* s;
++ gint index;
++ EaseSlide* ret;
++ GtkTreeIter itr = {0};
++#line 255 "ease-document.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 255 "ease-document.vala"
++ g_return_val_if_fail (slide != NULL, NULL);
++#line 643 "ease-document.c"
++ s = NULL;
++#line 258 "ease-document.vala"
++ index = 0;
++#line 647 "ease-document.c"
++ {
++ EaseIterableTreeModelIterator* _itr_it;
++#line 259 "ease-document.vala"
++ _itr_it = ease_iterable_tree_model_iterator ((EaseIterableTreeModel*) self->slides);
++#line 259 "ease-document.vala"
++ while (TRUE) {
++#line 654 "ease-document.c"
++ GtkTreeIter _tmp0_ = {0};
++ GtkTreeIter itr;
++#line 259 "ease-document.vala"
++ if (!ease_iterable_tree_model_iterator_next (_itr_it)) {
++#line 259 "ease-document.vala"
++ break;
++#line 661 "ease-document.c"
++ }
++#line 259 "ease-document.vala"
++ itr = (ease_iterable_tree_model_iterator_get (_itr_it, &_tmp0_), _tmp0_);
++#line 261 "ease-document.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &s, -1);
++#line 262 "ease-document.vala"
++ if (slide == s) {
++#line 264 "ease-document.vala"
++ gtk_list_store_remove ((GtkListStore*) self->slides, &itr);
++#line 265 "ease-document.vala"
++ g_signal_emit_by_name (self, "slide-deleted", s, index);
++#line 266 "ease-document.vala"
++ ease_undo_source_silence ((EaseUndoSource*) self, (EaseUndoSource*) s);
++#line 267 "ease-document.vala"
++ break;
++#line 677 "ease-document.c"
++ }
++#line 269 "ease-document.vala"
++ index++;
++#line 681 "ease-document.c"
++ }
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++ }
++ ret = NULL;
++#line 274 "ease-document.vala"
++ gtk_tree_model_get_iter_first ((GtkTreeModel*) self->slides, &itr);
++#line 688 "ease-document.c"
++ {
++ gint i;
++#line 277 "ease-document.vala"
++ i = 1;
++#line 693 "ease-document.c"
++ {
++ gboolean _tmp1_;
++#line 277 "ease-document.vala"
++ _tmp1_ = TRUE;
++#line 277 "ease-document.vala"
++ while (TRUE) {
++#line 277 "ease-document.vala"
++ if (!_tmp1_) {
++#line 277 "ease-document.vala"
++ i++;
++#line 704 "ease-document.c"
++ }
++#line 277 "ease-document.vala"
++ _tmp1_ = FALSE;
++#line 277 "ease-document.vala"
++ if (!(i < index)) {
++#line 277 "ease-document.vala"
++ break;
++#line 712 "ease-document.c"
++ }
++#line 277 "ease-document.vala"
++ gtk_tree_model_iter_next ((GtkTreeModel*) self->slides, &itr);
++#line 716 "ease-document.c"
++ }
++ }
++ }
++#line 280 "ease-document.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &ret, -1);
++#line 722 "ease-document.c"
++ result = ret;
++ _g_object_unref0 (s);
++#line 281 "ease-document.vala"
++ return result;
++#line 727 "ease-document.c"
++}
++
++
++#line 288 "ease-document.vala"
++gboolean ease_document_has_next_slide (EaseDocument* self, EaseSlide* slide) {
++#line 733 "ease-document.c"
++ gboolean result = FALSE;
++ EaseSlide* s;
++ GtkTreeIter itr = {0};
++#line 288 "ease-document.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 288 "ease-document.vala"
++ g_return_val_if_fail (slide != NULL, FALSE);
++#line 741 "ease-document.c"
++ s = NULL;
++#line 292 "ease-document.vala"
++ if (!gtk_tree_model_get_iter_first ((GtkTreeModel*) self->slides, &itr)) {
++#line 745 "ease-document.c"
++ result = FALSE;
++ _g_object_unref0 (s);
++#line 292 "ease-document.vala"
++ return result;
++#line 750 "ease-document.c"
++ }
++ {
++ gboolean _tmp0_;
++#line 294 "ease-document.vala"
++ _tmp0_ = TRUE;
++#line 294 "ease-document.vala"
++ while (TRUE) {
++#line 294 "ease-document.vala"
++ if (!_tmp0_) {
++#line 298 "ease-document.vala"
++ if (!gtk_tree_model_iter_next ((GtkTreeModel*) self->slides, &itr)) {
++#line 298 "ease-document.vala"
++ break;
++#line 764 "ease-document.c"
++ }
++ }
++#line 294 "ease-document.vala"
++ _tmp0_ = FALSE;
++#line 296 "ease-document.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &s, -1);
++#line 297 "ease-document.vala"
++ if (s == slide) {
++#line 773 "ease-document.c"
++ result = gtk_tree_model_iter_next ((GtkTreeModel*) self->slides, &itr);
++ _g_object_unref0 (s);
++#line 297 "ease-document.vala"
++ return result;
++#line 778 "ease-document.c"
++ }
++ }
++ }
++ result = FALSE;
++ _g_object_unref0 (s);
++#line 300 "ease-document.vala"
++ return result;
++#line 786 "ease-document.c"
++}
++
++
++#line 308 "ease-document.vala"
++gint ease_document_index_of (EaseDocument* self, EaseSlide* slide) {
++#line 792 "ease-document.c"
++ gint result = 0;
++ EaseSlide* s;
++ gint i;
++#line 308 "ease-document.vala"
++ g_return_val_if_fail (self != NULL, 0);
++#line 308 "ease-document.vala"
++ g_return_val_if_fail (slide != NULL, 0);
++#line 800 "ease-document.c"
++ s = NULL;
++#line 311 "ease-document.vala"
++ i = 0;
++#line 804 "ease-document.c"
++ {
++ EaseIterableTreeModelIterator* _itr_it;
++#line 312 "ease-document.vala"
++ _itr_it = ease_iterable_tree_model_iterator ((EaseIterableTreeModel*) self->slides);
++#line 312 "ease-document.vala"
++ while (TRUE) {
++#line 811 "ease-document.c"
++ GtkTreeIter _tmp0_ = {0};
++ GtkTreeIter itr;
++#line 312 "ease-document.vala"
++ if (!ease_iterable_tree_model_iterator_next (_itr_it)) {
++#line 312 "ease-document.vala"
++ break;
++#line 818 "ease-document.c"
++ }
++#line 312 "ease-document.vala"
++ itr = (ease_iterable_tree_model_iterator_get (_itr_it, &_tmp0_), _tmp0_);
++#line 314 "ease-document.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &s, -1);
++#line 315 "ease-document.vala"
++ if (s == slide) {
++#line 826 "ease-document.c"
++ result = i;
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++ _g_object_unref0 (s);
++#line 317 "ease-document.vala"
++ return result;
++#line 832 "ease-document.c"
++ }
++#line 319 "ease-document.vala"
++ i++;
++#line 836 "ease-document.c"
++ }
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++ }
++ result = -1;
++ _g_object_unref0 (s);
++#line 321 "ease-document.vala"
++ return result;
++#line 844 "ease-document.c"
++}
++
++
++#line 327 "ease-document.vala"
++EaseSlide* ease_document_get_slide (EaseDocument* self, gint index) {
++#line 850 "ease-document.c"
++ EaseSlide* result = NULL;
++ EaseSlide* ret;
++ GtkTreeIter itr = {0};
++#line 327 "ease-document.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 856 "ease-document.c"
++ ret = NULL;
++#line 331 "ease-document.vala"
++ gtk_tree_model_get_iter_first ((GtkTreeModel*) self->slides, &itr);
++#line 860 "ease-document.c"
++ {
++ gint i;
++#line 334 "ease-document.vala"
++ i = 0;
++#line 865 "ease-document.c"
++ {
++ gboolean _tmp0_;
++#line 334 "ease-document.vala"
++ _tmp0_ = TRUE;
++#line 334 "ease-document.vala"
++ while (TRUE) {
++#line 334 "ease-document.vala"
++ if (!_tmp0_) {
++#line 334 "ease-document.vala"
++ i++;
++#line 876 "ease-document.c"
++ }
++#line 334 "ease-document.vala"
++ _tmp0_ = FALSE;
++#line 334 "ease-document.vala"
++ if (!(i < index)) {
++#line 334 "ease-document.vala"
++ break;
++#line 884 "ease-document.c"
++ }
++#line 334 "ease-document.vala"
++ gtk_tree_model_iter_next ((GtkTreeModel*) self->slides, &itr);
++#line 888 "ease-document.c"
++ }
++ }
++ }
++#line 337 "ease-document.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &ret, -1);
++#line 894 "ease-document.c"
++ result = ret;
++#line 338 "ease-document.vala"
++ return result;
++#line 898 "ease-document.c"
++}
++
++
++#line 346 "ease-document.vala"
++EaseSlide* ease_document_slide_by_title (EaseDocument* self, const char* title) {
++#line 904 "ease-document.c"
++ EaseSlide* result = NULL;
++ EaseSlide* s;
++#line 346 "ease-document.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 346 "ease-document.vala"
++ g_return_val_if_fail (title != NULL, NULL);
++#line 911 "ease-document.c"
++ s = NULL;
++ {
++ EaseIterableTreeModelIterator* _itr_it;
++#line 349 "ease-document.vala"
++ _itr_it = ease_iterable_tree_model_iterator ((EaseIterableTreeModel*) self->slides);
++#line 349 "ease-document.vala"
++ while (TRUE) {
++#line 919 "ease-document.c"
++ GtkTreeIter _tmp0_ = {0};
++ GtkTreeIter itr;
++#line 349 "ease-document.vala"
++ if (!ease_iterable_tree_model_iterator_next (_itr_it)) {
++#line 349 "ease-document.vala"
++ break;
++#line 926 "ease-document.c"
++ }
++#line 349 "ease-document.vala"
++ itr = (ease_iterable_tree_model_iterator_get (_itr_it, &_tmp0_), _tmp0_);
++#line 351 "ease-document.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &s, -1);
++#line 352 "ease-document.vala"
++ if (_vala_strcmp0 (ease_slide_get_title (s), title) == 0) {
++#line 934 "ease-document.c"
++ result = s;
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++#line 354 "ease-document.vala"
++ return result;
++#line 939 "ease-document.c"
++ }
++ }
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++ }
++ result = NULL;
++ _g_object_unref0 (s);
++#line 357 "ease-document.vala"
++ return result;
++#line 948 "ease-document.c"
++}
++
++
++#line 366 "ease-document.vala"
++void ease_document_cairo_render (EaseDocument* self, cairo_surface_t* surface, GError** error) {
++#line 954 "ease-document.c"
++ GError * _inner_error_;
++ cairo_t* context;
++ EaseSlide* s;
++#line 366 "ease-document.vala"
++ g_return_if_fail (self != NULL);
++#line 366 "ease-document.vala"
++ g_return_if_fail (surface != NULL);
++#line 962 "ease-document.c"
++ _inner_error_ = NULL;
++#line 368 "ease-document.vala"
++ context = cairo_create (surface);
++#line 966 "ease-document.c"
++ s = NULL;
++ {
++ EaseIterableTreeModelIterator* _itr_it;
++#line 371 "ease-document.vala"
++ _itr_it = ease_iterable_tree_model_iterator ((EaseIterableTreeModel*) self->slides);
++#line 371 "ease-document.vala"
++ while (TRUE) {
++#line 974 "ease-document.c"
++ GtkTreeIter _tmp0_ = {0};
++ GtkTreeIter itr;
++#line 371 "ease-document.vala"
++ if (!ease_iterable_tree_model_iterator_next (_itr_it)) {
++#line 371 "ease-document.vala"
++ break;
++#line 981 "ease-document.c"
++ }
++#line 371 "ease-document.vala"
++ itr = (ease_iterable_tree_model_iterator_get (_itr_it, &_tmp0_), _tmp0_);
++#line 373 "ease-document.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &s, -1);
++#line 374 "ease-document.vala"
++ ease_slide_cairo_render (s, context, &_inner_error_);
++#line 989 "ease-document.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++ _g_object_unref0 (s);
++ _cairo_destroy0 (context);
++ return;
++ }
++#line 375 "ease-document.vala"
++ cairo_show_page (context);
++#line 999 "ease-document.c"
++ }
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++ }
++#line 378 "ease-document.vala"
++ cairo_surface_flush (surface);
++#line 379 "ease-document.vala"
++ cairo_surface_finish (surface);
++#line 1007 "ease-document.c"
++ _g_object_unref0 (s);
++ _cairo_destroy0 (context);
++}
++
++
++#line 387 "ease-document.vala"
++void ease_document_export_as_pdf (EaseDocument* self, GtkWindow* win) {
++#line 1015 "ease-document.c"
++ GError * _inner_error_;
++ char* path;
++#line 387 "ease-document.vala"
++ g_return_if_fail (self != NULL);
++#line 387 "ease-document.vala"
++ g_return_if_fail (win != NULL);
++#line 1022 "ease-document.c"
++ _inner_error_ = NULL;
++#line 389 "ease-document.vala"
++ path = save_dialog (_ ("Export as PDF"), win);
++#line 390 "ease-document.vala"
++ if (path == NULL) {
++#line 1028 "ease-document.c"
++ _g_free0 (path);
++#line 390 "ease-document.vala"
++ return;
++#line 1032 "ease-document.c"
++ }
++ {
++ cairo_surface_t* _tmp0_;
++#line 395 "ease-document.vala"
++ ease_document_cairo_render (self, _tmp0_ = cairo_pdf_surface_create (path, (double) self->priv->_width, (double) self->priv->_height), &_inner_error_);
++#line 1038 "ease-document.c"
++ _cairo_surface_destroy0 (_tmp0_);
++ if (_inner_error_ != NULL) {
++ goto __catch1_g_error;
++ }
++ }
++ goto __finally1;
++ __catch1_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 399 "ease-document.vala"
++ ease_error_dialog (_ ("Error Exporting to PDF"), e->message);
++#line 1053 "ease-document.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally1:
++ if (_inner_error_ != NULL) {
++ _g_free0 (path);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++ _g_free0 (path);
++}
++
++
++#line 408 "ease-document.vala"
++void ease_document_export_as_postscript (EaseDocument* self, GtkWindow* win) {
++#line 1070 "ease-document.c"
++ GError * _inner_error_;
++ char* path;
++#line 408 "ease-document.vala"
++ g_return_if_fail (self != NULL);
++#line 408 "ease-document.vala"
++ g_return_if_fail (win != NULL);
++#line 1077 "ease-document.c"
++ _inner_error_ = NULL;
++#line 410 "ease-document.vala"
++ path = save_dialog (_ ("Export as PostScript"), win);
++#line 411 "ease-document.vala"
++ if (path == NULL) {
++#line 1083 "ease-document.c"
++ _g_free0 (path);
++#line 411 "ease-document.vala"
++ return;
++#line 1087 "ease-document.c"
++ }
++ {
++ cairo_surface_t* _tmp0_;
++#line 416 "ease-document.vala"
++ ease_document_cairo_render (self, _tmp0_ = cairo_ps_surface_create (path, (double) self->priv->_width, (double) self->priv->_height), &_inner_error_);
++#line 1093 "ease-document.c"
++ _cairo_surface_destroy0 (_tmp0_);
++ if (_inner_error_ != NULL) {
++ goto __catch2_g_error;
++ }
++ }
++ goto __finally2;
++ __catch2_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 420 "ease-document.vala"
++ ease_error_dialog (_ ("Error Exporting to PostScript"), e->message);
++#line 1108 "ease-document.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally2:
++ if (_inner_error_ != NULL) {
++ _g_free0 (path);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++ _g_free0 (path);
++}
++
++
++#line 429 "ease-document.vala"
++void ease_document_export_as_html (EaseDocument* self, GtkWindow* window) {
++#line 1125 "ease-document.c"
++ GError * _inner_error_;
++ EaseHTMLExporter* exporter;
++ char* html;
++ EaseSlide* slide;
++ gint index;
++ char* _tmp1_;
++#line 429 "ease-document.vala"
++ g_return_if_fail (self != NULL);
++#line 429 "ease-document.vala"
++ g_return_if_fail (window != NULL);
++#line 1136 "ease-document.c"
++ _inner_error_ = NULL;
++#line 432 "ease-document.vala"
++ exporter = ease_html_exporter_new ();
++#line 434 "ease-document.vala"
++ if (!ease_html_exporter_request_path (exporter, window)) {
++#line 1142 "ease-document.c"
++ _g_object_unref0 (exporter);
++#line 436 "ease-document.vala"
++ return;
++#line 1146 "ease-document.c"
++ }
++#line 440 "ease-document.vala"
++ html = g_strdup_printf (EASE_HTML_EXPORTER_HEADER, self->priv->_width, self->priv->_height);
++#line 1150 "ease-document.c"
++ slide = NULL;
++#line 446 "ease-document.vala"
++ index = 0;
++#line 1154 "ease-document.c"
++ {
++ EaseIterableTreeModelIterator* _itr_it;
++#line 447 "ease-document.vala"
++ _itr_it = ease_iterable_tree_model_iterator ((EaseIterableTreeModel*) self->slides);
++#line 447 "ease-document.vala"
++ while (TRUE) {
++#line 1161 "ease-document.c"
++ GtkTreeIter _tmp0_ = {0};
++ GtkTreeIter itr;
++#line 447 "ease-document.vala"
++ if (!ease_iterable_tree_model_iterator_next (_itr_it)) {
++#line 447 "ease-document.vala"
++ break;
++#line 1168 "ease-document.c"
++ }
++#line 447 "ease-document.vala"
++ itr = (ease_iterable_tree_model_iterator_get (_itr_it, &_tmp0_), _tmp0_);
++#line 449 "ease-document.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &slide, -1);
++#line 450 "ease-document.vala"
++ ease_slide_to_html (slide, &html, exporter, 1.0 / ease_iterable_list_store_get_size (self->slides), index);
++#line 451 "ease-document.vala"
++ index++;
++#line 1178 "ease-document.c"
++ }
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++ }
++#line 455 "ease-document.vala"
++ html = (_tmp1_ = g_strconcat (html, "\n</body>\n</html>\n", NULL), _g_free0 (html), _tmp1_);
++#line 1184 "ease-document.c"
++ {
++ GFile* file;
++ GFileOutputStream* stream;
++ GDataOutputStream* data_stream;
++#line 460 "ease-document.vala"
++ file = g_file_new_for_path (ease_html_exporter_get_path (exporter));
++#line 461 "ease-document.vala"
++ stream = g_file_replace (file, NULL, TRUE, G_FILE_CREATE_NONE, NULL, &_inner_error_);
++#line 1193 "ease-document.c"
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (file);
++ goto __catch3_g_error;
++ }
++#line 462 "ease-document.vala"
++ data_stream = g_data_output_stream_new ((GOutputStream*) stream);
++#line 463 "ease-document.vala"
++ g_data_output_stream_put_string (data_stream, html, NULL, &_inner_error_);
++#line 1202 "ease-document.c"
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (data_stream);
++ _g_object_unref0 (stream);
++ _g_object_unref0 (file);
++ goto __catch3_g_error;
++ }
++ _g_object_unref0 (data_stream);
++ _g_object_unref0 (stream);
++ _g_object_unref0 (file);
++ }
++ goto __finally3;
++ __catch3_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 467 "ease-document.vala"
++ ease_error_dialog (_ ("Error exporting as HTML"), e->message);
++#line 1222 "ease-document.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally3:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (slide);
++ _g_free0 (html);
++ _g_object_unref0 (exporter);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++#line 470 "ease-document.vala"
++ ease_html_exporter_finish (exporter);
++#line 1237 "ease-document.c"
++ _g_object_unref0 (slide);
++ _g_free0 (html);
++ _g_object_unref0 (exporter);
++}
++
++
++#line 481 "ease-document.vala"
++char* ease_document_add_media_file (EaseDocument* self, const char* file, GError** error) {
++#line 1246 "ease-document.c"
++ char* result = NULL;
++ GError * _inner_error_;
++ char* _tmp0_;
++ GFile* _tmp1_;
++ GFile* media;
++ GFile* orig;
++ char* _tmp2_;
++ char* _tmp3_;
++ char* rel_path;
++ char* _tmp4_;
++ GFile* _tmp5_;
++ GFile* dest;
++#line 481 "ease-document.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 481 "ease-document.vala"
++ g_return_val_if_fail (file != NULL, NULL);
++#line 1263 "ease-document.c"
++ _inner_error_ = NULL;
++#line 484 "ease-document.vala"
++ media = (_tmp1_ = g_file_new_for_path (_tmp0_ = g_build_filename (self->priv->_path, EASE_DOCUMENT_MEDIA_PATH, NULL)), _g_free0 (_tmp0_), _tmp1_);
++#line 485 "ease-document.vala"
++ if (!g_file_query_exists (media, NULL)) {
++#line 485 "ease-document.vala"
++ g_file_make_directory_with_parents (media, NULL, &_inner_error_);
++#line 1271 "ease-document.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (media);
++ return NULL;
++ }
++ }
++#line 488 "ease-document.vala"
++ orig = g_file_new_for_path (file);
++#line 489 "ease-document.vala"
++ rel_path = (_tmp3_ = g_build_filename (EASE_DOCUMENT_MEDIA_PATH, _tmp2_ = g_file_get_basename (orig), NULL), _g_free0 (_tmp2_), _tmp3_);
++#line 490 "ease-document.vala"
++ dest = (_tmp5_ = g_file_new_for_path (_tmp4_ = g_build_filename (self->priv->_path, rel_path, NULL)), _g_free0 (_tmp4_), _tmp5_);
++#line 1284 "ease-document.c"
++ {
++ gint i;
++#line 493 "ease-document.vala"
++ i = 0;
++#line 1289 "ease-document.c"
++ {
++ gboolean _tmp6_;
++#line 493 "ease-document.vala"
++ _tmp6_ = TRUE;
++#line 493 "ease-document.vala"
++ while (TRUE) {
++#line 1296 "ease-document.c"
++ char* _tmp11_;
++ char* _tmp10_;
++ char* _tmp9_;
++ char* _tmp8_;
++ char* _tmp7_;
++ GFile* _tmp13_;
++ char* _tmp12_;
++#line 493 "ease-document.vala"
++ if (!_tmp6_) {
++#line 493 "ease-document.vala"
++ i++;
++#line 1308 "ease-document.c"
++ }
++#line 493 "ease-document.vala"
++ _tmp6_ = FALSE;
++#line 493 "ease-document.vala"
++ if (!g_file_query_exists (dest, NULL)) {
++#line 493 "ease-document.vala"
++ break;
++#line 1316 "ease-document.c"
++ }
++#line 495 "ease-document.vala"
++ rel_path = (_tmp11_ = g_build_filename (EASE_DOCUMENT_MEDIA_PATH, _tmp10_ = g_strconcat (_tmp8_ = g_strconcat (_tmp7_ = g_strdup_printf ("%i", i), "-", NULL), _tmp9_ = g_file_get_basename (orig), NULL), NULL), _g_free0 (rel_path), _tmp11_);
++#line 1320 "ease-document.c"
++ _g_free0 (_tmp10_);
++ _g_free0 (_tmp9_);
++ _g_free0 (_tmp8_);
++ _g_free0 (_tmp7_);
++#line 497 "ease-document.vala"
++ dest = (_tmp13_ = g_file_new_for_path (_tmp12_ = g_build_filename (self->priv->_path, rel_path, NULL)), _g_object_unref0 (dest), _tmp13_);
++#line 1327 "ease-document.c"
++ _g_free0 (_tmp12_);
++ }
++ }
++ }
++#line 501 "ease-document.vala"
++ g_file_copy (orig, dest, 0, NULL, NULL, NULL, &_inner_error_);
++#line 1334 "ease-document.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (dest);
++ _g_free0 (rel_path);
++ _g_object_unref0 (orig);
++ _g_object_unref0 (media);
++ return NULL;
++ }
++ result = rel_path;
++ _g_object_unref0 (dest);
++ _g_object_unref0 (orig);
++ _g_object_unref0 (media);
++#line 502 "ease-document.vala"
++ return result;
++#line 1349 "ease-document.c"
++}
++
++
++EaseTheme* ease_document_get_theme (EaseDocument* self) {
++ EaseTheme* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_theme;
++#line 66 "ease-document.vala"
++ return result;
++#line 1359 "ease-document.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++void ease_document_set_theme (EaseDocument* self, EaseTheme* value) {
++ EaseTheme* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_theme = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_theme), _tmp0_);
++ g_object_notify ((GObject *) self, "theme");
++}
++
++
++gint ease_document_get_width (EaseDocument* self) {
++ gint result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->_width;
++#line 71 "ease-document.vala"
++ return result;
++#line 1382 "ease-document.c"
++}
++
++
++void ease_document_set_width (EaseDocument* self, gint value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_width = value;
++ g_object_notify ((GObject *) self, "width");
++}
++
++
++gint ease_document_get_height (EaseDocument* self) {
++ gint result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->_height;
++#line 76 "ease-document.vala"
++ return result;
++#line 1399 "ease-document.c"
++}
++
++
++void ease_document_set_height (EaseDocument* self, gint value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_height = value;
++ g_object_notify ((GObject *) self, "height");
++}
++
++
++float ease_document_get_aspect (EaseDocument* self) {
++ float result;
++ g_return_val_if_fail (self != NULL, 0.0F);
++ result = ((float) self->priv->_width) / ((float) self->priv->_height);
++#line 81 "ease-document.vala"
++ return result;
++#line 1416 "ease-document.c"
++}
++
++
++const char* ease_document_get_filename (EaseDocument* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_filename;
++#line 87 "ease-document.vala"
++ return result;
++#line 1426 "ease-document.c"
++}
++
++
++void ease_document_set_filename (EaseDocument* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_filename = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_filename), _tmp0_);
++ g_object_notify ((GObject *) self, "filename");
++}
++
++
++const char* ease_document_get_path (EaseDocument* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_path;
++#line 92 "ease-document.vala"
++ return result;
++#line 1444 "ease-document.c"
++}
++
++
++void ease_document_set_path (EaseDocument* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_path = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_path), _tmp0_);
++ g_object_notify ((GObject *) self, "path");
++}
++
++
++gint ease_document_get_length (EaseDocument* self) {
++ gint result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = ease_iterable_list_store_get_size (self->slides);
++#line 104 "ease-document.vala"
++ return result;
++#line 1462 "ease-document.c"
++}
++
++
++static void ease_document_class_init (EaseDocumentClass * klass) {
++ ease_document_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseDocumentPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_document_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_document_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_document_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_DOCUMENT_THEME, g_param_spec_object ("theme", "theme", "theme", EASE_TYPE_THEME, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_DOCUMENT_WIDTH, g_param_spec_int ("width", "width", "width", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_DOCUMENT_HEIGHT, g_param_spec_int ("height", "height", "height", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_DOCUMENT_ASPECT, g_param_spec_float ("aspect", "aspect", "aspect", -G_MAXFLOAT, G_MAXFLOAT, 0.0F, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_DOCUMENT_FILENAME, g_param_spec_string ("filename", "filename", "filename", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_DOCUMENT_PATH, g_param_spec_string ("path", "path", "path", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_DOCUMENT_LENGTH, g_param_spec_int ("length", "length", "length", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_signal_new ("slide_deleted", EASE_TYPE_DOCUMENT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_INT, G_TYPE_NONE, 2, EASE_TYPE_SLIDE, G_TYPE_INT);
++ g_signal_new ("slide_added", EASE_TYPE_DOCUMENT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_INT, G_TYPE_NONE, 2, EASE_TYPE_SLIDE, G_TYPE_INT);
++}
++
++
++static void ease_document_ease_undo_source_interface_init (EaseUndoSourceIface * iface) {
++ ease_document_ease_undo_source_parent_iface = g_type_interface_peek_parent (iface);
++}
++
++
++static void ease_document_instance_init (EaseDocument * self) {
++ gint _tmp1__length1;
++ GType* _tmp1_;
++ GType* _tmp0_ = NULL;
++ self->priv = EASE_DOCUMENT_GET_PRIVATE (self);
++ self->slides = ease_iterable_list_store_new ((_tmp1_ = (_tmp0_ = g_new0 (GType, 2), _tmp0_[0] = EASE_TYPE_SLIDE, _tmp0_[1] = GDK_TYPE_PIXBUF, _tmp0_), _tmp1__length1 = 2, _tmp1_), 2);
++ _tmp1_ = (g_free (_tmp1_), NULL);
++}
++
++
++static void ease_document_finalize (GObject* obj) {
++ EaseDocument * self;
++ self = EASE_DOCUMENT (obj);
++ _g_object_unref0 (self->priv->_theme);
++ _g_free0 (self->priv->_filename);
++ _g_free0 (self->priv->_path);
++ _g_object_unref0 (self->slides);
++ G_OBJECT_CLASS (ease_document_parent_class)->finalize (obj);
++}
++
++
++GType ease_document_get_type (void) {
++ static volatile gsize ease_document_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_document_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseDocumentClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_document_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseDocument), 0, (GInstanceInitFunc) ease_document_instance_init, NULL };
++ static const GInterfaceInfo ease_undo_source_info = { (GInterfaceInitFunc) ease_document_ease_undo_source_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
++ GType ease_document_type_id;
++ ease_document_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseDocument", &g_define_type_info, 0);
++ g_type_add_interface_static (ease_document_type_id, EASE_TYPE_UNDO_SOURCE, &ease_undo_source_info);
++ g_once_init_leave (&ease_document_type_id__volatile, ease_document_type_id);
++ }
++ return ease_document_type_id__volatile;
++}
++
++
++static void ease_document_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseDocument * self;
++ self = EASE_DOCUMENT (object);
++ switch (property_id) {
++ case EASE_DOCUMENT_THEME:
++ g_value_set_object (value, ease_document_get_theme (self));
++ break;
++ case EASE_DOCUMENT_WIDTH:
++ g_value_set_int (value, ease_document_get_width (self));
++ break;
++ case EASE_DOCUMENT_HEIGHT:
++ g_value_set_int (value, ease_document_get_height (self));
++ break;
++ case EASE_DOCUMENT_ASPECT:
++ g_value_set_float (value, ease_document_get_aspect (self));
++ break;
++ case EASE_DOCUMENT_FILENAME:
++ g_value_set_string (value, ease_document_get_filename (self));
++ break;
++ case EASE_DOCUMENT_PATH:
++ g_value_set_string (value, ease_document_get_path (self));
++ break;
++ case EASE_DOCUMENT_LENGTH:
++ g_value_set_int (value, ease_document_get_length (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_document_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseDocument * self;
++ self = EASE_DOCUMENT (object);
++ switch (property_id) {
++ case EASE_DOCUMENT_THEME:
++ ease_document_set_theme (self, g_value_get_object (value));
++ break;
++ case EASE_DOCUMENT_WIDTH:
++ ease_document_set_width (self, g_value_get_int (value));
++ break;
++ case EASE_DOCUMENT_HEIGHT:
++ ease_document_set_height (self, g_value_get_int (value));
++ break;
++ case EASE_DOCUMENT_FILENAME:
++ ease_document_set_filename (self, g_value_get_string (value));
++ break;
++ case EASE_DOCUMENT_PATH:
++ ease_document_set_path (self, g_value_get_string (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static int _vala_strcmp0 (const char * str1, const char * str2) {
++ if (str1 == NULL) {
++ return -(str1 != str2);
++ }
++ if (str2 == NULL) {
++ return str1 != str2;
++ }
++ return strcmp (str1, str2);
++}
++
++
++
++static void g_cclosure_user_marshal_VOID__OBJECT_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
++ typedef void (*GMarshalFunc_VOID__OBJECT_INT) (gpointer data1, gpointer arg_1, gint arg_2, gpointer data2);
++ register GMarshalFunc_VOID__OBJECT_INT callback;
++ register GCClosure * cc;
++ register gpointer data1, 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__OBJECT_INT) (marshal_data ? marshal_data : cc->callback);
++ callback (data1, g_value_get_object (param_values + 1), g_value_get_int (param_values + 2), data2);
++}
++
++
++
diff --cc ease-core/ease-editor-embed.c
index 0000000,0000000..c45a317
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-editor-embed.c
@@@ -1,0 -1,0 +1,1971 @@@
++/* ease-editor-embed.c generated by valac, the Vala compiler
++ * generated from ease-editor-embed.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <clutter/clutter.h>
++#include <float.h>
++#include <math.h>
++#include <stdlib.h>
++#include <string.h>
++#include <gdk/gdk.h>
++
++
++#define EASE_TYPE_SCROLLABLE_EMBED (ease_scrollable_embed_get_type ())
++#define EASE_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbed))
++#define EASE_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++#define EASE_IS_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_IS_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_SCROLLABLE_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++
++typedef struct _EaseScrollableEmbed EaseScrollableEmbed;
++typedef struct _EaseScrollableEmbedClass EaseScrollableEmbedClass;
++typedef struct _EaseScrollableEmbedPrivate EaseScrollableEmbedPrivate;
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_EDITOR_EMBED (ease_editor_embed_get_type ())
++#define EASE_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbed))
++#define EASE_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++#define EASE_IS_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_EMBED))
++#define EASE_IS_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_EMBED))
++#define EASE_EDITOR_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++
++typedef struct _EaseEditorEmbed EaseEditorEmbed;
++typedef struct _EaseEditorEmbedClass EaseEditorEmbedClass;
++typedef struct _EaseEditorEmbedPrivate EaseEditorEmbedPrivate;
++
++#define EASE_TYPE_SLIDE_ACTOR (ease_slide_actor_get_type ())
++#define EASE_SLIDE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_ACTOR, EaseSlideActor))
++#define EASE_SLIDE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_ACTOR, EaseSlideActorClass))
++#define EASE_IS_SLIDE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_ACTOR))
++#define EASE_IS_SLIDE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_ACTOR))
++#define EASE_SLIDE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_ACTOR, EaseSlideActorClass))
++
++typedef struct _EaseSlideActor EaseSlideActor;
++typedef struct _EaseSlideActorClass EaseSlideActorClass;
++
++#define EASE_TYPE_EDITOR_WINDOW (ease_editor_window_get_type ())
++#define EASE_EDITOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindow))
++#define EASE_EDITOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindowClass))
++#define EASE_IS_EDITOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_WINDOW))
++#define EASE_IS_EDITOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_WINDOW))
++#define EASE_EDITOR_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindowClass))
++
++typedef struct _EaseEditorWindow EaseEditorWindow;
++typedef struct _EaseEditorWindowClass EaseEditorWindowClass;
++
++#define EASE_TYPE_SELECTION_RECTANGLE (ease_selection_rectangle_get_type ())
++#define EASE_SELECTION_RECTANGLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SELECTION_RECTANGLE, EaseSelectionRectangle))
++#define EASE_SELECTION_RECTANGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SELECTION_RECTANGLE, EaseSelectionRectangleClass))
++#define EASE_IS_SELECTION_RECTANGLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SELECTION_RECTANGLE))
++#define EASE_IS_SELECTION_RECTANGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SELECTION_RECTANGLE))
++#define EASE_SELECTION_RECTANGLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SELECTION_RECTANGLE, EaseSelectionRectangleClass))
++
++typedef struct _EaseSelectionRectangle EaseSelectionRectangle;
++typedef struct _EaseSelectionRectangleClass EaseSelectionRectangleClass;
++
++#define EASE_TYPE_HANDLE (ease_handle_get_type ())
++#define EASE_HANDLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_HANDLE, EaseHandle))
++#define EASE_HANDLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_HANDLE, EaseHandleClass))
++#define EASE_IS_HANDLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_HANDLE))
++#define EASE_IS_HANDLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_HANDLE))
++#define EASE_HANDLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_HANDLE, EaseHandleClass))
++
++typedef struct _EaseHandle EaseHandle;
++typedef struct _EaseHandleClass EaseHandleClass;
++
++#define EASE_TYPE_ACTOR (ease_actor_get_type ())
++#define EASE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ACTOR, EaseActor))
++#define EASE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ACTOR, EaseActorClass))
++#define EASE_IS_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ACTOR))
++#define EASE_IS_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ACTOR))
++#define EASE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ACTOR, EaseActorClass))
++
++typedef struct _EaseActor EaseActor;
++typedef struct _EaseActorClass EaseActorClass;
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++
++#define EASE_TYPE_UNDO_ACTION (ease_undo_action_get_type ())
++#define EASE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoAction))
++#define EASE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++#define EASE_IS_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ACTION))
++#define EASE_IS_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ACTION))
++#define EASE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++
++typedef struct _EaseUndoAction EaseUndoAction;
++typedef struct _EaseUndoActionClass EaseUndoActionClass;
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) ((var == NULL) ? NULL : (var = (g_free (var), NULL)))
++typedef struct _EaseSlideActorPrivate EaseSlideActorPrivate;
++
++#define EASE_TYPE_CLUTTER_ITERABLE_GROUP (ease_clutter_iterable_group_get_type ())
++#define EASE_CLUTTER_ITERABLE_GROUP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_CLUTTER_ITERABLE_GROUP, EaseClutterIterableGroup))
++#define EASE_CLUTTER_ITERABLE_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_CLUTTER_ITERABLE_GROUP, EaseClutterIterableGroupClass))
++#define EASE_IS_CLUTTER_ITERABLE_GROUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_CLUTTER_ITERABLE_GROUP))
++#define EASE_IS_CLUTTER_ITERABLE_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_CLUTTER_ITERABLE_GROUP))
++#define EASE_CLUTTER_ITERABLE_GROUP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_CLUTTER_ITERABLE_GROUP, EaseClutterIterableGroupClass))
++
++typedef struct _EaseClutterIterableGroup EaseClutterIterableGroup;
++typedef struct _EaseClutterIterableGroupClass EaseClutterIterableGroupClass;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++#define EASE_TYPE_CLUTTER_ITERABLE_CONTAINER (ease_clutter_iterable_container_get_type ())
++#define EASE_CLUTTER_ITERABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_CLUTTER_ITERABLE_CONTAINER, EaseClutterIterableContainer))
++#define EASE_IS_CLUTTER_ITERABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_CLUTTER_ITERABLE_CONTAINER))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_CLUTTER_ITERABLE_CONTAINER, EaseClutterIterableContainerIface))
++
++typedef struct _EaseClutterIterableContainer EaseClutterIterableContainer;
++typedef struct _EaseClutterIterableContainerIface EaseClutterIterableContainerIface;
++
++#define EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR (ease_clutter_iterable_container_iterator_get_type ())
++#define EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR, EaseClutterIterableContainerIterator))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR, EaseClutterIterableContainerIteratorClass))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR, EaseClutterIterableContainerIteratorClass))
++
++typedef struct _EaseClutterIterableContainerIterator EaseClutterIterableContainerIterator;
++typedef struct _EaseClutterIterableContainerIteratorClass EaseClutterIterableContainerIteratorClass;
++#define _ease_clutter_iterable_container_iterator_unref0(var) ((var == NULL) ? NULL : (var = (ease_clutter_iterable_container_iterator_unref (var), NULL)))
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++typedef struct _EaseActorPrivate EaseActorPrivate;
++
++#define EASE_TYPE_HANDLE_POSITION (ease_handle_position_get_type ())
++
++#define EASE_TYPE_KEY (ease_key_get_type ())
++
++#define EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION (ease_element_remove_undo_action_get_type ())
++#define EASE_ELEMENT_REMOVE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION, EaseElementRemoveUndoAction))
++#define EASE_ELEMENT_REMOVE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION, EaseElementRemoveUndoActionClass))
++#define EASE_IS_ELEMENT_REMOVE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION))
++#define EASE_IS_ELEMENT_REMOVE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION))
++#define EASE_ELEMENT_REMOVE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION, EaseElementRemoveUndoActionClass))
++
++typedef struct _EaseElementRemoveUndoAction EaseElementRemoveUndoAction;
++typedef struct _EaseElementRemoveUndoActionClass EaseElementRemoveUndoActionClass;
++
++struct _EaseScrollableEmbed {
++ GtkHBox parent_instance;
++ EaseScrollableEmbedPrivate * priv;
++};
++
++struct _EaseScrollableEmbedClass {
++ GtkHBoxClass parent_class;
++};
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseEditorEmbed {
++ EaseScrollableEmbed parent_instance;
++ EaseEditorEmbedPrivate * priv;
++ EaseSlideActor* slide_actor;
++};
++
++struct _EaseEditorEmbedClass {
++ EaseScrollableEmbedClass parent_class;
++};
++
++struct _EaseEditorEmbedPrivate {
++ EaseEditorWindow* win;
++ EaseSelectionRectangle* selection_rectangle;
++ EaseHandle** handles;
++ gint handles_length1;
++ gint _handles_size_;
++ EaseActor* _selected;
++ gboolean _is_editing;
++ gboolean is_dragging;
++ gboolean is_drag_initialized;
++ EaseUndoAction* move_undo;
++ float mouse_x;
++ float mouse_y;
++ float orig_x;
++ float orig_y;
++ float orig_w;
++ float orig_h;
++ gboolean keys_connected;
++ EaseDocument* document;
++ float zoom_priv;
++ gboolean _zoom_fit;
++};
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++struct _EaseSlideActor {
++ ClutterGroup parent_instance;
++ EaseSlideActorPrivate * priv;
++ ClutterCairoTexture* background;
++ EaseClutterIterableGroup* contents;
++ EaseActorContext context;
++};
++
++struct _EaseSlideActorClass {
++ ClutterGroupClass parent_class;
++};
++
++struct _EaseClutterIterableContainerIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseActor {
++ ClutterGroup parent_instance;
++ EaseActorPrivate * priv;
++ ClutterActor* contents;
++ EaseElement* element;
++ EaseActorContext context;
++ gboolean is_background;
++};
++
++struct _EaseActorClass {
++ ClutterGroupClass parent_class;
++ void (*edit) (EaseActor* self, EaseEditorEmbed* sender);
++ void (*end_edit) (EaseActor* self, EaseEditorEmbed* sender);
++};
++
++typedef enum {
++ EASE_HANDLE_POSITION_TOP_LEFT = 0,
++ EASE_HANDLE_POSITION_TOP_RIGHT = 1,
++ EASE_HANDLE_POSITION_TOP = 2,
++ EASE_HANDLE_POSITION_LEFT = 3,
++ EASE_HANDLE_POSITION_RIGHT = 4,
++ EASE_HANDLE_POSITION_BOTTOM_LEFT = 5,
++ EASE_HANDLE_POSITION_BOTTOM_RIGHT = 6,
++ EASE_HANDLE_POSITION_BOTTOM = 7
++} EaseHandlePosition;
++
++typedef enum {
++ EASE_KEY_UP = 65362,
++ EASE_KEY_DOWN = 65364,
++ EASE_KEY_LEFT = 65361,
++ EASE_KEY_RIGHT = 65363,
++ EASE_KEY_BACKSPACE = 65288,
++ EASE_KEY_DELETE = 65535
++} EaseKey;
++
++
++static gpointer ease_editor_embed_parent_class = NULL;
++static EaseUndoSourceIface* ease_editor_embed_ease_undo_source_parent_iface = NULL;
++
++GType ease_scrollable_embed_get_type (void) G_GNUC_CONST;
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_editor_embed_get_type (void) G_GNUC_CONST;
++GType ease_slide_actor_get_type (void) G_GNUC_CONST;
++GType ease_editor_window_get_type (void) G_GNUC_CONST;
++GType ease_selection_rectangle_get_type (void) G_GNUC_CONST;
++GType ease_handle_get_type (void) G_GNUC_CONST;
++GType ease_actor_get_type (void) G_GNUC_CONST;
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++GType ease_undo_action_get_type (void) G_GNUC_CONST;
++GType ease_document_get_type (void) G_GNUC_CONST;
++#define EASE_EDITOR_EMBED_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedPrivate))
++enum {
++ EASE_EDITOR_EMBED_DUMMY_PROPERTY,
++ EASE_EDITOR_EMBED_SELECTED,
++ EASE_EDITOR_EMBED_ZOOM
++};
++#define EASE_EDITOR_EMBED_BG_COLOR "bg_color:"
++#define EASE_EDITOR_EMBED_SHADE_FACTOR 0.9
++#define EASE_EDITOR_EMBED_HANDLE_COUNT 8
++#define EASE_EDITOR_EMBED_NUDGE_PIXELS 10
++#define EASE_EDITOR_EMBED_NUDGE_SHIFT_PIXELS 50
++EaseScrollableEmbed* ease_scrollable_embed_new (gboolean horizontal, gboolean has_frame);
++EaseScrollableEmbed* ease_scrollable_embed_construct (GType object_type, gboolean horizontal, gboolean has_frame);
++ClutterStage* ease_scrollable_embed_get_stage (EaseScrollableEmbed* self);
++GdkColor* ease_theme_color (const char* color);
++void ease_transformations_gdk_color_to_clutter_color (GdkColor* color, ClutterColor* result);
++void ease_editor_embed_set_zoom (EaseEditorEmbed* self, float value);
++static void ease_editor_embed_set_zoom_fit (EaseEditorEmbed* self, gboolean value);
++static gboolean ease_editor_embed_get_zoom_fit (EaseEditorEmbed* self);
++float ease_scrollable_embed_get_width (EaseScrollableEmbed* self);
++float ease_scrollable_embed_get_height (EaseScrollableEmbed* self);
++gint ease_document_get_width (EaseDocument* self);
++gint ease_document_get_height (EaseDocument* self);
++void ease_editor_embed_reposition_group (EaseEditorEmbed* self);
++static void _lambda96_ (EaseEditorEmbed* self);
++static void __lambda96__gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self);
++void ease_editor_embed_connect_keys (EaseEditorEmbed* self);
++EaseEditorEmbed* ease_editor_embed_new (EaseDocument* d, EaseEditorWindow* w);
++EaseEditorEmbed* ease_editor_embed_construct (GType object_type, EaseDocument* d, EaseEditorWindow* w);
++static gboolean ease_editor_embed_get_is_editing (EaseEditorEmbed* self);
++EaseActor* ease_editor_embed_get_selected (EaseEditorEmbed* self);
++void ease_actor_end_edit (EaseActor* self, EaseEditorEmbed* sender);
++static void ease_editor_embed_set_is_editing (EaseEditorEmbed* self, gboolean value);
++static void ease_editor_embed_deselect_actor (EaseEditorEmbed* self);
++ClutterGroup* ease_scrollable_embed_get_contents (EaseScrollableEmbed* self);
++GType ease_clutter_iterable_group_get_type (void) G_GNUC_CONST;
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++GType ease_clutter_iterable_container_get_type (void) G_GNUC_CONST;
++gpointer ease_clutter_iterable_container_iterator_ref (gpointer instance);
++void ease_clutter_iterable_container_iterator_unref (gpointer instance);
++GParamSpec* ease_clutter_iterable_container_param_spec_iterator (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
++void ease_clutter_iterable_container_value_set_iterator (GValue* value, gpointer v_object);
++void ease_clutter_iterable_container_value_take_iterator (GValue* value, gpointer v_object);
++gpointer ease_clutter_iterable_container_value_get_iterator (const GValue* value);
++GType ease_clutter_iterable_container_iterator_get_type (void) G_GNUC_CONST;
++EaseClutterIterableContainerIterator* ease_clutter_iterable_container_iterator (EaseClutterIterableContainer* self);
++gboolean ease_clutter_iterable_container_iterator_next (EaseClutterIterableContainerIterator* self);
++ClutterActor* ease_clutter_iterable_container_iterator_get (EaseClutterIterableContainerIterator* self);
++static gboolean ease_editor_embed_actor_clicked (EaseEditorEmbed* self, ClutterActor* sender, ClutterButtonEvent* event);
++static gboolean _ease_editor_embed_actor_clicked_clutter_actor_button_press_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self);
++static gboolean ease_editor_embed_actor_released (EaseEditorEmbed* self, ClutterActor* sender, ClutterButtonEvent* event);
++static gboolean _ease_editor_embed_actor_released_clutter_actor_button_release_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self);
++void ease_editor_embed_on_ease_actor_added (EaseEditorEmbed* self, EaseActor* actor);
++static void _ease_editor_embed_on_ease_actor_added_ease_slide_actor_ease_actor_added (EaseSlideActor* _sender, EaseActor* actor, gpointer self);
++void ease_editor_embed_on_ease_actor_removed (EaseEditorEmbed* self, EaseActor* actor);
++static void _ease_editor_embed_on_ease_actor_removed_ease_slide_actor_ease_actor_removed (EaseSlideActor* _sender, EaseActor* actor, gpointer self);
++GType ease_slide_get_type (void) G_GNUC_CONST;
++EaseSlide* ease_slide_actor_get_slide (EaseSlideActor* self);
++GType ease_element_get_type (void) G_GNUC_CONST;
++void ease_editor_embed_on_element_removed (EaseEditorEmbed* self, EaseSlide* slide, EaseElement* element, gint index);
++static void _ease_editor_embed_on_element_removed_ease_slide_element_removed (EaseSlide* _sender, EaseSlide* _self_, EaseElement* element, gint index, gpointer self);
++static void ease_editor_embed_remove_selection_rect (EaseEditorEmbed* self);
++EaseSlideActor* ease_slide_actor_new_from_slide (EaseDocument* document, EaseSlide* s, gboolean clip, EaseActorContext ctx);
++EaseSlideActor* ease_slide_actor_construct_from_slide (GType object_type, EaseDocument* document, EaseSlide* s, gboolean clip, EaseActorContext ctx);
++void ease_editor_embed_set_slide (EaseEditorEmbed* self, EaseSlide* slide);
++static gboolean ease_editor_embed_handle_clicked (EaseEditorEmbed* self, ClutterActor* sender, ClutterButtonEvent* event);
++static gboolean _ease_editor_embed_handle_clicked_clutter_actor_button_press_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self);
++static gboolean ease_editor_embed_handle_released (EaseEditorEmbed* self, ClutterActor* sender, ClutterButtonEvent* event);
++static gboolean _ease_editor_embed_handle_released_clutter_actor_button_release_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self);
++float ease_editor_embed_get_zoom (EaseEditorEmbed* self);
++gint ease_roundd (double num);
++static void ease_editor_embed_position_selection (EaseEditorEmbed* self);
++void ease_handle_reposition (EaseHandle* self, ClutterActor* selection);
++void ease_editor_embed_recreate_slide (EaseEditorEmbed* self);
++static void ease_editor_embed_select_actor (EaseEditorEmbed* self, EaseActor* sender);
++void ease_editor_embed_select_element (EaseEditorEmbed* self, EaseElement* e);
++void ease_editor_embed_disconnect_keys (EaseEditorEmbed* self);
++void ease_actor_edit (EaseActor* self, EaseEditorEmbed* sender);
++static gboolean ease_editor_embed_actor_motion (EaseEditorEmbed* self, ClutterActor* sender, ClutterMotionEvent* event);
++static gboolean _ease_editor_embed_actor_motion_clutter_actor_motion_event (ClutterActor* _sender, ClutterMotionEvent* event, gpointer self);
++EaseUndoAction* ease_undo_action_new (GObject* obj, const char* prop);
++EaseUndoAction* ease_undo_action_construct (GType object_type, GObject* obj, const char* prop);
++void ease_undo_action_add (EaseUndoAction* self, GObject* obj, const char* prop);
++static void ease_editor_embed_set_selected (EaseEditorEmbed* self, EaseActor* value);
++EaseSelectionRectangle* ease_selection_rectangle_new (void);
++EaseSelectionRectangle* ease_selection_rectangle_construct (GType object_type);
++GType ease_handle_position_get_type (void) G_GNUC_CONST;
++EaseHandle* ease_handle_new (EaseHandlePosition pos);
++EaseHandle* ease_handle_construct (GType object_type, EaseHandlePosition pos);
++void ease_actor_translate (EaseActor* self, float x_change, float y_change);
++EaseSlide* ease_element_get_parent (EaseElement* self);
++void ease_handle_flip (EaseHandle* self, gboolean f);
++static gboolean ease_editor_embed_handle_motion (EaseEditorEmbed* self, ClutterActor* sender, ClutterMotionEvent* event);
++static gboolean _ease_editor_embed_handle_motion_clutter_actor_motion_event (ClutterActor* _sender, ClutterMotionEvent* event, gpointer self);
++void ease_handle_drag_from_center (EaseHandle* self, float change_x, float change_y, EaseActor* target, gboolean prop);
++void ease_handle_drag (EaseHandle* self, float change_x, float change_y, EaseActor* target, gboolean prop);
++gboolean ease_element_set_color (EaseElement* self, ClutterColor* c);
++void ease_editor_embed_set_element_color (EaseEditorEmbed* self, ClutterColor* color);
++GType ease_key_get_type (void) G_GNUC_CONST;
++gint ease_slide_index_of (EaseSlide* self, EaseElement* e);
++EaseElement* ease_slide_element_at (EaseSlide* self, gint i);
++EaseElementRemoveUndoAction* ease_element_remove_undo_action_new (EaseElement* e);
++EaseElementRemoveUndoAction* ease_element_remove_undo_action_construct (GType object_type, EaseElement* e);
++GType ease_element_remove_undo_action_get_type (void) G_GNUC_CONST;
++void ease_slide_remove_at (EaseSlide* self, gint index);
++gboolean ease_editor_embed_on_key_press_event (EaseEditorEmbed* self, GtkWidget* _self_, GdkEventKey* event);
++static gboolean _ease_editor_embed_on_key_press_event_gtk_widget_key_press_event (GtkWidget* _sender, GdkEventKey* event, gpointer self);
++static void ease_editor_embed_finalize (GObject* obj);
++static void ease_editor_embed_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_editor_embed_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
++static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
++
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 222 "ease-editor-embed.vala"
++static void _lambda96_ (EaseEditorEmbed* self) {
++#line 223 "ease-editor-embed.vala"
++ if (self->priv->_zoom_fit) {
++#line 454 "ease-editor-embed.c"
++ float _tmp0_ = 0.0F;
++#line 225 "ease-editor-embed.vala"
++ if ((ease_scrollable_embed_get_width ((EaseScrollableEmbed*) self) / ease_scrollable_embed_get_height ((EaseScrollableEmbed*) self)) > (((float) ease_document_get_width (self->priv->document)) / ease_document_get_height (self->priv->document))) {
++#line 226 "ease-editor-embed.vala"
++ _tmp0_ = ease_scrollable_embed_get_height ((EaseScrollableEmbed*) self) / ease_document_get_height (self->priv->document);
++#line 460 "ease-editor-embed.c"
++ } else {
++#line 227 "ease-editor-embed.vala"
++ _tmp0_ = ease_scrollable_embed_get_width ((EaseScrollableEmbed*) self) / ease_document_get_width (self->priv->document);
++#line 464 "ease-editor-embed.c"
++ }
++#line 225 "ease-editor-embed.vala"
++ ease_editor_embed_set_zoom (self, _tmp0_);
++#line 228 "ease-editor-embed.vala"
++ ease_editor_embed_reposition_group (self);
++#line 470 "ease-editor-embed.c"
++ } else {
++#line 232 "ease-editor-embed.vala"
++ ease_editor_embed_reposition_group (self);
++#line 474 "ease-editor-embed.c"
++ }
++}
++
++
++#line 222 "ease-editor-embed.vala"
++static void __lambda96__gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self) {
++#line 481 "ease-editor-embed.c"
++ _lambda96_ (self);
++}
++
++
++#line 192 "ease-editor-embed.vala"
++EaseEditorEmbed* ease_editor_embed_construct (GType object_type, EaseDocument* d, EaseEditorWindow* w) {
++#line 488 "ease-editor-embed.c"
++ EaseEditorEmbed * self;
++ EaseEditorWindow* _tmp0_;
++ ClutterStage* _tmp1_;
++ ClutterColor out_color = {0};
++ GdkColor* color;
++ ClutterStage* _tmp4_;
++ EaseDocument* _tmp5_;
++#line 192 "ease-editor-embed.vala"
++ g_return_val_if_fail (d != NULL, NULL);
++#line 192 "ease-editor-embed.vala"
++ g_return_val_if_fail (w != NULL, NULL);
++#line 194 "ease-editor-embed.vala"
++ self = (EaseEditorEmbed*) ease_scrollable_embed_construct (object_type, TRUE, TRUE);
++#line 195 "ease-editor-embed.vala"
++ self->priv->win = (_tmp0_ = _g_object_ref0 (w), _g_object_unref0 (self->priv->win), _tmp0_);
++#line 198 "ease-editor-embed.vala"
++ clutter_stage_set_use_fog (_tmp1_ = ease_scrollable_embed_get_stage ((EaseScrollableEmbed*) self), FALSE);
++#line 506 "ease-editor-embed.c"
++ _g_object_unref0 (_tmp1_);
++#line 202 "ease-editor-embed.vala"
++ color = ease_theme_color (EASE_EDITOR_EMBED_BG_COLOR);
++#line 203 "ease-editor-embed.vala"
++ if (color == NULL) {
++#line 512 "ease-editor-embed.c"
++ ClutterColor _tmp2_ = {0};
++#line 205 "ease-editor-embed.vala"
++ out_color = (_tmp2_.red = (guchar) 150, _tmp2_.green = (guchar) 150, _tmp2_.blue = (guchar) 150, _tmp2_.alpha = (guchar) 255, _tmp2_);
++#line 206 "ease-editor-embed.vala"
++ clutter_color_shade (&out_color, EASE_EDITOR_EMBED_SHADE_FACTOR, &out_color);
++#line 518 "ease-editor-embed.c"
++ } else {
++ ClutterColor _tmp3_ = {0};
++#line 210 "ease-editor-embed.vala"
++ out_color = (ease_transformations_gdk_color_to_clutter_color (color, &_tmp3_), _tmp3_);
++#line 523 "ease-editor-embed.c"
++ }
++#line 213 "ease-editor-embed.vala"
++ clutter_stage_set_color (_tmp4_ = ease_scrollable_embed_get_stage ((EaseScrollableEmbed*) self), &out_color);
++#line 527 "ease-editor-embed.c"
++ _g_object_unref0 (_tmp4_);
++#line 215 "ease-editor-embed.vala"
++ self->priv->document = (_tmp5_ = _g_object_ref0 (d), _g_object_unref0 (self->priv->document), _tmp5_);
++#line 216 "ease-editor-embed.vala"
++ gtk_widget_set_size_request ((GtkWidget*) self, 320, 240);
++#line 218 "ease-editor-embed.vala"
++ ease_editor_embed_set_zoom (self, (float) 1);
++#line 219 "ease-editor-embed.vala"
++ ease_editor_embed_set_zoom_fit (self, FALSE);
++#line 222 "ease-editor-embed.vala"
++ g_signal_connect_object ((GtkWidget*) self, "size-allocate", (GCallback) __lambda96__gtk_widget_size_allocate, self, 0);
++#line 236 "ease-editor-embed.vala"
++ ease_editor_embed_connect_keys (self);
++#line 541 "ease-editor-embed.c"
++ _g_free0 (color);
++ return self;
++}
++
++
++#line 192 "ease-editor-embed.vala"
++EaseEditorEmbed* ease_editor_embed_new (EaseDocument* d, EaseEditorWindow* w) {
++#line 192 "ease-editor-embed.vala"
++ return ease_editor_embed_construct (EASE_TYPE_EDITOR_EMBED, d, w);
++#line 551 "ease-editor-embed.c"
++}
++
++
++#line 415 "ease-editor-embed.vala"
++static gboolean _ease_editor_embed_actor_clicked_clutter_actor_button_press_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self) {
++#line 557 "ease-editor-embed.c"
++ gboolean result;
++ result = ease_editor_embed_actor_clicked (self, _sender, event);
++ return result;
++}
++
++
++#line 524 "ease-editor-embed.vala"
++static gboolean _ease_editor_embed_actor_released_clutter_actor_button_release_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self) {
++#line 566 "ease-editor-embed.c"
++ gboolean result;
++ result = ease_editor_embed_actor_released (self, _sender, event);
++ return result;
++}
++
++
++#line 716 "ease-editor-embed.vala"
++static void _ease_editor_embed_on_ease_actor_added_ease_slide_actor_ease_actor_added (EaseSlideActor* _sender, EaseActor* actor, gpointer self) {
++#line 575 "ease-editor-embed.c"
++ ease_editor_embed_on_ease_actor_added (self, actor);
++}
++
++
++#line 705 "ease-editor-embed.vala"
++static void _ease_editor_embed_on_ease_actor_removed_ease_slide_actor_ease_actor_removed (EaseSlideActor* _sender, EaseActor* actor, gpointer self) {
++#line 582 "ease-editor-embed.c"
++ ease_editor_embed_on_ease_actor_removed (self, actor);
++}
++
++
++#line 797 "ease-editor-embed.vala"
++static void _ease_editor_embed_on_element_removed_ease_slide_element_removed (EaseSlide* _sender, EaseSlide* _self_, EaseElement* element, gint index, gpointer self) {
++#line 589 "ease-editor-embed.c"
++ ease_editor_embed_on_element_removed (self, _self_, element, index);
++}
++
++
++#line 252 "ease-editor-embed.vala"
++void ease_editor_embed_set_slide (EaseEditorEmbed* self, EaseSlide* slide) {
++#line 596 "ease-editor-embed.c"
++ EaseSlideActor* _tmp5_;
++#line 252 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 252 "ease-editor-embed.vala"
++ g_return_if_fail (slide != NULL);
++#line 254 "ease-editor-embed.vala"
++ if (slide == NULL) {
++#line 254 "ease-editor-embed.vala"
++ return;
++#line 606 "ease-editor-embed.c"
++ }
++#line 256 "ease-editor-embed.vala"
++ if (self->priv->_is_editing) {
++#line 258 "ease-editor-embed.vala"
++ ease_actor_end_edit (self->priv->_selected, self);
++#line 259 "ease-editor-embed.vala"
++ ease_editor_embed_set_is_editing (self, FALSE);
++#line 614 "ease-editor-embed.c"
++ }
++#line 262 "ease-editor-embed.vala"
++ ease_editor_embed_connect_keys (self);
++#line 263 "ease-editor-embed.vala"
++ ease_editor_embed_deselect_actor (self);
++#line 264 "ease-editor-embed.vala"
++ g_signal_emit_by_name (self, "element-deselected", NULL);
++#line 267 "ease-editor-embed.vala"
++ if (self->slide_actor != NULL) {
++#line 624 "ease-editor-embed.c"
++ guint _tmp2_;
++ guint _tmp3_;
++ guint _tmp4_;
++#line 269 "ease-editor-embed.vala"
++ clutter_container_remove_actor ((ClutterContainer*) ease_scrollable_embed_get_contents ((EaseScrollableEmbed*) self), (ClutterActor*) self->slide_actor);
++#line 630 "ease-editor-embed.c"
++ {
++ EaseClutterIterableContainerIterator* _a_it;
++#line 270 "ease-editor-embed.vala"
++ _a_it = ease_clutter_iterable_container_iterator ((EaseClutterIterableContainer*) self->slide_actor->contents);
++#line 270 "ease-editor-embed.vala"
++ while (TRUE) {
++#line 637 "ease-editor-embed.c"
++ ClutterActor* a;
++ guint _tmp0_;
++ guint _tmp1_;
++#line 270 "ease-editor-embed.vala"
++ if (!ease_clutter_iterable_container_iterator_next (_a_it)) {
++#line 270 "ease-editor-embed.vala"
++ break;
++#line 645 "ease-editor-embed.c"
++ }
++#line 270 "ease-editor-embed.vala"
++ a = ease_clutter_iterable_container_iterator_get (_a_it);
++#line 272 "ease-editor-embed.vala"
++ g_signal_parse_name ("button-press-event", CLUTTER_TYPE_ACTOR, &_tmp0_, NULL, FALSE);
++#line 272 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched (a, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _ease_editor_embed_actor_clicked_clutter_actor_button_press_event, self);
++#line 273 "ease-editor-embed.vala"
++ g_signal_parse_name ("button-release-event", CLUTTER_TYPE_ACTOR, &_tmp1_, NULL, FALSE);
++#line 273 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched (a, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _ease_editor_embed_actor_released_clutter_actor_button_release_event, self);
++#line 274 "ease-editor-embed.vala"
++ clutter_actor_set_reactive (a, FALSE);
++#line 659 "ease-editor-embed.c"
++ _g_object_unref0 (a);
++ }
++ _ease_clutter_iterable_container_iterator_unref0 (_a_it);
++ }
++#line 277 "ease-editor-embed.vala"
++ g_signal_parse_name ("ease-actor-added", EASE_TYPE_SLIDE_ACTOR, &_tmp2_, NULL, FALSE);
++#line 277 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched (self->slide_actor, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp2_, 0, NULL, (GCallback) _ease_editor_embed_on_ease_actor_added_ease_slide_actor_ease_actor_added, self);
++#line 278 "ease-editor-embed.vala"
++ g_signal_parse_name ("ease-actor-removed", EASE_TYPE_SLIDE_ACTOR, &_tmp3_, NULL, FALSE);
++#line 278 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched (self->slide_actor, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp3_, 0, NULL, (GCallback) _ease_editor_embed_on_ease_actor_removed_ease_slide_actor_ease_actor_removed, self);
++#line 279 "ease-editor-embed.vala"
++ g_signal_parse_name ("element-removed", EASE_TYPE_SLIDE, &_tmp4_, NULL, FALSE);
++#line 279 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched (ease_slide_actor_get_slide (self->slide_actor), G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp4_, 0, NULL, (GCallback) _ease_editor_embed_on_element_removed_ease_slide_element_removed, self);
++#line 676 "ease-editor-embed.c"
++ }
++#line 283 "ease-editor-embed.vala"
++ ease_editor_embed_remove_selection_rect (self);
++#line 286 "ease-editor-embed.vala"
++ self->slide_actor = (_tmp5_ = g_object_ref_sink (ease_slide_actor_new_from_slide (self->priv->document, slide, FALSE, EASE_ACTOR_CONTEXT_EDITOR)), _g_object_unref0 (self->slide_actor), _tmp5_);
++#line 682 "ease-editor-embed.c"
++ {
++ EaseClutterIterableContainerIterator* _a_it;
++#line 292 "ease-editor-embed.vala"
++ _a_it = ease_clutter_iterable_container_iterator ((EaseClutterIterableContainer*) self->slide_actor->contents);
++#line 292 "ease-editor-embed.vala"
++ while (TRUE) {
++#line 689 "ease-editor-embed.c"
++ ClutterActor* a;
++#line 292 "ease-editor-embed.vala"
++ if (!ease_clutter_iterable_container_iterator_next (_a_it)) {
++#line 292 "ease-editor-embed.vala"
++ break;
++#line 695 "ease-editor-embed.c"
++ }
++#line 292 "ease-editor-embed.vala"
++ a = ease_clutter_iterable_container_iterator_get (_a_it);
++#line 294 "ease-editor-embed.vala"
++ g_signal_connect_object (a, "button-press-event", (GCallback) _ease_editor_embed_actor_clicked_clutter_actor_button_press_event, self, 0);
++#line 295 "ease-editor-embed.vala"
++ g_signal_connect_object (a, "button-release-event", (GCallback) _ease_editor_embed_actor_released_clutter_actor_button_release_event, self, 0);
++#line 296 "ease-editor-embed.vala"
++ clutter_actor_set_reactive (a, TRUE);
++#line 705 "ease-editor-embed.c"
++ _g_object_unref0 (a);
++ }
++ _ease_clutter_iterable_container_iterator_unref0 (_a_it);
++ }
++#line 299 "ease-editor-embed.vala"
++ g_signal_connect_object (self->slide_actor, "ease-actor-added", (GCallback) _ease_editor_embed_on_ease_actor_added_ease_slide_actor_ease_actor_added, self, 0);
++#line 300 "ease-editor-embed.vala"
++ g_signal_connect_object (self->slide_actor, "ease-actor-removed", (GCallback) _ease_editor_embed_on_ease_actor_removed_ease_slide_actor_ease_actor_removed, self, 0);
++#line 301 "ease-editor-embed.vala"
++ g_signal_connect_object (ease_slide_actor_get_slide (self->slide_actor), "element-removed", (GCallback) _ease_editor_embed_on_element_removed_ease_slide_element_removed, self, 0);
++#line 303 "ease-editor-embed.vala"
++ clutter_container_add_actor ((ClutterContainer*) ease_scrollable_embed_get_contents ((EaseScrollableEmbed*) self), (ClutterActor*) self->slide_actor);
++#line 304 "ease-editor-embed.vala"
++ ease_editor_embed_reposition_group (self);
++#line 720 "ease-editor-embed.c"
++}
++
++
++#line 590 "ease-editor-embed.vala"
++static gboolean _ease_editor_embed_handle_clicked_clutter_actor_button_press_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self) {
++#line 726 "ease-editor-embed.c"
++ gboolean result;
++ result = ease_editor_embed_handle_clicked (self, _sender, event);
++ return result;
++}
++
++
++#line 618 "ease-editor-embed.vala"
++static gboolean _ease_editor_embed_handle_released_clutter_actor_button_release_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self) {
++#line 735 "ease-editor-embed.c"
++ gboolean result;
++ result = ease_editor_embed_handle_released (self, _sender, event);
++ return result;
++}
++
++
++#line 310 "ease-editor-embed.vala"
++static void ease_editor_embed_remove_selection_rect (EaseEditorEmbed* self) {
++#line 310 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 312 "ease-editor-embed.vala"
++ if (self->priv->selection_rectangle != NULL) {
++#line 748 "ease-editor-embed.c"
++ EaseHandle** _tmp2_;
++#line 314 "ease-editor-embed.vala"
++ if (clutter_actor_get_parent ((ClutterActor*) self->priv->selection_rectangle) == CLUTTER_ACTOR (ease_scrollable_embed_get_contents ((EaseScrollableEmbed*) self))) {
++#line 316 "ease-editor-embed.vala"
++ clutter_container_remove_actor ((ClutterContainer*) ease_scrollable_embed_get_contents ((EaseScrollableEmbed*) self), (ClutterActor*) self->priv->selection_rectangle);
++#line 754 "ease-editor-embed.c"
++ }
++ {
++ EaseHandle** h_collection;
++ int h_collection_length1;
++ int h_it;
++#line 318 "ease-editor-embed.vala"
++ h_collection = self->priv->handles;
++#line 762 "ease-editor-embed.c"
++ h_collection_length1 = self->priv->handles_length1;
++ for (h_it = 0; h_it < self->priv->handles_length1; h_it = h_it + 1) {
++ EaseHandle* h;
++ h = _g_object_ref0 (h_collection[h_it]);
++ {
++ guint _tmp0_;
++ guint _tmp1_;
++#line 320 "ease-editor-embed.vala"
++ if (clutter_actor_get_parent ((ClutterActor*) h) == CLUTTER_ACTOR (ease_scrollable_embed_get_contents ((EaseScrollableEmbed*) self))) {
++#line 322 "ease-editor-embed.vala"
++ clutter_container_remove_actor ((ClutterContainer*) ease_scrollable_embed_get_contents ((EaseScrollableEmbed*) self), (ClutterActor*) h);
++#line 774 "ease-editor-embed.c"
++ }
++#line 324 "ease-editor-embed.vala"
++ g_signal_parse_name ("button-press-event", CLUTTER_TYPE_ACTOR, &_tmp0_, NULL, FALSE);
++#line 324 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched ((ClutterActor*) h, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _ease_editor_embed_handle_clicked_clutter_actor_button_press_event, self);
++#line 325 "ease-editor-embed.vala"
++ g_signal_parse_name ("button-release-event", CLUTTER_TYPE_ACTOR, &_tmp1_, NULL, FALSE);
++#line 325 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched ((ClutterActor*) h, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _ease_editor_embed_handle_released_clutter_actor_button_release_event, self);
++#line 784 "ease-editor-embed.c"
++ _g_object_unref0 (h);
++ }
++ }
++ }
++#line 327 "ease-editor-embed.vala"
++ self->priv->handles = (_tmp2_ = NULL, self->priv->handles = (_vala_array_free (self->priv->handles, self->priv->handles_length1, (GDestroyNotify) g_object_unref), NULL), self->priv->handles_length1 = 0, self->priv->_handles_size_ = self->priv->handles_length1, _tmp2_);
++#line 791 "ease-editor-embed.c"
++ }
++}
++
++
++#line 337 "ease-editor-embed.vala"
++void ease_editor_embed_reposition_group (EaseEditorEmbed* self) {
++#line 798 "ease-editor-embed.c"
++ float w;
++ float h;
++ float _tmp0_ = 0.0F;
++ float _tmp1_ = 0.0F;
++ gboolean _tmp2_ = FALSE;
++#line 337 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 339 "ease-editor-embed.vala"
++ if (self->slide_actor == NULL) {
++#line 341 "ease-editor-embed.vala"
++ return;
++#line 810 "ease-editor-embed.c"
++ }
++#line 344 "ease-editor-embed.vala"
++ w = ease_editor_embed_get_zoom (self) * ease_document_get_width (self->priv->document);
++#line 345 "ease-editor-embed.vala"
++ h = ease_editor_embed_get_zoom (self) * ease_document_get_height (self->priv->document);
++#line 347 "ease-editor-embed.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) self->slide_actor, (double) ease_editor_embed_get_zoom (self), (double) ease_editor_embed_get_zoom (self), (float) 0, (float) 0);
++#line 349 "ease-editor-embed.vala"
++ if (w < ease_scrollable_embed_get_width ((EaseScrollableEmbed*) self)) {
++#line 350 "ease-editor-embed.vala"
++ _tmp0_ = (ease_scrollable_embed_get_width ((EaseScrollableEmbed*) self) / 2) - (w / 2);
++#line 822 "ease-editor-embed.c"
++ } else {
++#line 351 "ease-editor-embed.vala"
++ _tmp0_ = (float) 0;
++#line 826 "ease-editor-embed.c"
++ }
++#line 349 "ease-editor-embed.vala"
++ clutter_actor_set_x ((ClutterActor*) self->slide_actor, (float) ease_roundd ((double) _tmp0_));
++#line 353 "ease-editor-embed.vala"
++ if (h < ease_scrollable_embed_get_height ((EaseScrollableEmbed*) self)) {
++#line 354 "ease-editor-embed.vala"
++ _tmp1_ = (ease_scrollable_embed_get_height ((EaseScrollableEmbed*) self) / 2) - (h / 2);
++#line 834 "ease-editor-embed.c"
++ } else {
++#line 355 "ease-editor-embed.vala"
++ _tmp1_ = (float) 0;
++#line 838 "ease-editor-embed.c"
++ }
++#line 353 "ease-editor-embed.vala"
++ clutter_actor_set_y ((ClutterActor*) self->slide_actor, (float) ease_roundd ((double) _tmp1_));
++#line 357 "ease-editor-embed.vala"
++ if (self->priv->selection_rectangle != NULL) {
++#line 357 "ease-editor-embed.vala"
++ _tmp2_ = self->priv->_selected != NULL;
++#line 846 "ease-editor-embed.c"
++ } else {
++#line 357 "ease-editor-embed.vala"
++ _tmp2_ = FALSE;
++#line 850 "ease-editor-embed.c"
++ }
++#line 357 "ease-editor-embed.vala"
++ if (_tmp2_) {
++#line 359 "ease-editor-embed.vala"
++ ease_editor_embed_position_selection (self);
++#line 856 "ease-editor-embed.c"
++ }
++}
++
++
++#line 369 "ease-editor-embed.vala"
++static void ease_editor_embed_position_selection (EaseEditorEmbed* self) {
++#line 369 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 371 "ease-editor-embed.vala"
++ clutter_actor_set_position ((ClutterActor*) self->priv->selection_rectangle, (ease_editor_embed_get_zoom (self) * clutter_actor_get_x ((ClutterActor*) self->priv->_selected)) + clutter_actor_get_x ((ClutterActor*) self->slide_actor), (ease_editor_embed_get_zoom (self) * clutter_actor_get_y ((ClutterActor*) self->priv->_selected)) + clutter_actor_get_y ((ClutterActor*) self->slide_actor));
++#line 373 "ease-editor-embed.vala"
++ clutter_actor_set_size ((ClutterActor*) self->priv->selection_rectangle, ease_editor_embed_get_zoom (self) * clutter_actor_get_width ((ClutterActor*) self->priv->_selected), ease_editor_embed_get_zoom (self) * clutter_actor_get_height ((ClutterActor*) self->priv->_selected));
++#line 869 "ease-editor-embed.c"
++ {
++ EaseHandle** h_collection;
++ int h_collection_length1;
++ int h_it;
++#line 376 "ease-editor-embed.vala"
++ h_collection = self->priv->handles;
++#line 876 "ease-editor-embed.c"
++ h_collection_length1 = self->priv->handles_length1;
++ for (h_it = 0; h_it < self->priv->handles_length1; h_it = h_it + 1) {
++ EaseHandle* h;
++ h = _g_object_ref0 (h_collection[h_it]);
++ {
++#line 378 "ease-editor-embed.vala"
++ ease_handle_reposition (h, (ClutterActor*) self->priv->selection_rectangle);
++#line 884 "ease-editor-embed.c"
++ _g_object_unref0 (h);
++ }
++ }
++ }
++}
++
++
++#line 385 "ease-editor-embed.vala"
++void ease_editor_embed_recreate_slide (EaseEditorEmbed* self) {
++#line 385 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 387 "ease-editor-embed.vala"
++ ease_editor_embed_set_slide (self, ease_slide_actor_get_slide (self->slide_actor));
++#line 898 "ease-editor-embed.c"
++}
++
++
++#line 395 "ease-editor-embed.vala"
++void ease_editor_embed_select_element (EaseEditorEmbed* self, EaseElement* e) {
++#line 395 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 395 "ease-editor-embed.vala"
++ g_return_if_fail (e != NULL);
++#line 908 "ease-editor-embed.c"
++ {
++ EaseClutterIterableContainerIterator* _a_it;
++#line 397 "ease-editor-embed.vala"
++ _a_it = ease_clutter_iterable_container_iterator ((EaseClutterIterableContainer*) self->slide_actor->contents);
++#line 397 "ease-editor-embed.vala"
++ while (TRUE) {
++#line 915 "ease-editor-embed.c"
++ ClutterActor* a;
++ ClutterActor* _tmp0_;
++#line 397 "ease-editor-embed.vala"
++ if (!ease_clutter_iterable_container_iterator_next (_a_it)) {
++#line 397 "ease-editor-embed.vala"
++ break;
++#line 922 "ease-editor-embed.c"
++ }
++#line 397 "ease-editor-embed.vala"
++ a = ease_clutter_iterable_container_iterator_get (_a_it);
++#line 399 "ease-editor-embed.vala"
++ if ((_tmp0_ = a, EASE_IS_ACTOR (_tmp0_) ? ((EaseActor*) _tmp0_) : NULL)->element == e) {
++#line 928 "ease-editor-embed.c"
++ ClutterActor* _tmp1_;
++#line 401 "ease-editor-embed.vala"
++ ease_editor_embed_select_actor (self, (_tmp1_ = a, EASE_IS_ACTOR (_tmp1_) ? ((EaseActor*) _tmp1_) : NULL));
++#line 932 "ease-editor-embed.c"
++ }
++ _g_object_unref0 (a);
++ }
++ _ease_clutter_iterable_container_iterator_unref0 (_a_it);
++ }
++}
++
++
++#line 546 "ease-editor-embed.vala"
++static gboolean _ease_editor_embed_actor_motion_clutter_actor_motion_event (ClutterActor* _sender, ClutterMotionEvent* event, gpointer self) {
++#line 943 "ease-editor-embed.c"
++ gboolean result;
++ result = ease_editor_embed_actor_motion (self, _sender, event);
++ return result;
++}
++
++
++#line 415 "ease-editor-embed.vala"
++static gboolean ease_editor_embed_actor_clicked (EaseEditorEmbed* self, ClutterActor* sender, ClutterButtonEvent* event) {
++#line 952 "ease-editor-embed.c"
++ gboolean result = FALSE;
++ ClutterActor* _tmp2_;
++#line 415 "ease-editor-embed.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 415 "ease-editor-embed.vala"
++ g_return_val_if_fail (sender != NULL, FALSE);
++#line 418 "ease-editor-embed.vala"
++ if ((*event).click_count == 2) {
++#line 961 "ease-editor-embed.c"
++ ClutterActor* _tmp0_;
++#line 420 "ease-editor-embed.vala"
++ ease_editor_embed_disconnect_keys (self);
++#line 421 "ease-editor-embed.vala"
++ ease_actor_edit ((_tmp0_ = sender, EASE_IS_ACTOR (_tmp0_) ? ((EaseActor*) _tmp0_) : NULL), self);
++#line 422 "ease-editor-embed.vala"
++ ease_editor_embed_set_is_editing (self, TRUE);
++#line 969 "ease-editor-embed.c"
++ result = TRUE;
++#line 423 "ease-editor-embed.vala"
++ return result;
++#line 973 "ease-editor-embed.c"
++ } else {
++#line 427 "ease-editor-embed.vala"
++ if (sender == CLUTTER_ACTOR (self->priv->_selected)) {
++#line 977 "ease-editor-embed.c"
++ EaseUndoAction* _tmp1_;
++#line 429 "ease-editor-embed.vala"
++ self->priv->is_dragging = TRUE;
++#line 430 "ease-editor-embed.vala"
++ self->priv->is_drag_initialized = FALSE;
++#line 431 "ease-editor-embed.vala"
++ clutter_grab_pointer (sender);
++#line 432 "ease-editor-embed.vala"
++ g_signal_connect_object (sender, "motion-event", (GCallback) _ease_editor_embed_actor_motion_clutter_actor_motion_event, self, 0);
++#line 435 "ease-editor-embed.vala"
++ self->priv->move_undo = (_tmp1_ = ease_undo_action_new ((GObject*) self->priv->_selected->element, "x"), _g_object_unref0 (self->priv->move_undo), _tmp1_);
++#line 436 "ease-editor-embed.vala"
++ ease_undo_action_add (self->priv->move_undo, (GObject*) self->priv->_selected->element, "y");
++#line 991 "ease-editor-embed.c"
++ result = TRUE;
++#line 438 "ease-editor-embed.vala"
++ return result;
++#line 995 "ease-editor-embed.c"
++ }
++ }
++#line 441 "ease-editor-embed.vala"
++ ease_editor_embed_select_actor (self, (_tmp2_ = sender, EASE_IS_ACTOR (_tmp2_) ? ((EaseActor*) _tmp2_) : NULL));
++#line 1000 "ease-editor-embed.c"
++ result = TRUE;
++#line 443 "ease-editor-embed.vala"
++ return result;
++#line 1004 "ease-editor-embed.c"
++}
++
++
++#line 451 "ease-editor-embed.vala"
++static void ease_editor_embed_select_actor (EaseEditorEmbed* self, EaseActor* sender) {
++#line 1010 "ease-editor-embed.c"
++ EaseActor* _tmp0_;
++ EaseSelectionRectangle* _tmp1_;
++#line 451 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 451 "ease-editor-embed.vala"
++ g_return_if_fail (sender != NULL);
++#line 454 "ease-editor-embed.vala"
++ ease_editor_embed_deselect_actor (self);
++#line 456 "ease-editor-embed.vala"
++ ease_editor_embed_connect_keys (self);
++#line 458 "ease-editor-embed.vala"
++ ease_editor_embed_set_selected (self, (_tmp0_ = sender, EASE_IS_ACTOR (_tmp0_) ? ((EaseActor*) _tmp0_) : NULL));
++#line 459 "ease-editor-embed.vala"
++ g_signal_emit_by_name (self, "element-selected", self->priv->_selected->element);
++#line 462 "ease-editor-embed.vala"
++ self->priv->selection_rectangle = (_tmp1_ = g_object_ref_sink (ease_selection_rectangle_new ()), _g_object_unref0 (self->priv->selection_rectangle), _tmp1_);
++#line 463 "ease-editor-embed.vala"
++ ease_editor_embed_position_selection (self);
++#line 464 "ease-editor-embed.vala"
++ clutter_container_add_actor ((ClutterContainer*) ease_scrollable_embed_get_contents ((EaseScrollableEmbed*) self), (ClutterActor*) self->priv->selection_rectangle);
++#line 467 "ease-editor-embed.vala"
++ if (self->priv->handles == NULL) {
++#line 1033 "ease-editor-embed.c"
++ EaseHandle** _tmp2_;
++#line 469 "ease-editor-embed.vala"
++ self->priv->handles = (_tmp2_ = g_new0 (EaseHandle*, EASE_EDITOR_EMBED_HANDLE_COUNT + 1), self->priv->handles = (_vala_array_free (self->priv->handles, self->priv->handles_length1, (GDestroyNotify) g_object_unref), NULL), self->priv->handles_length1 = EASE_EDITOR_EMBED_HANDLE_COUNT, self->priv->_handles_size_ = self->priv->handles_length1, _tmp2_);
++#line 1037 "ease-editor-embed.c"
++ {
++ gint i;
++#line 470 "ease-editor-embed.vala"
++ i = 0;
++#line 1042 "ease-editor-embed.c"
++ {
++ gboolean _tmp3_;
++#line 470 "ease-editor-embed.vala"
++ _tmp3_ = TRUE;
++#line 470 "ease-editor-embed.vala"
++ while (TRUE) {
++#line 1049 "ease-editor-embed.c"
++ EaseHandle* _tmp4_;
++#line 470 "ease-editor-embed.vala"
++ if (!_tmp3_) {
++#line 470 "ease-editor-embed.vala"
++ i++;
++#line 1055 "ease-editor-embed.c"
++ }
++#line 470 "ease-editor-embed.vala"
++ _tmp3_ = FALSE;
++#line 470 "ease-editor-embed.vala"
++ if (!(i < EASE_EDITOR_EMBED_HANDLE_COUNT)) {
++#line 470 "ease-editor-embed.vala"
++ break;
++#line 1063 "ease-editor-embed.c"
++ }
++#line 472 "ease-editor-embed.vala"
++ self->priv->handles[i] = (_tmp4_ = g_object_ref_sink (ease_handle_new ((EaseHandlePosition) i)), _g_object_unref0 (self->priv->handles[i]), _tmp4_);
++#line 473 "ease-editor-embed.vala"
++ clutter_container_add_actor ((ClutterContainer*) ease_scrollable_embed_get_contents ((EaseScrollableEmbed*) self), (ClutterActor*) self->priv->handles[i]);
++#line 474 "ease-editor-embed.vala"
++ g_signal_connect_object ((ClutterActor*) self->priv->handles[i], "button-press-event", (GCallback) _ease_editor_embed_handle_clicked_clutter_actor_button_press_event, self, 0);
++#line 475 "ease-editor-embed.vala"
++ g_signal_connect_object ((ClutterActor*) self->priv->handles[i], "button-release-event", (GCallback) _ease_editor_embed_handle_released_clutter_actor_button_release_event, self, 0);
++#line 1073 "ease-editor-embed.c"
++ }
++ }
++ }
++ }
++ {
++ gint i;
++#line 479 "ease-editor-embed.vala"
++ i = 0;
++#line 1082 "ease-editor-embed.c"
++ {
++ gboolean _tmp5_;
++#line 479 "ease-editor-embed.vala"
++ _tmp5_ = TRUE;
++#line 479 "ease-editor-embed.vala"
++ while (TRUE) {
++#line 479 "ease-editor-embed.vala"
++ if (!_tmp5_) {
++#line 479 "ease-editor-embed.vala"
++ i++;
++#line 1093 "ease-editor-embed.c"
++ }
++#line 479 "ease-editor-embed.vala"
++ _tmp5_ = FALSE;
++#line 479 "ease-editor-embed.vala"
++ if (!(i < EASE_EDITOR_EMBED_HANDLE_COUNT)) {
++#line 479 "ease-editor-embed.vala"
++ break;
++#line 1101 "ease-editor-embed.c"
++ }
++#line 481 "ease-editor-embed.vala"
++ ease_handle_reposition (self->priv->handles[i], (ClutterActor*) self->priv->selection_rectangle);
++#line 482 "ease-editor-embed.vala"
++ clutter_container_raise_child ((ClutterContainer*) ease_scrollable_embed_get_contents ((EaseScrollableEmbed*) self), (ClutterActor*) self->priv->handles[i], (ClutterActor*) self->priv->selection_rectangle);
++#line 1107 "ease-editor-embed.c"
++ }
++ }
++ }
++#line 486 "ease-editor-embed.vala"
++ gtk_widget_set_can_focus ((GtkWidget*) self, TRUE);
++#line 487 "ease-editor-embed.vala"
++ gtk_widget_grab_focus ((GtkWidget*) self);
++#line 1115 "ease-editor-embed.c"
++}
++
++
++#line 495 "ease-editor-embed.vala"
++static void ease_editor_embed_deselect_actor (EaseEditorEmbed* self) {
++#line 1121 "ease-editor-embed.c"
++ gboolean _tmp0_ = FALSE;
++#line 495 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 498 "ease-editor-embed.vala"
++ if (self->priv->_selected != NULL) {
++#line 498 "ease-editor-embed.vala"
++ _tmp0_ = self->priv->_is_editing;
++#line 1129 "ease-editor-embed.c"
++ } else {
++#line 498 "ease-editor-embed.vala"
++ _tmp0_ = FALSE;
++#line 1133 "ease-editor-embed.c"
++ }
++#line 498 "ease-editor-embed.vala"
++ if (_tmp0_) {
++#line 500 "ease-editor-embed.vala"
++ ease_actor_end_edit (self->priv->_selected, self);
++#line 501 "ease-editor-embed.vala"
++ ease_editor_embed_set_is_editing (self, FALSE);
++#line 502 "ease-editor-embed.vala"
++ g_signal_emit_by_name (self, "element-deselected", self->priv->_selected->element);
++#line 1143 "ease-editor-embed.c"
++ }
++#line 504 "ease-editor-embed.vala"
++ ease_editor_embed_connect_keys (self);
++#line 507 "ease-editor-embed.vala"
++ ease_editor_embed_set_selected (self, NULL);
++#line 510 "ease-editor-embed.vala"
++ ease_editor_embed_remove_selection_rect (self);
++#line 1151 "ease-editor-embed.c"
++}
++
++
++#line 524 "ease-editor-embed.vala"
++static gboolean ease_editor_embed_actor_released (EaseEditorEmbed* self, ClutterActor* sender, ClutterButtonEvent* event) {
++#line 1157 "ease-editor-embed.c"
++ gboolean result = FALSE;
++ gboolean _tmp0_ = FALSE;
++#line 524 "ease-editor-embed.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 524 "ease-editor-embed.vala"
++ g_return_val_if_fail (sender != NULL, FALSE);
++#line 526 "ease-editor-embed.vala"
++ if (sender == CLUTTER_ACTOR (self->priv->_selected)) {
++#line 526 "ease-editor-embed.vala"
++ _tmp0_ = self->priv->is_dragging;
++#line 1168 "ease-editor-embed.c"
++ } else {
++#line 526 "ease-editor-embed.vala"
++ _tmp0_ = FALSE;
++#line 1172 "ease-editor-embed.c"
++ }
++#line 526 "ease-editor-embed.vala"
++ if (_tmp0_) {
++#line 1176 "ease-editor-embed.c"
++ guint _tmp1_;
++#line 528 "ease-editor-embed.vala"
++ self->priv->is_dragging = FALSE;
++#line 529 "ease-editor-embed.vala"
++ clutter_ungrab_pointer ();
++#line 530 "ease-editor-embed.vala"
++ g_signal_parse_name ("motion-event", CLUTTER_TYPE_ACTOR, &_tmp1_, NULL, FALSE);
++#line 530 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched (sender, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _ease_editor_embed_actor_motion_clutter_actor_motion_event, self);
++#line 531 "ease-editor-embed.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) self->priv->move_undo);
++#line 1188 "ease-editor-embed.c"
++ }
++ result = TRUE;
++#line 533 "ease-editor-embed.vala"
++ return result;
++#line 1193 "ease-editor-embed.c"
++}
++
++
++#line 546 "ease-editor-embed.vala"
++static gboolean ease_editor_embed_actor_motion (EaseEditorEmbed* self, ClutterActor* sender, ClutterMotionEvent* event) {
++#line 1199 "ease-editor-embed.c"
++ gboolean result = FALSE;
++ EaseActor* actor;
++ gboolean _tmp0_ = FALSE;
++#line 546 "ease-editor-embed.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 546 "ease-editor-embed.vala"
++ g_return_val_if_fail (sender != NULL, FALSE);
++#line 548 "ease-editor-embed.vala"
++ actor = _g_object_ref0 (EASE_ACTOR (sender));
++#line 550 "ease-editor-embed.vala"
++ if (sender == CLUTTER_ACTOR (self->priv->_selected)) {
++#line 550 "ease-editor-embed.vala"
++ _tmp0_ = self->priv->is_dragging;
++#line 1213 "ease-editor-embed.c"
++ } else {
++#line 550 "ease-editor-embed.vala"
++ _tmp0_ = FALSE;
++#line 1217 "ease-editor-embed.c"
++ }
++#line 550 "ease-editor-embed.vala"
++ if (_tmp0_) {
++#line 1221 "ease-editor-embed.c"
++ float factor;
++#line 552 "ease-editor-embed.vala"
++ if (!self->priv->is_drag_initialized) {
++#line 554 "ease-editor-embed.vala"
++ self->priv->is_drag_initialized = TRUE;
++#line 555 "ease-editor-embed.vala"
++ self->priv->mouse_x = (*event).x;
++#line 556 "ease-editor-embed.vala"
++ self->priv->mouse_y = (*event).y;
++#line 558 "ease-editor-embed.vala"
++ self->priv->orig_x = clutter_actor_get_x ((ClutterActor*) self->priv->_selected);
++#line 559 "ease-editor-embed.vala"
++ self->priv->orig_y = clutter_actor_get_y ((ClutterActor*) self->priv->_selected);
++#line 560 "ease-editor-embed.vala"
++ self->priv->orig_w = clutter_actor_get_width ((ClutterActor*) self->priv->_selected);
++#line 561 "ease-editor-embed.vala"
++ self->priv->orig_h = clutter_actor_get_height ((ClutterActor*) self->priv->_selected);
++#line 1239 "ease-editor-embed.c"
++ result = TRUE;
++ _g_object_unref0 (actor);
++#line 563 "ease-editor-embed.vala"
++ return result;
++#line 1244 "ease-editor-embed.c"
++ }
++#line 566 "ease-editor-embed.vala"
++ factor = 1 / ease_editor_embed_get_zoom (self);
++#line 568 "ease-editor-embed.vala"
++ ease_actor_translate (actor, factor * ((*event).x - self->priv->mouse_x), factor * ((*event).y - self->priv->mouse_y));
++#line 571 "ease-editor-embed.vala"
++ self->priv->mouse_x = (*event).x;
++#line 572 "ease-editor-embed.vala"
++ self->priv->mouse_y = (*event).y;
++#line 574 "ease-editor-embed.vala"
++ ease_editor_embed_position_selection (self);
++#line 576 "ease-editor-embed.vala"
++ g_signal_emit_by_name (ease_element_get_parent (self->priv->_selected->element), "changed", ease_element_get_parent (self->priv->_selected->element));
++#line 1258 "ease-editor-embed.c"
++ }
++ result = TRUE;
++ _g_object_unref0 (actor);
++#line 578 "ease-editor-embed.vala"
++ return result;
++#line 1264 "ease-editor-embed.c"
++}
++
++
++#line 643 "ease-editor-embed.vala"
++static gboolean _ease_editor_embed_handle_motion_clutter_actor_motion_event (ClutterActor* _sender, ClutterMotionEvent* event, gpointer self) {
++#line 1270 "ease-editor-embed.c"
++ gboolean result;
++ result = ease_editor_embed_handle_motion (self, _sender, event);
++ return result;
++}
++
++
++#line 590 "ease-editor-embed.vala"
++static gboolean ease_editor_embed_handle_clicked (EaseEditorEmbed* self, ClutterActor* sender, ClutterButtonEvent* event) {
++#line 1279 "ease-editor-embed.c"
++ gboolean result = FALSE;
++ ClutterActor* _tmp0_;
++ EaseUndoAction* _tmp1_;
++#line 590 "ease-editor-embed.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 590 "ease-editor-embed.vala"
++ g_return_val_if_fail (sender != NULL, FALSE);
++#line 592 "ease-editor-embed.vala"
++ ease_handle_flip ((_tmp0_ = sender, EASE_IS_HANDLE (_tmp0_) ? ((EaseHandle*) _tmp0_) : NULL), TRUE);
++#line 593 "ease-editor-embed.vala"
++ self->priv->is_dragging = TRUE;
++#line 594 "ease-editor-embed.vala"
++ self->priv->is_drag_initialized = FALSE;
++#line 595 "ease-editor-embed.vala"
++ g_signal_connect_object (sender, "motion-event", (GCallback) _ease_editor_embed_handle_motion_clutter_actor_motion_event, self, 0);
++#line 596 "ease-editor-embed.vala"
++ clutter_grab_pointer (sender);
++#line 599 "ease-editor-embed.vala"
++ self->priv->move_undo = (_tmp1_ = ease_undo_action_new ((GObject*) self->priv->_selected->element, "x"), _g_object_unref0 (self->priv->move_undo), _tmp1_);
++#line 600 "ease-editor-embed.vala"
++ ease_undo_action_add (self->priv->move_undo, (GObject*) self->priv->_selected->element, "y");
++#line 601 "ease-editor-embed.vala"
++ ease_undo_action_add (self->priv->move_undo, (GObject*) self->priv->_selected->element, "width");
++#line 602 "ease-editor-embed.vala"
++ ease_undo_action_add (self->priv->move_undo, (GObject*) self->priv->_selected->element, "height");
++#line 1305 "ease-editor-embed.c"
++ result = TRUE;
++#line 604 "ease-editor-embed.vala"
++ return result;
++#line 1309 "ease-editor-embed.c"
++}
++
++
++#line 618 "ease-editor-embed.vala"
++static gboolean ease_editor_embed_handle_released (EaseEditorEmbed* self, ClutterActor* sender, ClutterButtonEvent* event) {
++#line 1315 "ease-editor-embed.c"
++ gboolean result = FALSE;
++#line 618 "ease-editor-embed.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 618 "ease-editor-embed.vala"
++ g_return_val_if_fail (sender != NULL, FALSE);
++#line 620 "ease-editor-embed.vala"
++ if (self->priv->is_dragging) {
++#line 1323 "ease-editor-embed.c"
++ ClutterActor* _tmp0_;
++ guint _tmp1_;
++#line 622 "ease-editor-embed.vala"
++ ease_handle_flip ((_tmp0_ = sender, EASE_IS_HANDLE (_tmp0_) ? ((EaseHandle*) _tmp0_) : NULL), FALSE);
++#line 623 "ease-editor-embed.vala"
++ self->priv->is_dragging = FALSE;
++#line 624 "ease-editor-embed.vala"
++ g_signal_parse_name ("motion-event", CLUTTER_TYPE_ACTOR, &_tmp1_, NULL, FALSE);
++#line 624 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched (sender, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _ease_editor_embed_handle_motion_clutter_actor_motion_event, self);
++#line 625 "ease-editor-embed.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) self->priv->move_undo);
++#line 1336 "ease-editor-embed.c"
++ }
++#line 628 "ease-editor-embed.vala"
++ clutter_ungrab_pointer ();
++#line 1340 "ease-editor-embed.c"
++ result = TRUE;
++#line 629 "ease-editor-embed.vala"
++ return result;
++#line 1344 "ease-editor-embed.c"
++}
++
++
++#line 643 "ease-editor-embed.vala"
++static gboolean ease_editor_embed_handle_motion (EaseEditorEmbed* self, ClutterActor* sender, ClutterMotionEvent* event) {
++#line 1350 "ease-editor-embed.c"
++ gboolean result = FALSE;
++ EaseHandle* handle;
++ float factor;
++ gboolean p;
++ float change_x;
++ float change_y;
++#line 643 "ease-editor-embed.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 643 "ease-editor-embed.vala"
++ g_return_val_if_fail (sender != NULL, FALSE);
++#line 645 "ease-editor-embed.vala"
++ handle = _g_object_ref0 (EASE_HANDLE (sender));
++#line 647 "ease-editor-embed.vala"
++ if (!self->priv->is_drag_initialized) {
++#line 649 "ease-editor-embed.vala"
++ self->priv->is_drag_initialized = TRUE;
++#line 650 "ease-editor-embed.vala"
++ self->priv->mouse_x = (*event).x;
++#line 651 "ease-editor-embed.vala"
++ self->priv->mouse_y = (*event).y;
++#line 653 "ease-editor-embed.vala"
++ self->priv->orig_x = clutter_actor_get_x ((ClutterActor*) self->priv->_selected);
++#line 654 "ease-editor-embed.vala"
++ self->priv->orig_y = clutter_actor_get_y ((ClutterActor*) self->priv->_selected);
++#line 655 "ease-editor-embed.vala"
++ self->priv->orig_w = clutter_actor_get_width ((ClutterActor*) self->priv->_selected);
++#line 656 "ease-editor-embed.vala"
++ self->priv->orig_h = clutter_actor_get_height ((ClutterActor*) self->priv->_selected);
++#line 1379 "ease-editor-embed.c"
++ result = TRUE;
++ _g_object_unref0 (handle);
++#line 658 "ease-editor-embed.vala"
++ return result;
++#line 1384 "ease-editor-embed.c"
++ }
++#line 661 "ease-editor-embed.vala"
++ factor = 1 / ease_editor_embed_get_zoom (self);
++#line 662 "ease-editor-embed.vala"
++ p = ((*event).modifier_state & CLUTTER_SHIFT_MASK) != 0;
++#line 663 "ease-editor-embed.vala"
++ change_x = (*event).x - self->priv->mouse_x;
++#line 664 "ease-editor-embed.vala"
++ change_y = (*event).y - self->priv->mouse_y;
++#line 667 "ease-editor-embed.vala"
++ if (((*event).modifier_state & CLUTTER_CONTROL_MASK) != 0) {
++#line 669 "ease-editor-embed.vala"
++ ease_handle_drag_from_center (handle, factor * change_x, factor * change_y, self->priv->_selected, p);
++#line 1398 "ease-editor-embed.c"
++ } else {
++#line 676 "ease-editor-embed.vala"
++ ease_handle_drag (handle, factor * change_x, factor * change_y, self->priv->_selected, p);
++#line 1402 "ease-editor-embed.c"
++ }
++#line 679 "ease-editor-embed.vala"
++ self->priv->mouse_x = (*event).x;
++#line 680 "ease-editor-embed.vala"
++ self->priv->mouse_y = (*event).y;
++#line 682 "ease-editor-embed.vala"
++ ease_editor_embed_position_selection (self);
++#line 684 "ease-editor-embed.vala"
++ g_signal_emit_by_name (ease_element_get_parent (self->priv->_selected->element), "changed", ease_element_get_parent (self->priv->_selected->element));
++#line 1412 "ease-editor-embed.c"
++ result = TRUE;
++ _g_object_unref0 (handle);
++#line 686 "ease-editor-embed.vala"
++ return result;
++#line 1417 "ease-editor-embed.c"
++}
++
++
++#line 695 "ease-editor-embed.vala"
++void ease_editor_embed_set_element_color (EaseEditorEmbed* self, ClutterColor* color) {
++#line 695 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 697 "ease-editor-embed.vala"
++ if (self->priv->_selected == NULL) {
++#line 697 "ease-editor-embed.vala"
++ return;
++#line 1429 "ease-editor-embed.c"
++ }
++#line 698 "ease-editor-embed.vala"
++ if (!ease_element_set_color (self->priv->_selected->element, color)) {
++#line 698 "ease-editor-embed.vala"
++ return;
++#line 1435 "ease-editor-embed.c"
++ }
++}
++
++
++#line 705 "ease-editor-embed.vala"
++void ease_editor_embed_on_ease_actor_removed (EaseEditorEmbed* self, EaseActor* actor) {
++#line 1442 "ease-editor-embed.c"
++ guint _tmp0_;
++ guint _tmp1_;
++#line 705 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 705 "ease-editor-embed.vala"
++ g_return_if_fail (actor != NULL);
++#line 707 "ease-editor-embed.vala"
++ if (self->priv->_selected == actor) {
++#line 707 "ease-editor-embed.vala"
++ ease_editor_embed_deselect_actor (self);
++#line 1453 "ease-editor-embed.c"
++ }
++#line 708 "ease-editor-embed.vala"
++ g_signal_parse_name ("button-press-event", CLUTTER_TYPE_ACTOR, &_tmp0_, NULL, FALSE);
++#line 708 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched ((ClutterActor*) actor, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _ease_editor_embed_actor_clicked_clutter_actor_button_press_event, self);
++#line 709 "ease-editor-embed.vala"
++ g_signal_parse_name ("button-release-event", CLUTTER_TYPE_ACTOR, &_tmp1_, NULL, FALSE);
++#line 709 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched ((ClutterActor*) actor, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _ease_editor_embed_actor_released_clutter_actor_button_release_event, self);
++#line 710 "ease-editor-embed.vala"
++ clutter_actor_set_reactive ((ClutterActor*) actor, FALSE);
++#line 1465 "ease-editor-embed.c"
++}
++
++
++#line 716 "ease-editor-embed.vala"
++void ease_editor_embed_on_ease_actor_added (EaseEditorEmbed* self, EaseActor* actor) {
++#line 716 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 716 "ease-editor-embed.vala"
++ g_return_if_fail (actor != NULL);
++#line 718 "ease-editor-embed.vala"
++ g_signal_connect_object ((ClutterActor*) actor, "button-press-event", (GCallback) _ease_editor_embed_actor_clicked_clutter_actor_button_press_event, self, 0);
++#line 719 "ease-editor-embed.vala"
++ g_signal_connect_object ((ClutterActor*) actor, "button-release-event", (GCallback) _ease_editor_embed_actor_released_clutter_actor_button_release_event, self, 0);
++#line 720 "ease-editor-embed.vala"
++ clutter_actor_set_reactive ((ClutterActor*) actor, TRUE);
++#line 1481 "ease-editor-embed.c"
++}
++
++
++#line 726 "ease-editor-embed.vala"
++gboolean ease_editor_embed_on_key_press_event (EaseEditorEmbed* self, GtkWidget* _self_, GdkEventKey* event) {
++#line 1487 "ease-editor-embed.c"
++ gboolean result = FALSE;
++ gboolean shift;
++#line 726 "ease-editor-embed.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 726 "ease-editor-embed.vala"
++ g_return_val_if_fail (_self_ != NULL, FALSE);
++#line 728 "ease-editor-embed.vala"
++ if ((*event).type == GDK_KEY_RELEASE) {
++#line 1496 "ease-editor-embed.c"
++ result = FALSE;
++#line 728 "ease-editor-embed.vala"
++ return result;
++#line 1500 "ease-editor-embed.c"
++ }
++#line 730 "ease-editor-embed.vala"
++ shift = ((*event).state & GDK_SHIFT_MASK) != 0;
++#line 732 "ease-editor-embed.vala"
++ switch ((*event).keyval) {
++#line 1506 "ease-editor-embed.c"
++ case EASE_KEY_UP:
++ {
++ EaseUndoAction* _tmp0_;
++ gint _tmp1_ = 0;
++#line 735 "ease-editor-embed.vala"
++ if (self->priv->_selected == NULL) {
++#line 735 "ease-editor-embed.vala"
++ break;
++#line 1515 "ease-editor-embed.c"
++ }
++#line 736 "ease-editor-embed.vala"
++ if (self->priv->_is_editing) {
++#line 1519 "ease-editor-embed.c"
++ result = TRUE;
++#line 736 "ease-editor-embed.vala"
++ return result;
++#line 1523 "ease-editor-embed.c"
++ }
++#line 738 "ease-editor-embed.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) (_tmp0_ = ease_undo_action_new ((GObject*) self->priv->_selected->element, "y")));
++#line 1527 "ease-editor-embed.c"
++ _g_object_unref0 (_tmp0_);
++#line 739 "ease-editor-embed.vala"
++ if (shift) {
++#line 740 "ease-editor-embed.vala"
++ _tmp1_ = -EASE_EDITOR_EMBED_NUDGE_SHIFT_PIXELS;
++#line 1533 "ease-editor-embed.c"
++ } else {
++#line 740 "ease-editor-embed.vala"
++ _tmp1_ = -EASE_EDITOR_EMBED_NUDGE_PIXELS;
++#line 1537 "ease-editor-embed.c"
++ }
++#line 739 "ease-editor-embed.vala"
++ ease_actor_translate (self->priv->_selected, (float) 0, (float) _tmp1_);
++#line 741 "ease-editor-embed.vala"
++ ease_editor_embed_position_selection (self);
++#line 742 "ease-editor-embed.vala"
++ g_signal_emit_by_name (ease_element_get_parent (self->priv->_selected->element), "changed", ease_element_get_parent (self->priv->_selected->element));
++#line 1545 "ease-editor-embed.c"
++ result = TRUE;
++#line 743 "ease-editor-embed.vala"
++ return result;
++#line 1549 "ease-editor-embed.c"
++ }
++ case EASE_KEY_DOWN:
++ {
++ EaseUndoAction* _tmp2_;
++ gint _tmp3_ = 0;
++#line 746 "ease-editor-embed.vala"
++ if (self->priv->_selected == NULL) {
++#line 746 "ease-editor-embed.vala"
++ break;
++#line 1559 "ease-editor-embed.c"
++ }
++#line 747 "ease-editor-embed.vala"
++ if (self->priv->_is_editing) {
++#line 1563 "ease-editor-embed.c"
++ result = TRUE;
++#line 747 "ease-editor-embed.vala"
++ return result;
++#line 1567 "ease-editor-embed.c"
++ }
++#line 749 "ease-editor-embed.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) (_tmp2_ = ease_undo_action_new ((GObject*) self->priv->_selected->element, "y")));
++#line 1571 "ease-editor-embed.c"
++ _g_object_unref0 (_tmp2_);
++#line 750 "ease-editor-embed.vala"
++ if (shift) {
++#line 751 "ease-editor-embed.vala"
++ _tmp3_ = EASE_EDITOR_EMBED_NUDGE_SHIFT_PIXELS;
++#line 1577 "ease-editor-embed.c"
++ } else {
++#line 751 "ease-editor-embed.vala"
++ _tmp3_ = EASE_EDITOR_EMBED_NUDGE_PIXELS;
++#line 1581 "ease-editor-embed.c"
++ }
++#line 750 "ease-editor-embed.vala"
++ ease_actor_translate (self->priv->_selected, (float) 0, (float) _tmp3_);
++#line 752 "ease-editor-embed.vala"
++ ease_editor_embed_position_selection (self);
++#line 753 "ease-editor-embed.vala"
++ g_signal_emit_by_name (ease_element_get_parent (self->priv->_selected->element), "changed", ease_element_get_parent (self->priv->_selected->element));
++#line 1589 "ease-editor-embed.c"
++ result = TRUE;
++#line 754 "ease-editor-embed.vala"
++ return result;
++#line 1593 "ease-editor-embed.c"
++ }
++ case EASE_KEY_LEFT:
++ {
++ EaseUndoAction* _tmp4_;
++ gint _tmp5_ = 0;
++#line 757 "ease-editor-embed.vala"
++ if (self->priv->_selected == NULL) {
++#line 757 "ease-editor-embed.vala"
++ break;
++#line 1603 "ease-editor-embed.c"
++ }
++#line 758 "ease-editor-embed.vala"
++ if (self->priv->_is_editing) {
++#line 1607 "ease-editor-embed.c"
++ result = TRUE;
++#line 758 "ease-editor-embed.vala"
++ return result;
++#line 1611 "ease-editor-embed.c"
++ }
++#line 760 "ease-editor-embed.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) (_tmp4_ = ease_undo_action_new ((GObject*) self->priv->_selected->element, "x")));
++#line 1615 "ease-editor-embed.c"
++ _g_object_unref0 (_tmp4_);
++#line 761 "ease-editor-embed.vala"
++ if (shift) {
++#line 762 "ease-editor-embed.vala"
++ _tmp5_ = -EASE_EDITOR_EMBED_NUDGE_SHIFT_PIXELS;
++#line 1621 "ease-editor-embed.c"
++ } else {
++#line 762 "ease-editor-embed.vala"
++ _tmp5_ = -EASE_EDITOR_EMBED_NUDGE_PIXELS;
++#line 1625 "ease-editor-embed.c"
++ }
++#line 761 "ease-editor-embed.vala"
++ ease_actor_translate (self->priv->_selected, (float) _tmp5_, (float) 0);
++#line 763 "ease-editor-embed.vala"
++ ease_editor_embed_position_selection (self);
++#line 764 "ease-editor-embed.vala"
++ g_signal_emit_by_name (ease_element_get_parent (self->priv->_selected->element), "changed", ease_element_get_parent (self->priv->_selected->element));
++#line 1633 "ease-editor-embed.c"
++ result = TRUE;
++#line 765 "ease-editor-embed.vala"
++ return result;
++#line 1637 "ease-editor-embed.c"
++ }
++ case EASE_KEY_RIGHT:
++ {
++ EaseUndoAction* _tmp6_;
++ gint _tmp7_ = 0;
++#line 768 "ease-editor-embed.vala"
++ if (self->priv->_selected == NULL) {
++#line 768 "ease-editor-embed.vala"
++ break;
++#line 1647 "ease-editor-embed.c"
++ }
++#line 769 "ease-editor-embed.vala"
++ if (self->priv->_is_editing) {
++#line 1651 "ease-editor-embed.c"
++ result = TRUE;
++#line 769 "ease-editor-embed.vala"
++ return result;
++#line 1655 "ease-editor-embed.c"
++ }
++#line 771 "ease-editor-embed.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) (_tmp6_ = ease_undo_action_new ((GObject*) self->priv->_selected->element, "x")));
++#line 1659 "ease-editor-embed.c"
++ _g_object_unref0 (_tmp6_);
++#line 772 "ease-editor-embed.vala"
++ if (shift) {
++#line 773 "ease-editor-embed.vala"
++ _tmp7_ = EASE_EDITOR_EMBED_NUDGE_SHIFT_PIXELS;
++#line 1665 "ease-editor-embed.c"
++ } else {
++#line 773 "ease-editor-embed.vala"
++ _tmp7_ = EASE_EDITOR_EMBED_NUDGE_PIXELS;
++#line 1669 "ease-editor-embed.c"
++ }
++#line 772 "ease-editor-embed.vala"
++ ease_actor_translate (self->priv->_selected, (float) _tmp7_, (float) 0);
++#line 774 "ease-editor-embed.vala"
++ ease_editor_embed_position_selection (self);
++#line 775 "ease-editor-embed.vala"
++ g_signal_emit_by_name (ease_element_get_parent (self->priv->_selected->element), "changed", ease_element_get_parent (self->priv->_selected->element));
++#line 1677 "ease-editor-embed.c"
++ result = TRUE;
++#line 776 "ease-editor-embed.vala"
++ return result;
++#line 1681 "ease-editor-embed.c"
++ }
++ case EASE_KEY_BACKSPACE:
++ case EASE_KEY_DELETE:
++ {
++ EaseSlide* slide;
++ gint i;
++ EaseElementRemoveUndoAction* _tmp9_;
++ EaseElement* _tmp8_;
++#line 780 "ease-editor-embed.vala"
++ if (self->priv->_selected == NULL) {
++#line 780 "ease-editor-embed.vala"
++ break;
++#line 1694 "ease-editor-embed.c"
++ }
++#line 782 "ease-editor-embed.vala"
++ slide = _g_object_ref0 (ease_slide_actor_get_slide (self->slide_actor));
++#line 783 "ease-editor-embed.vala"
++ i = ease_slide_index_of (slide, self->priv->_selected->element);
++#line 784 "ease-editor-embed.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) (_tmp9_ = ease_element_remove_undo_action_new (_tmp8_ = ease_slide_element_at (slide, i))));
++#line 1702 "ease-editor-embed.c"
++ _g_object_unref0 (_tmp9_);
++ _g_object_unref0 (_tmp8_);
++#line 785 "ease-editor-embed.vala"
++ ease_slide_remove_at (slide, i);
++#line 786 "ease-editor-embed.vala"
++ g_signal_emit_by_name (self, "element-deselected", NULL);
++#line 1709 "ease-editor-embed.c"
++ result = TRUE;
++ _g_object_unref0 (slide);
++#line 788 "ease-editor-embed.vala"
++ return result;
++#line 1714 "ease-editor-embed.c"
++ }
++ }
++ result = FALSE;
++#line 791 "ease-editor-embed.vala"
++ return result;
++#line 1720 "ease-editor-embed.c"
++}
++
++
++#line 797 "ease-editor-embed.vala"
++void ease_editor_embed_on_element_removed (EaseEditorEmbed* self, EaseSlide* slide, EaseElement* element, gint index) {
++#line 797 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 797 "ease-editor-embed.vala"
++ g_return_if_fail (slide != NULL);
++#line 797 "ease-editor-embed.vala"
++ g_return_if_fail (element != NULL);
++#line 799 "ease-editor-embed.vala"
++ if (slide != ease_slide_actor_get_slide (self->slide_actor)) {
++#line 799 "ease-editor-embed.vala"
++ return;
++#line 1736 "ease-editor-embed.c"
++ }
++#line 800 "ease-editor-embed.vala"
++ if (self->priv->_selected == NULL) {
++#line 800 "ease-editor-embed.vala"
++ g_signal_emit_by_name (self, "element-deselected", element);
++#line 1742 "ease-editor-embed.c"
++ }
++}
++
++
++#line 726 "ease-editor-embed.vala"
++static gboolean _ease_editor_embed_on_key_press_event_gtk_widget_key_press_event (GtkWidget* _sender, GdkEventKey* event, gpointer self) {
++#line 1749 "ease-editor-embed.c"
++ gboolean result;
++ result = ease_editor_embed_on_key_press_event (self, _sender, event);
++ return result;
++}
++
++
++#line 806 "ease-editor-embed.vala"
++void ease_editor_embed_connect_keys (EaseEditorEmbed* self) {
++#line 806 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 808 "ease-editor-embed.vala"
++ if (self->priv->keys_connected) {
++#line 808 "ease-editor-embed.vala"
++ return;
++#line 1764 "ease-editor-embed.c"
++ }
++#line 809 "ease-editor-embed.vala"
++ self->priv->keys_connected = TRUE;
++#line 810 "ease-editor-embed.vala"
++ g_signal_connect_object ((GtkWidget*) self, "key-press-event", (GCallback) _ease_editor_embed_on_key_press_event_gtk_widget_key_press_event, self, 0);
++#line 1770 "ease-editor-embed.c"
++}
++
++
++#line 816 "ease-editor-embed.vala"
++void ease_editor_embed_disconnect_keys (EaseEditorEmbed* self) {
++#line 1776 "ease-editor-embed.c"
++ guint _tmp0_;
++#line 816 "ease-editor-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 818 "ease-editor-embed.vala"
++ if (!self->priv->keys_connected) {
++#line 818 "ease-editor-embed.vala"
++ return;
++#line 1784 "ease-editor-embed.c"
++ }
++#line 819 "ease-editor-embed.vala"
++ self->priv->keys_connected = FALSE;
++#line 820 "ease-editor-embed.vala"
++ g_signal_parse_name ("key-press-event", GTK_TYPE_WIDGET, &_tmp0_, NULL, FALSE);
++#line 820 "ease-editor-embed.vala"
++ g_signal_handlers_disconnect_matched ((GtkWidget*) self, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _ease_editor_embed_on_key_press_event_gtk_widget_key_press_event, self);
++#line 1792 "ease-editor-embed.c"
++}
++
++
++EaseActor* ease_editor_embed_get_selected (EaseEditorEmbed* self) {
++ EaseActor* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_selected;
++#line 55 "ease-editor-embed.vala"
++ return result;
++#line 1802 "ease-editor-embed.c"
++}
++
++
++static void ease_editor_embed_set_selected (EaseEditorEmbed* self, EaseActor* value) {
++ EaseActor* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_selected = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_selected), _tmp0_);
++ g_object_notify ((GObject *) self, "selected");
++}
++
++
++static gboolean ease_editor_embed_get_is_editing (EaseEditorEmbed* self) {
++ gboolean result;
++ g_return_val_if_fail (self != NULL, FALSE);
++ result = self->priv->_is_editing;
++#line 60 "ease-editor-embed.vala"
++ return result;
++#line 1820 "ease-editor-embed.c"
++}
++
++
++static void ease_editor_embed_set_is_editing (EaseEditorEmbed* self, gboolean value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_is_editing = value;
++}
++
++
++float ease_editor_embed_get_zoom (EaseEditorEmbed* self) {
++ float result;
++ g_return_val_if_fail (self != NULL, 0.0F);
++ result = self->priv->zoom_priv;
++#line 161 "ease-editor-embed.vala"
++ return result;
++#line 1836 "ease-editor-embed.c"
++}
++
++
++void ease_editor_embed_set_zoom (EaseEditorEmbed* self, float value) {
++ g_return_if_fail (self != NULL);
++#line 165 "ease-editor-embed.vala"
++ self->priv->zoom_priv = value;
++#line 166 "ease-editor-embed.vala"
++ ease_editor_embed_reposition_group (self);
++#line 1846 "ease-editor-embed.c"
++ g_object_notify ((GObject *) self, "zoom");
++}
++
++
++static gboolean ease_editor_embed_get_zoom_fit (EaseEditorEmbed* self) {
++ gboolean result;
++ g_return_val_if_fail (self != NULL, FALSE);
++ result = self->priv->_zoom_fit;
++#line 178 "ease-editor-embed.vala"
++ return result;
++#line 1857 "ease-editor-embed.c"
++}
++
++
++static void ease_editor_embed_set_zoom_fit (EaseEditorEmbed* self, gboolean value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_zoom_fit = value;
++}
++
++
++static void ease_editor_embed_class_init (EaseEditorEmbedClass * klass) {
++ ease_editor_embed_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseEditorEmbedPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_editor_embed_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_editor_embed_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_editor_embed_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_EDITOR_EMBED_SELECTED, g_param_spec_object ("selected", "selected", "selected", EASE_TYPE_ACTOR, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_EDITOR_EMBED_ZOOM, g_param_spec_float ("zoom", "zoom", "zoom", -G_MAXFLOAT, G_MAXFLOAT, 0.0F, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_signal_new ("element_selected", EASE_TYPE_EDITOR_EMBED, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_ELEMENT);
++ g_signal_new ("element_deselected", EASE_TYPE_EDITOR_EMBED, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_ELEMENT);
++}
++
++
++static void ease_editor_embed_ease_undo_source_interface_init (EaseUndoSourceIface * iface) {
++ ease_editor_embed_ease_undo_source_parent_iface = g_type_interface_peek_parent (iface);
++}
++
++
++static void ease_editor_embed_instance_init (EaseEditorEmbed * self) {
++ self->priv = EASE_EDITOR_EMBED_GET_PRIVATE (self);
++ self->priv->keys_connected = FALSE;
++}
++
++
++static void ease_editor_embed_finalize (GObject* obj) {
++ EaseEditorEmbed * self;
++ self = EASE_EDITOR_EMBED (obj);
++ _g_object_unref0 (self->priv->win);
++ _g_object_unref0 (self->priv->selection_rectangle);
++ self->priv->handles = (_vala_array_free (self->priv->handles, self->priv->handles_length1, (GDestroyNotify) g_object_unref), NULL);
++ _g_object_unref0 (self->slide_actor);
++ _g_object_unref0 (self->priv->_selected);
++ _g_object_unref0 (self->priv->move_undo);
++ _g_object_unref0 (self->priv->document);
++ G_OBJECT_CLASS (ease_editor_embed_parent_class)->finalize (obj);
++}
++
++
++GType ease_editor_embed_get_type (void) {
++ static volatile gsize ease_editor_embed_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_editor_embed_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseEditorEmbedClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_editor_embed_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseEditorEmbed), 0, (GInstanceInitFunc) ease_editor_embed_instance_init, NULL };
++ static const GInterfaceInfo ease_undo_source_info = { (GInterfaceInitFunc) ease_editor_embed_ease_undo_source_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
++ GType ease_editor_embed_type_id;
++ ease_editor_embed_type_id = g_type_register_static (EASE_TYPE_SCROLLABLE_EMBED, "EaseEditorEmbed", &g_define_type_info, 0);
++ g_type_add_interface_static (ease_editor_embed_type_id, EASE_TYPE_UNDO_SOURCE, &ease_undo_source_info);
++ g_once_init_leave (&ease_editor_embed_type_id__volatile, ease_editor_embed_type_id);
++ }
++ return ease_editor_embed_type_id__volatile;
++}
++
++
++static void ease_editor_embed_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseEditorEmbed * self;
++ self = EASE_EDITOR_EMBED (object);
++ switch (property_id) {
++ case EASE_EDITOR_EMBED_SELECTED:
++ g_value_set_object (value, ease_editor_embed_get_selected (self));
++ break;
++ case EASE_EDITOR_EMBED_ZOOM:
++ g_value_set_float (value, ease_editor_embed_get_zoom (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_editor_embed_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseEditorEmbed * self;
++ self = EASE_EDITOR_EMBED (object);
++ switch (property_id) {
++ case EASE_EDITOR_EMBED_SELECTED:
++ ease_editor_embed_set_selected (self, g_value_get_object (value));
++ break;
++ case EASE_EDITOR_EMBED_ZOOM:
++ ease_editor_embed_set_zoom (self, g_value_get_float (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
++ if ((array != NULL) && (destroy_func != NULL)) {
++ int 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, gint array_length, GDestroyNotify destroy_func) {
++ _vala_array_destroy (array, array_length, destroy_func);
++ g_free (array);
++}
++
++
++
++
diff --cc ease-core/ease-editor-window.c
index 0000000,0000000..2fd2a9c
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-editor-window.c
@@@ -1,0 -1,0 +1,1961 @@@
++/* ease-editor-window.c generated by valac, the Vala compiler
++ * generated from ease-editor-window.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++#include <glib/gi18n-lib.h>
++#include <time.h>
++#include <gdk/gdk.h>
++#include <clutter/clutter.h>
++#include <float.h>
++#include <math.h>
++#include <pango/pango.h>
++
++
++#define EASE_TYPE_EDITOR_WINDOW (ease_editor_window_get_type ())
++#define EASE_EDITOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindow))
++#define EASE_EDITOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindowClass))
++#define EASE_IS_EDITOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_WINDOW))
++#define EASE_IS_EDITOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_WINDOW))
++#define EASE_EDITOR_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindowClass))
++
++typedef struct _EaseEditorWindow EaseEditorWindow;
++typedef struct _EaseEditorWindowClass EaseEditorWindowClass;
++typedef struct _EaseEditorWindowPrivate EaseEditorWindowPrivate;
++
++#define EASE_TYPE_SCROLLABLE_EMBED (ease_scrollable_embed_get_type ())
++#define EASE_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbed))
++#define EASE_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++#define EASE_IS_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_IS_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_SCROLLABLE_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++
++typedef struct _EaseScrollableEmbed EaseScrollableEmbed;
++typedef struct _EaseScrollableEmbedClass EaseScrollableEmbedClass;
++
++#define EASE_TYPE_EDITOR_EMBED (ease_editor_embed_get_type ())
++#define EASE_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbed))
++#define EASE_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++#define EASE_IS_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_EMBED))
++#define EASE_IS_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_EMBED))
++#define EASE_EDITOR_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++
++typedef struct _EaseEditorEmbed EaseEditorEmbed;
++typedef struct _EaseEditorEmbedClass EaseEditorEmbedClass;
++
++#define EASE_TYPE_SLIDE_BUTTON_PANEL (ease_slide_button_panel_get_type ())
++#define EASE_SLIDE_BUTTON_PANEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_BUTTON_PANEL, EaseSlideButtonPanel))
++#define EASE_SLIDE_BUTTON_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_BUTTON_PANEL, EaseSlideButtonPanelClass))
++#define EASE_IS_SLIDE_BUTTON_PANEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_BUTTON_PANEL))
++#define EASE_IS_SLIDE_BUTTON_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_BUTTON_PANEL))
++#define EASE_SLIDE_BUTTON_PANEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_BUTTON_PANEL, EaseSlideButtonPanelClass))
++
++typedef struct _EaseSlideButtonPanel EaseSlideButtonPanel;
++typedef struct _EaseSlideButtonPanelClass EaseSlideButtonPanelClass;
++
++#define EASE_TYPE_ZOOM_SLIDER (ease_zoom_slider_get_type ())
++#define EASE_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ZOOM_SLIDER, EaseZoomSlider))
++#define EASE_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ZOOM_SLIDER, EaseZoomSliderClass))
++#define EASE_IS_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ZOOM_SLIDER))
++#define EASE_IS_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ZOOM_SLIDER))
++#define EASE_ZOOM_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ZOOM_SLIDER, EaseZoomSliderClass))
++
++typedef struct _EaseZoomSlider EaseZoomSlider;
++typedef struct _EaseZoomSliderClass EaseZoomSliderClass;
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++
++#define EASE_TYPE_PLAYER (ease_player_get_type ())
++#define EASE_PLAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_PLAYER, EasePlayer))
++#define EASE_PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_PLAYER, EasePlayerClass))
++#define EASE_IS_PLAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_PLAYER))
++#define EASE_IS_PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_PLAYER))
++#define EASE_PLAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_PLAYER, EasePlayerClass))
++
++typedef struct _EasePlayer EasePlayer;
++typedef struct _EasePlayerClass EasePlayerClass;
++
++#define EASE_TYPE_INSPECTOR (ease_inspector_get_type ())
++#define EASE_INSPECTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR, EaseInspector))
++#define EASE_INSPECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR, EaseInspectorClass))
++#define EASE_IS_INSPECTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR))
++#define EASE_IS_INSPECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR))
++#define EASE_INSPECTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR, EaseInspectorClass))
++
++typedef struct _EaseInspector EaseInspector;
++typedef struct _EaseInspectorClass EaseInspectorClass;
++
++#define EASE_TYPE_UNDO_CONTROLLER (ease_undo_controller_get_type ())
++#define EASE_UNDO_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_CONTROLLER, EaseUndoController))
++#define EASE_UNDO_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_CONTROLLER, EaseUndoControllerClass))
++#define EASE_IS_UNDO_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_CONTROLLER))
++#define EASE_IS_UNDO_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_CONTROLLER))
++#define EASE_UNDO_CONTROLLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_CONTROLLER, EaseUndoControllerClass))
++
++typedef struct _EaseUndoController EaseUndoController;
++typedef struct _EaseUndoControllerClass EaseUndoControllerClass;
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++
++#define EASE_TYPE_UNDO_ACTION (ease_undo_action_get_type ())
++#define EASE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoAction))
++#define EASE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++#define EASE_IS_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ACTION))
++#define EASE_IS_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ACTION))
++#define EASE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++
++typedef struct _EaseUndoAction EaseUndoAction;
++typedef struct _EaseUndoActionClass EaseUndoActionClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++typedef struct _EaseInspectorPrivate EaseInspectorPrivate;
++
++#define EASE_TYPE_INSPECTOR_PANE (ease_inspector_pane_get_type ())
++#define EASE_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPane))
++#define EASE_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++#define EASE_IS_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_IS_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_INSPECTOR_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++
++typedef struct _EaseInspectorPane EaseInspectorPane;
++typedef struct _EaseInspectorPaneClass EaseInspectorPaneClass;
++
++#define EASE_TYPE_INSPECTOR_ELEMENT_PANE (ease_inspector_element_pane_get_type ())
++#define EASE_INSPECTOR_ELEMENT_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_ELEMENT_PANE, EaseInspectorElementPane))
++#define EASE_INSPECTOR_ELEMENT_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_ELEMENT_PANE, EaseInspectorElementPaneClass))
++#define EASE_IS_INSPECTOR_ELEMENT_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_ELEMENT_PANE))
++#define EASE_IS_INSPECTOR_ELEMENT_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_ELEMENT_PANE))
++#define EASE_INSPECTOR_ELEMENT_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_ELEMENT_PANE, EaseInspectorElementPaneClass))
++
++typedef struct _EaseInspectorElementPane EaseInspectorElementPane;
++typedef struct _EaseInspectorElementPaneClass EaseInspectorElementPaneClass;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++
++#define EASE_TYPE_CLOSE_CONFIRM_DIALOG (ease_close_confirm_dialog_get_type ())
++#define EASE_CLOSE_CONFIRM_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_CLOSE_CONFIRM_DIALOG, EaseCloseConfirmDialog))
++#define EASE_CLOSE_CONFIRM_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_CLOSE_CONFIRM_DIALOG, EaseCloseConfirmDialogClass))
++#define EASE_IS_CLOSE_CONFIRM_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_CLOSE_CONFIRM_DIALOG))
++#define EASE_IS_CLOSE_CONFIRM_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_CLOSE_CONFIRM_DIALOG))
++#define EASE_CLOSE_CONFIRM_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_CLOSE_CONFIRM_DIALOG, EaseCloseConfirmDialogClass))
++
++typedef struct _EaseCloseConfirmDialog EaseCloseConfirmDialog;
++typedef struct _EaseCloseConfirmDialogClass EaseCloseConfirmDialogClass;
++
++#define EASE_TYPE_ACTOR (ease_actor_get_type ())
++#define EASE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ACTOR, EaseActor))
++#define EASE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ACTOR, EaseActorClass))
++#define EASE_IS_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ACTOR))
++#define EASE_IS_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ACTOR))
++#define EASE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ACTOR, EaseActorClass))
++
++typedef struct _EaseActor EaseActor;
++typedef struct _EaseActorClass EaseActorClass;
++typedef struct _EaseActorPrivate EaseActorPrivate;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++#define EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION (ease_element_remove_undo_action_get_type ())
++#define EASE_ELEMENT_REMOVE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION, EaseElementRemoveUndoAction))
++#define EASE_ELEMENT_REMOVE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION, EaseElementRemoveUndoActionClass))
++#define EASE_IS_ELEMENT_REMOVE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION))
++#define EASE_IS_ELEMENT_REMOVE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION))
++#define EASE_ELEMENT_REMOVE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION, EaseElementRemoveUndoActionClass))
++
++typedef struct _EaseElementRemoveUndoAction EaseElementRemoveUndoAction;
++typedef struct _EaseElementRemoveUndoActionClass EaseElementRemoveUndoActionClass;
++
++#define EASE_TYPE_THEME (ease_theme_get_type ())
++#define EASE_THEME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_THEME, EaseTheme))
++#define EASE_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_THEME, EaseThemeClass))
++#define EASE_IS_THEME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_THEME))
++#define EASE_IS_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_THEME))
++#define EASE_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_THEME, EaseThemeClass))
++
++typedef struct _EaseTheme EaseTheme;
++typedef struct _EaseThemeClass EaseThemeClass;
++
++#define EASE_TYPE_SLIDE_ADD_UNDO_ACTION (ease_slide_add_undo_action_get_type ())
++#define EASE_SLIDE_ADD_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_ADD_UNDO_ACTION, EaseSlideAddUndoAction))
++#define EASE_SLIDE_ADD_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_ADD_UNDO_ACTION, EaseSlideAddUndoActionClass))
++#define EASE_IS_SLIDE_ADD_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_ADD_UNDO_ACTION))
++#define EASE_IS_SLIDE_ADD_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_ADD_UNDO_ACTION))
++#define EASE_SLIDE_ADD_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_ADD_UNDO_ACTION, EaseSlideAddUndoActionClass))
++
++typedef struct _EaseSlideAddUndoAction EaseSlideAddUndoAction;
++typedef struct _EaseSlideAddUndoActionClass EaseSlideAddUndoActionClass;
++
++#define EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION (ease_slide_remove_undo_action_get_type ())
++#define EASE_SLIDE_REMOVE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION, EaseSlideRemoveUndoAction))
++#define EASE_SLIDE_REMOVE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION, EaseSlideRemoveUndoActionClass))
++#define EASE_IS_SLIDE_REMOVE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION))
++#define EASE_IS_SLIDE_REMOVE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION))
++#define EASE_SLIDE_REMOVE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION, EaseSlideRemoveUndoActionClass))
++
++typedef struct _EaseSlideRemoveUndoAction EaseSlideRemoveUndoAction;
++typedef struct _EaseSlideRemoveUndoActionClass EaseSlideRemoveUndoActionClass;
++typedef struct _EaseScrollableEmbedPrivate EaseScrollableEmbedPrivate;
++typedef struct _EaseEditorEmbedPrivate EaseEditorEmbedPrivate;
++
++#define EASE_TYPE_SLIDE_ACTOR (ease_slide_actor_get_type ())
++#define EASE_SLIDE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_ACTOR, EaseSlideActor))
++#define EASE_SLIDE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_ACTOR, EaseSlideActorClass))
++#define EASE_IS_SLIDE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_ACTOR))
++#define EASE_IS_SLIDE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_ACTOR))
++#define EASE_SLIDE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_ACTOR, EaseSlideActorClass))
++
++typedef struct _EaseSlideActor EaseSlideActor;
++typedef struct _EaseSlideActorClass EaseSlideActorClass;
++
++#define EASE_TYPE_TEXT_ELEMENT (ease_text_element_get_type ())
++#define EASE_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElement))
++#define EASE_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++#define EASE_IS_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_IS_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_TEXT_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++
++typedef struct _EaseTextElement EaseTextElement;
++typedef struct _EaseTextElementClass EaseTextElementClass;
++
++#define EASE_TYPE_ELEMENT_ADD_UNDO_ACTION (ease_element_add_undo_action_get_type ())
++#define EASE_ELEMENT_ADD_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT_ADD_UNDO_ACTION, EaseElementAddUndoAction))
++#define EASE_ELEMENT_ADD_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT_ADD_UNDO_ACTION, EaseElementAddUndoActionClass))
++#define EASE_IS_ELEMENT_ADD_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT_ADD_UNDO_ACTION))
++#define EASE_IS_ELEMENT_ADD_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT_ADD_UNDO_ACTION))
++#define EASE_ELEMENT_ADD_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT_ADD_UNDO_ACTION, EaseElementAddUndoActionClass))
++
++typedef struct _EaseElementAddUndoAction EaseElementAddUndoAction;
++typedef struct _EaseElementAddUndoActionClass EaseElementAddUndoActionClass;
++
++#define EASE_TYPE_MEDIA_ELEMENT (ease_media_element_get_type ())
++#define EASE_MEDIA_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElement))
++#define EASE_MEDIA_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElementClass))
++#define EASE_IS_MEDIA_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_MEDIA_ELEMENT))
++#define EASE_IS_MEDIA_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_MEDIA_ELEMENT))
++#define EASE_MEDIA_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElementClass))
++
++typedef struct _EaseMediaElement EaseMediaElement;
++typedef struct _EaseMediaElementClass EaseMediaElementClass;
++
++#define EASE_TYPE_IMAGE_ELEMENT (ease_image_element_get_type ())
++#define EASE_IMAGE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_IMAGE_ELEMENT, EaseImageElement))
++#define EASE_IMAGE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_IMAGE_ELEMENT, EaseImageElementClass))
++#define EASE_IS_IMAGE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_IMAGE_ELEMENT))
++#define EASE_IS_IMAGE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_IMAGE_ELEMENT))
++#define EASE_IMAGE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_IMAGE_ELEMENT, EaseImageElementClass))
++
++typedef struct _EaseImageElement EaseImageElement;
++typedef struct _EaseImageElementClass EaseImageElementClass;
++typedef struct _Block1Data Block1Data;
++#define _pango_font_description_free0(var) ((var == NULL) ? NULL : (var = (pango_font_description_free (var), NULL)))
++
++#define EASE_TYPE_ANIMATED_ZOOM_SLIDER (ease_animated_zoom_slider_get_type ())
++#define EASE_ANIMATED_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ANIMATED_ZOOM_SLIDER, EaseAnimatedZoomSlider))
++#define EASE_ANIMATED_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ANIMATED_ZOOM_SLIDER, EaseAnimatedZoomSliderClass))
++#define EASE_IS_ANIMATED_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ANIMATED_ZOOM_SLIDER))
++#define EASE_IS_ANIMATED_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ANIMATED_ZOOM_SLIDER))
++#define EASE_ANIMATED_ZOOM_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ANIMATED_ZOOM_SLIDER, EaseAnimatedZoomSliderClass))
++
++typedef struct _EaseAnimatedZoomSlider EaseAnimatedZoomSlider;
++typedef struct _EaseAnimatedZoomSliderClass EaseAnimatedZoomSliderClass;
++
++struct _EaseEditorWindow {
++ GtkWindow parent_instance;
++ EaseEditorWindowPrivate * priv;
++ EaseEditorEmbed* embed;
++ EaseSlideButtonPanel* slide_button_panel;
++ EaseZoomSlider* zoom_slider;
++ EaseDocument* document;
++ EaseSlide* slide;
++};
++
++struct _EaseEditorWindowClass {
++ GtkWindowClass parent_class;
++};
++
++struct _EaseEditorWindowPrivate {
++ EasePlayer* player;
++ EaseInspector* inspector;
++ EaseUndoController* undo;
++ EaseUndoAction* undo_action;
++ GtkToolButton* undo_button;
++ GtkToolButton* redo_button;
++ gboolean _slides_shown;
++ GtkColorSelectionDialog* color_dialog;
++ GtkColorSelection* color_selection;
++ glong last_saved;
++ gint* ZOOM_LEVELS;
++ gint ZOOM_LEVELS_length1;
++ gint _ZOOM_LEVELS_size_;
++};
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseInspector {
++ GtkNotebook parent_instance;
++ EaseInspectorPrivate * priv;
++ EaseInspectorElementPane* element_pane;
++};
++
++struct _EaseInspectorClass {
++ GtkNotebookClass parent_class;
++};
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++struct _EaseActor {
++ ClutterGroup parent_instance;
++ EaseActorPrivate * priv;
++ ClutterActor* contents;
++ EaseElement* element;
++ EaseActorContext context;
++ gboolean is_background;
++};
++
++struct _EaseActorClass {
++ ClutterGroupClass parent_class;
++ void (*edit) (EaseActor* self, EaseEditorEmbed* sender);
++ void (*end_edit) (EaseActor* self, EaseEditorEmbed* sender);
++};
++
++struct _EaseScrollableEmbed {
++ GtkHBox parent_instance;
++ EaseScrollableEmbedPrivate * priv;
++};
++
++struct _EaseScrollableEmbedClass {
++ GtkHBoxClass parent_class;
++};
++
++struct _EaseEditorEmbed {
++ EaseScrollableEmbed parent_instance;
++ EaseEditorEmbedPrivate * priv;
++ EaseSlideActor* slide_actor;
++};
++
++struct _EaseEditorEmbedClass {
++ EaseScrollableEmbedClass parent_class;
++};
++
++struct _Block1Data {
++ int _ref_count_;
++ EaseEditorWindow * self;
++ ClutterColor* original_color;
++};
++
++
++static gpointer ease_editor_window_parent_class = NULL;
++
++GType ease_editor_window_get_type (void) G_GNUC_CONST;
++GType ease_scrollable_embed_get_type (void) G_GNUC_CONST;
++GType ease_editor_embed_get_type (void) G_GNUC_CONST;
++GType ease_slide_button_panel_get_type (void) G_GNUC_CONST;
++GType ease_zoom_slider_get_type (void) G_GNUC_CONST;
++GType ease_document_get_type (void) G_GNUC_CONST;
++GType ease_slide_get_type (void) G_GNUC_CONST;
++GType ease_player_get_type (void) G_GNUC_CONST;
++GType ease_inspector_get_type (void) G_GNUC_CONST;
++GType ease_undo_controller_get_type (void) G_GNUC_CONST;
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++GType ease_undo_action_get_type (void) G_GNUC_CONST;
++#define EASE_EDITOR_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindowPrivate))
++enum {
++ EASE_EDITOR_WINDOW_DUMMY_PROPERTY,
++ EASE_EDITOR_WINDOW_SLIDES_SHOWN
++};
++#define EASE_EDITOR_WINDOW_UI_FILE_PATH "editor-window.ui"
++#define EASE_EDITOR_WINDOW_FONT_TEXT _ ("The quick brown fox jumps over the lazy dog")
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++void ease_editor_window_add_undo_action (EaseEditorWindow* self, EaseUndoItem* action);
++static void _ease_editor_window_add_undo_action_ease_undo_source_undo (EaseUndoSource* _sender, EaseUndoItem* action, gpointer self);
++char* ease_data_path (const char* path);
++#define EASE_TEMP_UI_DIR "ui"
++EaseSlideButtonPanel* ease_slide_button_panel_new (EaseDocument* d, EaseEditorWindow* win);
++EaseSlideButtonPanel* ease_slide_button_panel_construct (GType object_type, EaseDocument* d, EaseEditorWindow* win);
++EaseUndoController* ease_undo_controller_new (void);
++EaseUndoController* ease_undo_controller_construct (GType object_type);
++EaseEditorEmbed* ease_editor_embed_new (EaseDocument* d, EaseEditorWindow* w);
++EaseEditorEmbed* ease_editor_embed_construct (GType object_type, EaseDocument* d, EaseEditorWindow* w);
++EaseInspector* ease_inspector_new (void);
++EaseInspector* ease_inspector_construct (GType object_type);
++GType ease_inspector_pane_get_type (void) G_GNUC_CONST;
++GType ease_inspector_element_pane_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++void ease_inspector_element_pane_on_element_selected (EaseInspectorElementPane* self, EaseElement* selected);
++static void _ease_inspector_element_pane_on_element_selected_ease_editor_embed_element_selected (EaseEditorEmbed* _sender, EaseElement* selected, gpointer self);
++void ease_inspector_element_pane_on_element_deselected (EaseInspectorElementPane* self, EaseElement* deselected);
++static void _ease_inspector_element_pane_on_element_deselected_ease_editor_embed_element_deselected (EaseEditorEmbed* _sender, EaseElement* deselected, gpointer self);
++static EaseZoomSlider* ease_editor_window_create_zoom_slider (EaseEditorWindow* self);
++#define EASE_THEME_TITLE "title"
++#define EASE_THEME_CONTENT_HEADER "content-header"
++#define EASE_THEME_CONTENT "content"
++#define EASE_THEME_CONTENT_DUAL_HEADER "content-dual-header"
++#define EASE_THEME_CONTENT_DUAL "content-dual"
++#define EASE_THEME_MEDIA_HEADER "media-header"
++#define EASE_THEME_MEDIA "media"
++char* ease_theme_master_mnemonic_description (const char* master);
++void ease_editor_window_on_new_slide_menu (EaseEditorWindow* self, GtkWidget* sender);
++static void _ease_editor_window_on_new_slide_menu_gtk_menu_item_activate (GtkMenuItem* _sender, gpointer self);
++void ease_editor_window_set_slides_shown (EaseEditorWindow* self, gboolean value);
++const char* ease_document_get_filename (EaseDocument* self);
++EaseCloseConfirmDialog* ease_close_confirm_dialog_new (const char* filename, gint seconds);
++EaseCloseConfirmDialog* ease_close_confirm_dialog_construct (GType object_type, const char* filename, gint seconds);
++GType ease_close_confirm_dialog_get_type (void) G_GNUC_CONST;
++void ease_main_remove_window (EaseEditorWindow* win);
++gboolean ease_editor_window_save_document (GtkWidget* sender, EaseEditorWindow* self);
++static gboolean _lambda79_ (GtkWidget* sender, GdkEvent* event, EaseEditorWindow* self);
++static gboolean __lambda79__gtk_widget_delete_event (GtkWidget* _sender, GdkEvent* event, gpointer self);
++void ease_editor_window_set_slide (EaseEditorWindow* self, gint index);
++static void ease_editor_window_update_undo (EaseEditorWindow* self);
++EaseEditorWindow* ease_editor_window_new (EaseDocument* doc);
++EaseEditorWindow* ease_editor_window_construct (GType object_type, EaseDocument* doc);
++EaseSlide* ease_document_get_slide (EaseDocument* self, gint index);
++void ease_inspector_set_slide (EaseInspector* self, EaseSlide* value);
++void ease_editor_embed_set_slide (EaseEditorEmbed* self, EaseSlide* slide);
++void ease_undo_controller_add_action (EaseUndoController* self, EaseUndoItem* action);
++void ease_undo_controller_clear_redo (EaseUndoController* self);
++gboolean ease_undo_controller_can_undo (EaseUndoController* self);
++gboolean ease_undo_controller_can_redo (EaseUndoController* self);
++void ease_editor_window_on_quit (GtkWidget* sender, EaseEditorWindow* self);
++GType ease_actor_get_type (void) G_GNUC_CONST;
++EaseActor* ease_editor_embed_get_selected (EaseEditorEmbed* self);
++gint ease_slide_index_of (EaseSlide* self, EaseElement* e);
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++EaseElement* ease_slide_element_at (EaseSlide* self, gint i);
++EaseElementRemoveUndoAction* ease_element_remove_undo_action_new (EaseElement* e);
++EaseElementRemoveUndoAction* ease_element_remove_undo_action_construct (GType object_type, EaseElement* e);
++GType ease_element_remove_undo_action_get_type (void) G_GNUC_CONST;
++void ease_slide_remove_at (EaseSlide* self, gint index);
++void ease_editor_window_on_delete (GtkWidget* sender, EaseEditorWindow* self);
++GType ease_theme_get_type (void) G_GNUC_CONST;
++EaseTheme* ease_document_get_theme (EaseDocument* self);
++EaseSlide* ease_theme_create_slide (EaseTheme* self, const char* master, gint width, gint height);
++#define EASE_DOCUMENT_DEFAULT_SLIDE EASE_THEME_CONTENT_HEADER
++gint ease_document_get_width (EaseDocument* self);
++gint ease_document_get_height (EaseDocument* self);
++gint ease_document_index_of (EaseDocument* self, EaseSlide* slide);
++EaseSlideAddUndoAction* ease_slide_add_undo_action_new (EaseSlide* s);
++EaseSlideAddUndoAction* ease_slide_add_undo_action_construct (GType object_type, EaseSlide* s);
++GType ease_slide_add_undo_action_get_type (void) G_GNUC_CONST;
++void ease_document_add_slide (EaseDocument* self, gint index, EaseSlide* s);
++void ease_editor_window_new_slide_handler (GtkWidget* sender, EaseEditorWindow* self);
++char* ease_theme_master_from_description (const char* desc);
++gint ease_document_get_length (EaseDocument* self);
++EaseSlideRemoveUndoAction* ease_slide_remove_undo_action_new (EaseSlide* s);
++EaseSlideRemoveUndoAction* ease_slide_remove_undo_action_construct (GType object_type, EaseSlide* s);
++GType ease_slide_remove_undo_action_get_type (void) G_GNUC_CONST;
++void ease_slide_button_panel_select_slide (EaseSlideButtonPanel* self, EaseSlide* slide);
++EaseSlide* ease_document_remove_slide (EaseDocument* self, EaseSlide* slide);
++void ease_editor_window_remove_slide (GtkWidget* sender, EaseEditorWindow* self);
++EasePlayer* ease_player_new (EaseDocument* doc);
++EasePlayer* ease_player_construct (GType object_type, EaseDocument* doc);
++static void _lambda91_ (EaseEditorWindow* self);
++static void __lambda91__ease_player_complete (EasePlayer* _sender, gpointer self);
++void ease_editor_window_play_handler (GtkWidget* sender, EaseEditorWindow* self);
++void ease_undo_controller_undo (EaseUndoController* self);
++GType ease_slide_actor_get_type (void) G_GNUC_CONST;
++void ease_slide_actor_relayout (EaseSlideActor* self);
++void ease_editor_embed_reposition_group (EaseEditorEmbed* self);
++void ease_editor_window_undo_handler (GtkWidget* sender, EaseEditorWindow* self);
++void ease_undo_controller_redo (EaseUndoController* self);
++void ease_editor_window_redo_handler (GtkWidget* sender, EaseEditorWindow* self);
++GType ease_text_element_get_type (void) G_GNUC_CONST;
++EaseTextElement* ease_theme_create_custom_text (EaseTheme* self);
++float ease_element_get_width (EaseElement* self);
++void ease_element_set_x (EaseElement* self, float value);
++float ease_element_get_height (EaseElement* self);
++void ease_element_set_y (EaseElement* self, float value);
++void ease_slide_add (EaseSlide* self, EaseElement* e);
++EaseElementAddUndoAction* ease_element_add_undo_action_new (EaseElement* e);
++EaseElementAddUndoAction* ease_element_add_undo_action_construct (GType object_type, EaseElement* e);
++GType ease_element_add_undo_action_get_type (void) G_GNUC_CONST;
++void ease_editor_embed_select_element (EaseEditorEmbed* self, EaseElement* e);
++void ease_editor_window_insert_text (GtkWidget* sender, EaseEditorWindow* self);
++EaseImageElement* ease_image_element_new (void);
++EaseImageElement* ease_image_element_construct (GType object_type);
++GType ease_media_element_get_type (void) G_GNUC_CONST;
++GType ease_image_element_get_type (void) G_GNUC_CONST;
++void ease_element_set_width (EaseElement* self, float value);
++void ease_element_set_height (EaseElement* self, float value);
++#define EASE_SLIDE_IMAGE_TYPE "EaseImageElement"
++void ease_element_set_element_type (EaseElement* self, const char* value);
++#define EASE_THEME_CUSTOM_MEDIA "custom-media"
++void ease_element_set_identifier (EaseElement* self, const char* value);
++char* ease_document_add_media_file (EaseDocument* self, const char* file, GError** error);
++void ease_media_element_set_filename (EaseMediaElement* self, const char* value);
++void ease_media_element_set_source_filename (EaseMediaElement* self, const char* value);
++void ease_error_dialog (const char* title, const char* message);
++void ease_editor_window_insert_image (GtkWidget* sender, EaseEditorWindow* self);
++void ease_editor_window_insert_video (GtkWidget* sender, EaseEditorWindow* self);
++void ease_zoom_slider_zoom_in (EaseZoomSlider* self);
++void ease_editor_window_zoom_in (GtkWidget* sender, EaseEditorWindow* self);
++void ease_zoom_slider_zoom_out (EaseZoomSlider* self);
++void ease_editor_window_zoom_out (GtkWidget* sender, EaseEditorWindow* self);
++void ease_document_set_filename (EaseDocument* self, const char* value);
++void ease_document_to_json (EaseDocument* self, GError** error);
++void ease_document_export_as_pdf (EaseDocument* self, GtkWindow* win);
++void ease_editor_window_export_as_pdf (GtkWidget* sender, EaseEditorWindow* self);
++void ease_document_export_as_postscript (EaseDocument* self, GtkWindow* win);
++void ease_editor_window_export_as_postscript (GtkWidget* sender, EaseEditorWindow* self);
++void ease_document_export_as_html (EaseDocument* self, GtkWindow* window);
++void ease_editor_window_export_as_html (GtkWidget* sender, EaseEditorWindow* self);
++void ease_editor_window_inspector_clicked_handler (GtkWidget* sender, EaseEditorWindow* self);
++ClutterColor* ease_element_get_color (EaseElement* self);
++EaseUndoAction* ease_undo_action_new (GObject* obj, const char* prop);
++EaseUndoAction* ease_undo_action_construct (GType object_type, GObject* obj, const char* prop);
++static void ease_editor_window_color_dialog_changed (EaseEditorWindow* self, GtkColorSelection* sender);
++static void _ease_editor_window_color_dialog_changed_gtk_color_selection_color_changed (GtkColorSelection* _sender, gpointer self);
++static void ease_editor_window_color_dialog_selection (EaseEditorWindow* self, GObject* sender, GParamSpec* spec);
++static void _ease_editor_window_color_dialog_selection_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static void _lambda92_ (EaseEditorWindow* self);
++static void __lambda92__gtk_widget_hide (GtkWidget* _sender, gpointer self);
++static gboolean _clutter_color_equal (const ClutterColor* s1, const ClutterColor* s2);
++static void _lambda93_ (Block1Data* _data1_);
++static void __lambda93__gtk_button_clicked (GtkButton* _sender, gpointer self);
++gboolean ease_element_set_color (EaseElement* self, ClutterColor* c);
++static void _lambda94_ (Block1Data* _data1_);
++static void __lambda94__gtk_button_clicked (GtkButton* _sender, gpointer self);
++static void _lambda95_ (EaseEditorWindow* self);
++static void __lambda95__gtk_dialog_close (GtkDialog* _sender, gpointer self);
++static Block1Data* block1_data_ref (Block1Data* _data1_);
++static void block1_data_unref (Block1Data* _data1_);
++void ease_editor_window_show_color_dialog (GtkWidget* sender, EaseEditorWindow* self);
++void ease_editor_embed_set_element_color (EaseEditorEmbed* self, ClutterColor* color);
++void ease_transformations_gdk_color_to_clutter_color (GdkColor* color, ClutterColor* result);
++void ease_transformations_clutter_color_to_gdk_color (ClutterColor* color, GdkColor* result);
++const char* ease_text_element_get_text (EaseTextElement* self);
++PangoFontDescription* ease_text_element_get_font_description (EaseTextElement* self);
++void ease_text_element_set_font_description (EaseTextElement* self, const PangoFontDescription* value);
++EaseSlide* ease_element_get_parent (EaseElement* self);
++void ease_editor_window_select_font (GtkWidget* sender, EaseEditorWindow* self);
++EaseAnimatedZoomSlider* ease_animated_zoom_slider_new (GtkAdjustment* adjustment, gint* button_values, int button_values_length1);
++EaseAnimatedZoomSlider* ease_animated_zoom_slider_construct (GType object_type, GtkAdjustment* adjustment, gint* button_values, int button_values_length1);
++GType ease_animated_zoom_slider_get_type (void) G_GNUC_CONST;
++void ease_zoom_slider_set_value_pos (EaseZoomSlider* self, GtkPositionType value);
++void ease_zoom_slider_set_digits (EaseZoomSlider* self, gint value);
++double ease_zoom_slider_get_value (EaseZoomSlider* self);
++void ease_editor_embed_set_zoom (EaseEditorEmbed* self, float value);
++static void _lambda78_ (EaseEditorWindow* self);
++static void __lambda78__ease_zoom_slider_value_changed (EaseZoomSlider* _sender, gpointer self);
++gboolean ease_editor_window_get_slides_shown (EaseEditorWindow* self);
++static void ease_editor_window_finalize (GObject* obj);
++static void ease_editor_window_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_editor_window_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++static int _vala_strcmp0 (const char * str1, const char * str2);
++
++extern const char* EASE_THEME_MASTER_SLIDES[7];
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 242 "ease-editor-window.vala"
++static void _ease_editor_window_add_undo_action_ease_undo_source_undo (EaseUndoSource* _sender, EaseUndoItem* action, gpointer self) {
++#line 626 "ease-editor-window.c"
++ ease_editor_window_add_undo_action (self, action);
++}
++
++
++#line 40 "ease-inspector-element-pane.vala"
++static void _ease_inspector_element_pane_on_element_selected_ease_editor_embed_element_selected (EaseEditorEmbed* _sender, EaseElement* selected, gpointer self) {
++#line 633 "ease-editor-window.c"
++ ease_inspector_element_pane_on_element_selected (self, selected);
++}
++
++
++#line 51 "ease-inspector-element-pane.vala"
++static void _ease_inspector_element_pane_on_element_deselected_ease_editor_embed_element_deselected (EaseEditorEmbed* _sender, EaseElement* deselected, gpointer self) {
++#line 640 "ease-editor-window.c"
++ ease_inspector_element_pane_on_element_deselected (self, deselected);
++}
++
++
++#line 297 "ease-editor-window.vala"
++static void _ease_editor_window_on_new_slide_menu_gtk_menu_item_activate (GtkMenuItem* _sender, gpointer self) {
++#line 647 "ease-editor-window.c"
++ ease_editor_window_on_new_slide_menu (self, _sender);
++}
++
++
++#line 195 "ease-editor-window.vala"
++static gboolean _lambda79_ (GtkWidget* sender, GdkEvent* event, EaseEditorWindow* self) {
++#line 654 "ease-editor-window.c"
++ gboolean result = FALSE;
++ const char* _tmp0_;
++ char* name;
++ gint time_diff;
++ EaseCloseConfirmDialog* dialog;
++ gint response;
++ gboolean _result_;
++#line 195 "ease-editor-window.vala"
++ g_return_val_if_fail (sender != NULL, FALSE);
++#line 195 "ease-editor-window.vala"
++ g_return_val_if_fail (event != NULL, FALSE);
++#line 196 "ease-editor-window.vala"
++ if (self->priv->last_saved == 0) {
++#line 668 "ease-editor-window.c"
++ result = FALSE;
++#line 196 "ease-editor-window.vala"
++ return result;
++#line 672 "ease-editor-window.c"
++ }
++ _tmp0_ = NULL;
++#line 198 "ease-editor-window.vala"
++ if (ease_document_get_filename (self->document) == NULL) {
++#line 198 "ease-editor-window.vala"
++ _tmp0_ = _ ("Untitled Document");
++#line 679 "ease-editor-window.c"
++ } else {
++#line 199 "ease-editor-window.vala"
++ _tmp0_ = ease_document_get_filename (self->document);
++#line 683 "ease-editor-window.c"
++ }
++#line 198 "ease-editor-window.vala"
++ name = g_strdup (_tmp0_);
++#line 200 "ease-editor-window.vala"
++ time_diff = (gint) (time (NULL) - self->priv->last_saved);
++#line 202 "ease-editor-window.vala"
++ dialog = g_object_ref_sink (ease_close_confirm_dialog_new (name, time_diff));
++#line 203 "ease-editor-window.vala"
++ response = gtk_dialog_run ((GtkDialog*) dialog);
++#line 204 "ease-editor-window.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 206 "ease-editor-window.vala"
++ if (response == GTK_RESPONSE_CANCEL) {
++#line 697 "ease-editor-window.c"
++ result = TRUE;
++ _g_object_unref0 (dialog);
++ _g_free0 (name);
++#line 206 "ease-editor-window.vala"
++ return result;
++#line 703 "ease-editor-window.c"
++ }
++#line 207 "ease-editor-window.vala"
++ if (response == GTK_RESPONSE_NO) {
++#line 209 "ease-editor-window.vala"
++ ease_main_remove_window (self);
++#line 709 "ease-editor-window.c"
++ result = FALSE;
++ _g_object_unref0 (dialog);
++ _g_free0 (name);
++#line 210 "ease-editor-window.vala"
++ return result;
++#line 715 "ease-editor-window.c"
++ }
++#line 214 "ease-editor-window.vala"
++ _result_ = !ease_editor_window_save_document (NULL, self);
++#line 215 "ease-editor-window.vala"
++ if (!_result_) {
++#line 215 "ease-editor-window.vala"
++ ease_main_remove_window (self);
++#line 723 "ease-editor-window.c"
++ }
++ result = _result_;
++ _g_object_unref0 (dialog);
++ _g_free0 (name);
++#line 216 "ease-editor-window.vala"
++ return result;
++#line 730 "ease-editor-window.c"
++}
++
++
++#line 195 "ease-editor-window.vala"
++static gboolean __lambda79__gtk_widget_delete_event (GtkWidget* _sender, GdkEvent* event, gpointer self) {
++#line 736 "ease-editor-window.c"
++ gboolean result;
++ result = _lambda79_ (_sender, event, self);
++ return result;
++}
++
++
++#line 124 "ease-editor-window.vala"
++EaseEditorWindow* ease_editor_window_construct (GType object_type, EaseDocument* doc) {
++#line 745 "ease-editor-window.c"
++ GError * _inner_error_;
++ EaseEditorWindow * self;
++ EaseDocument* _tmp0_;
++ GtkBuilder* builder;
++ GObject* _tmp3_;
++ EaseSlideButtonPanel* _tmp4_;
++ GObject* _tmp5_;
++ EaseUndoController* _tmp6_;
++ GtkToolButton* _tmp8_;
++ GObject* _tmp7_;
++ GtkToolButton* _tmp10_;
++ GObject* _tmp9_;
++ EaseEditorEmbed* _tmp11_;
++ GObject* _tmp12_;
++ EaseInspector* _tmp13_;
++ GObject* _tmp14_;
++ EaseZoomSlider* _tmp16_;
++ GObject* _tmp15_;
++ GObject* _tmp17_;
++ GtkMenuShell* menu;
++ GObject* _tmp20_;
++#line 124 "ease-editor-window.vala"
++ g_return_val_if_fail (doc != NULL, NULL);
++#line 769 "ease-editor-window.c"
++ _inner_error_ = NULL;
++ self = g_object_newv (object_type, 0, NULL);
++#line 126 "ease-editor-window.vala"
++ gtk_window_set_title ((GtkWindow*) self, "Ease");
++#line 127 "ease-editor-window.vala"
++ gtk_window_set_default_size ((GtkWindow*) self, 1024, 768);
++#line 129 "ease-editor-window.vala"
++ self->document = (_tmp0_ = _g_object_ref0 (doc), _g_object_unref0 (self->document), _tmp0_);
++#line 130 "ease-editor-window.vala"
++ g_signal_connect_object ((EaseUndoSource*) self->document, "undo", (GCallback) _ease_editor_window_add_undo_action_ease_undo_source_undo, self, 0);
++#line 132 "ease-editor-window.vala"
++ builder = gtk_builder_new ();
++#line 782 "ease-editor-window.c"
++ {
++ char* _tmp2_;
++ char* _tmp1_;
++#line 135 "ease-editor-window.vala"
++ gtk_builder_add_from_file (builder, _tmp2_ = ease_data_path (_tmp1_ = g_build_filename (EASE_TEMP_UI_DIR, EASE_EDITOR_WINDOW_UI_FILE_PATH, NULL)), &_inner_error_);
++#line 788 "ease-editor-window.c"
++ _g_free0 (_tmp2_);
++ _g_free0 (_tmp1_);
++ if (_inner_error_ != NULL) {
++ goto __catch4_g_error;
++ }
++ }
++ goto __finally4;
++ __catch4_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 138 "ease-editor-window.vala"
++ g_error ("ease-editor-window.vala:138: Error loading UI: %s", e->message);
++#line 804 "ease-editor-window.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally4:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (builder);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++#line 140 "ease-editor-window.vala"
++ gtk_builder_connect_signals (builder, self);
++#line 141 "ease-editor-window.vala"
++ gtk_container_add ((GtkContainer*) self, (GtkWidget*) (_tmp3_ = gtk_builder_get_object (builder, "Editor Widget"), GTK_IS_VBOX (_tmp3_) ? ((GtkVBox*) _tmp3_) : NULL));
++#line 144 "ease-editor-window.vala"
++ self->slide_button_panel = (_tmp4_ = g_object_ref_sink (ease_slide_button_panel_new (self->document, self)), _g_object_unref0 (self->slide_button_panel), _tmp4_);
++#line 145 "ease-editor-window.vala"
++ gtk_container_add ((GtkContainer*) (_tmp5_ = gtk_builder_get_object (builder, "Slides Align"), GTK_IS_ALIGNMENT (_tmp5_) ? ((GtkAlignment*) _tmp5_) : NULL), (GtkWidget*) self->slide_button_panel);
++#line 149 "ease-editor-window.vala"
++ self->priv->undo = (_tmp6_ = ease_undo_controller_new (), _g_object_unref0 (self->priv->undo), _tmp6_);
++#line 150 "ease-editor-window.vala"
++ self->priv->undo_button = (_tmp8_ = _g_object_ref0 ((_tmp7_ = gtk_builder_get_object (builder, "Undo"), GTK_IS_TOOL_BUTTON (_tmp7_) ? ((GtkToolButton*) _tmp7_) : NULL)), _g_object_unref0 (self->priv->undo_button), _tmp8_);
++#line 151 "ease-editor-window.vala"
++ self->priv->redo_button = (_tmp10_ = _g_object_ref0 ((_tmp9_ = gtk_builder_get_object (builder, "Redo"), GTK_IS_TOOL_BUTTON (_tmp9_) ? ((GtkToolButton*) _tmp9_) : NULL)), _g_object_unref0 (self->priv->redo_button), _tmp10_);
++#line 154 "ease-editor-window.vala"
++ self->embed = (_tmp11_ = g_object_ref_sink (ease_editor_embed_new (self->document, self)), _g_object_unref0 (self->embed), _tmp11_);
++#line 155 "ease-editor-window.vala"
++ gtk_container_add ((GtkContainer*) (_tmp12_ = gtk_builder_get_object (builder, "Embed Align"), GTK_IS_ALIGNMENT (_tmp12_) ? ((GtkAlignment*) _tmp12_) : NULL), (GtkWidget*) self->embed);
++#line 156 "ease-editor-window.vala"
++ g_signal_connect_object ((EaseUndoSource*) self->embed, "undo", (GCallback) _ease_editor_window_add_undo_action_ease_undo_source_undo, self, 0);
++#line 159 "ease-editor-window.vala"
++ self->priv->inspector = (_tmp13_ = g_object_ref_sink (ease_inspector_new ()), _g_object_unref0 (self->priv->inspector), _tmp13_);
++#line 160 "ease-editor-window.vala"
++ gtk_container_add ((GtkContainer*) (_tmp14_ = gtk_builder_get_object (builder, "Inspector Align"), GTK_IS_ALIGNMENT (_tmp14_) ? ((GtkAlignment*) _tmp14_) : NULL), (GtkWidget*) self->priv->inspector);
++#line 161 "ease-editor-window.vala"
++ g_signal_connect_object ((EaseUndoSource*) self->priv->inspector, "undo", (GCallback) _ease_editor_window_add_undo_action_ease_undo_source_undo, self, 0);
++#line 162 "ease-editor-window.vala"
++ g_signal_connect_object (self->embed, "element-selected", (GCallback) _ease_inspector_element_pane_on_element_selected_ease_editor_embed_element_selected, self->priv->inspector->element_pane, 0);
++#line 164 "ease-editor-window.vala"
++ g_signal_connect_object (self->embed, "element-deselected", (GCallback) _ease_inspector_element_pane_on_element_deselected_ease_editor_embed_element_deselected, self->priv->inspector->element_pane, 0);
++#line 168 "ease-editor-window.vala"
++ gtk_container_add ((GtkContainer*) (_tmp15_ = gtk_builder_get_object (builder, "Zoom Slider Item"), GTK_IS_TOOL_ITEM (_tmp15_) ? ((GtkToolItem*) _tmp15_) : NULL), (GtkWidget*) (_tmp16_ = ease_editor_window_create_zoom_slider (self)));
++#line 847 "ease-editor-window.c"
++ _g_object_unref0 (_tmp16_);
++#line 172 "ease-editor-window.vala"
++ menu = _g_object_ref0 ((_tmp17_ = gtk_builder_get_object (builder, "add-slide-menu"), GTK_IS_MENU_SHELL (_tmp17_) ? ((GtkMenuShell*) _tmp17_) : NULL));
++#line 851 "ease-editor-window.c"
++ {
++ const char** master_collection;
++ int master_collection_length1;
++ int master_it;
++#line 174 "ease-editor-window.vala"
++ master_collection = EASE_THEME_MASTER_SLIDES;
++#line 858 "ease-editor-window.c"
++ master_collection_length1 = G_N_ELEMENTS (EASE_THEME_MASTER_SLIDES);
++ for (master_it = 0; master_it < G_N_ELEMENTS (EASE_THEME_MASTER_SLIDES); master_it = master_it + 1) {
++ const char* master;
++ master = master_collection[master_it];
++ {
++ char* _tmp18_;
++ GtkMenuItem* _tmp19_;
++ GtkMenuItem* item;
++#line 176 "ease-editor-window.vala"
++ item = (_tmp19_ = g_object_ref_sink ((GtkMenuItem*) gtk_menu_item_new_with_mnemonic (_tmp18_ = ease_theme_master_mnemonic_description (master))), _g_free0 (_tmp18_), _tmp19_);
++#line 178 "ease-editor-window.vala"
++ gtk_menu_shell_append (menu, (GtkWidget*) item);
++#line 180 "ease-editor-window.vala"
++ g_signal_connect_object (item, "activate", (GCallback) _ease_editor_window_on_new_slide_menu_gtk_menu_item_activate, self, 0);
++#line 873 "ease-editor-window.c"
++ _g_object_unref0 (item);
++ }
++ }
++ }
++#line 182 "ease-editor-window.vala"
++ gtk_widget_show_all ((GtkWidget*) menu);
++#line 185 "ease-editor-window.vala"
++ gtk_widget_show_all ((GtkWidget*) self->slide_button_panel);
++#line 186 "ease-editor-window.vala"
++ gtk_widget_show_all ((GtkWidget*) self->embed);
++#line 187 "ease-editor-window.vala"
++ gtk_widget_show ((GtkWidget*) self);
++#line 188 "ease-editor-window.vala"
++ gtk_widget_hide ((GtkWidget*) self->priv->inspector);
++#line 189 "ease-editor-window.vala"
++ ease_editor_window_set_slides_shown (self, TRUE);
++#line 192 "ease-editor-window.vala"
++ gtk_window_add_accel_group ((GtkWindow*) self, (_tmp20_ = gtk_builder_get_object (builder, "accel-group"), GTK_IS_ACCEL_GROUP (_tmp20_) ? ((GtkAccelGroup*) _tmp20_) : NULL));
++#line 195 "ease-editor-window.vala"
++ g_signal_connect_object ((GtkWidget*) self, "delete-event", (GCallback) __lambda79__gtk_widget_delete_event, self, 0);
++#line 219 "ease-editor-window.vala"
++ ease_editor_window_set_slide (self, 0);
++#line 220 "ease-editor-window.vala"
++ ease_editor_window_update_undo (self);
++#line 898 "ease-editor-window.c"
++ _g_object_unref0 (builder);
++ _g_object_unref0 (menu);
++ return self;
++}
++
++
++#line 124 "ease-editor-window.vala"
++EaseEditorWindow* ease_editor_window_new (EaseDocument* doc) {
++#line 124 "ease-editor-window.vala"
++ return ease_editor_window_construct (EASE_TYPE_EDITOR_WINDOW, doc);
++#line 909 "ease-editor-window.c"
++}
++
++
++#line 228 "ease-editor-window.vala"
++void ease_editor_window_set_slide (EaseEditorWindow* self, gint index) {
++#line 915 "ease-editor-window.c"
++ EaseSlide* _tmp0_;
++#line 228 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 230 "ease-editor-window.vala"
++ self->slide = (_tmp0_ = ease_document_get_slide (self->document, index), _g_object_unref0 (self->slide), _tmp0_);
++#line 233 "ease-editor-window.vala"
++ ease_inspector_set_slide (self->priv->inspector, self->slide);
++#line 234 "ease-editor-window.vala"
++ ease_editor_embed_set_slide (self->embed, self->slide);
++#line 925 "ease-editor-window.c"
++}
++
++
++#line 242 "ease-editor-window.vala"
++void ease_editor_window_add_undo_action (EaseEditorWindow* self, EaseUndoItem* action) {
++#line 242 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 242 "ease-editor-window.vala"
++ g_return_if_fail (action != NULL);
++#line 244 "ease-editor-window.vala"
++ ease_undo_controller_add_action (self->priv->undo, action);
++#line 245 "ease-editor-window.vala"
++ ease_undo_controller_clear_redo (self->priv->undo);
++#line 246 "ease-editor-window.vala"
++ ease_editor_window_update_undo (self);
++#line 249 "ease-editor-window.vala"
++ if (self->priv->last_saved == 0) {
++#line 251 "ease-editor-window.vala"
++ self->priv->last_saved = (glong) time (NULL);
++#line 945 "ease-editor-window.c"
++ }
++}
++
++
++#line 259 "ease-editor-window.vala"
++static void ease_editor_window_update_undo (EaseEditorWindow* self) {
++#line 259 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 261 "ease-editor-window.vala"
++ gtk_widget_set_sensitive ((GtkWidget*) self->priv->undo_button, ease_undo_controller_can_undo (self->priv->undo));
++#line 262 "ease-editor-window.vala"
++ gtk_widget_set_sensitive ((GtkWidget*) self->priv->redo_button, ease_undo_controller_can_redo (self->priv->undo));
++#line 958 "ease-editor-window.c"
++}
++
++
++#line 267 "ease-editor-window.vala"
++void ease_editor_window_on_quit (GtkWidget* sender, EaseEditorWindow* self) {
++#line 267 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 267 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 269 "ease-editor-window.vala"
++ gtk_main_quit ();
++#line 970 "ease-editor-window.c"
++}
++
++
++#line 273 "ease-editor-window.vala"
++void ease_editor_window_on_delete (GtkWidget* sender, EaseEditorWindow* self) {
++#line 976 "ease-editor-window.c"
++ gint i;
++ EaseElementRemoveUndoAction* _tmp1_;
++ EaseElement* _tmp0_;
++#line 273 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 273 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 275 "ease-editor-window.vala"
++ if (ease_editor_embed_get_selected (self->embed) == NULL) {
++#line 275 "ease-editor-window.vala"
++ return;
++#line 988 "ease-editor-window.c"
++ }
++#line 277 "ease-editor-window.vala"
++ i = ease_slide_index_of (self->slide, ease_editor_embed_get_selected (self->embed)->element);
++#line 278 "ease-editor-window.vala"
++ ease_editor_window_add_undo_action (self, (EaseUndoItem*) (_tmp1_ = ease_element_remove_undo_action_new (_tmp0_ = ease_slide_element_at (self->slide, i))));
++#line 994 "ease-editor-window.c"
++ _g_object_unref0 (_tmp1_);
++ _g_object_unref0 (_tmp0_);
++#line 279 "ease-editor-window.vala"
++ ease_slide_remove_at (self->slide, i);
++#line 999 "ease-editor-window.c"
++}
++
++
++#line 283 "ease-editor-window.vala"
++void ease_editor_window_new_slide_handler (GtkWidget* sender, EaseEditorWindow* self) {
++#line 1005 "ease-editor-window.c"
++ EaseSlide* s;
++ gint index;
++ EaseSlideAddUndoAction* _tmp0_;
++#line 283 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 285 "ease-editor-window.vala"
++ s = ease_theme_create_slide (ease_document_get_theme (self->document), EASE_DOCUMENT_DEFAULT_SLIDE, ease_document_get_width (self->document), ease_document_get_height (self->document));
++#line 289 "ease-editor-window.vala"
++ index = ease_document_index_of (self->document, self->slide) + 1;
++#line 292 "ease-editor-window.vala"
++ ease_editor_window_add_undo_action (self, (EaseUndoItem*) (_tmp0_ = ease_slide_add_undo_action_new (s)));
++#line 1017 "ease-editor-window.c"
++ _g_object_unref0 (_tmp0_);
++#line 294 "ease-editor-window.vala"
++ ease_document_add_slide (self->document, index, s);
++#line 1021 "ease-editor-window.c"
++ _g_object_unref0 (s);
++}
++
++
++#line 297 "ease-editor-window.vala"
++void ease_editor_window_on_new_slide_menu (EaseEditorWindow* self, GtkWidget* sender) {
++#line 1028 "ease-editor-window.c"
++ GtkWidget* _tmp0_;
++ GtkMenuItem* item;
++ char* _tmp1_;
++ EaseSlide* _tmp2_;
++ EaseSlide* s;
++ gint index;
++ EaseSlideAddUndoAction* _tmp3_;
++#line 297 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 299 "ease-editor-window.vala"
++ item = _g_object_ref0 ((_tmp0_ = sender, GTK_IS_MENU_ITEM (_tmp0_) ? ((GtkMenuItem*) _tmp0_) : NULL));
++#line 300 "ease-editor-window.vala"
++ s = (_tmp2_ = ease_theme_create_slide (ease_document_get_theme (self->document), _tmp1_ = ease_theme_master_from_description (gtk_menu_item_get_label (item)), ease_document_get_width (self->document), ease_document_get_height (self->document)), _g_free0 (_tmp1_), _tmp2_);
++#line 304 "ease-editor-window.vala"
++ index = ease_document_index_of (self->document, self->slide) + 1;
++#line 307 "ease-editor-window.vala"
++ ease_editor_window_add_undo_action (self, (EaseUndoItem*) (_tmp3_ = ease_slide_add_undo_action_new (s)));
++#line 1046 "ease-editor-window.c"
++ _g_object_unref0 (_tmp3_);
++#line 309 "ease-editor-window.vala"
++ ease_document_add_slide (self->document, index, s);
++#line 1050 "ease-editor-window.c"
++ _g_object_unref0 (s);
++ _g_object_unref0 (item);
++}
++
++
++#line 313 "ease-editor-window.vala"
++void ease_editor_window_remove_slide (GtkWidget* sender, EaseEditorWindow* self) {
++#line 1058 "ease-editor-window.c"
++ EaseSlideRemoveUndoAction* _tmp0_;
++ EaseSlide* _tmp1_;
++#line 313 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 316 "ease-editor-window.vala"
++ if (ease_document_get_length (self->document) < 2) {
++#line 316 "ease-editor-window.vala"
++ return;
++#line 1067 "ease-editor-window.c"
++ }
++#line 319 "ease-editor-window.vala"
++ ease_editor_window_add_undo_action (self, (EaseUndoItem*) (_tmp0_ = ease_slide_remove_undo_action_new (self->slide)));
++#line 1071 "ease-editor-window.c"
++ _g_object_unref0 (_tmp0_);
++#line 322 "ease-editor-window.vala"
++ ease_slide_button_panel_select_slide (self->slide_button_panel, _tmp1_ = ease_document_remove_slide (self->document, self->slide));
++#line 1075 "ease-editor-window.c"
++ _g_object_unref0 (_tmp1_);
++}
++
++
++#line 332 "ease-editor-window.vala"
++static void _lambda91_ (EaseEditorWindow* self) {
++#line 1082 "ease-editor-window.c"
++ EasePlayer* _tmp0_;
++#line 333 "ease-editor-window.vala"
++ self->priv->player = (_tmp0_ = NULL, _g_object_unref0 (self->priv->player), _tmp0_);
++#line 334 "ease-editor-window.vala"
++ gtk_widget_show ((GtkWidget*) self);
++#line 335 "ease-editor-window.vala"
++ gtk_window_present ((GtkWindow*) self);
++#line 1090 "ease-editor-window.c"
++}
++
++
++#line 332 "ease-editor-window.vala"
++static void __lambda91__ease_player_complete (EasePlayer* _sender, gpointer self) {
++#line 1096 "ease-editor-window.c"
++ _lambda91_ (self);
++}
++
++
++#line 326 "ease-editor-window.vala"
++void ease_editor_window_play_handler (GtkWidget* sender, EaseEditorWindow* self) {
++#line 1103 "ease-editor-window.c"
++ EasePlayer* _tmp0_;
++#line 326 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 326 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 328 "ease-editor-window.vala"
++ gtk_widget_hide ((GtkWidget*) self);
++#line 330 "ease-editor-window.vala"
++ self->priv->player = (_tmp0_ = ease_player_new (self->document), _g_object_unref0 (self->priv->player), _tmp0_);
++#line 332 "ease-editor-window.vala"
++ g_signal_connect_object (self->priv->player, "complete", (GCallback) __lambda91__ease_player_complete, self, 0);
++#line 1115 "ease-editor-window.c"
++}
++
++
++#line 340 "ease-editor-window.vala"
++void ease_editor_window_undo_handler (GtkWidget* sender, EaseEditorWindow* self) {
++#line 340 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 340 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 342 "ease-editor-window.vala"
++ ease_undo_controller_undo (self->priv->undo);
++#line 343 "ease-editor-window.vala"
++ ease_editor_window_update_undo (self);
++#line 344 "ease-editor-window.vala"
++ ease_slide_actor_relayout (self->embed->slide_actor);
++#line 345 "ease-editor-window.vala"
++ ease_editor_embed_reposition_group (self->embed);
++#line 346 "ease-editor-window.vala"
++ g_signal_emit_by_name (self->slide, "changed", self->slide);
++#line 1135 "ease-editor-window.c"
++}
++
++
++#line 350 "ease-editor-window.vala"
++void ease_editor_window_redo_handler (GtkWidget* sender, EaseEditorWindow* self) {
++#line 350 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 350 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 352 "ease-editor-window.vala"
++ ease_undo_controller_redo (self->priv->undo);
++#line 353 "ease-editor-window.vala"
++ ease_editor_window_update_undo (self);
++#line 354 "ease-editor-window.vala"
++ ease_slide_actor_relayout (self->embed->slide_actor);
++#line 355 "ease-editor-window.vala"
++ ease_editor_embed_reposition_group (self->embed);
++#line 356 "ease-editor-window.vala"
++ g_signal_emit_by_name (self->slide, "changed", self->slide);
++#line 1155 "ease-editor-window.c"
++}
++
++
++#line 360 "ease-editor-window.vala"
++void ease_editor_window_insert_text (GtkWidget* sender, EaseEditorWindow* self) {
++#line 1161 "ease-editor-window.c"
++ EaseTextElement* text;
++ EaseElementAddUndoAction* _tmp0_;
++#line 360 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 360 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 362 "ease-editor-window.vala"
++ text = ease_theme_create_custom_text (ease_document_get_theme (self->document));
++#line 363 "ease-editor-window.vala"
++ ease_element_set_x ((EaseElement*) text, (ease_document_get_width (self->document) / 2) - (ease_element_get_width ((EaseElement*) text) / 2));
++#line 364 "ease-editor-window.vala"
++ ease_element_set_y ((EaseElement*) text, (ease_document_get_height (self->document) / 2) - (ease_element_get_height ((EaseElement*) text) / 2));
++#line 365 "ease-editor-window.vala"
++ ease_slide_add (self->slide, (EaseElement*) text);
++#line 366 "ease-editor-window.vala"
++ ease_editor_window_add_undo_action (self, (EaseUndoItem*) (_tmp0_ = ease_element_add_undo_action_new ((EaseElement*) text)));
++#line 1178 "ease-editor-window.c"
++ _g_object_unref0 (_tmp0_);
++#line 367 "ease-editor-window.vala"
++ ease_editor_embed_select_element (self->embed, (EaseElement*) text);
++#line 1182 "ease-editor-window.c"
++ _g_object_unref0 (text);
++}
++
++
++#line 371 "ease-editor-window.vala"
++void ease_editor_window_insert_image (GtkWidget* sender, EaseEditorWindow* self) {
++#line 1189 "ease-editor-window.c"
++ GError * _inner_error_;
++ GtkFileChooserDialog* dialog;
++#line 371 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 371 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 1196 "ease-editor-window.c"
++ _inner_error_ = NULL;
++#line 373 "ease-editor-window.vala"
++ dialog = g_object_ref_sink ((GtkFileChooserDialog*) gtk_file_chooser_dialog_new (_ ("Insert Image"), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, "gtk-cancel", GTK_RESPONSE_CANCEL, "gtk-open", GTK_RESPONSE_ACCEPT, NULL));
++#line 381 "ease-editor-window.vala"
++ if (gtk_dialog_run ((GtkDialog*) dialog) == GTK_RESPONSE_ACCEPT) {
++#line 1202 "ease-editor-window.c"
++ {
++ char* _tmp0_;
++ ClutterTexture* _tmp1_;
++ ClutterTexture* img;
++ EaseImageElement* e;
++ gint width;
++ gint height;
++ char* _tmp2_;
++ char* _tmp3_;
++ char* _tmp4_;
++ char* _tmp5_;
++ char* _tmp6_;
++ EaseElementAddUndoAction* _tmp7_;
++#line 385 "ease-editor-window.vala"
++ img = (_tmp1_ = g_object_ref_sink (clutter_texture_new_from_file (_tmp0_ = gtk_file_chooser_get_filename ((GtkFileChooser*) dialog), &_inner_error_)), _g_free0 (_tmp0_), _tmp1_);
++#line 1218 "ease-editor-window.c"
++ if (_inner_error_ != NULL) {
++ goto __catch5_g_error;
++ }
++#line 386 "ease-editor-window.vala"
++ e = ease_image_element_new ();
++#line 389 "ease-editor-window.vala"
++ width = 0;
++#line 389 "ease-editor-window.vala"
++ height = 0;
++#line 390 "ease-editor-window.vala"
++ clutter_texture_get_base_size (img, &width, &height);
++#line 392 "ease-editor-window.vala"
++ ease_element_set_width ((EaseElement*) e, (float) width);
++#line 393 "ease-editor-window.vala"
++ ease_element_set_height ((EaseElement*) e, (float) height);
++#line 394 "ease-editor-window.vala"
++ ease_element_set_x ((EaseElement*) e, (float) ((ease_document_get_width (self->document) / 2) - (width / 2)));
++#line 395 "ease-editor-window.vala"
++ ease_element_set_y ((EaseElement*) e, (float) ((ease_document_get_height (self->document) / 2) - (width / 2)));
++#line 397 "ease-editor-window.vala"
++ ease_element_set_element_type ((EaseElement*) e, EASE_SLIDE_IMAGE_TYPE);
++#line 398 "ease-editor-window.vala"
++ ease_element_set_identifier ((EaseElement*) e, EASE_THEME_CUSTOM_MEDIA);
++#line 399 "ease-editor-window.vala"
++ _tmp4_ = (_tmp3_ = ease_document_add_media_file (self->document, _tmp2_ = gtk_file_chooser_get_filename ((GtkFileChooser*) dialog), &_inner_error_), _g_free0 (_tmp2_), _tmp3_);
++#line 1244 "ease-editor-window.c"
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (e);
++ _g_object_unref0 (img);
++ goto __catch5_g_error;
++ }
++#line 399 "ease-editor-window.vala"
++ ease_media_element_set_filename ((EaseMediaElement*) e, _tmp5_ = _tmp4_);
++#line 1252 "ease-editor-window.c"
++ _g_free0 (_tmp5_);
++#line 400 "ease-editor-window.vala"
++ ease_media_element_set_source_filename ((EaseMediaElement*) e, _tmp6_ = gtk_file_chooser_get_filename ((GtkFileChooser*) dialog));
++#line 1256 "ease-editor-window.c"
++ _g_free0 (_tmp6_);
++#line 403 "ease-editor-window.vala"
++ ease_slide_add (self->slide, (EaseElement*) e);
++#line 404 "ease-editor-window.vala"
++ ease_editor_window_add_undo_action (self, (EaseUndoItem*) (_tmp7_ = ease_element_add_undo_action_new ((EaseElement*) e)));
++#line 1262 "ease-editor-window.c"
++ _g_object_unref0 (_tmp7_);
++#line 405 "ease-editor-window.vala"
++ ease_editor_embed_select_element (self->embed, (EaseElement*) e);
++#line 1266 "ease-editor-window.c"
++ _g_object_unref0 (e);
++ _g_object_unref0 (img);
++ }
++ goto __finally5;
++ __catch5_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 409 "ease-editor-window.vala"
++ ease_error_dialog (_ ("Error Inserting Image"), e->message);
++#line 1279 "ease-editor-window.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally5:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (dialog);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++ }
++#line 412 "ease-editor-window.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 1293 "ease-editor-window.c"
++ _g_object_unref0 (dialog);
++}
++
++
++#line 416 "ease-editor-window.vala"
++void ease_editor_window_insert_video (GtkWidget* sender, EaseEditorWindow* self) {
++#line 416 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 416 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 1304 "ease-editor-window.c"
++}
++
++
++#line 422 "ease-editor-window.vala"
++void ease_editor_window_zoom_in (GtkWidget* sender, EaseEditorWindow* self) {
++#line 422 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 422 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 424 "ease-editor-window.vala"
++ ease_zoom_slider_zoom_in (self->zoom_slider);
++#line 1316 "ease-editor-window.c"
++}
++
++
++#line 428 "ease-editor-window.vala"
++void ease_editor_window_zoom_out (GtkWidget* sender, EaseEditorWindow* self) {
++#line 428 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 428 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 430 "ease-editor-window.vala"
++ ease_zoom_slider_zoom_out (self->zoom_slider);
++#line 1328 "ease-editor-window.c"
++}
++
++
++#line 434 "ease-editor-window.vala"
++gboolean ease_editor_window_save_document (GtkWidget* sender, EaseEditorWindow* self) {
++#line 1334 "ease-editor-window.c"
++ gboolean result = FALSE;
++ GError * _inner_error_;
++#line 434 "ease-editor-window.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 1339 "ease-editor-window.c"
++ _inner_error_ = NULL;
++#line 436 "ease-editor-window.vala"
++ if (ease_document_get_filename (self->document) == NULL) {
++#line 1343 "ease-editor-window.c"
++ GtkFileChooserDialog* dialog;
++ GtkFileFilter* filter;
++#line 439 "ease-editor-window.vala"
++ dialog = g_object_ref_sink ((GtkFileChooserDialog*) gtk_file_chooser_dialog_new (_ ("Save Document"), NULL, GTK_FILE_CHOOSER_ACTION_SAVE, "gtk-cancel", GTK_RESPONSE_CANCEL, "gtk-save", GTK_RESPONSE_ACCEPT, NULL, NULL));
++#line 447 "ease-editor-window.vala"
++ filter = g_object_ref_sink (gtk_file_filter_new ());
++#line 448 "ease-editor-window.vala"
++ gtk_file_filter_add_pattern (filter, "*.ease");
++#line 449 "ease-editor-window.vala"
++ gtk_file_chooser_set_filter ((GtkFileChooser*) dialog, filter);
++#line 451 "ease-editor-window.vala"
++ if (gtk_dialog_run ((GtkDialog*) dialog) == GTK_RESPONSE_ACCEPT) {
++#line 1356 "ease-editor-window.c"
++ char* _tmp0_;
++#line 453 "ease-editor-window.vala"
++ ease_document_set_filename (self->document, _tmp0_ = gtk_file_chooser_get_filename ((GtkFileChooser*) dialog));
++#line 1360 "ease-editor-window.c"
++ _g_free0 (_tmp0_);
++ } else {
++#line 457 "ease-editor-window.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 1365 "ease-editor-window.c"
++ result = FALSE;
++ _g_object_unref0 (filter);
++ _g_object_unref0 (dialog);
++#line 458 "ease-editor-window.vala"
++ return result;
++#line 1371 "ease-editor-window.c"
++ }
++#line 460 "ease-editor-window.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 1375 "ease-editor-window.c"
++ _g_object_unref0 (filter);
++ _g_object_unref0 (dialog);
++ }
++ {
++#line 465 "ease-editor-window.vala"
++ ease_document_to_json (self->document, &_inner_error_);
++#line 1382 "ease-editor-window.c"
++ if (_inner_error_ != NULL) {
++ goto __catch6_g_error;
++ }
++#line 466 "ease-editor-window.vala"
++ self->priv->last_saved = (glong) 0;
++#line 1388 "ease-editor-window.c"
++ }
++ goto __finally6;
++ __catch6_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 470 "ease-editor-window.vala"
++ ease_error_dialog (_ ("Error Saving Document"), e->message);
++#line 1399 "ease-editor-window.c"
++ result = FALSE;
++ _g_error_free0 (e);
++#line 471 "ease-editor-window.vala"
++ return result;
++#line 1404 "ease-editor-window.c"
++ }
++ }
++ __finally6:
++ if (_inner_error_ != NULL) {
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return FALSE;
++ }
++ result = TRUE;
++#line 473 "ease-editor-window.vala"
++ return result;
++#line 1416 "ease-editor-window.c"
++}
++
++
++#line 478 "ease-editor-window.vala"
++void ease_editor_window_export_as_pdf (GtkWidget* sender, EaseEditorWindow* self) {
++#line 478 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 478 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 480 "ease-editor-window.vala"
++ ease_document_export_as_pdf (self->document, (GtkWindow*) self);
++#line 1428 "ease-editor-window.c"
++}
++
++
++#line 484 "ease-editor-window.vala"
++void ease_editor_window_export_as_postscript (GtkWidget* sender, EaseEditorWindow* self) {
++#line 484 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 484 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 486 "ease-editor-window.vala"
++ ease_document_export_as_postscript (self->document, (GtkWindow*) self);
++#line 1440 "ease-editor-window.c"
++}
++
++
++#line 490 "ease-editor-window.vala"
++void ease_editor_window_export_as_html (GtkWidget* sender, EaseEditorWindow* self) {
++#line 490 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 490 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 492 "ease-editor-window.vala"
++ ease_document_export_as_html (self->document, (GtkWindow*) self);
++#line 1452 "ease-editor-window.c"
++}
++
++
++#line 496 "ease-editor-window.vala"
++void ease_editor_window_inspector_clicked_handler (GtkWidget* sender, EaseEditorWindow* self) {
++#line 496 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 498 "ease-editor-window.vala"
++ if (gtk_widget_get_visible ((GtkWidget*) self->priv->inspector)) {
++#line 500 "ease-editor-window.vala"
++ gtk_widget_hide ((GtkWidget*) self->priv->inspector);
++#line 1464 "ease-editor-window.c"
++ } else {
++#line 504 "ease-editor-window.vala"
++ gtk_widget_show ((GtkWidget*) self->priv->inspector);
++#line 1468 "ease-editor-window.c"
++ }
++}
++
++
++#line 575 "ease-editor-window.vala"
++static void _ease_editor_window_color_dialog_changed_gtk_color_selection_color_changed (GtkColorSelection* _sender, gpointer self) {
++#line 1475 "ease-editor-window.c"
++ ease_editor_window_color_dialog_changed (self, _sender);
++}
++
++
++#line 582 "ease-editor-window.vala"
++static void _ease_editor_window_color_dialog_selection_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 1482 "ease-editor-window.c"
++ ease_editor_window_color_dialog_selection (self, _sender, pspec);
++}
++
++
++#line 538 "ease-editor-window.vala"
++static void _lambda92_ (EaseEditorWindow* self) {
++#line 1489 "ease-editor-window.c"
++ GQuark _tmp1_;
++ guint _tmp0_;
++ guint _tmp2_;
++ GtkColorSelectionDialog* _tmp3_;
++#line 539 "ease-editor-window.vala"
++ g_signal_parse_name ("notify::selected", G_TYPE_OBJECT, &_tmp0_, &_tmp1_, TRUE);
++#line 539 "ease-editor-window.vala"
++ g_signal_handlers_disconnect_matched ((GObject*) self->embed, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, _tmp1_, NULL, (GCallback) _ease_editor_window_color_dialog_selection_g_object_notify, self);
++#line 540 "ease-editor-window.vala"
++ g_signal_parse_name ("color-changed", GTK_TYPE_COLOR_SELECTION, &_tmp2_, NULL, FALSE);
++#line 540 "ease-editor-window.vala"
++ g_signal_handlers_disconnect_matched (self->priv->color_selection, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp2_, 0, NULL, (GCallback) _ease_editor_window_color_dialog_changed_gtk_color_selection_color_changed, self);
++#line 541 "ease-editor-window.vala"
++ gtk_object_destroy ((GtkObject*) self->priv->color_dialog);
++#line 542 "ease-editor-window.vala"
++ self->priv->color_dialog = (_tmp3_ = NULL, _g_object_unref0 (self->priv->color_dialog), _tmp3_);
++#line 1506 "ease-editor-window.c"
++}
++
++
++#line 538 "ease-editor-window.vala"
++static void __lambda92__gtk_widget_hide (GtkWidget* _sender, gpointer self) {
++#line 1512 "ease-editor-window.c"
++ _lambda92_ (self);
++}
++
++
++static gboolean _clutter_color_equal (const ClutterColor* s1, const ClutterColor* s2) {
++ if (s1 == s2) {
++ return TRUE;
++ }
++ if (s1 == NULL) {
++ return FALSE;
++ }
++ if (s2 == NULL) {
++ return FALSE;
++ }
++ if (s1->red != s2->red) {
++ return FALSE;
++ }
++ if (s1->green != s2->green) {
++ return FALSE;
++ }
++ if (s1->blue != s2->blue) {
++ return FALSE;
++ }
++ if (s1->alpha != s2->alpha) {
++ return FALSE;
++ }
++ return TRUE;
++}
++
++
++#line 546 "ease-editor-window.vala"
++static void _lambda93_ (Block1Data* _data1_) {
++#line 1545 "ease-editor-window.c"
++ EaseEditorWindow * self;
++ ClutterColor* _tmp0_;
++ gboolean _tmp1_;
++ self = _data1_->self;
++#line 547 "ease-editor-window.vala"
++ gtk_widget_hide ((GtkWidget*) self->priv->color_dialog);
++#line 550 "ease-editor-window.vala"
++ if ((_tmp1_ = _clutter_color_equal (_data1_->original_color, _tmp0_ = ease_element_get_color (ease_editor_embed_get_selected (self->embed)->element)) != TRUE, _g_free0 (_tmp0_), _tmp1_)) {
++#line 552 "ease-editor-window.vala"
++ ease_editor_window_add_undo_action (self, (EaseUndoItem*) self->priv->undo_action);
++#line 1556 "ease-editor-window.c"
++ }
++}
++
++
++#line 546 "ease-editor-window.vala"
++static void __lambda93__gtk_button_clicked (GtkButton* _sender, gpointer self) {
++#line 1563 "ease-editor-window.c"
++ _lambda93_ (self);
++}
++
++
++#line 557 "ease-editor-window.vala"
++static void _lambda94_ (Block1Data* _data1_) {
++#line 1570 "ease-editor-window.c"
++ EaseEditorWindow * self;
++ self = _data1_->self;
++#line 558 "ease-editor-window.vala"
++ ease_element_set_color (ease_editor_embed_get_selected (self->embed)->element, _data1_->original_color);
++#line 559 "ease-editor-window.vala"
++ gtk_widget_hide ((GtkWidget*) self->priv->color_dialog);
++#line 1577 "ease-editor-window.c"
++}
++
++
++#line 557 "ease-editor-window.vala"
++static void __lambda94__gtk_button_clicked (GtkButton* _sender, gpointer self) {
++#line 1583 "ease-editor-window.c"
++ _lambda94_ (self);
++}
++
++
++#line 563 "ease-editor-window.vala"
++static void _lambda95_ (EaseEditorWindow* self) {
++#line 1590 "ease-editor-window.c"
++ GtkWidget* _tmp1_;
++ GtkWidget* _tmp0_ = NULL;
++#line 564 "ease-editor-window.vala"
++ gtk_widget_activate (_tmp1_ = (g_object_get (self->priv->color_dialog, "cancel-button", &_tmp0_, NULL), _tmp0_));
++#line 1595 "ease-editor-window.c"
++ _g_object_unref0 (_tmp1_);
++}
++
++
++#line 563 "ease-editor-window.vala"
++static void __lambda95__gtk_dialog_close (GtkDialog* _sender, gpointer self) {
++#line 1602 "ease-editor-window.c"
++ _lambda95_ (self);
++}
++
++
++static Block1Data* block1_data_ref (Block1Data* _data1_) {
++ g_atomic_int_inc (&_data1_->_ref_count_);
++ return _data1_;
++}
++
++
++static void block1_data_unref (Block1Data* _data1_) {
++ if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {
++ _g_object_unref0 (_data1_->self);
++ _g_free0 (_data1_->original_color);
++ g_slice_free (Block1Data, _data1_);
++ }
++}
++
++
++#line 509 "ease-editor-window.vala"
++void ease_editor_window_show_color_dialog (GtkWidget* sender, EaseEditorWindow* self) {
++#line 1624 "ease-editor-window.c"
++ Block1Data* _data1_;
++ EaseUndoAction* _tmp0_;
++ GtkColorSelectionDialog* _tmp1_;
++ GtkColorSelection* _tmp3_;
++ GtkWidget* _tmp2_;
++ GtkButton* _tmp6_;
++ GtkWidget* _tmp4_ = NULL;
++ GtkWidget* _tmp5_;
++ GtkButton* _tmp9_;
++ GtkWidget* _tmp7_ = NULL;
++ GtkWidget* _tmp8_;
++#line 509 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 509 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 1640 "ease-editor-window.c"
++ _data1_ = g_slice_new0 (Block1Data);
++ _data1_->_ref_count_ = 1;
++ _data1_->self = g_object_ref (self);
++#line 512 "ease-editor-window.vala"
++ if (ease_editor_embed_get_selected (self->embed) == NULL) {
++#line 1646 "ease-editor-window.c"
++ block1_data_unref (_data1_);
++#line 512 "ease-editor-window.vala"
++ return;
++#line 1650 "ease-editor-window.c"
++ }
++#line 515 "ease-editor-window.vala"
++ if (self->priv->color_dialog != NULL) {
++#line 517 "ease-editor-window.vala"
++ gtk_window_present ((GtkWindow*) self->priv->color_dialog);
++#line 1656 "ease-editor-window.c"
++ block1_data_unref (_data1_);
++#line 518 "ease-editor-window.vala"
++ return;
++#line 1660 "ease-editor-window.c"
++ }
++ _data1_->original_color = ease_element_get_color (ease_editor_embed_get_selected (self->embed)->element);
++#line 525 "ease-editor-window.vala"
++ self->priv->undo_action = (_tmp0_ = ease_undo_action_new ((GObject*) ease_editor_embed_get_selected (self->embed)->element, "color"), _g_object_unref0 (self->priv->undo_action), _tmp0_);
++#line 528 "ease-editor-window.vala"
++ self->priv->color_dialog = (_tmp1_ = g_object_ref_sink ((GtkColorSelectionDialog*) gtk_color_selection_dialog_new (_ ("Select Color"))), _g_object_unref0 (self->priv->color_dialog), _tmp1_);
++#line 529 "ease-editor-window.vala"
++ self->priv->color_selection = (_tmp3_ = _g_object_ref0 ((_tmp2_ = gtk_color_selection_dialog_get_color_selection (self->priv->color_dialog), GTK_IS_COLOR_SELECTION (_tmp2_) ? ((GtkColorSelection*) _tmp2_) : NULL)), _g_object_unref0 (self->priv->color_selection), _tmp3_);
++#line 532 "ease-editor-window.vala"
++ g_signal_connect_object (self->priv->color_selection, "color-changed", (GCallback) _ease_editor_window_color_dialog_changed_gtk_color_selection_color_changed, self, 0);
++#line 535 "ease-editor-window.vala"
++ g_signal_connect_object ((GObject*) self->embed, "notify::selected", (GCallback) _ease_editor_window_color_dialog_selection_g_object_notify, self, 0);
++#line 538 "ease-editor-window.vala"
++ g_signal_connect_object ((GtkWidget*) self->priv->color_dialog, "hide", (GCallback) __lambda92__gtk_widget_hide, self, 0);
++#line 546 "ease-editor-window.vala"
++ g_signal_connect_data (_tmp6_ = (_tmp5_ = (g_object_get (self->priv->color_dialog, "ok-button", &_tmp4_, NULL), _tmp4_), GTK_IS_BUTTON (_tmp5_) ? ((GtkButton*) _tmp5_) : NULL), "clicked", (GCallback) __lambda93__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);
++#line 1677 "ease-editor-window.c"
++ _g_object_unref0 (_tmp6_);
++#line 557 "ease-editor-window.vala"
++ g_signal_connect_data (_tmp9_ = (_tmp8_ = (g_object_get (self->priv->color_dialog, "cancel-button", &_tmp7_, NULL), _tmp7_), GTK_IS_BUTTON (_tmp8_) ? ((GtkButton*) _tmp8_) : NULL), "clicked", (GCallback) __lambda94__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);
++#line 1681 "ease-editor-window.c"
++ _g_object_unref0 (_tmp9_);
++#line 563 "ease-editor-window.vala"
++ g_signal_connect_object ((GtkDialog*) self->priv->color_dialog, "close", (GCallback) __lambda95__gtk_dialog_close, self, 0);
++#line 568 "ease-editor-window.vala"
++ gtk_window_set_transient_for ((GtkWindow*) self->priv->color_dialog, (GtkWindow*) self);
++#line 569 "ease-editor-window.vala"
++ gtk_window_set_modal ((GtkWindow*) self->priv->color_dialog, TRUE);
++#line 572 "ease-editor-window.vala"
++ gtk_dialog_run ((GtkDialog*) self->priv->color_dialog);
++#line 1691 "ease-editor-window.c"
++ block1_data_unref (_data1_);
++}
++
++
++#line 575 "ease-editor-window.vala"
++static void ease_editor_window_color_dialog_changed (EaseEditorWindow* self, GtkColorSelection* sender) {
++#line 1698 "ease-editor-window.c"
++ ClutterColor _tmp3_;
++ ClutterColor _tmp2_ = {0};
++ GdkColor _tmp1_;
++ GdkColor _tmp0_ = {0};
++#line 575 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 575 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 577 "ease-editor-window.vala"
++ ease_editor_embed_set_element_color (self->embed, (_tmp3_ = (ease_transformations_gdk_color_to_clutter_color ((_tmp1_ = (gtk_color_selection_get_current_color (sender, &_tmp0_), _tmp0_), &_tmp1_), &_tmp2_), _tmp2_), &_tmp3_));
++#line 579 "ease-editor-window.vala"
++ g_signal_emit_by_name (self->slide, "changed", self->slide);
++#line 1711 "ease-editor-window.c"
++}
++
++
++#line 582 "ease-editor-window.vala"
++static void ease_editor_window_color_dialog_selection (EaseEditorWindow* self, GObject* sender, GParamSpec* spec) {
++#line 1717 "ease-editor-window.c"
++ GObject* _tmp0_;
++ ClutterColor* color;
++ GdkColor _tmp1_ = {0};
++ GdkColor _tmp2_;
++#line 582 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 582 "ease-editor-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 582 "ease-editor-window.vala"
++ g_return_if_fail (spec != NULL);
++#line 584 "ease-editor-window.vala"
++ color = ease_element_get_color (ease_editor_embed_get_selected ((_tmp0_ = sender, EASE_IS_EDITOR_EMBED (_tmp0_) ? ((EaseEditorEmbed*) _tmp0_) : NULL))->element);
++#line 585 "ease-editor-window.vala"
++ if (color == NULL) {
++#line 1732 "ease-editor-window.c"
++ _g_free0 (color);
++#line 585 "ease-editor-window.vala"
++ return;
++#line 1736 "ease-editor-window.c"
++ }
++#line 587 "ease-editor-window.vala"
++ gtk_color_selection_set_current_color (self->priv->color_selection, (_tmp2_ = (ease_transformations_clutter_color_to_gdk_color (color, &_tmp1_), _tmp1_), &_tmp2_));
++#line 1740 "ease-editor-window.c"
++ _g_free0 (color);
++}
++
++
++#line 592 "ease-editor-window.vala"
++void ease_editor_window_select_font (GtkWidget* sender, EaseEditorWindow* self) {
++#line 1747 "ease-editor-window.c"
++ GtkFontSelectionDialog* font_selection;
++ EaseElement* _tmp0_;
++ EaseTextElement* text;
++ const char* _tmp1_;
++ PangoFontDescription* _tmp2_;
++#line 592 "ease-editor-window.vala"
++ g_return_if_fail (self != NULL);
++#line 595 "ease-editor-window.vala"
++ font_selection = g_object_ref_sink ((GtkFontSelectionDialog*) gtk_font_selection_dialog_new (_ ("Select Font")));
++#line 598 "ease-editor-window.vala"
++ text = _g_object_ref0 ((_tmp0_ = ease_editor_embed_get_selected (self->embed)->element, EASE_IS_TEXT_ELEMENT (_tmp0_) ? ((EaseTextElement*) _tmp0_) : NULL));
++#line 1759 "ease-editor-window.c"
++ _tmp1_ = NULL;
++#line 601 "ease-editor-window.vala"
++ if (_vala_strcmp0 (ease_text_element_get_text (text), "") != 0) {
++#line 602 "ease-editor-window.vala"
++ _tmp1_ = ease_text_element_get_text (text);
++#line 1765 "ease-editor-window.c"
++ } else {
++#line 602 "ease-editor-window.vala"
++ _tmp1_ = EASE_EDITOR_WINDOW_FONT_TEXT;
++#line 1769 "ease-editor-window.c"
++ }
++#line 601 "ease-editor-window.vala"
++ gtk_font_selection_dialog_set_preview_text (font_selection, _tmp1_);
++#line 605 "ease-editor-window.vala"
++ gtk_font_selection_dialog_set_font_name (font_selection, pango_font_description_to_string (_tmp2_ = ease_text_element_get_font_description (text)));
++#line 1775 "ease-editor-window.c"
++ _pango_font_description_free0 (_tmp2_);
++#line 608 "ease-editor-window.vala"
++ switch (gtk_dialog_run ((GtkDialog*) font_selection)) {
++#line 1779 "ease-editor-window.c"
++ case GTK_RESPONSE_OK:
++ {
++ EaseUndoAction* _tmp3_;
++ PangoFontDescription* _tmp4_;
++#line 612 "ease-editor-window.vala"
++ ease_editor_window_add_undo_action (self, (EaseUndoItem*) (_tmp3_ = ease_undo_action_new ((GObject*) ease_editor_embed_get_selected (self->embed)->element, "font-description")));
++#line 1786 "ease-editor-window.c"
++ _g_object_unref0 (_tmp3_);
++#line 616 "ease-editor-window.vala"
++ ease_text_element_set_font_description (text, _tmp4_ = pango_font_description_from_string (gtk_font_selection_dialog_get_font_name (font_selection)));
++#line 1790 "ease-editor-window.c"
++ _pango_font_description_free0 (_tmp4_);
++#line 621 "ease-editor-window.vala"
++ g_signal_emit_by_name (ease_element_get_parent ((EaseElement*) text), "changed", ease_element_get_parent ((EaseElement*) text));
++#line 622 "ease-editor-window.vala"
++ break;
++#line 1796 "ease-editor-window.c"
++ }
++ }
++#line 625 "ease-editor-window.vala"
++ gtk_object_destroy ((GtkObject*) font_selection);
++#line 1801 "ease-editor-window.c"
++ _g_object_unref0 (text);
++ _g_object_unref0 (font_selection);
++}
++
++
++#line 638 "ease-editor-window.vala"
++static void _lambda78_ (EaseEditorWindow* self) {
++#line 639 "ease-editor-window.vala"
++ ease_editor_embed_set_zoom (self->embed, ((float) ease_zoom_slider_get_value (self->zoom_slider)) / 100.f);
++#line 1811 "ease-editor-window.c"
++}
++
++
++#line 638 "ease-editor-window.vala"
++static void __lambda78__ease_zoom_slider_value_changed (EaseZoomSlider* _sender, gpointer self) {
++#line 1817 "ease-editor-window.c"
++ _lambda78_ (self);
++}
++
++
++#line 628 "ease-editor-window.vala"
++static EaseZoomSlider* ease_editor_window_create_zoom_slider (EaseEditorWindow* self) {
++#line 1824 "ease-editor-window.c"
++ EaseZoomSlider* result = NULL;
++ EaseZoomSlider* _tmp1_;
++ GtkAdjustment* _tmp0_;
++#line 628 "ease-editor-window.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 631 "ease-editor-window.vala"
++ self->zoom_slider = (_tmp1_ = (EaseZoomSlider*) g_object_ref_sink (ease_animated_zoom_slider_new (_tmp0_ = g_object_ref_sink ((GtkAdjustment*) gtk_adjustment_new ((double) 100, (double) 10, (double) 400, (double) 10, (double) 50, (double) 50)), self->priv->ZOOM_LEVELS, self->priv->ZOOM_LEVELS_length1)), _g_object_unref0 (self->zoom_slider), _tmp1_);
++#line 1832 "ease-editor-window.c"
++ _g_object_unref0 (_tmp0_);
++#line 634 "ease-editor-window.vala"
++ g_object_set ((GtkWidget*) self->zoom_slider, "width-request", 200, NULL);
++#line 635 "ease-editor-window.vala"
++ ease_zoom_slider_set_value_pos (self->zoom_slider, GTK_POS_RIGHT);
++#line 636 "ease-editor-window.vala"
++ ease_zoom_slider_set_digits (self->zoom_slider, 0);
++#line 638 "ease-editor-window.vala"
++ g_signal_connect_object (self->zoom_slider, "value-changed", (GCallback) __lambda78__ease_zoom_slider_value_changed, self, 0);
++#line 642 "ease-editor-window.vala"
++ gtk_widget_show_all ((GtkWidget*) self->zoom_slider);
++#line 1844 "ease-editor-window.c"
++ result = _g_object_ref0 (self->zoom_slider);
++#line 644 "ease-editor-window.vala"
++ return result;
++#line 1848 "ease-editor-window.c"
++}
++
++
++gboolean ease_editor_window_get_slides_shown (EaseEditorWindow* self) {
++ gboolean result;
++ g_return_val_if_fail (self != NULL, FALSE);
++ result = self->priv->_slides_shown;
++#line 87 "ease-editor-window.vala"
++ return result;
++#line 1858 "ease-editor-window.c"
++}
++
++
++void ease_editor_window_set_slides_shown (EaseEditorWindow* self, gboolean value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_slides_shown = value;
++ g_object_notify ((GObject *) self, "slides-shown");
++}
++
++
++static void ease_editor_window_class_init (EaseEditorWindowClass * klass) {
++ ease_editor_window_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseEditorWindowPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_editor_window_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_editor_window_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_editor_window_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_EDITOR_WINDOW_SLIDES_SHOWN, g_param_spec_boolean ("slides-shown", "slides-shown", "slides-shown", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++}
++
++
++static void ease_editor_window_instance_init (EaseEditorWindow * self) {
++ gint* _tmp0_ = NULL;
++ self->priv = EASE_EDITOR_WINDOW_GET_PRIVATE (self);
++ self->priv->last_saved = (glong) 0;
++ self->priv->ZOOM_LEVELS = (_tmp0_ = g_new0 (gint, 13), _tmp0_[0] = 10, _tmp0_[1] = 25, _tmp0_[2] = 33, _tmp0_[3] = 50, _tmp0_[4] = 66, _tmp0_[5] = 75, _tmp0_[6] = 100, _tmp0_[7] = 125, _tmp0_[8] = 150, _tmp0_[9] = 200, _tmp0_[10] = 250, _tmp0_[11] = 300, _tmp0_[12] = 400, _tmp0_);
++ self->priv->ZOOM_LEVELS_length1 = 13;
++ self->priv->_ZOOM_LEVELS_size_ = self->priv->ZOOM_LEVELS_length1;
++}
++
++
++static void ease_editor_window_finalize (GObject* obj) {
++ EaseEditorWindow * self;
++ self = EASE_EDITOR_WINDOW (obj);
++ _g_object_unref0 (self->embed);
++ _g_object_unref0 (self->slide_button_panel);
++ _g_object_unref0 (self->zoom_slider);
++ _g_object_unref0 (self->priv->player);
++ _g_object_unref0 (self->document);
++ _g_object_unref0 (self->slide);
++ _g_object_unref0 (self->priv->inspector);
++ _g_object_unref0 (self->priv->undo);
++ _g_object_unref0 (self->priv->undo_action);
++ _g_object_unref0 (self->priv->undo_button);
++ _g_object_unref0 (self->priv->redo_button);
++ _g_object_unref0 (self->priv->color_dialog);
++ _g_object_unref0 (self->priv->color_selection);
++ self->priv->ZOOM_LEVELS = (g_free (self->priv->ZOOM_LEVELS), NULL);
++ G_OBJECT_CLASS (ease_editor_window_parent_class)->finalize (obj);
++}
++
++
++GType ease_editor_window_get_type (void) {
++ static volatile gsize ease_editor_window_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_editor_window_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseEditorWindowClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_editor_window_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseEditorWindow), 0, (GInstanceInitFunc) ease_editor_window_instance_init, NULL };
++ GType ease_editor_window_type_id;
++ ease_editor_window_type_id = g_type_register_static (GTK_TYPE_WINDOW, "EaseEditorWindow", &g_define_type_info, 0);
++ g_once_init_leave (&ease_editor_window_type_id__volatile, ease_editor_window_type_id);
++ }
++ return ease_editor_window_type_id__volatile;
++}
++
++
++static void ease_editor_window_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseEditorWindow * self;
++ self = EASE_EDITOR_WINDOW (object);
++ switch (property_id) {
++ case EASE_EDITOR_WINDOW_SLIDES_SHOWN:
++ g_value_set_boolean (value, ease_editor_window_get_slides_shown (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_editor_window_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseEditorWindow * self;
++ self = EASE_EDITOR_WINDOW (object);
++ switch (property_id) {
++ case EASE_EDITOR_WINDOW_SLIDES_SHOWN:
++ ease_editor_window_set_slides_shown (self, g_value_get_boolean (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static int _vala_strcmp0 (const char * str1, const char * str2) {
++ if (str1 == NULL) {
++ return -(str1 != str2);
++ }
++ if (str2 == NULL) {
++ return str1 != str2;
++ }
++ return strcmp (str1, str2);
++}
++
++
++
++
diff --cc ease-core/ease-element.c
index 0000000,0000000..14ee5a4
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-element.c
@@@ -1,0 -1,0 +1,820 @@@
++/* ease-element.c generated by valac, the Vala compiler
++ * generated from ease-element.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <json-glib/json-glib.h>
++#include <stdlib.h>
++#include <string.h>
++#include <float.h>
++#include <math.h>
++#include <cairo.h>
++#include <clutter/clutter.h>
++#include <gtk/gtk.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++typedef struct _EaseElementPrivate EaseElementPrivate;
++
++#define EASE_TYPE_HTML_EXPORTER (ease_html_exporter_get_type ())
++#define EASE_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporter))
++#define EASE_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++#define EASE_IS_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_HTML_EXPORTER))
++#define EASE_IS_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_HTML_EXPORTER))
++#define EASE_HTML_EXPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++
++typedef struct _EaseHTMLExporter EaseHTMLExporter;
++typedef struct _EaseHTMLExporterClass EaseHTMLExporterClass;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++#define EASE_TYPE_ACTOR (ease_actor_get_type ())
++#define EASE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ACTOR, EaseActor))
++#define EASE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ACTOR, EaseActorClass))
++#define EASE_IS_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ACTOR))
++#define EASE_IS_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ACTOR))
++#define EASE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ACTOR, EaseActorClass))
++
++typedef struct _EaseActor EaseActor;
++typedef struct _EaseActorClass EaseActorClass;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _json_object_unref0(var) ((var == NULL) ? NULL : (var = (json_object_unref (var), NULL)))
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++struct _EaseElement {
++ GObject parent_instance;
++ EaseElementPrivate * priv;
++};
++
++struct _EaseElementClass {
++ GObjectClass parent_class;
++ JsonObject* (*to_json) (EaseElement* self);
++ void (*to_html) (EaseElement* self, char** html, EaseHTMLExporter* exporter, double amount);
++ void (*write_html) (EaseElement* self, char** html, EaseHTMLExporter* exporter);
++ void (*cairo_render) (EaseElement* self, cairo_t* context, GError** error);
++ EaseActor* (*actor) (EaseElement* self, EaseActorContext c);
++ GtkWidget* (*inspector_widget) (EaseElement* self);
++ GList* (*tool_items) (EaseElement* self);
++ gboolean (*set_color) (EaseElement* self, ClutterColor* c);
++ ClutterColor* (*get_color) (EaseElement* self);
++};
++
++struct _EaseElementPrivate {
++ EaseSlide* _parent;
++ char* _identifier;
++ char* _element_type;
++ float _x;
++ float _y;
++ float _width;
++ float _height;
++ gboolean _has_been_edited;
++};
++
++
++static gpointer ease_element_parent_class = NULL;
++static EaseUndoSourceIface* ease_element_ease_undo_source_parent_iface = NULL;
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++GType ease_html_exporter_get_type (void) G_GNUC_CONST;
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++GType ease_actor_get_type (void) G_GNUC_CONST;
++GType ease_slide_get_type (void) G_GNUC_CONST;
++#define EASE_ELEMENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_ELEMENT, EaseElementPrivate))
++enum {
++ EASE_ELEMENT_DUMMY_PROPERTY,
++ EASE_ELEMENT_PARENT,
++ EASE_ELEMENT_DOCUMENT,
++ EASE_ELEMENT_IDENTIFIER,
++ EASE_ELEMENT_ELEMENT_TYPE,
++ EASE_ELEMENT_X,
++ EASE_ELEMENT_Y,
++ EASE_ELEMENT_WIDTH,
++ EASE_ELEMENT_HEIGHT,
++ EASE_ELEMENT_HAS_BEEN_EDITED
++};
++#define EASE_ELEMENT_THEME_WIDTH ((float) 800)
++#define EASE_ELEMENT_THEME_HEIGHT ((float) 600)
++#define EASE_THEME_E_IDENTIFIER "element-identifier"
++void ease_element_set_identifier (EaseElement* self, const char* value);
++#define EASE_THEME_X "x"
++void ease_element_set_x (EaseElement* self, float value);
++#define EASE_THEME_Y "y"
++void ease_element_set_y (EaseElement* self, float value);
++#define EASE_THEME_WIDTH "width"
++void ease_element_set_width (EaseElement* self, float value);
++#define EASE_THEME_HEIGHT "height"
++void ease_element_set_height (EaseElement* self, float value);
++#define EASE_THEME_HAS_BEEN_EDITED "has-been-edited"
++void ease_element_set_has_been_edited (EaseElement* self, gboolean value);
++EaseElement* ease_element_construct_from_json (GType object_type, JsonObject* obj);
++const char* ease_element_get_identifier (EaseElement* self);
++#define EASE_THEME_ELEMENT_TYPE "element-type"
++float ease_element_get_x (EaseElement* self);
++float ease_element_get_y (EaseElement* self);
++float ease_element_get_width (EaseElement* self);
++float ease_element_get_height (EaseElement* self);
++gboolean ease_element_get_has_been_edited (EaseElement* self);
++JsonObject* ease_element_to_json (EaseElement* self);
++static JsonObject* ease_element_real_to_json (EaseElement* self);
++void ease_element_set_parent (EaseElement* self, EaseSlide* value);
++EaseElement* ease_element_construct_with_owner (GType object_type, EaseSlide* owner);
++void ease_element_write_html (EaseElement* self, char** html, EaseHTMLExporter* exporter);
++void ease_html_exporter_add_progress (EaseHTMLExporter* self, double amount);
++void ease_element_to_html (EaseElement* self, char** html, EaseHTMLExporter* exporter, double amount);
++static void ease_element_real_to_html (EaseElement* self, char** html, EaseHTMLExporter* exporter, double amount);
++static void ease_element_real_write_html (EaseElement* self, char** html, EaseHTMLExporter* exporter);
++void ease_element_cairo_render (EaseElement* self, cairo_t* context, GError** error);
++static void ease_element_real_cairo_render (EaseElement* self, cairo_t* context, GError** error);
++EaseActor* ease_element_actor (EaseElement* self, EaseActorContext c);
++static EaseActor* ease_element_real_actor (EaseElement* self, EaseActorContext c);
++GtkWidget* ease_element_inspector_widget (EaseElement* self);
++static GtkWidget* ease_element_real_inspector_widget (EaseElement* self);
++GList* ease_element_tool_items (EaseElement* self);
++static GList* ease_element_real_tool_items (EaseElement* self);
++gboolean ease_element_set_color (EaseElement* self, ClutterColor* c);
++static gboolean ease_element_real_set_color (EaseElement* self, ClutterColor* c);
++ClutterColor* ease_element_get_color (EaseElement* self);
++static ClutterColor* ease_element_real_get_color (EaseElement* self);
++EaseElement* ease_element_construct (GType object_type);
++EaseSlide* ease_element_get_parent (EaseElement* self);
++GType ease_document_get_type (void) G_GNUC_CONST;
++EaseDocument* ease_slide_get_parent (EaseSlide* self);
++EaseDocument* ease_element_get_document (EaseElement* self);
++const char* ease_element_get_element_type (EaseElement* self);
++void ease_element_set_element_type (EaseElement* self, const char* value);
++static void ease_element_finalize (GObject* obj);
++static void ease_element_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_element_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++static int _vala_strcmp0 (const char * str1, const char * str2);
++
++
++
++#line 1056 "glib-2.0.vapi"
++static gboolean string_to_bool (const char* self) {
++#line 219 "ease-element.c"
++ gboolean result = FALSE;
++#line 1056 "glib-2.0.vapi"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 1057 "glib-2.0.vapi"
++ if (_vala_strcmp0 (self, "true") == 0) {
++#line 225 "ease-element.c"
++ result = TRUE;
++#line 1058 "glib-2.0.vapi"
++ return result;
++#line 229 "ease-element.c"
++ } else {
++ result = FALSE;
++#line 1060 "glib-2.0.vapi"
++ return result;
++#line 234 "ease-element.c"
++ }
++}
++
++
++#line 50 "ease-element.vala"
++EaseElement* ease_element_construct_from_json (GType object_type, JsonObject* obj) {
++#line 241 "ease-element.c"
++ EaseElement * self;
++#line 50 "ease-element.vala"
++ g_return_val_if_fail (obj != NULL, NULL);
++#line 50 "ease-element.vala"
++ self = (EaseElement*) g_object_new (object_type, NULL);
++#line 52 "ease-element.vala"
++ ease_element_set_identifier (self, json_object_get_string_member (obj, EASE_THEME_E_IDENTIFIER));
++#line 53 "ease-element.vala"
++ ease_element_set_x (self, (float) g_ascii_strtod (json_object_get_string_member (obj, EASE_THEME_X), NULL));
++#line 54 "ease-element.vala"
++ ease_element_set_y (self, (float) g_ascii_strtod (json_object_get_string_member (obj, EASE_THEME_Y), NULL));
++#line 55 "ease-element.vala"
++ ease_element_set_width (self, (float) g_ascii_strtod (json_object_get_string_member (obj, EASE_THEME_WIDTH), NULL));
++#line 56 "ease-element.vala"
++ ease_element_set_height (self, (float) g_ascii_strtod (json_object_get_string_member (obj, EASE_THEME_HEIGHT), NULL));
++#line 57 "ease-element.vala"
++ ease_element_set_has_been_edited (self, string_to_bool (json_object_get_string_member (obj, EASE_THEME_HAS_BEEN_EDITED)));
++#line 259 "ease-element.c"
++ return self;
++}
++
++
++#line 35 "glib-2.0.vapi"
++static char* bool_to_string (gboolean self) {
++#line 266 "ease-element.c"
++ char* result = NULL;
++#line 36 "glib-2.0.vapi"
++ if (self) {
++#line 270 "ease-element.c"
++ result = g_strdup ("true");
++#line 37 "glib-2.0.vapi"
++ return result;
++#line 274 "ease-element.c"
++ } else {
++ result = g_strdup ("false");
++#line 39 "glib-2.0.vapi"
++ return result;
++#line 279 "ease-element.c"
++ }
++}
++
++
++#line 64 "ease-element.vala"
++static JsonObject* ease_element_real_to_json (EaseElement* self) {
++#line 286 "ease-element.c"
++ JsonObject* result = NULL;
++ JsonObject* obj;
++ char* _tmp0_;
++ char* _tmp1_;
++ char* _tmp2_;
++ char* _tmp3_;
++ char* _tmp4_;
++#line 64 "ease-element.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 66 "ease-element.vala"
++ obj = json_object_new ();
++#line 68 "ease-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_E_IDENTIFIER, self->priv->_identifier);
++#line 69 "ease-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_ELEMENT_TYPE, g_type_name (G_TYPE_FROM_INSTANCE ((GObject*) self)));
++#line 70 "ease-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_X, _tmp0_ = g_strdup_printf ("%g", self->priv->_x));
++#line 304 "ease-element.c"
++ _g_free0 (_tmp0_);
++#line 71 "ease-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_Y, _tmp1_ = g_strdup_printf ("%g", self->priv->_y));
++#line 308 "ease-element.c"
++ _g_free0 (_tmp1_);
++#line 72 "ease-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_WIDTH, _tmp2_ = g_strdup_printf ("%g", self->priv->_width));
++#line 312 "ease-element.c"
++ _g_free0 (_tmp2_);
++#line 73 "ease-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_HEIGHT, _tmp3_ = g_strdup_printf ("%g", self->priv->_height));
++#line 316 "ease-element.c"
++ _g_free0 (_tmp3_);
++#line 74 "ease-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_HAS_BEEN_EDITED, _tmp4_ = bool_to_string (self->priv->_has_been_edited));
++#line 320 "ease-element.c"
++ _g_free0 (_tmp4_);
++ result = obj;
++#line 77 "ease-element.vala"
++ return result;
++#line 325 "ease-element.c"
++}
++
++
++#line 64 "ease-element.vala"
++JsonObject* ease_element_to_json (EaseElement* self) {
++#line 64 "ease-element.vala"
++ return EASE_ELEMENT_GET_CLASS (self)->to_json (self);
++#line 333 "ease-element.c"
++}
++
++
++#line 85 "ease-element.vala"
++EaseElement* ease_element_construct_with_owner (GType object_type, EaseSlide* owner) {
++#line 339 "ease-element.c"
++ EaseElement * self;
++#line 85 "ease-element.vala"
++ g_return_val_if_fail (owner != NULL, NULL);
++#line 85 "ease-element.vala"
++ self = (EaseElement*) g_object_new (object_type, NULL);
++#line 87 "ease-element.vala"
++ ease_element_set_parent (self, owner);
++#line 347 "ease-element.c"
++ return self;
++}
++
++
++#line 100 "ease-element.vala"
++static void ease_element_real_to_html (EaseElement* self, char** html, EaseHTMLExporter* exporter, double amount) {
++#line 100 "ease-element.vala"
++ g_return_if_fail (self != NULL);
++#line 100 "ease-element.vala"
++ g_return_if_fail (html != NULL);
++#line 100 "ease-element.vala"
++ g_return_if_fail (exporter != NULL);
++#line 105 "ease-element.vala"
++ ease_element_write_html (self, html, exporter);
++#line 108 "ease-element.vala"
++ ease_html_exporter_add_progress (exporter, amount);
++#line 364 "ease-element.c"
++}
++
++
++#line 100 "ease-element.vala"
++void ease_element_to_html (EaseElement* self, char** html, EaseHTMLExporter* exporter, double amount) {
++#line 100 "ease-element.vala"
++ EASE_ELEMENT_GET_CLASS (self)->to_html (self, html, exporter, amount);
++#line 372 "ease-element.c"
++}
++
++
++#line 117 "ease-element.vala"
++static void ease_element_real_write_html (EaseElement* self, char** html, EaseHTMLExporter* exporter) {
++#line 378 "ease-element.c"
++ g_return_if_fail (self != NULL);
++ g_critical ("Type `%s' does not implement abstract method `ease_element_write_html'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
++ return;
++}
++
++
++#line 117 "ease-element.vala"
++void ease_element_write_html (EaseElement* self, char** html, EaseHTMLExporter* exporter) {
++#line 117 "ease-element.vala"
++ EASE_ELEMENT_GET_CLASS (self)->write_html (self, html, exporter);
++#line 389 "ease-element.c"
++}
++
++
++#line 124 "ease-element.vala"
++static void ease_element_real_cairo_render (EaseElement* self, cairo_t* context, GError** error) {
++#line 395 "ease-element.c"
++ g_return_if_fail (self != NULL);
++ g_critical ("Type `%s' does not implement abstract method `ease_element_cairo_render'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
++ return;
++}
++
++
++#line 124 "ease-element.vala"
++void ease_element_cairo_render (EaseElement* self, cairo_t* context, GError** error) {
++#line 124 "ease-element.vala"
++ EASE_ELEMENT_GET_CLASS (self)->cairo_render (self, context, error);
++#line 406 "ease-element.c"
++}
++
++
++#line 131 "ease-element.vala"
++static EaseActor* ease_element_real_actor (EaseElement* self, EaseActorContext c) {
++#line 412 "ease-element.c"
++ g_return_val_if_fail (self != NULL, NULL);
++ g_critical ("Type `%s' does not implement abstract method `ease_element_actor'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
++ return NULL;
++}
++
++
++#line 131 "ease-element.vala"
++EaseActor* ease_element_actor (EaseElement* self, EaseActorContext c) {
++#line 131 "ease-element.vala"
++ return EASE_ELEMENT_GET_CLASS (self)->actor (self, c);
++#line 423 "ease-element.c"
++}
++
++
++#line 136 "ease-element.vala"
++static GtkWidget* ease_element_real_inspector_widget (EaseElement* self) {
++#line 429 "ease-element.c"
++ g_return_val_if_fail (self != NULL, NULL);
++ g_critical ("Type `%s' does not implement abstract method `ease_element_inspector_widget'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
++ return NULL;
++}
++
++
++#line 136 "ease-element.vala"
++GtkWidget* ease_element_inspector_widget (EaseElement* self) {
++#line 136 "ease-element.vala"
++ return EASE_ELEMENT_GET_CLASS (self)->inspector_widget (self);
++#line 440 "ease-element.c"
++}
++
++
++#line 142 "ease-element.vala"
++static GList* ease_element_real_tool_items (EaseElement* self) {
++#line 446 "ease-element.c"
++ GList* result = NULL;
++#line 142 "ease-element.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 450 "ease-element.c"
++ result = NULL;
++#line 144 "ease-element.vala"
++ return result;
++#line 454 "ease-element.c"
++}
++
++
++#line 142 "ease-element.vala"
++GList* ease_element_tool_items (EaseElement* self) {
++#line 142 "ease-element.vala"
++ return EASE_ELEMENT_GET_CLASS (self)->tool_items (self);
++#line 462 "ease-element.c"
++}
++
++
++#line 154 "ease-element.vala"
++static gboolean ease_element_real_set_color (EaseElement* self, ClutterColor* c) {
++#line 468 "ease-element.c"
++ gboolean result = FALSE;
++#line 154 "ease-element.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 472 "ease-element.c"
++ result = FALSE;
++#line 156 "ease-element.vala"
++ return result;
++#line 476 "ease-element.c"
++}
++
++
++#line 154 "ease-element.vala"
++gboolean ease_element_set_color (EaseElement* self, ClutterColor* c) {
++#line 154 "ease-element.vala"
++ return EASE_ELEMENT_GET_CLASS (self)->set_color (self, c);
++#line 484 "ease-element.c"
++}
++
++
++#line 164 "ease-element.vala"
++static ClutterColor* ease_element_real_get_color (EaseElement* self) {
++#line 490 "ease-element.c"
++ ClutterColor* result = NULL;
++#line 164 "ease-element.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 494 "ease-element.c"
++ result = NULL;
++#line 166 "ease-element.vala"
++ return result;
++#line 498 "ease-element.c"
++}
++
++
++#line 164 "ease-element.vala"
++ClutterColor* ease_element_get_color (EaseElement* self) {
++#line 164 "ease-element.vala"
++ return EASE_ELEMENT_GET_CLASS (self)->get_color (self);
++#line 506 "ease-element.c"
++}
++
++
++#line 25 "ease-element.vala"
++EaseElement* ease_element_construct (GType object_type) {
++#line 512 "ease-element.c"
++ EaseElement * self;
++#line 25 "ease-element.vala"
++ self = (EaseElement*) g_object_new (object_type, NULL);
++#line 516 "ease-element.c"
++ return self;
++}
++
++
++EaseSlide* ease_element_get_parent (EaseElement* self) {
++ EaseSlide* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_parent;
++#line 40 "ease-element.vala"
++ return result;
++#line 527 "ease-element.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++void ease_element_set_parent (EaseElement* self, EaseSlide* value) {
++ EaseSlide* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_parent = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_parent), _tmp0_);
++ g_object_notify ((GObject *) self, "parent");
++}
++
++
++EaseDocument* ease_element_get_document (EaseElement* self) {
++ EaseDocument* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = ease_slide_get_parent (self->priv->_parent);
++#line 45 "ease-element.vala"
++ return result;
++#line 550 "ease-element.c"
++}
++
++
++const char* ease_element_get_identifier (EaseElement* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_identifier;
++#line 175 "ease-element.vala"
++ return result;
++#line 560 "ease-element.c"
++}
++
++
++void ease_element_set_identifier (EaseElement* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_identifier = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_identifier), _tmp0_);
++ g_object_notify ((GObject *) self, "identifier");
++}
++
++
++const char* ease_element_get_element_type (EaseElement* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_element_type;
++#line 180 "ease-element.vala"
++ return result;
++#line 578 "ease-element.c"
++}
++
++
++void ease_element_set_element_type (EaseElement* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_element_type = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_element_type), _tmp0_);
++ g_object_notify ((GObject *) self, "element-type");
++}
++
++
++float ease_element_get_x (EaseElement* self) {
++ float result;
++ g_return_val_if_fail (self != NULL, 0.0F);
++ result = self->priv->_x;
++#line 185 "ease-element.vala"
++ return result;
++#line 596 "ease-element.c"
++}
++
++
++void ease_element_set_x (EaseElement* self, float value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_x = value;
++ g_object_notify ((GObject *) self, "x");
++}
++
++
++float ease_element_get_y (EaseElement* self) {
++ float result;
++ g_return_val_if_fail (self != NULL, 0.0F);
++ result = self->priv->_y;
++#line 190 "ease-element.vala"
++ return result;
++#line 613 "ease-element.c"
++}
++
++
++void ease_element_set_y (EaseElement* self, float value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_y = value;
++ g_object_notify ((GObject *) self, "y");
++}
++
++
++float ease_element_get_width (EaseElement* self) {
++ float result;
++ g_return_val_if_fail (self != NULL, 0.0F);
++ result = self->priv->_width;
++#line 195 "ease-element.vala"
++ return result;
++#line 630 "ease-element.c"
++}
++
++
++void ease_element_set_width (EaseElement* self, float value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_width = value;
++ g_object_notify ((GObject *) self, "width");
++}
++
++
++float ease_element_get_height (EaseElement* self) {
++ float result;
++ g_return_val_if_fail (self != NULL, 0.0F);
++ result = self->priv->_height;
++#line 200 "ease-element.vala"
++ return result;
++#line 647 "ease-element.c"
++}
++
++
++void ease_element_set_height (EaseElement* self, float value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_height = value;
++ g_object_notify ((GObject *) self, "height");
++}
++
++
++gboolean ease_element_get_has_been_edited (EaseElement* self) {
++ gboolean result;
++ g_return_val_if_fail (self != NULL, FALSE);
++ result = self->priv->_has_been_edited;
++#line 205 "ease-element.vala"
++ return result;
++#line 664 "ease-element.c"
++}
++
++
++void ease_element_set_has_been_edited (EaseElement* self, gboolean value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_has_been_edited = value;
++ g_object_notify ((GObject *) self, "has-been-edited");
++}
++
++
++static void ease_element_class_init (EaseElementClass * klass) {
++ ease_element_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseElementPrivate));
++ EASE_ELEMENT_CLASS (klass)->to_json = ease_element_real_to_json;
++ EASE_ELEMENT_CLASS (klass)->to_html = ease_element_real_to_html;
++ EASE_ELEMENT_CLASS (klass)->write_html = ease_element_real_write_html;
++ EASE_ELEMENT_CLASS (klass)->cairo_render = ease_element_real_cairo_render;
++ EASE_ELEMENT_CLASS (klass)->actor = ease_element_real_actor;
++ EASE_ELEMENT_CLASS (klass)->inspector_widget = ease_element_real_inspector_widget;
++ EASE_ELEMENT_CLASS (klass)->tool_items = ease_element_real_tool_items;
++ EASE_ELEMENT_CLASS (klass)->set_color = ease_element_real_set_color;
++ EASE_ELEMENT_CLASS (klass)->get_color = ease_element_real_get_color;
++ G_OBJECT_CLASS (klass)->get_property = ease_element_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_element_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_element_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ELEMENT_PARENT, g_param_spec_object ("parent", "parent", "parent", EASE_TYPE_SLIDE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ELEMENT_DOCUMENT, g_param_spec_object ("document", "document", "document", EASE_TYPE_DOCUMENT, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ELEMENT_IDENTIFIER, g_param_spec_string ("identifier", "identifier", "identifier", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ELEMENT_ELEMENT_TYPE, g_param_spec_string ("element-type", "element-type", "element-type", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ELEMENT_X, g_param_spec_float ("x", "x", "x", -G_MAXFLOAT, G_MAXFLOAT, 0.0F, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ELEMENT_Y, g_param_spec_float ("y", "y", "y", -G_MAXFLOAT, G_MAXFLOAT, 0.0F, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ELEMENT_WIDTH, g_param_spec_float ("width", "width", "width", -G_MAXFLOAT, G_MAXFLOAT, 0.0F, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ELEMENT_HEIGHT, g_param_spec_float ("height", "height", "height", -G_MAXFLOAT, G_MAXFLOAT, 0.0F, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ELEMENT_HAS_BEEN_EDITED, g_param_spec_boolean ("has-been-edited", "has-been-edited", "has-been-edited", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++}
++
++
++static void ease_element_ease_undo_source_interface_init (EaseUndoSourceIface * iface) {
++ ease_element_ease_undo_source_parent_iface = g_type_interface_peek_parent (iface);
++}
++
++
++static void ease_element_instance_init (EaseElement * self) {
++ self->priv = EASE_ELEMENT_GET_PRIVATE (self);
++}
++
++
++static void ease_element_finalize (GObject* obj) {
++ EaseElement * self;
++ self = EASE_ELEMENT (obj);
++ _g_object_unref0 (self->priv->_parent);
++ _g_free0 (self->priv->_identifier);
++ _g_free0 (self->priv->_element_type);
++ G_OBJECT_CLASS (ease_element_parent_class)->finalize (obj);
++}
++
++
++GType ease_element_get_type (void) {
++ static volatile gsize ease_element_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_element_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseElementClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_element_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseElement), 0, (GInstanceInitFunc) ease_element_instance_init, NULL };
++ static const GInterfaceInfo ease_undo_source_info = { (GInterfaceInitFunc) ease_element_ease_undo_source_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
++ GType ease_element_type_id;
++ ease_element_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseElement", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
++ g_type_add_interface_static (ease_element_type_id, EASE_TYPE_UNDO_SOURCE, &ease_undo_source_info);
++ g_once_init_leave (&ease_element_type_id__volatile, ease_element_type_id);
++ }
++ return ease_element_type_id__volatile;
++}
++
++
++static void ease_element_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseElement * self;
++ self = EASE_ELEMENT (object);
++ switch (property_id) {
++ case EASE_ELEMENT_PARENT:
++ g_value_set_object (value, ease_element_get_parent (self));
++ break;
++ case EASE_ELEMENT_DOCUMENT:
++ g_value_set_object (value, ease_element_get_document (self));
++ break;
++ case EASE_ELEMENT_IDENTIFIER:
++ g_value_set_string (value, ease_element_get_identifier (self));
++ break;
++ case EASE_ELEMENT_ELEMENT_TYPE:
++ g_value_set_string (value, ease_element_get_element_type (self));
++ break;
++ case EASE_ELEMENT_X:
++ g_value_set_float (value, ease_element_get_x (self));
++ break;
++ case EASE_ELEMENT_Y:
++ g_value_set_float (value, ease_element_get_y (self));
++ break;
++ case EASE_ELEMENT_WIDTH:
++ g_value_set_float (value, ease_element_get_width (self));
++ break;
++ case EASE_ELEMENT_HEIGHT:
++ g_value_set_float (value, ease_element_get_height (self));
++ break;
++ case EASE_ELEMENT_HAS_BEEN_EDITED:
++ g_value_set_boolean (value, ease_element_get_has_been_edited (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_element_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseElement * self;
++ self = EASE_ELEMENT (object);
++ switch (property_id) {
++ case EASE_ELEMENT_PARENT:
++ ease_element_set_parent (self, g_value_get_object (value));
++ break;
++ case EASE_ELEMENT_IDENTIFIER:
++ ease_element_set_identifier (self, g_value_get_string (value));
++ break;
++ case EASE_ELEMENT_ELEMENT_TYPE:
++ ease_element_set_element_type (self, g_value_get_string (value));
++ break;
++ case EASE_ELEMENT_X:
++ ease_element_set_x (self, g_value_get_float (value));
++ break;
++ case EASE_ELEMENT_Y:
++ ease_element_set_y (self, g_value_get_float (value));
++ break;
++ case EASE_ELEMENT_WIDTH:
++ ease_element_set_width (self, g_value_get_float (value));
++ break;
++ case EASE_ELEMENT_HEIGHT:
++ ease_element_set_height (self, g_value_get_float (value));
++ break;
++ case EASE_ELEMENT_HAS_BEEN_EDITED:
++ ease_element_set_has_been_edited (self, g_value_get_boolean (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static int _vala_strcmp0 (const char * str1, const char * str2) {
++ if (str1 == NULL) {
++ return -(str1 != str2);
++ }
++ if (str2 == NULL) {
++ return str1 != str2;
++ }
++ return strcmp (str1, str2);
++}
++
++
++
++
diff --cc ease-core/ease-enums.c
index 0000000,0000000..6fe201d
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-enums.c
@@@ -1,0 -1,0 +1,102 @@@
++/* ease-enums.c generated by valac, the Vala compiler
++ * generated from ease-enums.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++
++
++#define EASE_TYPE_HANDLE_POSITION (ease_handle_position_get_type ())
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++#define EASE_TYPE_KEY (ease_key_get_type ())
++
++typedef enum {
++ EASE_HANDLE_POSITION_TOP_LEFT = 0,
++ EASE_HANDLE_POSITION_TOP_RIGHT = 1,
++ EASE_HANDLE_POSITION_TOP = 2,
++ EASE_HANDLE_POSITION_LEFT = 3,
++ EASE_HANDLE_POSITION_RIGHT = 4,
++ EASE_HANDLE_POSITION_BOTTOM_LEFT = 5,
++ EASE_HANDLE_POSITION_BOTTOM_RIGHT = 6,
++ EASE_HANDLE_POSITION_BOTTOM = 7
++} EaseHandlePosition;
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++typedef enum {
++ EASE_KEY_UP = 65362,
++ EASE_KEY_DOWN = 65364,
++ EASE_KEY_LEFT = 65361,
++ EASE_KEY_RIGHT = 65363,
++ EASE_KEY_BACKSPACE = 65288,
++ EASE_KEY_DELETE = 65535
++} EaseKey;
++
++
++
++GType ease_handle_position_get_type (void) G_GNUC_CONST;
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++GType ease_key_get_type (void) G_GNUC_CONST;
++
++
++
++GType ease_handle_position_get_type (void) {
++ static volatile gsize ease_handle_position_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_handle_position_type_id__volatile)) {
++ static const GEnumValue values[] = {{EASE_HANDLE_POSITION_TOP_LEFT, "EASE_HANDLE_POSITION_TOP_LEFT", "top-left"}, {EASE_HANDLE_POSITION_TOP_RIGHT, "EASE_HANDLE_POSITION_TOP_RIGHT", "top-right"}, {EASE_HANDLE_POSITION_TOP, "EASE_HANDLE_POSITION_TOP", "top"}, {EASE_HANDLE_POSITION_LEFT, "EASE_HANDLE_POSITION_LEFT", "left"}, {EASE_HANDLE_POSITION_RIGHT, "EASE_HANDLE_POSITION_RIGHT", "right"}, {EASE_HANDLE_POSITION_BOTTOM_LEFT, "EASE_HANDLE_POSITION_BOTTOM_LEFT", "bottom-left"}, {EASE_HANDLE_POSITION_BOTTOM_RIGHT, "EASE_HANDLE_POSITION_BOTTOM_RIGHT", "bottom-right"}, {EASE_HANDLE_POSITION_BOTTOM, "EASE_HANDLE_POSITION_BOTTOM", "bottom"}, {0, NULL, NULL}};
++ GType ease_handle_position_type_id;
++ ease_handle_position_type_id = g_enum_register_static ("EaseHandlePosition", values);
++ g_once_init_leave (&ease_handle_position_type_id__volatile, ease_handle_position_type_id);
++ }
++ return ease_handle_position_type_id__volatile;
++}
++
++
++GType ease_actor_context_get_type (void) {
++ static volatile gsize ease_actor_context_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_actor_context_type_id__volatile)) {
++ static const GEnumValue values[] = {{EASE_ACTOR_CONTEXT_PRESENTATION, "EASE_ACTOR_CONTEXT_PRESENTATION", "presentation"}, {EASE_ACTOR_CONTEXT_EDITOR, "EASE_ACTOR_CONTEXT_EDITOR", "editor"}, {EASE_ACTOR_CONTEXT_INSPECTOR, "EASE_ACTOR_CONTEXT_INSPECTOR", "inspector"}, {0, NULL, NULL}};
++ GType ease_actor_context_type_id;
++ ease_actor_context_type_id = g_enum_register_static ("EaseActorContext", values);
++ g_once_init_leave (&ease_actor_context_type_id__volatile, ease_actor_context_type_id);
++ }
++ return ease_actor_context_type_id__volatile;
++}
++
++
++GType ease_key_get_type (void) {
++ static volatile gsize ease_key_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_key_type_id__volatile)) {
++ static const GEnumValue values[] = {{EASE_KEY_UP, "EASE_KEY_UP", "up"}, {EASE_KEY_DOWN, "EASE_KEY_DOWN", "down"}, {EASE_KEY_LEFT, "EASE_KEY_LEFT", "left"}, {EASE_KEY_RIGHT, "EASE_KEY_RIGHT", "right"}, {EASE_KEY_BACKSPACE, "EASE_KEY_BACKSPACE", "backspace"}, {EASE_KEY_DELETE, "EASE_KEY_DELETE", "delete"}, {0, NULL, NULL}};
++ GType ease_key_type_id;
++ ease_key_type_id = g_enum_register_static ("EaseKey", values);
++ g_once_init_leave (&ease_key_type_id__volatile, ease_key_type_id);
++ }
++ return ease_key_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-gradient.c
index 0000000,0000000..c1f3cc1
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-gradient.c
@@@ -1,0 -1,0 +1,1096 @@@
++/* ease-gradient.c generated by valac, the Vala compiler
++ * generated from ease-gradient.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <float.h>
++#include <math.h>
++#include <stdlib.h>
++#include <string.h>
++#include <cairo.h>
++#include <glib/gi18n-lib.h>
++#include <gtk/gtk.h>
++
++
++#define EASE_TYPE_GRADIENT (ease_gradient_get_type ())
++#define EASE_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_GRADIENT, EaseGradient))
++#define EASE_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_GRADIENT, EaseGradientClass))
++#define EASE_IS_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_GRADIENT))
++#define EASE_IS_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_GRADIENT))
++#define EASE_GRADIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_GRADIENT, EaseGradientClass))
++
++typedef struct _EaseGradient EaseGradient;
++typedef struct _EaseGradientClass EaseGradientClass;
++typedef struct _EaseGradientPrivate EaseGradientPrivate;
++
++#define EASE_TYPE_COLOR (ease_color_get_type ())
++#define EASE_COLOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_COLOR, EaseColor))
++#define EASE_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_COLOR, EaseColorClass))
++#define EASE_IS_COLOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_COLOR))
++#define EASE_IS_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_COLOR))
++#define EASE_COLOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_COLOR, EaseColorClass))
++
++typedef struct _EaseColor EaseColor;
++typedef struct _EaseColorClass EaseColorClass;
++
++#define EASE_TYPE_GRADIENT_TYPE (ease_gradient_type_get_type ())
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++#define _cairo_pattern_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_pattern_destroy (var), NULL)))
++
++struct _EaseGradient {
++ GObject parent_instance;
++ EaseGradientPrivate * priv;
++};
++
++struct _EaseGradientClass {
++ GObjectClass parent_class;
++};
++
++typedef enum {
++ EASE_GRADIENT_TYPE_LINEAR,
++ EASE_GRADIENT_TYPE_LINEAR_MIRRORED,
++ EASE_GRADIENT_TYPE_RADIAL
++} EaseGradientType;
++
++struct _EaseGradientPrivate {
++ EaseColor* start_priv;
++ EaseColor* end_priv;
++ EaseGradientType _mode;
++ double _angle;
++};
++
++
++static gpointer ease_gradient_parent_class = NULL;
++
++GType ease_gradient_get_type (void) G_GNUC_CONST;
++GType ease_color_get_type (void) G_GNUC_CONST;
++GType ease_gradient_type_get_type (void) G_GNUC_CONST;
++#define EASE_GRADIENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_GRADIENT, EaseGradientPrivate))
++enum {
++ EASE_GRADIENT_DUMMY_PROPERTY,
++ EASE_GRADIENT_START,
++ EASE_GRADIENT_END,
++ EASE_GRADIENT_MODE,
++ EASE_GRADIENT_ANGLE
++};
++#define EASE_GRADIENT_STR "%s|%s|%s|%f"
++#define EASE_GRADIENT_SPLIT "|"
++void ease_gradient_set_start (EaseGradient* self, EaseColor* value);
++void ease_gradient_set_end (EaseGradient* self, EaseColor* value);
++void ease_gradient_set_mode (EaseGradient* self, EaseGradientType value);
++void ease_gradient_set_angle (EaseGradient* self, double value);
++static void _lambda2_ (GObject* a, GParamSpec* b, EaseGradient* self);
++static void __lambda2__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static void _lambda3_ (GObject* a, GParamSpec* b, EaseGradient* self);
++static void __lambda3__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++EaseGradient* ease_gradient_new (EaseColor* start_color, EaseColor* end_color);
++EaseGradient* ease_gradient_construct (GType object_type, EaseColor* start_color, EaseColor* end_color);
++static void _lambda4_ (GObject* a, GParamSpec* b, EaseGradient* self);
++static void __lambda4__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static void _lambda5_ (GObject* a, GParamSpec* b, EaseGradient* self);
++static void __lambda5__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++EaseGradient* ease_gradient_new_mirrored (EaseColor* start_color, EaseColor* end_color);
++EaseGradient* ease_gradient_construct_mirrored (GType object_type, EaseColor* start_color, EaseColor* end_color);
++static void _lambda6_ (GObject* a, GParamSpec* b, EaseGradient* self);
++static void __lambda6__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static void _lambda7_ (GObject* a, GParamSpec* b, EaseGradient* self);
++static void __lambda7__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++EaseGradient* ease_gradient_new_radial (EaseColor* start_color, EaseColor* end_color);
++EaseGradient* ease_gradient_construct_radial (GType object_type, EaseColor* start_color, EaseColor* end_color);
++EaseColor* ease_color_new_from_string (const char* str);
++EaseColor* ease_color_construct_from_string (GType object_type, const char* str);
++EaseGradientType ease_gradient_type_from_string (const char* str);
++static void _lambda8_ (GObject* a, GParamSpec* b, EaseGradient* self);
++static void __lambda8__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static void _lambda9_ (GObject* a, GParamSpec* b, EaseGradient* self);
++static void __lambda9__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++EaseGradient* ease_gradient_new_from_string (const char* str);
++EaseGradient* ease_gradient_construct_from_string (GType object_type, const char* str);
++EaseColor* ease_gradient_get_start (EaseGradient* self);
++char* ease_color_to_string (EaseColor* self);
++EaseColor* ease_gradient_get_end (EaseGradient* self);
++EaseGradientType ease_gradient_get_mode (EaseGradient* self);
++char* ease_gradient_type_to_string (EaseGradientType self);
++double ease_gradient_get_angle (EaseGradient* self);
++char* ease_gradient_to_string (EaseGradient* self);
++EaseColor* ease_color_copy (EaseColor* self);
++EaseGradient* ease_gradient_copy (EaseGradient* self);
++void ease_gradient_flip (EaseGradient* self);
++double ease_color_get_red (EaseColor* self);
++double ease_color_get_green (EaseColor* self);
++double ease_color_get_blue (EaseColor* self);
++double ease_color_get_alpha (EaseColor* self);
++void ease_gradient_cairo_render_rect (EaseGradient* self, cairo_t* cr, gint width, gint height);
++static void ease_gradient_color_changed (EaseGradient* self, EaseColor* change);
++static void _ease_gradient_color_changed_ease_color_changed (EaseColor* _sender, EaseColor* _self_, gpointer self);
++EaseColor* ease_color_get_black (void);
++EaseColor* ease_color_get_white (void);
++EaseGradient* ease_gradient_get_default_background (void);
++static void ease_gradient_finalize (GObject* obj);
++static void ease_gradient_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_gradient_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++#define EASE_THEME_GRAD_LINEAR "linear"
++#define EASE_THEME_GRAD_LINEAR_MIRRORED "linear-mirrored"
++#define EASE_THEME_GRAD_RADIAL "radial"
++char* ease_gradient_type_description (EaseGradientType self);
++GtkListStore* ease_gradient_type_list_store (void);
++static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
++static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
++static gint _vala_array_length (gpointer array);
++
++
++
++#line 106 "ease-gradient.vala"
++static void _lambda2_ (GObject* a, GParamSpec* b, EaseGradient* self) {
++#line 106 "ease-gradient.vala"
++ g_return_if_fail (a != NULL);
++#line 106 "ease-gradient.vala"
++ g_return_if_fail (b != NULL);
++#line 106 "ease-gradient.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 172 "ease-gradient.c"
++}
++
++
++#line 106 "ease-gradient.vala"
++static void __lambda2__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 178 "ease-gradient.c"
++ _lambda2_ (_sender, pspec, self);
++}
++
++
++#line 107 "ease-gradient.vala"
++static void _lambda3_ (GObject* a, GParamSpec* b, EaseGradient* self) {
++#line 107 "ease-gradient.vala"
++ g_return_if_fail (a != NULL);
++#line 107 "ease-gradient.vala"
++ g_return_if_fail (b != NULL);
++#line 107 "ease-gradient.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 191 "ease-gradient.c"
++}
++
++
++#line 107 "ease-gradient.vala"
++static void __lambda3__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 197 "ease-gradient.c"
++ _lambda3_ (_sender, pspec, self);
++}
++
++
++#line 99 "ease-gradient.vala"
++EaseGradient* ease_gradient_construct (GType object_type, EaseColor* start_color, EaseColor* end_color) {
++#line 204 "ease-gradient.c"
++ EaseGradient * self;
++#line 99 "ease-gradient.vala"
++ g_return_val_if_fail (start_color != NULL, NULL);
++#line 99 "ease-gradient.vala"
++ g_return_val_if_fail (end_color != NULL, NULL);
++#line 99 "ease-gradient.vala"
++ self = (EaseGradient*) g_object_new (object_type, NULL);
++#line 101 "ease-gradient.vala"
++ ease_gradient_set_start (self, start_color);
++#line 102 "ease-gradient.vala"
++ ease_gradient_set_end (self, end_color);
++#line 103 "ease-gradient.vala"
++ ease_gradient_set_mode (self, EASE_GRADIENT_TYPE_LINEAR);
++#line 104 "ease-gradient.vala"
++ ease_gradient_set_angle (self, (double) 0);
++#line 106 "ease-gradient.vala"
++ g_signal_connect_object ((GObject*) self, "notify::mode", (GCallback) __lambda2__g_object_notify, self, 0);
++#line 107 "ease-gradient.vala"
++ g_signal_connect_object ((GObject*) self, "notify::angle", (GCallback) __lambda3__g_object_notify, self, 0);
++#line 224 "ease-gradient.c"
++ return self;
++}
++
++
++#line 99 "ease-gradient.vala"
++EaseGradient* ease_gradient_new (EaseColor* start_color, EaseColor* end_color) {
++#line 99 "ease-gradient.vala"
++ return ease_gradient_construct (EASE_TYPE_GRADIENT, start_color, end_color);
++#line 233 "ease-gradient.c"
++}
++
++
++#line 119 "ease-gradient.vala"
++static void _lambda4_ (GObject* a, GParamSpec* b, EaseGradient* self) {
++#line 119 "ease-gradient.vala"
++ g_return_if_fail (a != NULL);
++#line 119 "ease-gradient.vala"
++ g_return_if_fail (b != NULL);
++#line 119 "ease-gradient.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 245 "ease-gradient.c"
++}
++
++
++#line 119 "ease-gradient.vala"
++static void __lambda4__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 251 "ease-gradient.c"
++ _lambda4_ (_sender, pspec, self);
++}
++
++
++#line 120 "ease-gradient.vala"
++static void _lambda5_ (GObject* a, GParamSpec* b, EaseGradient* self) {
++#line 120 "ease-gradient.vala"
++ g_return_if_fail (a != NULL);
++#line 120 "ease-gradient.vala"
++ g_return_if_fail (b != NULL);
++#line 120 "ease-gradient.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 264 "ease-gradient.c"
++}
++
++
++#line 120 "ease-gradient.vala"
++static void __lambda5__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 270 "ease-gradient.c"
++ _lambda5_ (_sender, pspec, self);
++}
++
++
++#line 113 "ease-gradient.vala"
++EaseGradient* ease_gradient_construct_mirrored (GType object_type, EaseColor* start_color, EaseColor* end_color) {
++#line 277 "ease-gradient.c"
++ EaseGradient * self;
++#line 113 "ease-gradient.vala"
++ g_return_val_if_fail (start_color != NULL, NULL);
++#line 113 "ease-gradient.vala"
++ g_return_val_if_fail (end_color != NULL, NULL);
++#line 115 "ease-gradient.vala"
++ self = (EaseGradient*) ease_gradient_construct (object_type, start_color, end_color);
++#line 116 "ease-gradient.vala"
++ ease_gradient_set_mode (self, EASE_GRADIENT_TYPE_LINEAR_MIRRORED);
++#line 117 "ease-gradient.vala"
++ ease_gradient_set_angle (self, (double) 0);
++#line 119 "ease-gradient.vala"
++ g_signal_connect_object ((GObject*) self, "notify::mode", (GCallback) __lambda4__g_object_notify, self, 0);
++#line 120 "ease-gradient.vala"
++ g_signal_connect_object ((GObject*) self, "notify::angle", (GCallback) __lambda5__g_object_notify, self, 0);
++#line 293 "ease-gradient.c"
++ return self;
++}
++
++
++#line 113 "ease-gradient.vala"
++EaseGradient* ease_gradient_new_mirrored (EaseColor* start_color, EaseColor* end_color) {
++#line 113 "ease-gradient.vala"
++ return ease_gradient_construct_mirrored (EASE_TYPE_GRADIENT, start_color, end_color);
++#line 302 "ease-gradient.c"
++}
++
++
++#line 132 "ease-gradient.vala"
++static void _lambda6_ (GObject* a, GParamSpec* b, EaseGradient* self) {
++#line 132 "ease-gradient.vala"
++ g_return_if_fail (a != NULL);
++#line 132 "ease-gradient.vala"
++ g_return_if_fail (b != NULL);
++#line 132 "ease-gradient.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 314 "ease-gradient.c"
++}
++
++
++#line 132 "ease-gradient.vala"
++static void __lambda6__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 320 "ease-gradient.c"
++ _lambda6_ (_sender, pspec, self);
++}
++
++
++#line 133 "ease-gradient.vala"
++static void _lambda7_ (GObject* a, GParamSpec* b, EaseGradient* self) {
++#line 133 "ease-gradient.vala"
++ g_return_if_fail (a != NULL);
++#line 133 "ease-gradient.vala"
++ g_return_if_fail (b != NULL);
++#line 133 "ease-gradient.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 333 "ease-gradient.c"
++}
++
++
++#line 133 "ease-gradient.vala"
++static void __lambda7__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 339 "ease-gradient.c"
++ _lambda7_ (_sender, pspec, self);
++}
++
++
++#line 126 "ease-gradient.vala"
++EaseGradient* ease_gradient_construct_radial (GType object_type, EaseColor* start_color, EaseColor* end_color) {
++#line 346 "ease-gradient.c"
++ EaseGradient * self;
++#line 126 "ease-gradient.vala"
++ g_return_val_if_fail (start_color != NULL, NULL);
++#line 126 "ease-gradient.vala"
++ g_return_val_if_fail (end_color != NULL, NULL);
++#line 128 "ease-gradient.vala"
++ self = (EaseGradient*) ease_gradient_construct (object_type, start_color, end_color);
++#line 129 "ease-gradient.vala"
++ ease_gradient_set_mode (self, EASE_GRADIENT_TYPE_RADIAL);
++#line 130 "ease-gradient.vala"
++ ease_gradient_set_angle (self, (double) 0);
++#line 132 "ease-gradient.vala"
++ g_signal_connect_object ((GObject*) self, "notify::mode", (GCallback) __lambda6__g_object_notify, self, 0);
++#line 133 "ease-gradient.vala"
++ g_signal_connect_object ((GObject*) self, "notify::angle", (GCallback) __lambda7__g_object_notify, self, 0);
++#line 362 "ease-gradient.c"
++ return self;
++}
++
++
++#line 126 "ease-gradient.vala"
++EaseGradient* ease_gradient_new_radial (EaseColor* start_color, EaseColor* end_color) {
++#line 126 "ease-gradient.vala"
++ return ease_gradient_construct_radial (EASE_TYPE_GRADIENT, start_color, end_color);
++#line 371 "ease-gradient.c"
++}
++
++
++#line 1156 "glib-2.0.vapi"
++static char* string_replace (const char* self, const char* old, const char* replacement) {
++#line 377 "ease-gradient.c"
++ char* result = NULL;
++ GError * _inner_error_;
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (old != NULL, NULL);
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (replacement != NULL, NULL);
++#line 386 "ease-gradient.c"
++ _inner_error_ = NULL;
++ {
++ char* _tmp0_;
++ GRegex* _tmp1_;
++ GRegex* regex;
++ char* _tmp2_;
++#line 1158 "glib-2.0.vapi"
++ regex = (_tmp1_ = g_regex_new (_tmp0_ = g_regex_escape_string (old, -1), 0, 0, &_inner_error_), _g_free0 (_tmp0_), _tmp1_);
++#line 395 "ease-gradient.c"
++ if (_inner_error_ != NULL) {
++ if (_inner_error_->domain == G_REGEX_ERROR) {
++ goto __catch7_g_regex_error;
++ }
++ g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++#line 1159 "glib-2.0.vapi"
++ _tmp2_ = g_regex_replace_literal (regex, self, (gssize) (-1), 0, replacement, 0, &_inner_error_);
++#line 406 "ease-gradient.c"
++ if (_inner_error_ != NULL) {
++ _g_regex_unref0 (regex);
++ if (_inner_error_->domain == G_REGEX_ERROR) {
++ goto __catch7_g_regex_error;
++ }
++ _g_regex_unref0 (regex);
++ g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++ result = _tmp2_;
++ _g_regex_unref0 (regex);
++#line 1159 "glib-2.0.vapi"
++ return result;
++#line 421 "ease-gradient.c"
++ }
++ goto __finally7;
++ __catch7_g_regex_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 1161 "glib-2.0.vapi"
++ g_assert_not_reached ();
++#line 432 "ease-gradient.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally7:
++ if (_inner_error_ != NULL) {
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++}
++
++
++#line 147 "ease-gradient.vala"
++static void _lambda8_ (GObject* a, GParamSpec* b, EaseGradient* self) {
++#line 147 "ease-gradient.vala"
++ g_return_if_fail (a != NULL);
++#line 147 "ease-gradient.vala"
++ g_return_if_fail (b != NULL);
++#line 147 "ease-gradient.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 453 "ease-gradient.c"
++}
++
++
++#line 147 "ease-gradient.vala"
++static void __lambda8__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 459 "ease-gradient.c"
++ _lambda8_ (_sender, pspec, self);
++}
++
++
++#line 148 "ease-gradient.vala"
++static void _lambda9_ (GObject* a, GParamSpec* b, EaseGradient* self) {
++#line 148 "ease-gradient.vala"
++ g_return_if_fail (a != NULL);
++#line 148 "ease-gradient.vala"
++ g_return_if_fail (b != NULL);
++#line 148 "ease-gradient.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 472 "ease-gradient.c"
++}
++
++
++#line 148 "ease-gradient.vala"
++static void __lambda9__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 478 "ease-gradient.c"
++ _lambda9_ (_sender, pspec, self);
++}
++
++
++#line 139 "ease-gradient.vala"
++EaseGradient* ease_gradient_construct_from_string (GType object_type, const char* str) {
++#line 485 "ease-gradient.c"
++ EaseGradient * self;
++ char** _tmp3_;
++ gint _split_size_;
++ gint split_length1;
++ char** _tmp1_;
++ char* _tmp0_;
++ char** _tmp2_;
++ char** split;
++ EaseColor* _tmp4_;
++ EaseColor* _tmp5_;
++#line 139 "ease-gradient.vala"
++ g_return_val_if_fail (str != NULL, NULL);
++#line 139 "ease-gradient.vala"
++ self = (EaseGradient*) g_object_new (object_type, NULL);
++#line 500 "ease-gradient.c"
++ split = (_tmp3_ = (_tmp2_ = _tmp1_ = g_strsplit (_tmp0_ = string_replace (str, " ", ""), EASE_GRADIENT_SPLIT, 0), _g_free0 (_tmp0_), _tmp2_), split_length1 = _vala_array_length (_tmp1_), _split_size_ = split_length1, _tmp3_);
++#line 142 "ease-gradient.vala"
++ ease_gradient_set_start (self, _tmp4_ = ease_color_new_from_string (split[0]));
++#line 504 "ease-gradient.c"
++ _g_object_unref0 (_tmp4_);
++#line 143 "ease-gradient.vala"
++ ease_gradient_set_end (self, _tmp5_ = ease_color_new_from_string (split[1]));
++#line 508 "ease-gradient.c"
++ _g_object_unref0 (_tmp5_);
++#line 144 "ease-gradient.vala"
++ ease_gradient_set_mode (self, ease_gradient_type_from_string (split[2]));
++#line 145 "ease-gradient.vala"
++ ease_gradient_set_angle (self, g_ascii_strtod (split[3], NULL));
++#line 147 "ease-gradient.vala"
++ g_signal_connect_object ((GObject*) self, "notify::mode", (GCallback) __lambda8__g_object_notify, self, 0);
++#line 148 "ease-gradient.vala"
++ g_signal_connect_object ((GObject*) self, "notify::angle", (GCallback) __lambda9__g_object_notify, self, 0);
++#line 518 "ease-gradient.c"
++ split = (_vala_array_free (split, split_length1, (GDestroyNotify) g_free), NULL);
++ return self;
++}
++
++
++#line 139 "ease-gradient.vala"
++EaseGradient* ease_gradient_new_from_string (const char* str) {
++#line 139 "ease-gradient.vala"
++ return ease_gradient_construct_from_string (EASE_TYPE_GRADIENT, str);
++#line 528 "ease-gradient.c"
++}
++
++
++#line 154 "ease-gradient.vala"
++char* ease_gradient_to_string (EaseGradient* self) {
++#line 534 "ease-gradient.c"
++ char* result = NULL;
++ char* _tmp2_;
++ char* _tmp1_;
++ char* _tmp0_;
++ char* _tmp3_;
++#line 154 "ease-gradient.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 542 "ease-gradient.c"
++ result = (_tmp3_ = g_strdup_printf (EASE_GRADIENT_STR, _tmp0_ = ease_color_to_string (ease_gradient_get_start (self)), _tmp1_ = ease_color_to_string (ease_gradient_get_end (self)), _tmp2_ = ease_gradient_type_to_string (self->priv->_mode), self->priv->_angle), _g_free0 (_tmp2_), _g_free0 (_tmp1_), _g_free0 (_tmp0_), _tmp3_);
++#line 156 "ease-gradient.vala"
++ return result;
++#line 546 "ease-gradient.c"
++}
++
++
++#line 163 "ease-gradient.vala"
++EaseGradient* ease_gradient_copy (EaseGradient* self) {
++#line 552 "ease-gradient.c"
++ EaseGradient* result = NULL;
++ EaseColor* _tmp1_;
++ EaseColor* _tmp0_;
++ EaseGradient* _tmp2_;
++ EaseGradient* grad;
++#line 163 "ease-gradient.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 165 "ease-gradient.vala"
++ grad = (_tmp2_ = ease_gradient_new (_tmp0_ = ease_color_copy (ease_gradient_get_start (self)), _tmp1_ = ease_color_copy (ease_gradient_get_end (self))), _g_object_unref0 (_tmp1_), _g_object_unref0 (_tmp0_), _tmp2_);
++#line 166 "ease-gradient.vala"
++ ease_gradient_set_mode (grad, self->priv->_mode);
++#line 167 "ease-gradient.vala"
++ ease_gradient_set_angle (grad, self->priv->_angle);
++#line 566 "ease-gradient.c"
++ result = grad;
++#line 168 "ease-gradient.vala"
++ return result;
++#line 570 "ease-gradient.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 174 "ease-gradient.vala"
++void ease_gradient_flip (EaseGradient* self) {
++#line 581 "ease-gradient.c"
++ EaseColor* temp;
++#line 174 "ease-gradient.vala"
++ g_return_if_fail (self != NULL);
++#line 176 "ease-gradient.vala"
++ temp = _g_object_ref0 (ease_gradient_get_end (self));
++#line 177 "ease-gradient.vala"
++ ease_gradient_set_end (self, ease_gradient_get_start (self));
++#line 178 "ease-gradient.vala"
++ ease_gradient_set_start (self, temp);
++#line 591 "ease-gradient.c"
++ _g_object_unref0 (temp);
++}
++
++
++#line 188 "ease-gradient.vala"
++void ease_gradient_cairo_render_rect (EaseGradient* self, cairo_t* cr, gint width, gint height) {
++#line 598 "ease-gradient.c"
++ gint x_orig;
++ gint y_orig;
++ gint dist_x;
++ gint dist_y;
++ cairo_pattern_t* pattern;
++#line 188 "ease-gradient.vala"
++ g_return_if_fail (self != NULL);
++#line 188 "ease-gradient.vala"
++ g_return_if_fail (cr != NULL);
++#line 190 "ease-gradient.vala"
++ cairo_save (cr);
++#line 191 "ease-gradient.vala"
++ cairo_rectangle (cr, (double) 0, (double) 0, (double) width, (double) height);
++#line 193 "ease-gradient.vala"
++ x_orig = width / 2;
++#line 194 "ease-gradient.vala"
++ y_orig = height / 2;
++#line 195 "ease-gradient.vala"
++ dist_x = (gint) (cos (self->priv->_angle + (G_PI / 2)) * y_orig);
++#line 196 "ease-gradient.vala"
++ dist_y = (gint) (sin (self->priv->_angle + (G_PI / 2)) * y_orig);
++#line 620 "ease-gradient.c"
++ pattern = NULL;
++#line 199 "ease-gradient.vala"
++ switch (self->priv->_mode) {
++#line 624 "ease-gradient.c"
++ case EASE_GRADIENT_TYPE_LINEAR:
++ {
++ cairo_pattern_t* _tmp0_;
++#line 202 "ease-gradient.vala"
++ pattern = (_tmp0_ = cairo_pattern_create_linear ((double) (x_orig - dist_x), (double) (y_orig - dist_y), (double) (x_orig + dist_x), (double) (y_orig + dist_y)), _cairo_pattern_destroy0 (pattern), _tmp0_);
++#line 206 "ease-gradient.vala"
++ cairo_pattern_add_color_stop_rgba (pattern, (double) 0, ease_color_get_red (ease_gradient_get_start (self)), ease_color_get_green (ease_gradient_get_start (self)), ease_color_get_blue (ease_gradient_get_start (self)), ease_color_get_alpha (ease_gradient_get_start (self)));
++#line 208 "ease-gradient.vala"
++ cairo_pattern_add_color_stop_rgba (pattern, (double) 1, ease_color_get_red (ease_gradient_get_end (self)), ease_color_get_green (ease_gradient_get_end (self)), ease_color_get_blue (ease_gradient_get_end (self)), ease_color_get_alpha (ease_gradient_get_end (self)));
++#line 210 "ease-gradient.vala"
++ break;
++#line 636 "ease-gradient.c"
++ }
++ case EASE_GRADIENT_TYPE_LINEAR_MIRRORED:
++ {
++ cairo_pattern_t* _tmp1_;
++#line 212 "ease-gradient.vala"
++ pattern = (_tmp1_ = cairo_pattern_create_linear ((double) (x_orig - dist_x), (double) (y_orig - dist_y), (double) (x_orig + dist_x), (double) (y_orig + dist_y)), _cairo_pattern_destroy0 (pattern), _tmp1_);
++#line 216 "ease-gradient.vala"
++ cairo_pattern_add_color_stop_rgba (pattern, (double) 0, ease_color_get_red (ease_gradient_get_start (self)), ease_color_get_green (ease_gradient_get_start (self)), ease_color_get_blue (ease_gradient_get_start (self)), ease_color_get_alpha (ease_gradient_get_start (self)));
++#line 218 "ease-gradient.vala"
++ cairo_pattern_add_color_stop_rgba (pattern, 0.5, ease_color_get_red (ease_gradient_get_end (self)), ease_color_get_green (ease_gradient_get_end (self)), ease_color_get_blue (ease_gradient_get_end (self)), ease_color_get_alpha (ease_gradient_get_end (self)));
++#line 220 "ease-gradient.vala"
++ cairo_pattern_add_color_stop_rgba (pattern, (double) 1, ease_color_get_red (ease_gradient_get_start (self)), ease_color_get_green (ease_gradient_get_start (self)), ease_color_get_blue (ease_gradient_get_start (self)), ease_color_get_alpha (ease_gradient_get_start (self)));
++#line 222 "ease-gradient.vala"
++ break;
++#line 651 "ease-gradient.c"
++ }
++ default:
++ {
++ cairo_pattern_t* _tmp2_;
++#line 224 "ease-gradient.vala"
++ pattern = (_tmp2_ = cairo_pattern_create_radial ((double) (width / 2), (double) (height / 2), (double) 0, (double) (width / 2), (double) (height / 2), (double) (width / 2)), _cairo_pattern_destroy0 (pattern), _tmp2_);
++#line 227 "ease-gradient.vala"
++ cairo_pattern_add_color_stop_rgba (pattern, (double) 0, ease_color_get_red (ease_gradient_get_start (self)), ease_color_get_green (ease_gradient_get_start (self)), ease_color_get_blue (ease_gradient_get_start (self)), ease_color_get_alpha (ease_gradient_get_start (self)));
++#line 229 "ease-gradient.vala"
++ cairo_pattern_add_color_stop_rgba (pattern, (double) 1, ease_color_get_red (ease_gradient_get_end (self)), ease_color_get_green (ease_gradient_get_end (self)), ease_color_get_blue (ease_gradient_get_end (self)), ease_color_get_alpha (ease_gradient_get_end (self)));
++#line 231 "ease-gradient.vala"
++ break;
++#line 664 "ease-gradient.c"
++ }
++ }
++#line 234 "ease-gradient.vala"
++ cairo_set_source (cr, pattern);
++#line 235 "ease-gradient.vala"
++ cairo_fill (cr);
++#line 237 "ease-gradient.vala"
++ cairo_restore (cr);
++#line 673 "ease-gradient.c"
++ _cairo_pattern_destroy0 (pattern);
++}
++
++
++#line 243 "ease-gradient.vala"
++static void ease_gradient_color_changed (EaseGradient* self, EaseColor* change) {
++#line 243 "ease-gradient.vala"
++ g_return_if_fail (self != NULL);
++#line 243 "ease-gradient.vala"
++ g_return_if_fail (change != NULL);
++#line 245 "ease-gradient.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 686 "ease-gradient.c"
++}
++
++
++EaseColor* ease_gradient_get_start (EaseGradient* self) {
++ EaseColor* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->start_priv;
++#line 38 "ease-gradient.vala"
++ return result;
++#line 696 "ease-gradient.c"
++}
++
++
++#line 243 "ease-gradient.vala"
++static void _ease_gradient_color_changed_ease_color_changed (EaseColor* _sender, EaseColor* _self_, gpointer self) {
++#line 702 "ease-gradient.c"
++ ease_gradient_color_changed (self, _self_);
++}
++
++
++void ease_gradient_set_start (EaseGradient* self, EaseColor* value) {
++ EaseColor* _tmp1_;
++ g_return_if_fail (self != NULL);
++#line 41 "ease-gradient.vala"
++ if (self->priv->start_priv != NULL) {
++#line 712 "ease-gradient.c"
++ guint _tmp0_;
++#line 43 "ease-gradient.vala"
++ g_signal_parse_name ("changed", EASE_TYPE_COLOR, &_tmp0_, NULL, FALSE);
++#line 43 "ease-gradient.vala"
++ g_signal_handlers_disconnect_matched (self->priv->start_priv, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _ease_gradient_color_changed_ease_color_changed, self);
++#line 718 "ease-gradient.c"
++ }
++#line 46 "ease-gradient.vala"
++ self->priv->start_priv = (_tmp1_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->start_priv), _tmp1_);
++#line 47 "ease-gradient.vala"
++ g_signal_connect_object (self->priv->start_priv, "changed", (GCallback) _ease_gradient_color_changed_ease_color_changed, self, 0);
++#line 48 "ease-gradient.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 726 "ease-gradient.c"
++ g_object_notify ((GObject *) self, "start");
++}
++
++
++EaseColor* ease_gradient_get_end (EaseGradient* self) {
++ EaseColor* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->end_priv;
++#line 58 "ease-gradient.vala"
++ return result;
++#line 737 "ease-gradient.c"
++}
++
++
++void ease_gradient_set_end (EaseGradient* self, EaseColor* value) {
++ EaseColor* _tmp1_;
++ g_return_if_fail (self != NULL);
++#line 61 "ease-gradient.vala"
++ if (self->priv->end_priv != NULL) {
++#line 746 "ease-gradient.c"
++ guint _tmp0_;
++#line 63 "ease-gradient.vala"
++ g_signal_parse_name ("changed", EASE_TYPE_COLOR, &_tmp0_, NULL, FALSE);
++#line 63 "ease-gradient.vala"
++ g_signal_handlers_disconnect_matched (self->priv->end_priv, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _ease_gradient_color_changed_ease_color_changed, self);
++#line 752 "ease-gradient.c"
++ }
++#line 66 "ease-gradient.vala"
++ self->priv->end_priv = (_tmp1_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->end_priv), _tmp1_);
++#line 67 "ease-gradient.vala"
++ g_signal_connect_object (self->priv->end_priv, "changed", (GCallback) _ease_gradient_color_changed_ease_color_changed, self, 0);
++#line 68 "ease-gradient.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 760 "ease-gradient.c"
++ g_object_notify ((GObject *) self, "end");
++}
++
++
++EaseGradientType ease_gradient_get_mode (EaseGradient* self) {
++ EaseGradientType result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->_mode;
++#line 76 "ease-gradient.vala"
++ return result;
++#line 771 "ease-gradient.c"
++}
++
++
++void ease_gradient_set_mode (EaseGradient* self, EaseGradientType value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_mode = value;
++ g_object_notify ((GObject *) self, "mode");
++}
++
++
++double ease_gradient_get_angle (EaseGradient* self) {
++ double result;
++ g_return_val_if_fail (self != NULL, 0.0);
++ result = self->priv->_angle;
++#line 81 "ease-gradient.vala"
++ return result;
++#line 788 "ease-gradient.c"
++}
++
++
++void ease_gradient_set_angle (EaseGradient* self, double value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_angle = value;
++ g_object_notify ((GObject *) self, "angle");
++}
++
++
++EaseGradient* ease_gradient_get_default_background (void) {
++ EaseGradient* result;
++ EaseColor* _tmp1_;
++ EaseColor* _tmp0_;
++ EaseGradient* _tmp2_;
++ result = (_tmp2_ = ease_gradient_new (_tmp0_ = ease_color_get_black (), _tmp1_ = ease_color_get_white ()), _g_object_unref0 (_tmp1_), _g_object_unref0 (_tmp0_), _tmp2_);
++#line 93 "ease-gradient.vala"
++ return result;
++#line 807 "ease-gradient.c"
++}
++
++
++static void ease_gradient_class_init (EaseGradientClass * klass) {
++ ease_gradient_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseGradientPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_gradient_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_gradient_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_gradient_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_GRADIENT_START, g_param_spec_object ("start", "start", "start", EASE_TYPE_COLOR, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_GRADIENT_END, g_param_spec_object ("end", "end", "end", EASE_TYPE_COLOR, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_GRADIENT_MODE, g_param_spec_enum ("mode", "mode", "mode", EASE_TYPE_GRADIENT_TYPE, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_GRADIENT_ANGLE, g_param_spec_double ("angle", "angle", "angle", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_signal_new ("changed", EASE_TYPE_GRADIENT, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_GRADIENT);
++}
++
++
++static void ease_gradient_instance_init (EaseGradient * self) {
++ self->priv = EASE_GRADIENT_GET_PRIVATE (self);
++}
++
++
++static void ease_gradient_finalize (GObject* obj) {
++ EaseGradient * self;
++ self = EASE_GRADIENT (obj);
++ _g_object_unref0 (self->priv->start_priv);
++ _g_object_unref0 (self->priv->end_priv);
++ G_OBJECT_CLASS (ease_gradient_parent_class)->finalize (obj);
++}
++
++
++GType ease_gradient_get_type (void) {
++ static volatile gsize ease_gradient_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_gradient_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseGradientClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_gradient_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseGradient), 0, (GInstanceInitFunc) ease_gradient_instance_init, NULL };
++ GType ease_gradient_type_id;
++ ease_gradient_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseGradient", &g_define_type_info, 0);
++ g_once_init_leave (&ease_gradient_type_id__volatile, ease_gradient_type_id);
++ }
++ return ease_gradient_type_id__volatile;
++}
++
++
++static void ease_gradient_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseGradient * self;
++ self = EASE_GRADIENT (object);
++ switch (property_id) {
++ case EASE_GRADIENT_START:
++ g_value_set_object (value, ease_gradient_get_start (self));
++ break;
++ case EASE_GRADIENT_END:
++ g_value_set_object (value, ease_gradient_get_end (self));
++ break;
++ case EASE_GRADIENT_MODE:
++ g_value_set_enum (value, ease_gradient_get_mode (self));
++ break;
++ case EASE_GRADIENT_ANGLE:
++ g_value_set_double (value, ease_gradient_get_angle (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_gradient_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseGradient * self;
++ self = EASE_GRADIENT (object);
++ switch (property_id) {
++ case EASE_GRADIENT_START:
++ ease_gradient_set_start (self, g_value_get_object (value));
++ break;
++ case EASE_GRADIENT_END:
++ ease_gradient_set_end (self, g_value_get_object (value));
++ break;
++ case EASE_GRADIENT_MODE:
++ ease_gradient_set_mode (self, g_value_get_enum (value));
++ break;
++ case EASE_GRADIENT_ANGLE:
++ ease_gradient_set_angle (self, g_value_get_double (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++#line 274 "ease-gradient.vala"
++char* ease_gradient_type_to_string (EaseGradientType self) {
++#line 899 "ease-gradient.c"
++ char* result = NULL;
++#line 276 "ease-gradient.vala"
++ switch (self) {
++#line 903 "ease-gradient.c"
++ case EASE_GRADIENT_TYPE_LINEAR:
++ {
++ result = g_strdup (EASE_THEME_GRAD_LINEAR);
++#line 278 "ease-gradient.vala"
++ return result;
++#line 909 "ease-gradient.c"
++ }
++ case EASE_GRADIENT_TYPE_LINEAR_MIRRORED:
++ {
++ result = g_strdup (EASE_THEME_GRAD_LINEAR_MIRRORED);
++#line 279 "ease-gradient.vala"
++ return result;
++#line 916 "ease-gradient.c"
++ }
++ case EASE_GRADIENT_TYPE_RADIAL:
++ {
++ result = g_strdup (EASE_THEME_GRAD_RADIAL);
++#line 280 "ease-gradient.vala"
++ return result;
++#line 923 "ease-gradient.c"
++ }
++ }
++ result = g_strdup ("undefined");
++#line 282 "ease-gradient.vala"
++ return result;
++#line 929 "ease-gradient.c"
++}
++
++
++#line 288 "ease-gradient.vala"
++EaseGradientType ease_gradient_type_from_string (const char* str) {
++#line 935 "ease-gradient.c"
++ EaseGradientType result = 0;
++ GQuark _tmp1_;
++ const char* _tmp0_;
++#line 288 "ease-gradient.vala"
++ g_return_val_if_fail (str != NULL, 0);
++#line 941 "ease-gradient.c"
++ _tmp0_ = str;
++ _tmp1_ = (NULL == _tmp0_) ? 0 : g_quark_from_string (_tmp0_);
++ if (_tmp1_ == g_quark_from_string (EASE_THEME_GRAD_LINEAR))
++ switch (0) {
++ default:
++ {
++ result = EASE_GRADIENT_TYPE_LINEAR;
++#line 292 "ease-gradient.vala"
++ return result;
++#line 951 "ease-gradient.c"
++ }
++ } else if (_tmp1_ == g_quark_from_string (EASE_THEME_GRAD_LINEAR_MIRRORED))
++ switch (0) {
++ default:
++ {
++ result = EASE_GRADIENT_TYPE_LINEAR_MIRRORED;
++#line 293 "ease-gradient.vala"
++ return result;
++#line 960 "ease-gradient.c"
++ }
++ } else if (_tmp1_ == g_quark_from_string (EASE_THEME_GRAD_RADIAL))
++ switch (0) {
++ default:
++ {
++ result = EASE_GRADIENT_TYPE_RADIAL;
++#line 294 "ease-gradient.vala"
++ return result;
++#line 969 "ease-gradient.c"
++ }
++ }
++#line 297 "ease-gradient.vala"
++ g_warning ("ease-gradient.vala:297: %s is not a gradient type", str);
++#line 974 "ease-gradient.c"
++ result = EASE_GRADIENT_TYPE_LINEAR;
++#line 298 "ease-gradient.vala"
++ return result;
++#line 978 "ease-gradient.c"
++}
++
++
++#line 304 "ease-gradient.vala"
++char* ease_gradient_type_description (EaseGradientType self) {
++#line 984 "ease-gradient.c"
++ char* result = NULL;
++#line 306 "ease-gradient.vala"
++ switch (self) {
++#line 988 "ease-gradient.c"
++ case EASE_GRADIENT_TYPE_LINEAR:
++ {
++ result = g_strdup (_ ("Linear"));
++#line 308 "ease-gradient.vala"
++ return result;
++#line 994 "ease-gradient.c"
++ }
++ case EASE_GRADIENT_TYPE_LINEAR_MIRRORED:
++ {
++ result = g_strdup (_ ("Mirrored Linear"));
++#line 309 "ease-gradient.vala"
++ return result;
++#line 1001 "ease-gradient.c"
++ }
++ case EASE_GRADIENT_TYPE_RADIAL:
++ {
++ result = g_strdup (_ ("Radial"));
++#line 310 "ease-gradient.vala"
++ return result;
++#line 1008 "ease-gradient.c"
++ }
++ }
++ result = g_strdup ("undefined");
++#line 312 "ease-gradient.vala"
++ return result;
++#line 1014 "ease-gradient.c"
++}
++
++
++#line 319 "ease-gradient.vala"
++GtkListStore* ease_gradient_type_list_store (void) {
++#line 1020 "ease-gradient.c"
++ GtkListStore* result = NULL;
++ GtkListStore* store;
++ GtkTreeIter itr = {0};
++ char* _tmp0_;
++ char* _tmp1_;
++ char* _tmp2_;
++#line 321 "ease-gradient.vala"
++ store = gtk_list_store_new (2, G_TYPE_STRING, EASE_TYPE_GRADIENT_TYPE, NULL);
++#line 324 "ease-gradient.vala"
++ gtk_list_store_append (store, &itr);
++#line 325 "ease-gradient.vala"
++ gtk_list_store_set (store, &itr, 0, _tmp0_ = ease_gradient_type_description (EASE_GRADIENT_TYPE_LINEAR), 1, EASE_GRADIENT_TYPE_LINEAR, -1);
++#line 1033 "ease-gradient.c"
++ _g_free0 (_tmp0_);
++#line 326 "ease-gradient.vala"
++ gtk_list_store_append (store, &itr);
++#line 327 "ease-gradient.vala"
++ gtk_list_store_set (store, &itr, 0, _tmp1_ = ease_gradient_type_description (EASE_GRADIENT_TYPE_LINEAR_MIRRORED), 1, EASE_GRADIENT_TYPE_LINEAR_MIRRORED, -1);
++#line 1039 "ease-gradient.c"
++ _g_free0 (_tmp1_);
++#line 328 "ease-gradient.vala"
++ gtk_list_store_append (store, &itr);
++#line 329 "ease-gradient.vala"
++ gtk_list_store_set (store, &itr, 0, _tmp2_ = ease_gradient_type_description (EASE_GRADIENT_TYPE_RADIAL), 1, EASE_GRADIENT_TYPE_RADIAL, -1);
++#line 1045 "ease-gradient.c"
++ _g_free0 (_tmp2_);
++ result = store;
++#line 331 "ease-gradient.vala"
++ return result;
++#line 1050 "ease-gradient.c"
++}
++
++
++GType ease_gradient_type_get_type (void) {
++ static volatile gsize ease_gradient_type_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_gradient_type_type_id__volatile)) {
++ static const GEnumValue values[] = {{EASE_GRADIENT_TYPE_LINEAR, "EASE_GRADIENT_TYPE_LINEAR", "linear"}, {EASE_GRADIENT_TYPE_LINEAR_MIRRORED, "EASE_GRADIENT_TYPE_LINEAR_MIRRORED", "linear-mirrored"}, {EASE_GRADIENT_TYPE_RADIAL, "EASE_GRADIENT_TYPE_RADIAL", "radial"}, {0, NULL, NULL}};
++ GType ease_gradient_type_type_id;
++ ease_gradient_type_type_id = g_enum_register_static ("EaseGradientType", values);
++ g_once_init_leave (&ease_gradient_type_type_id__volatile, ease_gradient_type_type_id);
++ }
++ return ease_gradient_type_type_id__volatile;
++}
++
++
++static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
++ if ((array != NULL) && (destroy_func != NULL)) {
++ int 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, gint array_length, GDestroyNotify destroy_func) {
++ _vala_array_destroy (array, array_length, destroy_func);
++ g_free (array);
++}
++
++
++static gint _vala_array_length (gpointer array) {
++ int length;
++ length = 0;
++ if (array) {
++ while (((gpointer*) array)[length]) {
++ length++;
++ }
++ }
++ return length;
++}
++
++
++
++
diff --cc ease-core/ease-handle.c
index 0000000,0000000..14880be
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-handle.c
@@@ -1,0 -1,0 +1,489 @@@
++/* ease-handle.c generated by valac, the Vala compiler
++ * generated from ease-handle.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <clutter/clutter.h>
++#include <float.h>
++#include <math.h>
++#include <cairo.h>
++
++
++#define EASE_TYPE_HANDLE (ease_handle_get_type ())
++#define EASE_HANDLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_HANDLE, EaseHandle))
++#define EASE_HANDLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_HANDLE, EaseHandleClass))
++#define EASE_IS_HANDLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_HANDLE))
++#define EASE_IS_HANDLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_HANDLE))
++#define EASE_HANDLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_HANDLE, EaseHandleClass))
++
++typedef struct _EaseHandle EaseHandle;
++typedef struct _EaseHandleClass EaseHandleClass;
++typedef struct _EaseHandlePrivate EaseHandlePrivate;
++
++#define EASE_TYPE_HANDLE_POSITION (ease_handle_position_get_type ())
++
++#define EASE_TYPE_ACTOR (ease_actor_get_type ())
++#define EASE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ACTOR, EaseActor))
++#define EASE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ACTOR, EaseActorClass))
++#define EASE_IS_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ACTOR))
++#define EASE_IS_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ACTOR))
++#define EASE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ACTOR, EaseActorClass))
++
++typedef struct _EaseActor EaseActor;
++typedef struct _EaseActorClass EaseActorClass;
++#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL)))
++
++struct _EaseHandle {
++ ClutterCairoTexture parent_instance;
++ EaseHandlePrivate * priv;
++};
++
++struct _EaseHandleClass {
++ ClutterCairoTextureClass parent_class;
++};
++
++typedef enum {
++ EASE_HANDLE_POSITION_TOP_LEFT = 0,
++ EASE_HANDLE_POSITION_TOP_RIGHT = 1,
++ EASE_HANDLE_POSITION_TOP = 2,
++ EASE_HANDLE_POSITION_LEFT = 3,
++ EASE_HANDLE_POSITION_RIGHT = 4,
++ EASE_HANDLE_POSITION_BOTTOM_LEFT = 5,
++ EASE_HANDLE_POSITION_BOTTOM_RIGHT = 6,
++ EASE_HANDLE_POSITION_BOTTOM = 7
++} EaseHandlePosition;
++
++struct _EaseHandlePrivate {
++ EaseHandlePosition position;
++ gboolean flipped;
++};
++
++
++static gpointer ease_handle_parent_class = NULL;
++
++GType ease_handle_get_type (void) G_GNUC_CONST;
++GType ease_handle_position_get_type (void) G_GNUC_CONST;
++#define EASE_HANDLE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_HANDLE, EaseHandlePrivate))
++enum {
++ EASE_HANDLE_DUMMY_PROPERTY
++};
++#define EASE_HANDLE_SIZE 35
++static void ease_handle_redraw (EaseHandle* self);
++EaseHandle* ease_handle_new (EaseHandlePosition pos);
++EaseHandle* ease_handle_construct (GType object_type, EaseHandlePosition pos);
++GType ease_actor_get_type (void) G_GNUC_CONST;
++void ease_actor_translate (EaseActor* self, float x_change, float y_change);
++void ease_actor_resize (EaseActor* self, float w_change, float h_change, gboolean proportional);
++void ease_handle_drag (EaseHandle* self, float change_x, float change_y, EaseActor* target, gboolean prop);
++void ease_handle_drag_from_center (EaseHandle* self, float change_x, float change_y, EaseActor* target, gboolean prop);
++void ease_handle_reposition (EaseHandle* self, ClutterActor* selection);
++void ease_handle_flip (EaseHandle* self, gboolean f);
++static void ease_handle_finalize (GObject* obj);
++
++
++
++#line 45 "ease-handle.vala"
++EaseHandle* ease_handle_construct (GType object_type, EaseHandlePosition pos) {
++#line 105 "ease-handle.c"
++ EaseHandle * self;
++ guint _tmp0_;
++ guint _tmp1_;
++ self = g_object_newv (object_type, 0, NULL);
++#line 48 "ease-handle.vala"
++ clutter_actor_set_width ((ClutterActor*) self, (clutter_actor_set_height ((ClutterActor*) self, (float) (g_object_set ((ClutterCairoTexture*) self, "surface-width", (g_object_set ((ClutterCairoTexture*) self, "surface-height", (guint) EASE_HANDLE_SIZE, NULL), (g_object_get ((ClutterCairoTexture*) self, "surface-height", &_tmp0_, NULL), _tmp0_)), NULL), (g_object_get ((ClutterCairoTexture*) self, "surface-width", &_tmp1_, NULL), _tmp1_))), clutter_actor_get_height ((ClutterActor*) self)));
++#line 51 "ease-handle.vala"
++ ease_handle_redraw (self);
++#line 54 "ease-handle.vala"
++ self->priv->position = pos;
++#line 57 "ease-handle.vala"
++ clutter_actor_set_anchor_point ((ClutterActor*) self, (float) (EASE_HANDLE_SIZE / 2), (float) (EASE_HANDLE_SIZE / 2));
++#line 60 "ease-handle.vala"
++ clutter_actor_set_reactive ((ClutterActor*) self, TRUE);
++#line 120 "ease-handle.c"
++ return self;
++}
++
++
++#line 45 "ease-handle.vala"
++EaseHandle* ease_handle_new (EaseHandlePosition pos) {
++#line 45 "ease-handle.vala"
++ return ease_handle_construct (EASE_TYPE_HANDLE, pos);
++#line 129 "ease-handle.c"
++}
++
++
++#line 72 "ease-handle.vala"
++void ease_handle_drag (EaseHandle* self, float change_x, float change_y, EaseActor* target, gboolean prop) {
++#line 72 "ease-handle.vala"
++ g_return_if_fail (self != NULL);
++#line 72 "ease-handle.vala"
++ g_return_if_fail (target != NULL);
++#line 74 "ease-handle.vala"
++ switch (self->priv->position) {
++#line 141 "ease-handle.c"
++ case EASE_HANDLE_POSITION_TOP_LEFT:
++ {
++#line 77 "ease-handle.vala"
++ ease_actor_translate (target, change_x, change_y);
++#line 78 "ease-handle.vala"
++ ease_actor_resize (target, -change_x, -change_y, prop);
++#line 79 "ease-handle.vala"
++ break;
++#line 150 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_TOP_RIGHT:
++ {
++#line 82 "ease-handle.vala"
++ ease_actor_translate (target, (float) 0, change_y);
++#line 83 "ease-handle.vala"
++ ease_actor_resize (target, change_x, -change_y, prop);
++#line 84 "ease-handle.vala"
++ break;
++#line 160 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_TOP:
++ {
++#line 87 "ease-handle.vala"
++ ease_actor_translate (target, (float) 0, change_y);
++#line 88 "ease-handle.vala"
++ ease_actor_resize (target, (float) 0, -change_y, FALSE);
++#line 89 "ease-handle.vala"
++ break;
++#line 170 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_BOTTOM:
++ {
++#line 92 "ease-handle.vala"
++ ease_actor_resize (target, (float) 0, change_y, FALSE);
++#line 93 "ease-handle.vala"
++ break;
++#line 178 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_LEFT:
++ {
++#line 96 "ease-handle.vala"
++ ease_actor_translate (target, change_x, (float) 0);
++#line 97 "ease-handle.vala"
++ ease_actor_resize (target, -change_x, (float) 0, FALSE);
++#line 98 "ease-handle.vala"
++ break;
++#line 188 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_RIGHT:
++ {
++#line 101 "ease-handle.vala"
++ ease_actor_resize (target, change_x, (float) 0, FALSE);
++#line 102 "ease-handle.vala"
++ break;
++#line 196 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_BOTTOM_LEFT:
++ {
++#line 105 "ease-handle.vala"
++ ease_actor_translate (target, change_x, (float) 0);
++#line 106 "ease-handle.vala"
++ ease_actor_resize (target, -change_x, change_y, prop);
++#line 107 "ease-handle.vala"
++ break;
++#line 206 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_BOTTOM_RIGHT:
++ {
++#line 110 "ease-handle.vala"
++ ease_actor_resize (target, change_x, change_y, prop);
++#line 111 "ease-handle.vala"
++ break;
++#line 214 "ease-handle.c"
++ }
++ }
++}
++
++
++#line 124 "ease-handle.vala"
++void ease_handle_drag_from_center (EaseHandle* self, float change_x, float change_y, EaseActor* target, gboolean prop) {
++#line 124 "ease-handle.vala"
++ g_return_if_fail (self != NULL);
++#line 124 "ease-handle.vala"
++ g_return_if_fail (target != NULL);
++#line 127 "ease-handle.vala"
++ switch (self->priv->position) {
++#line 228 "ease-handle.c"
++ case EASE_HANDLE_POSITION_TOP_LEFT:
++ {
++#line 130 "ease-handle.vala"
++ ease_actor_translate (target, change_x, change_y);
++#line 131 "ease-handle.vala"
++ ease_actor_resize (target, (-change_x) * 2, (-change_y) * 2, FALSE);
++#line 132 "ease-handle.vala"
++ break;
++#line 237 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_TOP_RIGHT:
++ {
++#line 135 "ease-handle.vala"
++ ease_actor_translate (target, -change_x, change_y);
++#line 136 "ease-handle.vala"
++ ease_actor_resize (target, change_x * 2, (-change_y) * 2, prop);
++#line 137 "ease-handle.vala"
++ break;
++#line 247 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_TOP:
++ {
++#line 140 "ease-handle.vala"
++ ease_actor_translate (target, (float) 0, change_y);
++#line 141 "ease-handle.vala"
++ ease_actor_resize (target, (float) 0, (-change_y) * 2, FALSE);
++#line 142 "ease-handle.vala"
++ break;
++#line 257 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_BOTTOM:
++ {
++#line 145 "ease-handle.vala"
++ ease_actor_translate (target, (float) 0, -change_y);
++#line 146 "ease-handle.vala"
++ ease_actor_resize (target, (float) 0, change_y * 2, FALSE);
++#line 147 "ease-handle.vala"
++ break;
++#line 267 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_LEFT:
++ {
++#line 150 "ease-handle.vala"
++ ease_actor_translate (target, change_x, (float) 0);
++#line 151 "ease-handle.vala"
++ ease_actor_resize (target, (-change_x) * 2, (float) 0, FALSE);
++#line 152 "ease-handle.vala"
++ break;
++#line 277 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_RIGHT:
++ {
++#line 155 "ease-handle.vala"
++ ease_actor_translate (target, -change_x, (float) 0);
++#line 156 "ease-handle.vala"
++ ease_actor_resize (target, change_x * 2, (float) 0, FALSE);
++#line 157 "ease-handle.vala"
++ break;
++#line 287 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_BOTTOM_LEFT:
++ {
++#line 160 "ease-handle.vala"
++ ease_actor_translate (target, change_x, -change_y);
++#line 161 "ease-handle.vala"
++ ease_actor_resize (target, (-change_x) * 2, change_y * 2, prop);
++#line 162 "ease-handle.vala"
++ break;
++#line 297 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_BOTTOM_RIGHT:
++ {
++#line 165 "ease-handle.vala"
++ ease_actor_translate (target, -change_x, -change_y);
++#line 166 "ease-handle.vala"
++ ease_actor_resize (target, change_x * 2, change_y * 2, prop);
++#line 167 "ease-handle.vala"
++ break;
++#line 307 "ease-handle.c"
++ }
++ }
++}
++
++
++#line 177 "ease-handle.vala"
++void ease_handle_reposition (EaseHandle* self, ClutterActor* selection) {
++#line 177 "ease-handle.vala"
++ g_return_if_fail (self != NULL);
++#line 177 "ease-handle.vala"
++ g_return_if_fail (selection != NULL);
++#line 179 "ease-handle.vala"
++ switch (self->priv->position) {
++#line 321 "ease-handle.c"
++ case EASE_HANDLE_POSITION_TOP_LEFT:
++ {
++#line 182 "ease-handle.vala"
++ clutter_actor_set_x ((ClutterActor*) self, clutter_actor_get_x (selection));
++#line 183 "ease-handle.vala"
++ clutter_actor_set_y ((ClutterActor*) self, clutter_actor_get_y (selection));
++#line 184 "ease-handle.vala"
++ break;
++#line 330 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_TOP_RIGHT:
++ {
++#line 187 "ease-handle.vala"
++ clutter_actor_set_x ((ClutterActor*) self, clutter_actor_get_x (selection) + clutter_actor_get_width (selection));
++#line 188 "ease-handle.vala"
++ clutter_actor_set_y ((ClutterActor*) self, clutter_actor_get_y (selection));
++#line 189 "ease-handle.vala"
++ break;
++#line 340 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_TOP:
++ {
++#line 192 "ease-handle.vala"
++ clutter_actor_set_x ((ClutterActor*) self, clutter_actor_get_x (selection) + (clutter_actor_get_width (selection) / 2));
++#line 193 "ease-handle.vala"
++ clutter_actor_set_y ((ClutterActor*) self, clutter_actor_get_y (selection));
++#line 194 "ease-handle.vala"
++ break;
++#line 350 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_LEFT:
++ {
++#line 197 "ease-handle.vala"
++ clutter_actor_set_x ((ClutterActor*) self, clutter_actor_get_x (selection));
++#line 198 "ease-handle.vala"
++ clutter_actor_set_y ((ClutterActor*) self, clutter_actor_get_y (selection) + (clutter_actor_get_height (selection) / 2));
++#line 199 "ease-handle.vala"
++ break;
++#line 360 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_RIGHT:
++ {
++#line 202 "ease-handle.vala"
++ clutter_actor_set_x ((ClutterActor*) self, clutter_actor_get_x (selection) + clutter_actor_get_width (selection));
++#line 203 "ease-handle.vala"
++ clutter_actor_set_y ((ClutterActor*) self, clutter_actor_get_y (selection) + (clutter_actor_get_height (selection) / 2));
++#line 204 "ease-handle.vala"
++ break;
++#line 370 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_BOTTOM_LEFT:
++ {
++#line 207 "ease-handle.vala"
++ clutter_actor_set_x ((ClutterActor*) self, clutter_actor_get_x (selection));
++#line 208 "ease-handle.vala"
++ clutter_actor_set_y ((ClutterActor*) self, clutter_actor_get_y (selection) + clutter_actor_get_height (selection));
++#line 209 "ease-handle.vala"
++ break;
++#line 380 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_BOTTOM_RIGHT:
++ {
++#line 212 "ease-handle.vala"
++ clutter_actor_set_x ((ClutterActor*) self, clutter_actor_get_x (selection) + clutter_actor_get_width (selection));
++#line 213 "ease-handle.vala"
++ clutter_actor_set_y ((ClutterActor*) self, clutter_actor_get_y (selection) + clutter_actor_get_height (selection));
++#line 214 "ease-handle.vala"
++ break;
++#line 390 "ease-handle.c"
++ }
++ case EASE_HANDLE_POSITION_BOTTOM:
++ {
++#line 217 "ease-handle.vala"
++ clutter_actor_set_x ((ClutterActor*) self, clutter_actor_get_x (selection) + (clutter_actor_get_width (selection) / 2));
++#line 218 "ease-handle.vala"
++ clutter_actor_set_y ((ClutterActor*) self, clutter_actor_get_y (selection) + clutter_actor_get_height (selection));
++#line 219 "ease-handle.vala"
++ break;
++#line 400 "ease-handle.c"
++ }
++ }
++}
++
++
++#line 226 "ease-handle.vala"
++void ease_handle_flip (EaseHandle* self, gboolean f) {
++#line 226 "ease-handle.vala"
++ g_return_if_fail (self != NULL);
++#line 228 "ease-handle.vala"
++ self->priv->flipped = f;
++#line 229 "ease-handle.vala"
++ ease_handle_redraw (self);
++#line 414 "ease-handle.c"
++}
++
++
++#line 232 "ease-handle.vala"
++static void ease_handle_redraw (EaseHandle* self) {
++#line 420 "ease-handle.c"
++ cairo_t* cr;
++#line 232 "ease-handle.vala"
++ g_return_if_fail (self != NULL);
++#line 235 "ease-handle.vala"
++ cr = clutter_cairo_texture_create ((ClutterCairoTexture*) self);
++#line 238 "ease-handle.vala"
++ cairo_arc (cr, (double) (EASE_HANDLE_SIZE / 2), (double) (EASE_HANDLE_SIZE / 2), (double) (EASE_HANDLE_SIZE / 4), (double) 0, 2 * 3.1415);
++#line 241 "ease-handle.vala"
++ if (!self->priv->flipped) {
++#line 241 "ease-handle.vala"
++ cairo_set_source_rgba (cr, (double) 1, (double) 1, (double) 1, (double) 1);
++#line 432 "ease-handle.c"
++ } else {
++#line 242 "ease-handle.vala"
++ cairo_set_source_rgba (cr, (double) 0, (double) 0, (double) 0, (double) 1);
++#line 436 "ease-handle.c"
++ }
++#line 243 "ease-handle.vala"
++ cairo_fill_preserve (cr);
++#line 246 "ease-handle.vala"
++ if (!self->priv->flipped) {
++#line 246 "ease-handle.vala"
++ cairo_set_source_rgba (cr, (double) 0, (double) 0, (double) 0, (double) 1);
++#line 444 "ease-handle.c"
++ } else {
++#line 247 "ease-handle.vala"
++ cairo_set_source_rgba (cr, (double) 1, (double) 1, (double) 1, (double) 1);
++#line 448 "ease-handle.c"
++ }
++#line 248 "ease-handle.vala"
++ cairo_stroke (cr);
++#line 452 "ease-handle.c"
++ _cairo_destroy0 (cr);
++}
++
++
++static void ease_handle_class_init (EaseHandleClass * klass) {
++ ease_handle_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseHandlePrivate));
++ G_OBJECT_CLASS (klass)->finalize = ease_handle_finalize;
++}
++
++
++static void ease_handle_instance_init (EaseHandle * self) {
++ self->priv = EASE_HANDLE_GET_PRIVATE (self);
++ self->priv->flipped = FALSE;
++}
++
++
++static void ease_handle_finalize (GObject* obj) {
++ EaseHandle * self;
++ self = EASE_HANDLE (obj);
++ G_OBJECT_CLASS (ease_handle_parent_class)->finalize (obj);
++}
++
++
++GType ease_handle_get_type (void) {
++ static volatile gsize ease_handle_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_handle_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseHandleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_handle_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseHandle), 0, (GInstanceInitFunc) ease_handle_instance_init, NULL };
++ GType ease_handle_type_id;
++ ease_handle_type_id = g_type_register_static (CLUTTER_TYPE_CAIRO_TEXTURE, "EaseHandle", &g_define_type_info, 0);
++ g_once_init_leave (&ease_handle_type_id__volatile, ease_handle_type_id);
++ }
++ return ease_handle_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-html-exporter.c
index 0000000,0000000..1d8dd11
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-html-exporter.c
@@@ -1,0 -1,0 +1,434 @@@
++/* ease-html-exporter.c generated by valac, the Vala compiler
++ * generated from ease-html-exporter.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++#include <glib/gi18n-lib.h>
++#include <float.h>
++#include <math.h>
++#include <gio/gio.h>
++
++
++#define EASE_TYPE_HTML_EXPORTER (ease_html_exporter_get_type ())
++#define EASE_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporter))
++#define EASE_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++#define EASE_IS_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_HTML_EXPORTER))
++#define EASE_IS_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_HTML_EXPORTER))
++#define EASE_HTML_EXPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++
++typedef struct _EaseHTMLExporter EaseHTMLExporter;
++typedef struct _EaseHTMLExporterClass EaseHTMLExporterClass;
++typedef struct _EaseHTMLExporterPrivate EaseHTMLExporterPrivate;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++
++struct _EaseHTMLExporter {
++ GObject parent_instance;
++ EaseHTMLExporterPrivate * priv;
++};
++
++struct _EaseHTMLExporterClass {
++ GObjectClass parent_class;
++};
++
++struct _EaseHTMLExporterPrivate {
++ GtkDialog* window;
++ GtkProgressBar* progress;
++ char* _path;
++};
++
++
++static gpointer ease_html_exporter_parent_class = NULL;
++
++GType ease_html_exporter_get_type (void) G_GNUC_CONST;
++#define EASE_HTML_EXPORTER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterPrivate))
++enum {
++ EASE_HTML_EXPORTER_DUMMY_PROPERTY,
++ EASE_HTML_EXPORTER_PATH,
++ EASE_HTML_EXPORTER_BASENAME
++};
++#define EASE_HTML_EXPORTER_HEADER "<!DOCTYPE html>\n" \
++"<html>\n" \
++"<head>\n" \
++"\t<title>Presentation</title>\n" \
++"\t\n" \
++"\t<script type=\"text/javascript\">\n" \
++"\t\tvar slide = -1;\n" \
++"\n" \
++"\t\tfunction load() {\n" \
++"\t\t\tadvance();\n" \
++"\t\t}\n" \
++"\n" \
++"\t\tfunction keydown(e) {\n" \
++"\t\t\tvar code = e.keyCode;\n" \
++"\t\t\tif (code == 32 || code == 39 || code == 13 || code == 40 || code" \
++" == 39) {\n" \
++"\t\t\t\tadvance();\n" \
++"\t\t\t}\n" \
++"\t\n" \
++"\t\t\telse if (code == 8 || code == 46 || code == 37 || code == 38) {\n" \
++"\t\t\t\tretreat();\n" \
++"\t\t\t}\n" \
++"\t\t}\n" \
++"\n" \
++"\t\tfunction advance() {\n" \
++"\t\t\tif (document.getElementById(\"slide\" + (slide + 1)) != null) {\n" \
++"\t\t\t\tif (slide >= 0) {\n" \
++"\t\t\t\t\tdocument.getElementById(\"slide\" + slide).style.display = \"" \
++"none\";\n" \
++"\t\t\t\t}\n" \
++"\t\t\t\tslide++;\n" \
++"\t\t\t\tdocument.getElementById(\"slide\" + slide).style.display = \"b" \
++"lock\";\n" \
++"\t\t\t}\n" \
++"\t\t}\n" \
++"\n" \
++"\t\tfunction retreat() {\n" \
++"\t\t\tif (slide > 0) {\n" \
++"\t\t\t\tdocument.getElementById(\"slide\" + slide).style.display = \"n" \
++"one\";\n" \
++"\t\t\t\tslide--;\n" \
++"\t\t\t\tdocument.getElementById(\"slide\" + slide).style.display = \"b" \
++"lock\";\n" \
++"\t\t\t}\n" \
++"\t\t}\n" \
++"\n" \
++"\t\tdocument.onkeydown = keydown;\n" \
++"\t</script>\n" \
++"\t\n" \
++"\t<style>\n" \
++"\t\t.slide {\n" \
++"\t\t\twidth: %ipx;\n" \
++"\t\t\theight: %ipx;\n" \
++"\t\t\tdisplay: none;\n" \
++"\t\t\toverflow: hidden;\n" \
++"\t\t\tposition: relative;\n" \
++"\t\t\tmargin: 20px auto 20px auto;\n" \
++"\t\t}\n" \
++"\t\thtml {\n" \
++"\t\t\tpadding: 0px;\n" \
++"\t\t\tmargin: 0px;\n" \
++"\t\t\tbackground-color: black;\n" \
++"\t\t}\n" \
++"\t</style>\n" \
++"</head>\n" \
++"<body onload=load()>\n"
++EaseHTMLExporter* ease_html_exporter_new (void);
++EaseHTMLExporter* ease_html_exporter_construct (GType object_type);
++static void ease_html_exporter_set_path (EaseHTMLExporter* self, const char* value);
++gboolean ease_html_exporter_request_path (EaseHTMLExporter* self, GtkWindow* win);
++void ease_html_exporter_add_progress (EaseHTMLExporter* self, double amount);
++void ease_html_exporter_finish (EaseHTMLExporter* self);
++const char* ease_html_exporter_get_path (EaseHTMLExporter* self);
++void ease_error_dialog (const char* title, const char* message);
++void ease_html_exporter_copy_file (EaseHTMLExporter* self, const char* end_path, const char* base_path);
++char* ease_html_exporter_get_basename (EaseHTMLExporter* self);
++static void ease_html_exporter_finalize (GObject* obj);
++static void ease_html_exporter_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_html_exporter_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++
++
++
++#line 53 "ease-html-exporter.vala"
++EaseHTMLExporter* ease_html_exporter_construct (GType object_type) {
++#line 91 "ease-html-exporter.c"
++ EaseHTMLExporter * self;
++ GtkProgressBar* _tmp0_;
++#line 53 "ease-html-exporter.vala"
++ self = (EaseHTMLExporter*) g_object_new (object_type, NULL);
++#line 55 "ease-html-exporter.vala"
++ self->priv->progress = (_tmp0_ = g_object_ref_sink ((GtkProgressBar*) gtk_progress_bar_new ()), _g_object_unref0 (self->priv->progress), _tmp0_);
++#line 98 "ease-html-exporter.c"
++ return self;
++}
++
++
++#line 53 "ease-html-exporter.vala"
++EaseHTMLExporter* ease_html_exporter_new (void) {
++#line 53 "ease-html-exporter.vala"
++ return ease_html_exporter_construct (EASE_TYPE_HTML_EXPORTER);
++#line 107 "ease-html-exporter.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 67 "ease-html-exporter.vala"
++gboolean ease_html_exporter_request_path (EaseHTMLExporter* self, GtkWindow* win) {
++#line 118 "ease-html-exporter.c"
++ gboolean result = FALSE;
++ GtkFileChooserDialog* dialog;
++#line 67 "ease-html-exporter.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 67 "ease-html-exporter.vala"
++ g_return_val_if_fail (win != NULL, FALSE);
++#line 69 "ease-html-exporter.vala"
++ dialog = g_object_ref_sink ((GtkFileChooserDialog*) gtk_file_chooser_dialog_new (_ ("Export to HTML"), win, GTK_FILE_CHOOSER_ACTION_SAVE, "gtk-save", GTK_RESPONSE_ACCEPT, "gtk-cancel", GTK_RESPONSE_CANCEL, NULL, NULL));
++#line 78 "ease-html-exporter.vala"
++ if (gtk_dialog_run ((GtkDialog*) dialog) == GTK_RESPONSE_ACCEPT) {
++#line 129 "ease-html-exporter.c"
++ char* _tmp0_;
++ GtkDialog* _tmp1_;
++ GtkVBox* vbox;
++#line 81 "ease-html-exporter.vala"
++ ease_html_exporter_set_path (self, _tmp0_ = gtk_file_chooser_get_filename ((GtkFileChooser*) dialog));
++#line 135 "ease-html-exporter.c"
++ _g_free0 (_tmp0_);
++#line 82 "ease-html-exporter.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 85 "ease-html-exporter.vala"
++ self->priv->window = (_tmp1_ = g_object_ref_sink ((GtkDialog*) gtk_dialog_new ()), _g_object_unref0 (self->priv->window), _tmp1_);
++#line 86 "ease-html-exporter.vala"
++ g_object_set ((GtkWidget*) self->priv->window, "width-request", 400, NULL);
++#line 87 "ease-html-exporter.vala"
++ gtk_window_set_title ((GtkWindow*) self->priv->window, _ ("Exporting as HTML"));
++#line 88 "ease-html-exporter.vala"
++ vbox = _g_object_ref0 (GTK_VBOX (gtk_dialog_get_content_area (self->priv->window)));
++#line 89 "ease-html-exporter.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) self->priv->progress, TRUE, TRUE, (guint) 5);
++#line 90 "ease-html-exporter.vala"
++ gtk_widget_show_all ((GtkWidget*) self->priv->window);
++#line 151 "ease-html-exporter.c"
++ result = TRUE;
++ _g_object_unref0 (vbox);
++ _g_object_unref0 (dialog);
++#line 92 "ease-html-exporter.vala"
++ return result;
++#line 157 "ease-html-exporter.c"
++ } else {
++#line 96 "ease-html-exporter.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 161 "ease-html-exporter.c"
++ result = FALSE;
++ _g_object_unref0 (dialog);
++#line 97 "ease-html-exporter.vala"
++ return result;
++#line 166 "ease-html-exporter.c"
++ }
++ _g_object_unref0 (dialog);
++}
++
++
++#line 106 "ease-html-exporter.vala"
++void ease_html_exporter_add_progress (EaseHTMLExporter* self, double amount) {
++#line 106 "ease-html-exporter.vala"
++ g_return_if_fail (self != NULL);
++#line 108 "ease-html-exporter.vala"
++ gtk_progress_bar_set_fraction (self->priv->progress, gtk_progress_bar_get_fraction (self->priv->progress) + amount);
++#line 178 "ease-html-exporter.c"
++}
++
++
++#line 114 "ease-html-exporter.vala"
++void ease_html_exporter_finish (EaseHTMLExporter* self) {
++#line 114 "ease-html-exporter.vala"
++ g_return_if_fail (self != NULL);
++#line 116 "ease-html-exporter.vala"
++ gtk_widget_hide_all ((GtkWidget*) self->priv->window);
++#line 117 "ease-html-exporter.vala"
++ gtk_object_destroy ((GtkObject*) self->priv->window);
++#line 190 "ease-html-exporter.c"
++}
++
++
++#line 129 "ease-html-exporter.vala"
++void ease_html_exporter_copy_file (EaseHTMLExporter* self, const char* end_path, const char* base_path) {
++#line 196 "ease-html-exporter.c"
++ GError * _inner_error_;
++ char* _tmp0_;
++ GFile* _tmp1_;
++ GFile* source;
++ char* _tmp3_;
++ char* _tmp2_;
++ GFile* _tmp4_;
++ GFile* destination;
++#line 129 "ease-html-exporter.vala"
++ g_return_if_fail (self != NULL);
++#line 129 "ease-html-exporter.vala"
++ g_return_if_fail (end_path != NULL);
++#line 129 "ease-html-exporter.vala"
++ g_return_if_fail (base_path != NULL);
++#line 211 "ease-html-exporter.c"
++ _inner_error_ = NULL;
++#line 131 "ease-html-exporter.vala"
++ source = (_tmp1_ = g_file_new_for_path (_tmp0_ = g_build_path ("/", base_path, end_path, NULL)), _g_free0 (_tmp0_), _tmp1_);
++#line 133 "ease-html-exporter.vala"
++ destination = (_tmp4_ = g_file_new_for_path (_tmp3_ = g_strconcat (_tmp2_ = g_strconcat (self->priv->_path, " ", NULL), end_path, NULL)), _g_free0 (_tmp3_), _g_free0 (_tmp2_), _tmp4_);
++#line 217 "ease-html-exporter.c"
++ {
++ GFile* parent;
++#line 138 "ease-html-exporter.vala"
++ parent = g_file_get_parent (destination);
++#line 139 "ease-html-exporter.vala"
++ if (!g_file_query_exists (parent, NULL)) {
++#line 141 "ease-html-exporter.vala"
++ g_file_make_directory_with_parents (parent, NULL, &_inner_error_);
++#line 226 "ease-html-exporter.c"
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (parent);
++ goto __catch8_g_error;
++ }
++ }
++#line 145 "ease-html-exporter.vala"
++ g_file_copy (source, destination, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, &_inner_error_);
++#line 234 "ease-html-exporter.c"
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (parent);
++ goto __catch8_g_error;
++ }
++ _g_object_unref0 (parent);
++ }
++ goto __finally8;
++ __catch8_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 152 "ease-html-exporter.vala"
++ ease_error_dialog (_ ("Error Copying File"), e->message);
++#line 250 "ease-html-exporter.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally8:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (destination);
++ _g_object_unref0 (source);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++ _g_object_unref0 (destination);
++ _g_object_unref0 (source);
++}
++
++
++const char* ease_html_exporter_get_path (EaseHTMLExporter* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_path;
++#line 36 "ease-html-exporter.vala"
++ return result;
++#line 273 "ease-html-exporter.c"
++}
++
++
++static void ease_html_exporter_set_path (EaseHTMLExporter* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_path = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_path), _tmp0_);
++ g_object_notify ((GObject *) self, "path");
++}
++
++
++char* ease_html_exporter_get_basename (EaseHTMLExporter* self) {
++ char* result;
++ GFile* file;
++ g_return_val_if_fail (self != NULL, NULL);
++#line 45 "ease-html-exporter.vala"
++ file = g_file_new_for_path (self->priv->_path);
++#line 291 "ease-html-exporter.c"
++ result = g_file_get_basename (file);
++ _g_object_unref0 (file);
++#line 46 "ease-html-exporter.vala"
++ return result;
++#line 296 "ease-html-exporter.c"
++}
++
++
++static void ease_html_exporter_class_init (EaseHTMLExporterClass * klass) {
++ ease_html_exporter_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseHTMLExporterPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_html_exporter_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_html_exporter_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_html_exporter_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_HTML_EXPORTER_PATH, g_param_spec_string ("path", "path", "path", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_HTML_EXPORTER_BASENAME, g_param_spec_string ("basename", "basename", "basename", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++}
++
++
++static void ease_html_exporter_instance_init (EaseHTMLExporter * self) {
++ self->priv = EASE_HTML_EXPORTER_GET_PRIVATE (self);
++}
++
++
++static void ease_html_exporter_finalize (GObject* obj) {
++ EaseHTMLExporter * self;
++ self = EASE_HTML_EXPORTER (obj);
++ _g_object_unref0 (self->priv->window);
++ _g_object_unref0 (self->priv->progress);
++ _g_free0 (self->priv->_path);
++ G_OBJECT_CLASS (ease_html_exporter_parent_class)->finalize (obj);
++}
++
++
++GType ease_html_exporter_get_type (void) {
++ static volatile gsize ease_html_exporter_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_html_exporter_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseHTMLExporterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_html_exporter_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseHTMLExporter), 0, (GInstanceInitFunc) ease_html_exporter_instance_init, NULL };
++ GType ease_html_exporter_type_id;
++ ease_html_exporter_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseHTMLExporter", &g_define_type_info, 0);
++ g_once_init_leave (&ease_html_exporter_type_id__volatile, ease_html_exporter_type_id);
++ }
++ return ease_html_exporter_type_id__volatile;
++}
++
++
++static void ease_html_exporter_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseHTMLExporter * self;
++ self = EASE_HTML_EXPORTER (object);
++ switch (property_id) {
++ case EASE_HTML_EXPORTER_PATH:
++ g_value_set_string (value, ease_html_exporter_get_path (self));
++ break;
++ case EASE_HTML_EXPORTER_BASENAME:
++ g_value_take_string (value, ease_html_exporter_get_basename (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_html_exporter_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseHTMLExporter * self;
++ self = EASE_HTML_EXPORTER (object);
++ switch (property_id) {
++ case EASE_HTML_EXPORTER_PATH:
++ ease_html_exporter_set_path (self, g_value_get_string (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
diff --cc ease-core/ease-image-actor.c
index 0000000,0000000..5855806
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-image-actor.c
@@@ -1,0 -1,0 +1,322 @@@
++/* ease-image-actor.c generated by valac, the Vala compiler
++ * generated from ease-image-actor.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <clutter/clutter.h>
++#include <gtk/gtk.h>
++#include <float.h>
++#include <math.h>
++#include <stdlib.h>
++#include <string.h>
++#include <stdio.h>
++#include <glib/gi18n-lib.h>
++
++
++#define EASE_TYPE_ACTOR (ease_actor_get_type ())
++#define EASE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ACTOR, EaseActor))
++#define EASE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ACTOR, EaseActorClass))
++#define EASE_IS_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ACTOR))
++#define EASE_IS_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ACTOR))
++#define EASE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ACTOR, EaseActorClass))
++
++typedef struct _EaseActor EaseActor;
++typedef struct _EaseActorClass EaseActorClass;
++typedef struct _EaseActorPrivate EaseActorPrivate;
++
++#define EASE_TYPE_SCROLLABLE_EMBED (ease_scrollable_embed_get_type ())
++#define EASE_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbed))
++#define EASE_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++#define EASE_IS_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_IS_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_SCROLLABLE_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++
++typedef struct _EaseScrollableEmbed EaseScrollableEmbed;
++typedef struct _EaseScrollableEmbedClass EaseScrollableEmbedClass;
++
++#define EASE_TYPE_EDITOR_EMBED (ease_editor_embed_get_type ())
++#define EASE_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbed))
++#define EASE_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++#define EASE_IS_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_EMBED))
++#define EASE_IS_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_EMBED))
++#define EASE_EDITOR_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++
++typedef struct _EaseEditorEmbed EaseEditorEmbed;
++typedef struct _EaseEditorEmbedClass EaseEditorEmbedClass;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++#define EASE_TYPE_IMAGE_ACTOR (ease_image_actor_get_type ())
++#define EASE_IMAGE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_IMAGE_ACTOR, EaseImageActor))
++#define EASE_IMAGE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_IMAGE_ACTOR, EaseImageActorClass))
++#define EASE_IS_IMAGE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_IMAGE_ACTOR))
++#define EASE_IS_IMAGE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_IMAGE_ACTOR))
++#define EASE_IMAGE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_IMAGE_ACTOR, EaseImageActorClass))
++
++typedef struct _EaseImageActor EaseImageActor;
++typedef struct _EaseImageActorClass EaseImageActorClass;
++typedef struct _EaseImageActorPrivate EaseImageActorPrivate;
++
++#define EASE_TYPE_MEDIA_ELEMENT (ease_media_element_get_type ())
++#define EASE_MEDIA_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElement))
++#define EASE_MEDIA_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElementClass))
++#define EASE_IS_MEDIA_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_MEDIA_ELEMENT))
++#define EASE_IS_MEDIA_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_MEDIA_ELEMENT))
++#define EASE_MEDIA_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElementClass))
++
++typedef struct _EaseMediaElement EaseMediaElement;
++typedef struct _EaseMediaElementClass EaseMediaElementClass;
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++
++#define EASE_TYPE_IMAGE_ELEMENT (ease_image_element_get_type ())
++#define EASE_IMAGE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_IMAGE_ELEMENT, EaseImageElement))
++#define EASE_IMAGE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_IMAGE_ELEMENT, EaseImageElementClass))
++#define EASE_IS_IMAGE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_IMAGE_ELEMENT))
++#define EASE_IS_IMAGE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_IMAGE_ELEMENT))
++#define EASE_IMAGE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_IMAGE_ELEMENT, EaseImageElementClass))
++
++typedef struct _EaseImageElement EaseImageElement;
++typedef struct _EaseImageElementClass EaseImageElementClass;
++typedef struct _Block2Data Block2Data;
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++struct _EaseActor {
++ ClutterGroup parent_instance;
++ EaseActorPrivate * priv;
++ ClutterActor* contents;
++ EaseElement* element;
++ EaseActorContext context;
++ gboolean is_background;
++};
++
++struct _EaseActorClass {
++ ClutterGroupClass parent_class;
++ void (*edit) (EaseActor* self, EaseEditorEmbed* sender);
++ void (*end_edit) (EaseActor* self, EaseEditorEmbed* sender);
++};
++
++struct _EaseImageActor {
++ EaseActor parent_instance;
++ EaseImageActorPrivate * priv;
++};
++
++struct _EaseImageActorClass {
++ EaseActorClass parent_class;
++};
++
++struct _Block2Data {
++ int _ref_count_;
++ EaseImageActor * self;
++ EaseImageElement* e;
++};
++
++
++static gpointer ease_image_actor_parent_class = NULL;
++
++GType ease_actor_get_type (void) G_GNUC_CONST;
++GType ease_scrollable_embed_get_type (void) G_GNUC_CONST;
++GType ease_editor_embed_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++GType ease_image_actor_get_type (void) G_GNUC_CONST;
++enum {
++ EASE_IMAGE_ACTOR_DUMMY_PROPERTY
++};
++EaseActor* ease_actor_construct (GType object_type, EaseElement* e, EaseActorContext c);
++float ease_element_get_width (EaseElement* self);
++float ease_element_get_height (EaseElement* self);
++float ease_element_get_x (EaseElement* self);
++float ease_element_get_y (EaseElement* self);
++GType ease_media_element_get_type (void) G_GNUC_CONST;
++char* ease_media_element_get_full_filename (EaseMediaElement* self);
++static void _lambda22_ (GObject* obj, GParamSpec* spec, Block2Data* _data2_);
++static void __lambda22__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++GType ease_image_element_get_type (void) G_GNUC_CONST;
++static Block2Data* block2_data_ref (Block2Data* _data2_);
++static void block2_data_unref (Block2Data* _data2_);
++EaseImageActor* ease_image_actor_new (EaseImageElement* e, EaseActorContext c);
++EaseImageActor* ease_image_actor_construct (GType object_type, EaseImageElement* e, EaseActorContext c);
++
++
++
++#line 57 "ease-image-actor.vala"
++static void _lambda22_ (GObject* obj, GParamSpec* spec, Block2Data* _data2_) {
++#line 179 "ease-image-actor.c"
++ EaseImageActor * self;
++ char* _tmp0_;
++ ClutterActor* _tmp1_;
++ self = _data2_->self;
++#line 57 "ease-image-actor.vala"
++ g_return_if_fail (obj != NULL);
++#line 57 "ease-image-actor.vala"
++ g_return_if_fail (spec != NULL);
++#line 58 "ease-image-actor.vala"
++ g_object_set ((_tmp1_ = ((EaseActor*) self)->contents, CLUTTER_IS_TEXTURE (_tmp1_) ? ((ClutterTexture*) _tmp1_) : NULL), "filename", _tmp0_ = ease_media_element_get_full_filename ((EaseMediaElement*) _data2_->e), NULL);
++#line 190 "ease-image-actor.c"
++ _g_free0 (_tmp0_);
++}
++
++
++#line 57 "ease-image-actor.vala"
++static void __lambda22__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 197 "ease-image-actor.c"
++ _lambda22_ (_sender, pspec, self);
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++static Block2Data* block2_data_ref (Block2Data* _data2_) {
++ g_atomic_int_inc (&_data2_->_ref_count_);
++ return _data2_;
++}
++
++
++static void block2_data_unref (Block2Data* _data2_) {
++ if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {
++ _g_object_unref0 (_data2_->self);
++ _g_object_unref0 (_data2_->e);
++ g_slice_free (Block2Data, _data2_);
++ }
++}
++
++
++#line 37 "ease-image-actor.vala"
++EaseImageActor* ease_image_actor_construct (GType object_type, EaseImageElement* e, EaseActorContext c) {
++#line 224 "ease-image-actor.c"
++ GError * _inner_error_;
++ EaseImageActor * self;
++ Block2Data* _data2_;
++#line 37 "ease-image-actor.vala"
++ g_return_val_if_fail (e != NULL, NULL);
++#line 230 "ease-image-actor.c"
++ _inner_error_ = NULL;
++ _data2_ = g_slice_new0 (Block2Data);
++ _data2_->_ref_count_ = 1;
++ _data2_->e = _g_object_ref0 (e);
++#line 39 "ease-image-actor.vala"
++ _data2_->self = g_object_ref (self = (EaseImageActor*) ease_actor_construct (object_type, (EaseElement*) _data2_->e, c));
++#line 237 "ease-image-actor.c"
++ {
++ char* _tmp0_;
++ ClutterTexture* _tmp1_;
++ ClutterTexture* _tmp2_;
++ ClutterActor* _tmp3_;
++#line 43 "ease-image-actor.vala"
++ _tmp2_ = (_tmp1_ = g_object_ref_sink (clutter_texture_new_from_file (_tmp0_ = ease_media_element_get_full_filename ((EaseMediaElement*) _data2_->e), &_inner_error_)), _g_free0 (_tmp0_), _tmp1_);
++#line 245 "ease-image-actor.c"
++ if (_inner_error_ != NULL) {
++ goto __catch9_g_error;
++ }
++#line 43 "ease-image-actor.vala"
++ ((EaseActor*) self)->contents = (_tmp3_ = (ClutterActor*) g_object_ref_sink (_tmp2_), _g_object_unref0 (((EaseActor*) self)->contents), _tmp3_);
++#line 251 "ease-image-actor.c"
++ }
++ goto __finally9;
++ __catch9_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 47 "ease-image-actor.vala"
++ fprintf (stdout, _ ("Error loading ImageActor: %s\n"), e->message);
++#line 262 "ease-image-actor.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally9:
++ {
++#line 51 "ease-image-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) self, ((EaseActor*) self)->contents);
++#line 52 "ease-image-actor.vala"
++ clutter_actor_set_width (((EaseActor*) self)->contents, ease_element_get_width ((EaseElement*) _data2_->e));
++#line 53 "ease-image-actor.vala"
++ clutter_actor_set_height (((EaseActor*) self)->contents, ease_element_get_height ((EaseElement*) _data2_->e));
++#line 54 "ease-image-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) self, ease_element_get_x ((EaseElement*) _data2_->e));
++#line 55 "ease-image-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) self, ease_element_get_y ((EaseElement*) _data2_->e));
++#line 57 "ease-image-actor.vala"
++ g_signal_connect_data ((GObject*) _data2_->e, "notify::filename", (GCallback) __lambda22__g_object_notify, block2_data_ref (_data2_), (GClosureNotify) block2_data_unref, 0);
++#line 280 "ease-image-actor.c"
++ }
++ if (_inner_error_ != NULL) {
++ block2_data_unref (_data2_);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++ block2_data_unref (_data2_);
++ return self;
++}
++
++
++#line 37 "ease-image-actor.vala"
++EaseImageActor* ease_image_actor_new (EaseImageElement* e, EaseActorContext c) {
++#line 37 "ease-image-actor.vala"
++ return ease_image_actor_construct (EASE_TYPE_IMAGE_ACTOR, e, c);
++#line 297 "ease-image-actor.c"
++}
++
++
++static void ease_image_actor_class_init (EaseImageActorClass * klass) {
++ ease_image_actor_parent_class = g_type_class_peek_parent (klass);
++}
++
++
++static void ease_image_actor_instance_init (EaseImageActor * self) {
++}
++
++
++GType ease_image_actor_get_type (void) {
++ static volatile gsize ease_image_actor_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_image_actor_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseImageActorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_image_actor_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseImageActor), 0, (GInstanceInitFunc) ease_image_actor_instance_init, NULL };
++ GType ease_image_actor_type_id;
++ ease_image_actor_type_id = g_type_register_static (EASE_TYPE_ACTOR, "EaseImageActor", &g_define_type_info, 0);
++ g_once_init_leave (&ease_image_actor_type_id__volatile, ease_image_actor_type_id);
++ }
++ return ease_image_actor_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-image-element.c
index 0000000,0000000..55027d0
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-image-element.c
@@@ -1,0 -1,0 +1,669 @@@
++/* ease-image-element.c generated by valac, the Vala compiler
++ * generated from ease-image-element.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <json-glib/json-glib.h>
++#include <stdlib.h>
++#include <string.h>
++#include <float.h>
++#include <math.h>
++#include <cairo.h>
++#include <clutter/clutter.h>
++#include <gtk/gtk.h>
++#include <glib/gi18n-lib.h>
++#include <gdk-pixbuf/gdk-pixdata.h>
++#include <gdk/gdk.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++typedef struct _EaseElementPrivate EaseElementPrivate;
++
++#define EASE_TYPE_HTML_EXPORTER (ease_html_exporter_get_type ())
++#define EASE_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporter))
++#define EASE_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++#define EASE_IS_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_HTML_EXPORTER))
++#define EASE_IS_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_HTML_EXPORTER))
++#define EASE_HTML_EXPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++
++typedef struct _EaseHTMLExporter EaseHTMLExporter;
++typedef struct _EaseHTMLExporterClass EaseHTMLExporterClass;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++#define EASE_TYPE_ACTOR (ease_actor_get_type ())
++#define EASE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ACTOR, EaseActor))
++#define EASE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ACTOR, EaseActorClass))
++#define EASE_IS_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ACTOR))
++#define EASE_IS_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ACTOR))
++#define EASE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ACTOR, EaseActorClass))
++
++typedef struct _EaseActor EaseActor;
++typedef struct _EaseActorClass EaseActorClass;
++
++#define EASE_TYPE_MEDIA_ELEMENT (ease_media_element_get_type ())
++#define EASE_MEDIA_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElement))
++#define EASE_MEDIA_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElementClass))
++#define EASE_IS_MEDIA_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_MEDIA_ELEMENT))
++#define EASE_IS_MEDIA_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_MEDIA_ELEMENT))
++#define EASE_MEDIA_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElementClass))
++
++typedef struct _EaseMediaElement EaseMediaElement;
++typedef struct _EaseMediaElementClass EaseMediaElementClass;
++typedef struct _EaseMediaElementPrivate EaseMediaElementPrivate;
++
++#define EASE_TYPE_IMAGE_ELEMENT (ease_image_element_get_type ())
++#define EASE_IMAGE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_IMAGE_ELEMENT, EaseImageElement))
++#define EASE_IMAGE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_IMAGE_ELEMENT, EaseImageElementClass))
++#define EASE_IS_IMAGE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_IMAGE_ELEMENT))
++#define EASE_IS_IMAGE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_IMAGE_ELEMENT))
++#define EASE_IMAGE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_IMAGE_ELEMENT, EaseImageElementClass))
++
++typedef struct _EaseImageElement EaseImageElement;
++typedef struct _EaseImageElementClass EaseImageElementClass;
++typedef struct _EaseImageElementPrivate EaseImageElementPrivate;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++#define EASE_TYPE_IMAGE_ACTOR (ease_image_actor_get_type ())
++#define EASE_IMAGE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_IMAGE_ACTOR, EaseImageActor))
++#define EASE_IMAGE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_IMAGE_ACTOR, EaseImageActorClass))
++#define EASE_IS_IMAGE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_IMAGE_ACTOR))
++#define EASE_IS_IMAGE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_IMAGE_ACTOR))
++#define EASE_IMAGE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_IMAGE_ACTOR, EaseImageActorClass))
++
++typedef struct _EaseImageActor EaseImageActor;
++typedef struct _EaseImageActorClass EaseImageActorClass;
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++
++#define EASE_TYPE_UNDO_ACTION (ease_undo_action_get_type ())
++#define EASE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoAction))
++#define EASE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++#define EASE_IS_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ACTION))
++#define EASE_IS_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ACTION))
++#define EASE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++
++typedef struct _EaseUndoAction EaseUndoAction;
++typedef struct _EaseUndoActionClass EaseUndoActionClass;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++typedef struct _Block3Data Block3Data;
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++struct _EaseElement {
++ GObject parent_instance;
++ EaseElementPrivate * priv;
++};
++
++struct _EaseElementClass {
++ GObjectClass parent_class;
++ JsonObject* (*to_json) (EaseElement* self);
++ void (*to_html) (EaseElement* self, char** html, EaseHTMLExporter* exporter, double amount);
++ void (*write_html) (EaseElement* self, char** html, EaseHTMLExporter* exporter);
++ void (*cairo_render) (EaseElement* self, cairo_t* context, GError** error);
++ EaseActor* (*actor) (EaseElement* self, EaseActorContext c);
++ GtkWidget* (*inspector_widget) (EaseElement* self);
++ GList* (*tool_items) (EaseElement* self);
++ gboolean (*set_color) (EaseElement* self, ClutterColor* c);
++ ClutterColor* (*get_color) (EaseElement* self);
++};
++
++struct _EaseMediaElement {
++ EaseElement parent_instance;
++ EaseMediaElementPrivate * priv;
++};
++
++struct _EaseMediaElementClass {
++ EaseElementClass parent_class;
++};
++
++struct _EaseImageElement {
++ EaseMediaElement parent_instance;
++ EaseImageElementPrivate * priv;
++};
++
++struct _EaseImageElementClass {
++ EaseMediaElementClass parent_class;
++};
++
++struct _EaseImageElementPrivate {
++ GtkWidget* inspector_pane;
++};
++
++struct _Block3Data {
++ int _ref_count_;
++ EaseImageElement * self;
++ GtkFileChooserButton* file_b;
++};
++
++
++static gpointer ease_image_element_parent_class = NULL;
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++GType ease_html_exporter_get_type (void) G_GNUC_CONST;
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++GType ease_actor_get_type (void) G_GNUC_CONST;
++GType ease_media_element_get_type (void) G_GNUC_CONST;
++GType ease_image_element_get_type (void) G_GNUC_CONST;
++#define EASE_IMAGE_ELEMENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_IMAGE_ELEMENT, EaseImageElementPrivate))
++enum {
++ EASE_IMAGE_ELEMENT_DUMMY_PROPERTY
++};
++#define EASE_IMAGE_ELEMENT_UI_FILE_PATH "inspector-element-image.ui"
++EaseMediaElement* ease_media_element_construct (GType object_type);
++EaseImageElement* ease_image_element_new (void);
++EaseImageElement* ease_image_element_construct (GType object_type);
++EaseMediaElement* ease_media_element_construct_from_json (GType object_type, JsonObject* obj);
++EaseImageElement* ease_image_element_new_from_json (JsonObject* obj);
++EaseImageElement* ease_image_element_construct_from_json (GType object_type, JsonObject* obj);
++EaseImageActor* ease_image_actor_new (EaseImageElement* e, EaseActorContext c);
++EaseImageActor* ease_image_actor_construct (GType object_type, EaseImageElement* e, EaseActorContext c);
++GType ease_image_actor_get_type (void) G_GNUC_CONST;
++static EaseActor* ease_image_element_real_actor (EaseElement* base, EaseActorContext c);
++char* ease_data_path (const char* path);
++#define EASE_TEMP_UI_DIR "ui"
++const char* ease_media_element_get_source_filename (EaseMediaElement* self);
++EaseUndoAction* ease_undo_action_new (GObject* obj, const char* prop);
++EaseUndoAction* ease_undo_action_construct (GType object_type, GObject* obj, const char* prop);
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++GType ease_undo_action_get_type (void) G_GNUC_CONST;
++void ease_undo_action_add (EaseUndoAction* self, GObject* obj, const char* prop);
++GType ease_slide_get_type (void) G_GNUC_CONST;
++EaseSlide* ease_element_get_parent (EaseElement* self);
++GType ease_document_get_type (void) G_GNUC_CONST;
++EaseDocument* ease_slide_get_parent (EaseSlide* self);
++char* ease_document_add_media_file (EaseDocument* self, const char* file, GError** error);
++void ease_media_element_set_filename (EaseMediaElement* self, const char* value);
++void ease_media_element_set_source_filename (EaseMediaElement* self, const char* value);
++void ease_error_dialog (const char* title, const char* message);
++static void _lambda23_ (GtkFileChooserButton* button, Block3Data* _data3_);
++static void __lambda23__gtk_file_chooser_button_file_set (GtkFileChooserButton* _sender, gpointer self);
++static void _lambda24_ (GObject* obj, GParamSpec* spec, Block3Data* _data3_);
++static void __lambda24__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static Block3Data* block3_data_ref (Block3Data* _data3_);
++static void block3_data_unref (Block3Data* _data3_);
++static GtkWidget* ease_image_element_real_inspector_widget (EaseElement* base);
++float ease_element_get_x (EaseElement* self);
++float ease_element_get_y (EaseElement* self);
++float ease_element_get_width (EaseElement* self);
++float ease_element_get_height (EaseElement* self);
++char* ease_html_exporter_get_basename (EaseHTMLExporter* self);
++const char* ease_media_element_get_filename (EaseMediaElement* self);
++void ease_html_exporter_copy_file (EaseHTMLExporter* self, const char* end_path, const char* base_path);
++const char* ease_document_get_path (EaseDocument* self);
++static void ease_image_element_real_write_html (EaseElement* base, char** html, EaseHTMLExporter* exporter);
++static void ease_image_element_real_cairo_render (EaseElement* base, cairo_t* context, GError** error);
++static void ease_image_element_finalize (GObject* obj);
++
++
++
++#line 30 "ease-image-element.vala"
++EaseImageElement* ease_image_element_construct (GType object_type) {
++#line 274 "ease-image-element.c"
++ EaseImageElement * self;
++#line 30 "ease-image-element.vala"
++ self = (EaseImageElement*) ease_media_element_construct (object_type);
++#line 278 "ease-image-element.c"
++ return self;
++}
++
++
++#line 30 "ease-image-element.vala"
++EaseImageElement* ease_image_element_new (void) {
++#line 30 "ease-image-element.vala"
++ return ease_image_element_construct (EASE_TYPE_IMAGE_ELEMENT);
++#line 287 "ease-image-element.c"
++}
++
++
++#line 34 "ease-image-element.vala"
++EaseImageElement* ease_image_element_construct_from_json (GType object_type, JsonObject* obj) {
++#line 293 "ease-image-element.c"
++ EaseImageElement * self;
++#line 34 "ease-image-element.vala"
++ g_return_val_if_fail (obj != NULL, NULL);
++#line 36 "ease-image-element.vala"
++ self = (EaseImageElement*) ease_media_element_construct_from_json (object_type, obj);
++#line 299 "ease-image-element.c"
++ return self;
++}
++
++
++#line 34 "ease-image-element.vala"
++EaseImageElement* ease_image_element_new_from_json (JsonObject* obj) {
++#line 34 "ease-image-element.vala"
++ return ease_image_element_construct_from_json (EASE_TYPE_IMAGE_ELEMENT, obj);
++#line 308 "ease-image-element.c"
++}
++
++
++#line 39 "ease-image-element.vala"
++static EaseActor* ease_image_element_real_actor (EaseElement* base, EaseActorContext c) {
++#line 314 "ease-image-element.c"
++ EaseImageElement * self;
++ EaseActor* result = NULL;
++ self = (EaseImageElement*) base;
++ result = (EaseActor*) g_object_ref_sink (ease_image_actor_new (self, c));
++#line 41 "ease-image-element.vala"
++ return result;
++#line 321 "ease-image-element.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 63 "ease-image-element.vala"
++static void _lambda23_ (GtkFileChooserButton* button, Block3Data* _data3_) {
++#line 332 "ease-image-element.c"
++ EaseImageElement * self;
++ GError * _inner_error_;
++ EaseUndoAction* action;
++ self = _data3_->self;
++#line 63 "ease-image-element.vala"
++ g_return_if_fail (button != NULL);
++#line 339 "ease-image-element.c"
++ _inner_error_ = NULL;
++#line 65 "ease-image-element.vala"
++ action = ease_undo_action_new ((GObject*) self, "filename");
++#line 66 "ease-image-element.vala"
++ ease_undo_action_add (action, (GObject*) self, "source-filename");
++#line 345 "ease-image-element.c"
++ {
++ char* _tmp0_;
++ char* _tmp1_;
++ char* _tmp2_;
++ char* _tmp3_;
++ char* _tmp4_;
++#line 69 "ease-image-element.vala"
++ _tmp2_ = (_tmp1_ = ease_document_add_media_file (ease_slide_get_parent (ease_element_get_parent ((EaseElement*) self)), _tmp0_ = gtk_file_chooser_get_filename ((GtkFileChooser*) _data3_->file_b), &_inner_error_), _g_free0 (_tmp0_), _tmp1_);
++#line 354 "ease-image-element.c"
++ if (_inner_error_ != NULL) {
++ goto __catch11_g_error;
++ }
++#line 69 "ease-image-element.vala"
++ ease_media_element_set_filename ((EaseMediaElement*) self, _tmp3_ = _tmp2_);
++#line 360 "ease-image-element.c"
++ _g_free0 (_tmp3_);
++#line 70 "ease-image-element.vala"
++ ease_media_element_set_source_filename ((EaseMediaElement*) self, _tmp4_ = gtk_file_chooser_get_filename ((GtkFileChooser*) _data3_->file_b));
++#line 364 "ease-image-element.c"
++ _g_free0 (_tmp4_);
++#line 71 "ease-image-element.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) action);
++#line 368 "ease-image-element.c"
++ }
++ goto __finally11;
++ __catch11_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 75 "ease-image-element.vala"
++ ease_error_dialog (_ ("Error Inserting Image"), e->message);
++#line 379 "ease-image-element.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally11:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (action);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++ _g_object_unref0 (action);
++}
++
++
++#line 63 "ease-image-element.vala"
++static void __lambda23__gtk_file_chooser_button_file_set (GtkFileChooserButton* _sender, gpointer self) {
++#line 396 "ease-image-element.c"
++ _lambda23_ (_sender, self);
++}
++
++
++#line 79 "ease-image-element.vala"
++static void _lambda24_ (GObject* obj, GParamSpec* spec, Block3Data* _data3_) {
++#line 403 "ease-image-element.c"
++ EaseImageElement * self;
++ self = _data3_->self;
++#line 79 "ease-image-element.vala"
++ g_return_if_fail (obj != NULL);
++#line 79 "ease-image-element.vala"
++ g_return_if_fail (spec != NULL);
++#line 80 "ease-image-element.vala"
++ gtk_file_chooser_set_filename ((GtkFileChooser*) _data3_->file_b, ease_media_element_get_source_filename ((EaseMediaElement*) self));
++#line 412 "ease-image-element.c"
++}
++
++
++#line 79 "ease-image-element.vala"
++static void __lambda24__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 418 "ease-image-element.c"
++ _lambda24_ (_sender, pspec, self);
++}
++
++
++static Block3Data* block3_data_ref (Block3Data* _data3_) {
++ g_atomic_int_inc (&_data3_->_ref_count_);
++ return _data3_;
++}
++
++
++static void block3_data_unref (Block3Data* _data3_) {
++ if (g_atomic_int_dec_and_test (&_data3_->_ref_count_)) {
++ _g_object_unref0 (_data3_->self);
++ _g_object_unref0 (_data3_->file_b);
++ g_slice_free (Block3Data, _data3_);
++ }
++}
++
++
++#line 44 "ease-image-element.vala"
++static GtkWidget* ease_image_element_real_inspector_widget (EaseElement* base) {
++#line 440 "ease-image-element.c"
++ EaseImageElement * self;
++ GtkWidget* result = NULL;
++ GError * _inner_error_;
++ Block3Data* _data3_;
++ GtkBuilder* builder;
++ GObject* _tmp2_;
++ GtkWidget* _tmp4_;
++ GObject* _tmp3_;
++ self = (EaseImageElement*) base;
++ _inner_error_ = NULL;
++ _data3_ = g_slice_new0 (Block3Data);
++ _data3_->_ref_count_ = 1;
++ _data3_->self = g_object_ref (self);
++#line 46 "ease-image-element.vala"
++ if (self->priv->inspector_pane != NULL) {
++#line 456 "ease-image-element.c"
++ result = _g_object_ref0 (self->priv->inspector_pane);
++ block3_data_unref (_data3_);
++#line 46 "ease-image-element.vala"
++ return result;
++#line 461 "ease-image-element.c"
++ }
++#line 48 "ease-image-element.vala"
++ builder = gtk_builder_new ();
++#line 465 "ease-image-element.c"
++ {
++ char* _tmp1_;
++ char* _tmp0_;
++#line 51 "ease-image-element.vala"
++ gtk_builder_add_from_file (builder, _tmp1_ = ease_data_path (_tmp0_ = g_build_filename (EASE_TEMP_UI_DIR, EASE_IMAGE_ELEMENT_UI_FILE_PATH, NULL)), &_inner_error_);
++#line 471 "ease-image-element.c"
++ _g_free0 (_tmp1_);
++ _g_free0 (_tmp0_);
++ if (_inner_error_ != NULL) {
++ goto __catch10_g_error;
++ }
++ }
++ goto __finally10;
++ __catch10_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 54 "ease-image-element.vala"
++ g_error ("ease-image-element.vala:54: Error loading UI: %s", e->message);
++#line 487 "ease-image-element.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally10:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (builder);
++ block3_data_unref (_data3_);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++#line 57 "ease-image-element.vala"
++ gtk_builder_connect_signals (builder, self);
++#line 501 "ease-image-element.c"
++ _data3_->file_b = _g_object_ref0 ((_tmp2_ = gtk_builder_get_object (builder, "file-button"), GTK_IS_FILE_CHOOSER_BUTTON (_tmp2_) ? ((GtkFileChooserButton*) _tmp2_) : NULL));
++#line 61 "ease-image-element.vala"
++ gtk_file_chooser_set_filename ((GtkFileChooser*) _data3_->file_b, ease_media_element_get_source_filename ((EaseMediaElement*) self));
++#line 63 "ease-image-element.vala"
++ g_signal_connect_data (_data3_->file_b, "file-set", (GCallback) __lambda23__gtk_file_chooser_button_file_set, block3_data_ref (_data3_), (GClosureNotify) block3_data_unref, 0);
++#line 79 "ease-image-element.vala"
++ g_signal_connect_data ((GObject*) self, "notify::source-filename", (GCallback) __lambda24__g_object_notify, block3_data_ref (_data3_), (GClosureNotify) block3_data_unref, 0);
++#line 509 "ease-image-element.c"
++ result = _g_object_ref0 (self->priv->inspector_pane = (_tmp4_ = _g_object_ref0 ((_tmp3_ = gtk_builder_get_object (builder, "root"), GTK_IS_WIDGET (_tmp3_) ? ((GtkWidget*) _tmp3_) : NULL)), _g_object_unref0 (self->priv->inspector_pane), _tmp4_));
++ _g_object_unref0 (builder);
++ block3_data_unref (_data3_);
++#line 84 "ease-image-element.vala"
++ return result;
++#line 515 "ease-image-element.c"
++ _g_object_unref0 (builder);
++ block3_data_unref (_data3_);
++}
++
++
++#line 87 "ease-image-element.vala"
++static void ease_image_element_real_write_html (EaseElement* base, char** html, EaseHTMLExporter* exporter) {
++#line 523 "ease-image-element.c"
++ EaseImageElement * self;
++ char* _tmp0_;
++ char* _tmp1_;
++ char* _tmp5_;
++ char* _tmp4_;
++ char* _tmp3_;
++ char* _tmp2_;
++ char* _tmp9_;
++ char* _tmp8_;
++ char* _tmp7_;
++ char* _tmp6_;
++ char* _tmp13_;
++ char* _tmp12_;
++ char* _tmp11_;
++ char* _tmp10_;
++ char* _tmp17_;
++ char* _tmp16_;
++ char* _tmp15_;
++ char* _tmp14_;
++ char* _tmp18_;
++ char* _tmp24_;
++ char* _tmp23_;
++ char* _tmp22_;
++ char* _tmp21_;
++ char* _tmp20_;
++ char* _tmp19_;
++ self = (EaseImageElement*) base;
++#line 87 "ease-image-element.vala"
++ g_return_if_fail (html != NULL);
++#line 87 "ease-image-element.vala"
++ g_return_if_fail (exporter != NULL);
++#line 90 "ease-image-element.vala"
++ *html = (_tmp0_ = g_strconcat (*html, "<img class=\"image element\" ", NULL), _g_free0 (*html), _tmp0_);
++#line 93 "ease-image-element.vala"
++ *html = (_tmp1_ = g_strconcat (*html, "style=\"", NULL), _g_free0 (*html), _tmp1_);
++#line 94 "ease-image-element.vala"
++ *html = (_tmp5_ = g_strconcat (*html, _tmp4_ = g_strconcat (_tmp3_ = g_strconcat ("left:", _tmp2_ = g_strdup_printf ("%g", ease_element_get_x ((EaseElement*) self)), NULL), "px;", NULL), NULL), _g_free0 (*html), _tmp5_);
++#line 561 "ease-image-element.c"
++ _g_free0 (_tmp4_);
++ _g_free0 (_tmp3_);
++ _g_free0 (_tmp2_);
++#line 95 "ease-image-element.vala"
++ *html = (_tmp9_ = g_strconcat (*html, _tmp8_ = g_strconcat (_tmp7_ = g_strconcat (" top:", _tmp6_ = g_strdup_printf ("%g", ease_element_get_y ((EaseElement*) self)), NULL), "px;", NULL), NULL), _g_free0 (*html), _tmp9_);
++#line 567 "ease-image-element.c"
++ _g_free0 (_tmp8_);
++ _g_free0 (_tmp7_);
++ _g_free0 (_tmp6_);
++#line 96 "ease-image-element.vala"
++ *html = (_tmp13_ = g_strconcat (*html, _tmp12_ = g_strconcat (_tmp11_ = g_strconcat (" width:", _tmp10_ = g_strdup_printf ("%g", ease_element_get_width ((EaseElement*) self)), NULL), "px;", NULL), NULL), _g_free0 (*html), _tmp13_);
++#line 573 "ease-image-element.c"
++ _g_free0 (_tmp12_);
++ _g_free0 (_tmp11_);
++ _g_free0 (_tmp10_);
++#line 97 "ease-image-element.vala"
++ *html = (_tmp17_ = g_strconcat (*html, _tmp16_ = g_strconcat (_tmp15_ = g_strconcat (" height:", _tmp14_ = g_strdup_printf ("%g", ease_element_get_height ((EaseElement*) self)), NULL), "px;", NULL), NULL), _g_free0 (*html), _tmp17_);
++#line 579 "ease-image-element.c"
++ _g_free0 (_tmp16_);
++ _g_free0 (_tmp15_);
++ _g_free0 (_tmp14_);
++#line 98 "ease-image-element.vala"
++ *html = (_tmp18_ = g_strconcat (*html, " position: absolute;\" ", NULL), _g_free0 (*html), _tmp18_);
++#line 101 "ease-image-element.vala"
++ *html = (_tmp24_ = g_strconcat (*html, _tmp23_ = g_strconcat (_tmp22_ = g_strconcat (_tmp21_ = g_strconcat (_tmp20_ = g_strconcat ("src=\"", _tmp19_ = ease_html_exporter_get_basename (exporter), NULL), " ", NULL), ease_media_element_get_filename ((EaseMediaElement*) self), NULL), "\" alt=\"Image\" />", NULL), NULL), _g_free0 (*html), _tmp24_);
++#line 587 "ease-image-element.c"
++ _g_free0 (_tmp23_);
++ _g_free0 (_tmp22_);
++ _g_free0 (_tmp21_);
++ _g_free0 (_tmp20_);
++ _g_free0 (_tmp19_);
++#line 105 "ease-image-element.vala"
++ ease_html_exporter_copy_file (exporter, ease_media_element_get_filename ((EaseMediaElement*) self), ease_document_get_path (ease_slide_get_parent (ease_element_get_parent ((EaseElement*) self))));
++#line 595 "ease-image-element.c"
++}
++
++
++#line 111 "ease-image-element.vala"
++static void ease_image_element_real_cairo_render (EaseElement* base, cairo_t* context, GError** error) {
++#line 601 "ease-image-element.c"
++ EaseImageElement * self;
++ GError * _inner_error_;
++ char* filename;
++ GdkPixbuf* pixbuf;
++ self = (EaseImageElement*) base;
++#line 111 "ease-image-element.vala"
++ g_return_if_fail (context != NULL);
++#line 609 "ease-image-element.c"
++ _inner_error_ = NULL;
++#line 113 "ease-image-element.vala"
++ filename = g_build_path ("/", ease_document_get_path (ease_slide_get_parent (ease_element_get_parent ((EaseElement*) self))), ease_media_element_get_filename ((EaseMediaElement*) self), NULL);
++#line 116 "ease-image-element.vala"
++ pixbuf = gdk_pixbuf_new_from_file_at_scale (filename, (gint) ease_element_get_width ((EaseElement*) self), (gint) ease_element_get_height ((EaseElement*) self), FALSE, &_inner_error_);
++#line 615 "ease-image-element.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_free0 (filename);
++ return;
++ }
++#line 121 "ease-image-element.vala"
++ gdk_cairo_set_source_pixbuf (context, pixbuf, (double) ease_element_get_x ((EaseElement*) self), (double) ease_element_get_y ((EaseElement*) self));
++#line 123 "ease-image-element.vala"
++ cairo_rectangle (context, (double) ease_element_get_x ((EaseElement*) self), (double) ease_element_get_y ((EaseElement*) self), (double) ease_element_get_width ((EaseElement*) self), (double) ease_element_get_height ((EaseElement*) self));
++#line 124 "ease-image-element.vala"
++ cairo_fill (context);
++#line 627 "ease-image-element.c"
++ _g_object_unref0 (pixbuf);
++ _g_free0 (filename);
++}
++
++
++static void ease_image_element_class_init (EaseImageElementClass * klass) {
++ ease_image_element_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseImageElementPrivate));
++ EASE_ELEMENT_CLASS (klass)->actor = ease_image_element_real_actor;
++ EASE_ELEMENT_CLASS (klass)->inspector_widget = ease_image_element_real_inspector_widget;
++ EASE_ELEMENT_CLASS (klass)->write_html = ease_image_element_real_write_html;
++ EASE_ELEMENT_CLASS (klass)->cairo_render = ease_image_element_real_cairo_render;
++ G_OBJECT_CLASS (klass)->finalize = ease_image_element_finalize;
++}
++
++
++static void ease_image_element_instance_init (EaseImageElement * self) {
++ self->priv = EASE_IMAGE_ELEMENT_GET_PRIVATE (self);
++}
++
++
++static void ease_image_element_finalize (GObject* obj) {
++ EaseImageElement * self;
++ self = EASE_IMAGE_ELEMENT (obj);
++ _g_object_unref0 (self->priv->inspector_pane);
++ G_OBJECT_CLASS (ease_image_element_parent_class)->finalize (obj);
++}
++
++
++GType ease_image_element_get_type (void) {
++ static volatile gsize ease_image_element_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_image_element_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseImageElementClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_image_element_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseImageElement), 0, (GInstanceInitFunc) ease_image_element_instance_init, NULL };
++ GType ease_image_element_type_id;
++ ease_image_element_type_id = g_type_register_static (EASE_TYPE_MEDIA_ELEMENT, "EaseImageElement", &g_define_type_info, 0);
++ g_once_init_leave (&ease_image_element_type_id__volatile, ease_image_element_type_id);
++ }
++ return ease_image_element_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-image-element.vala
index 0000000,edacf44..edacf44
mode 000000,100644..100644
--- a/ease-core/ease-image-element.vala
+++ b/ease-core/ease-image-element.vala
diff --cc ease-core/ease-inspector-element-pane.c
index 0000000,0000000..cf11aca
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-inspector-element-pane.c
@@@ -1,0 -1,0 +1,315 @@@
++/* ease-inspector-element-pane.c generated by valac, the Vala compiler
++ * generated from ease-inspector-element-pane.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_INSPECTOR_PANE (ease_inspector_pane_get_type ())
++#define EASE_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPane))
++#define EASE_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++#define EASE_IS_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_IS_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_INSPECTOR_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++
++typedef struct _EaseInspectorPane EaseInspectorPane;
++typedef struct _EaseInspectorPaneClass EaseInspectorPaneClass;
++typedef struct _EaseInspectorPanePrivate EaseInspectorPanePrivate;
++
++#define EASE_TYPE_INSPECTOR_ELEMENT_PANE (ease_inspector_element_pane_get_type ())
++#define EASE_INSPECTOR_ELEMENT_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_ELEMENT_PANE, EaseInspectorElementPane))
++#define EASE_INSPECTOR_ELEMENT_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_ELEMENT_PANE, EaseInspectorElementPaneClass))
++#define EASE_IS_INSPECTOR_ELEMENT_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_ELEMENT_PANE))
++#define EASE_IS_INSPECTOR_ELEMENT_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_ELEMENT_PANE))
++#define EASE_INSPECTOR_ELEMENT_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_ELEMENT_PANE, EaseInspectorElementPaneClass))
++
++typedef struct _EaseInspectorElementPane EaseInspectorElementPane;
++typedef struct _EaseInspectorElementPaneClass EaseInspectorElementPaneClass;
++typedef struct _EaseInspectorElementPanePrivate EaseInspectorElementPanePrivate;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseInspectorPane {
++ GtkVBox parent_instance;
++ EaseInspectorPanePrivate * priv;
++};
++
++struct _EaseInspectorPaneClass {
++ GtkVBoxClass parent_class;
++ void (*slide_updated) (EaseInspectorPane* self);
++};
++
++struct _EaseInspectorElementPane {
++ EaseInspectorPane parent_instance;
++ EaseInspectorElementPanePrivate * priv;
++};
++
++struct _EaseInspectorElementPaneClass {
++ EaseInspectorPaneClass parent_class;
++};
++
++struct _EaseInspectorElementPanePrivate {
++ GtkWidget* none;
++ GtkWidget* current;
++};
++
++
++static gpointer ease_inspector_element_pane_parent_class = NULL;
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_inspector_pane_get_type (void) G_GNUC_CONST;
++GType ease_inspector_element_pane_get_type (void) G_GNUC_CONST;
++#define EASE_INSPECTOR_ELEMENT_PANE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_INSPECTOR_ELEMENT_PANE, EaseInspectorElementPanePrivate))
++enum {
++ EASE_INSPECTOR_ELEMENT_PANE_DUMMY_PROPERTY
++};
++#define EASE_INSPECTOR_ELEMENT_PANE_UI_FILE_PATH "inspector-element-none.ui"
++EaseInspectorPane* ease_inspector_pane_construct (GType object_type);
++char* ease_data_path (const char* path);
++#define EASE_TEMP_UI_DIR "ui"
++EaseInspectorElementPane* ease_inspector_element_pane_new (void);
++EaseInspectorElementPane* ease_inspector_element_pane_construct (GType object_type);
++GType ease_element_get_type (void) G_GNUC_CONST;
++GtkWidget* ease_element_inspector_widget (EaseElement* self);
++void ease_inspector_element_pane_on_element_selected (EaseInspectorElementPane* self, EaseElement* selected);
++void ease_inspector_element_pane_on_element_deselected (EaseInspectorElementPane* self, EaseElement* deselected);
++static void ease_inspector_element_pane_real_slide_updated (EaseInspectorPane* base);
++static void ease_inspector_element_pane_finalize (GObject* obj);
++
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 24 "ease-inspector-element-pane.vala"
++EaseInspectorElementPane* ease_inspector_element_pane_construct (GType object_type) {
++#line 132 "ease-inspector-element-pane.c"
++ GError * _inner_error_;
++ EaseInspectorElementPane * self;
++ GtkBuilder* builder;
++ GtkWidget* _tmp3_;
++ GObject* _tmp2_;
++ _inner_error_ = NULL;
++#line 24 "ease-inspector-element-pane.vala"
++ self = (EaseInspectorElementPane*) ease_inspector_pane_construct (object_type);
++#line 27 "ease-inspector-element-pane.vala"
++ builder = gtk_builder_new ();
++#line 143 "ease-inspector-element-pane.c"
++ {
++ char* _tmp1_;
++ char* _tmp0_;
++#line 30 "ease-inspector-element-pane.vala"
++ gtk_builder_add_from_file (builder, _tmp1_ = ease_data_path (_tmp0_ = g_build_filename (EASE_TEMP_UI_DIR, EASE_INSPECTOR_ELEMENT_PANE_UI_FILE_PATH, NULL)), &_inner_error_);
++#line 149 "ease-inspector-element-pane.c"
++ _g_free0 (_tmp1_);
++ _g_free0 (_tmp0_);
++ if (_inner_error_ != NULL) {
++ goto __catch12_g_error;
++ }
++ }
++ goto __finally12;
++ __catch12_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 33 "ease-inspector-element-pane.vala"
++ g_error ("ease-inspector-element-pane.vala:33: Error loading UI: %s", e->message);
++#line 165 "ease-inspector-element-pane.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally12:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (builder);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++#line 34 "ease-inspector-element-pane.vala"
++ self->priv->none = (_tmp3_ = _g_object_ref0 ((_tmp2_ = gtk_builder_get_object (builder, "root"), GTK_IS_WIDGET (_tmp2_) ? ((GtkWidget*) _tmp2_) : NULL)), _g_object_unref0 (self->priv->none), _tmp3_);
++#line 37 "ease-inspector-element-pane.vala"
++ gtk_box_pack_start ((GtkBox*) self, self->priv->none, TRUE, TRUE, (guint) 0);
++#line 180 "ease-inspector-element-pane.c"
++ _g_object_unref0 (builder);
++ return self;
++}
++
++
++#line 24 "ease-inspector-element-pane.vala"
++EaseInspectorElementPane* ease_inspector_element_pane_new (void) {
++#line 24 "ease-inspector-element-pane.vala"
++ return ease_inspector_element_pane_construct (EASE_TYPE_INSPECTOR_ELEMENT_PANE);
++#line 190 "ease-inspector-element-pane.c"
++}
++
++
++#line 40 "ease-inspector-element-pane.vala"
++void ease_inspector_element_pane_on_element_selected (EaseInspectorElementPane* self, EaseElement* selected) {
++#line 196 "ease-inspector-element-pane.c"
++ GtkWidget* _tmp0_;
++#line 40 "ease-inspector-element-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 40 "ease-inspector-element-pane.vala"
++ g_return_if_fail (selected != NULL);
++#line 42 "ease-inspector-element-pane.vala"
++ if (self->priv->current != NULL) {
++#line 44 "ease-inspector-element-pane.vala"
++ if (gtk_widget_get_parent (self->priv->current) == GTK_WIDGET (self)) {
++#line 44 "ease-inspector-element-pane.vala"
++ gtk_container_remove ((GtkContainer*) self, self->priv->current);
++#line 208 "ease-inspector-element-pane.c"
++ }
++ } else {
++#line 46 "ease-inspector-element-pane.vala"
++ if (gtk_widget_get_parent (self->priv->none) == GTK_WIDGET (self)) {
++#line 46 "ease-inspector-element-pane.vala"
++ gtk_container_remove ((GtkContainer*) self, self->priv->none);
++#line 215 "ease-inspector-element-pane.c"
++ }
++ }
++#line 47 "ease-inspector-element-pane.vala"
++ self->priv->current = (_tmp0_ = ease_element_inspector_widget (selected), _g_object_unref0 (self->priv->current), _tmp0_);
++#line 48 "ease-inspector-element-pane.vala"
++ gtk_box_pack_start ((GtkBox*) self, self->priv->current, FALSE, FALSE, (guint) 0);
++#line 222 "ease-inspector-element-pane.c"
++}
++
++
++#line 51 "ease-inspector-element-pane.vala"
++void ease_inspector_element_pane_on_element_deselected (EaseInspectorElementPane* self, EaseElement* deselected) {
++#line 228 "ease-inspector-element-pane.c"
++ GtkWidget* _tmp0_;
++#line 51 "ease-inspector-element-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 53 "ease-inspector-element-pane.vala"
++ if (gtk_widget_get_parent (self->priv->none) != GTK_WIDGET (self)) {
++#line 53 "ease-inspector-element-pane.vala"
++ gtk_box_pack_start ((GtkBox*) self, self->priv->none, TRUE, TRUE, (guint) 0);
++#line 236 "ease-inspector-element-pane.c"
++ }
++#line 54 "ease-inspector-element-pane.vala"
++ gtk_widget_show (self->priv->none);
++#line 55 "ease-inspector-element-pane.vala"
++ if (self->priv->current != NULL) {
++#line 57 "ease-inspector-element-pane.vala"
++ if (gtk_widget_get_parent (self->priv->current) == GTK_WIDGET (self)) {
++#line 57 "ease-inspector-element-pane.vala"
++ gtk_container_remove ((GtkContainer*) self, self->priv->current);
++#line 246 "ease-inspector-element-pane.c"
++ }
++ }
++#line 59 "ease-inspector-element-pane.vala"
++ self->priv->current = (_tmp0_ = NULL, _g_object_unref0 (self->priv->current), _tmp0_);
++#line 251 "ease-inspector-element-pane.c"
++}
++
++
++#line 62 "ease-inspector-element-pane.vala"
++static void ease_inspector_element_pane_real_slide_updated (EaseInspectorPane* base) {
++#line 257 "ease-inspector-element-pane.c"
++ EaseInspectorElementPane * self;
++ self = (EaseInspectorElementPane*) base;
++#line 64 "ease-inspector-element-pane.vala"
++ if (gtk_widget_get_parent (self->priv->none) != GTK_WIDGET (self)) {
++#line 64 "ease-inspector-element-pane.vala"
++ gtk_box_pack_start ((GtkBox*) self, self->priv->none, TRUE, TRUE, (guint) 0);
++#line 264 "ease-inspector-element-pane.c"
++ }
++#line 65 "ease-inspector-element-pane.vala"
++ if (self->priv->current == NULL) {
++#line 65 "ease-inspector-element-pane.vala"
++ return;
++#line 270 "ease-inspector-element-pane.c"
++ }
++#line 66 "ease-inspector-element-pane.vala"
++ if (gtk_widget_get_parent (self->priv->current) == GTK_WIDGET (self)) {
++#line 66 "ease-inspector-element-pane.vala"
++ gtk_container_remove ((GtkContainer*) self, self->priv->current);
++#line 276 "ease-inspector-element-pane.c"
++ }
++}
++
++
++static void ease_inspector_element_pane_class_init (EaseInspectorElementPaneClass * klass) {
++ ease_inspector_element_pane_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseInspectorElementPanePrivate));
++ EASE_INSPECTOR_PANE_CLASS (klass)->slide_updated = ease_inspector_element_pane_real_slide_updated;
++ G_OBJECT_CLASS (klass)->finalize = ease_inspector_element_pane_finalize;
++}
++
++
++static void ease_inspector_element_pane_instance_init (EaseInspectorElementPane * self) {
++ self->priv = EASE_INSPECTOR_ELEMENT_PANE_GET_PRIVATE (self);
++}
++
++
++static void ease_inspector_element_pane_finalize (GObject* obj) {
++ EaseInspectorElementPane * self;
++ self = EASE_INSPECTOR_ELEMENT_PANE (obj);
++ _g_object_unref0 (self->priv->none);
++ _g_object_unref0 (self->priv->current);
++ G_OBJECT_CLASS (ease_inspector_element_pane_parent_class)->finalize (obj);
++}
++
++
++GType ease_inspector_element_pane_get_type (void) {
++ static volatile gsize ease_inspector_element_pane_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_inspector_element_pane_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseInspectorElementPaneClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_inspector_element_pane_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseInspectorElementPane), 0, (GInstanceInitFunc) ease_inspector_element_pane_instance_init, NULL };
++ GType ease_inspector_element_pane_type_id;
++ ease_inspector_element_pane_type_id = g_type_register_static (EASE_TYPE_INSPECTOR_PANE, "EaseInspectorElementPane", &g_define_type_info, 0);
++ g_once_init_leave (&ease_inspector_element_pane_type_id__volatile, ease_inspector_element_pane_type_id);
++ }
++ return ease_inspector_element_pane_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-inspector-element-pane.vala
index 0000000,2e3f7dc..2e3f7dc
mode 000000,100644..100644
--- a/ease-core/ease-inspector-element-pane.vala
+++ b/ease-core/ease-inspector-element-pane.vala
diff --cc ease-core/ease-inspector-pane.c
index 0000000,0000000..60233a0
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-inspector-pane.c
@@@ -1,0 -1,0 +1,245 @@@
++/* ease-inspector-pane.c generated by valac, the Vala compiler
++ * generated from ease-inspector-pane.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_INSPECTOR_PANE (ease_inspector_pane_get_type ())
++#define EASE_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPane))
++#define EASE_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++#define EASE_IS_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_IS_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_INSPECTOR_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++
++typedef struct _EaseInspectorPane EaseInspectorPane;
++typedef struct _EaseInspectorPaneClass EaseInspectorPaneClass;
++typedef struct _EaseInspectorPanePrivate EaseInspectorPanePrivate;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseInspectorPane {
++ GtkVBox parent_instance;
++ EaseInspectorPanePrivate * priv;
++};
++
++struct _EaseInspectorPaneClass {
++ GtkVBoxClass parent_class;
++ void (*slide_updated) (EaseInspectorPane* self);
++};
++
++struct _EaseInspectorPanePrivate {
++ EaseSlide* _slide;
++};
++
++
++static gpointer ease_inspector_pane_parent_class = NULL;
++static EaseUndoSourceIface* ease_inspector_pane_ease_undo_source_parent_iface = NULL;
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_inspector_pane_get_type (void) G_GNUC_CONST;
++GType ease_slide_get_type (void) G_GNUC_CONST;
++#define EASE_INSPECTOR_PANE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPanePrivate))
++enum {
++ EASE_INSPECTOR_PANE_DUMMY_PROPERTY,
++ EASE_INSPECTOR_PANE_SLIDE
++};
++void ease_inspector_pane_slide_updated (EaseInspectorPane* self);
++static void _lambda27_ (GObject* a, GParamSpec* b, EaseInspectorPane* self);
++static void __lambda27__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++EaseInspectorPane* ease_inspector_pane_construct (GType object_type);
++static void ease_inspector_pane_real_slide_updated (EaseInspectorPane* self);
++EaseSlide* ease_inspector_pane_get_slide (EaseInspectorPane* self);
++void ease_inspector_pane_set_slide (EaseInspectorPane* self, EaseSlide* value);
++static void ease_inspector_pane_finalize (GObject* obj);
++static void ease_inspector_pane_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_inspector_pane_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++
++
++
++#line 30 "ease-inspector-pane.vala"
++static void _lambda27_ (GObject* a, GParamSpec* b, EaseInspectorPane* self) {
++#line 30 "ease-inspector-pane.vala"
++ g_return_if_fail (a != NULL);
++#line 30 "ease-inspector-pane.vala"
++ g_return_if_fail (b != NULL);
++#line 30 "ease-inspector-pane.vala"
++ ease_inspector_pane_slide_updated (self);
++#line 108 "ease-inspector-pane.c"
++}
++
++
++#line 30 "ease-inspector-pane.vala"
++static void __lambda27__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 114 "ease-inspector-pane.c"
++ _lambda27_ (_sender, pspec, self);
++}
++
++
++#line 25 "ease-inspector-pane.vala"
++EaseInspectorPane* ease_inspector_pane_construct (GType object_type) {
++#line 121 "ease-inspector-pane.c"
++ EaseInspectorPane * self;
++ self = g_object_newv (object_type, 0, NULL);
++#line 27 "ease-inspector-pane.vala"
++ gtk_box_set_homogeneous ((GtkBox*) self, FALSE);
++#line 28 "ease-inspector-pane.vala"
++ gtk_box_set_spacing ((GtkBox*) self, 0);
++#line 30 "ease-inspector-pane.vala"
++ g_signal_connect_object ((GObject*) self, "notify::slide", (GCallback) __lambda27__g_object_notify, self, 0);
++#line 130 "ease-inspector-pane.c"
++ return self;
++}
++
++
++#line 37 "ease-inspector-pane.vala"
++static void ease_inspector_pane_real_slide_updated (EaseInspectorPane* self) {
++#line 37 "ease-inspector-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 139 "ease-inspector-pane.c"
++}
++
++
++#line 37 "ease-inspector-pane.vala"
++void ease_inspector_pane_slide_updated (EaseInspectorPane* self) {
++#line 37 "ease-inspector-pane.vala"
++ EASE_INSPECTOR_PANE_GET_CLASS (self)->slide_updated (self);
++#line 147 "ease-inspector-pane.c"
++}
++
++
++EaseSlide* ease_inspector_pane_get_slide (EaseInspectorPane* self) {
++ EaseSlide* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_slide;
++#line 23 "ease-inspector-pane.vala"
++ return result;
++#line 157 "ease-inspector-pane.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++void ease_inspector_pane_set_slide (EaseInspectorPane* self, EaseSlide* value) {
++ EaseSlide* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_slide = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_slide), _tmp0_);
++ g_object_notify ((GObject *) self, "slide");
++}
++
++
++static void ease_inspector_pane_class_init (EaseInspectorPaneClass * klass) {
++ ease_inspector_pane_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseInspectorPanePrivate));
++ EASE_INSPECTOR_PANE_CLASS (klass)->slide_updated = ease_inspector_pane_real_slide_updated;
++ G_OBJECT_CLASS (klass)->get_property = ease_inspector_pane_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_inspector_pane_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_inspector_pane_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_INSPECTOR_PANE_SLIDE, g_param_spec_object ("slide", "slide", "slide", EASE_TYPE_SLIDE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++}
++
++
++static void ease_inspector_pane_ease_undo_source_interface_init (EaseUndoSourceIface * iface) {
++ ease_inspector_pane_ease_undo_source_parent_iface = g_type_interface_peek_parent (iface);
++}
++
++
++static void ease_inspector_pane_instance_init (EaseInspectorPane * self) {
++ self->priv = EASE_INSPECTOR_PANE_GET_PRIVATE (self);
++}
++
++
++static void ease_inspector_pane_finalize (GObject* obj) {
++ EaseInspectorPane * self;
++ self = EASE_INSPECTOR_PANE (obj);
++ _g_object_unref0 (self->priv->_slide);
++ G_OBJECT_CLASS (ease_inspector_pane_parent_class)->finalize (obj);
++}
++
++
++GType ease_inspector_pane_get_type (void) {
++ static volatile gsize ease_inspector_pane_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_inspector_pane_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseInspectorPaneClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_inspector_pane_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseInspectorPane), 0, (GInstanceInitFunc) ease_inspector_pane_instance_init, NULL };
++ static const GInterfaceInfo ease_undo_source_info = { (GInterfaceInitFunc) ease_inspector_pane_ease_undo_source_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
++ GType ease_inspector_pane_type_id;
++ ease_inspector_pane_type_id = g_type_register_static (GTK_TYPE_VBOX, "EaseInspectorPane", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
++ g_type_add_interface_static (ease_inspector_pane_type_id, EASE_TYPE_UNDO_SOURCE, &ease_undo_source_info);
++ g_once_init_leave (&ease_inspector_pane_type_id__volatile, ease_inspector_pane_type_id);
++ }
++ return ease_inspector_pane_type_id__volatile;
++}
++
++
++static void ease_inspector_pane_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseInspectorPane * self;
++ self = EASE_INSPECTOR_PANE (object);
++ switch (property_id) {
++ case EASE_INSPECTOR_PANE_SLIDE:
++ g_value_set_object (value, ease_inspector_pane_get_slide (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_inspector_pane_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseInspectorPane * self;
++ self = EASE_INSPECTOR_PANE (object);
++ switch (property_id) {
++ case EASE_INSPECTOR_PANE_SLIDE:
++ ease_inspector_pane_set_slide (self, g_value_get_object (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
diff --cc ease-core/ease-inspector-slide-pane.c
index 0000000,0000000..0a14fa7
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-inspector-slide-pane.c
@@@ -1,0 -1,0 +1,1146 @@@
++/* ease-inspector-slide-pane.c generated by valac, the Vala compiler
++ * generated from ease-inspector-slide-pane.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++#include <glib/gi18n-lib.h>
++#include <gdk/gdk.h>
++#include <float.h>
++#include <math.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_INSPECTOR_PANE (ease_inspector_pane_get_type ())
++#define EASE_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPane))
++#define EASE_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++#define EASE_IS_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_IS_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_INSPECTOR_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++
++typedef struct _EaseInspectorPane EaseInspectorPane;
++typedef struct _EaseInspectorPaneClass EaseInspectorPaneClass;
++typedef struct _EaseInspectorPanePrivate EaseInspectorPanePrivate;
++
++#define EASE_TYPE_INSPECTOR_SLIDE_PANE (ease_inspector_slide_pane_get_type ())
++#define EASE_INSPECTOR_SLIDE_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_SLIDE_PANE, EaseInspectorSlidePane))
++#define EASE_INSPECTOR_SLIDE_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_SLIDE_PANE, EaseInspectorSlidePaneClass))
++#define EASE_IS_INSPECTOR_SLIDE_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_SLIDE_PANE))
++#define EASE_IS_INSPECTOR_SLIDE_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_SLIDE_PANE))
++#define EASE_INSPECTOR_SLIDE_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_SLIDE_PANE, EaseInspectorSlidePaneClass))
++
++typedef struct _EaseInspectorSlidePane EaseInspectorSlidePane;
++typedef struct _EaseInspectorSlidePaneClass EaseInspectorSlidePaneClass;
++typedef struct _EaseInspectorSlidePanePrivate EaseInspectorSlidePanePrivate;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++
++#define EASE_TYPE_BACKGROUND_TYPE (ease_background_type_get_type ())
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++
++#define EASE_TYPE_UNDO_ACTION (ease_undo_action_get_type ())
++#define EASE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoAction))
++#define EASE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++#define EASE_IS_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ACTION))
++#define EASE_IS_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ACTION))
++#define EASE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++
++typedef struct _EaseUndoAction EaseUndoAction;
++typedef struct _EaseUndoActionClass EaseUndoActionClass;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++typedef struct _Block4Data Block4Data;
++
++#define EASE_TYPE_GRADIENT (ease_gradient_get_type ())
++#define EASE_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_GRADIENT, EaseGradient))
++#define EASE_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_GRADIENT, EaseGradientClass))
++#define EASE_IS_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_GRADIENT))
++#define EASE_IS_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_GRADIENT))
++#define EASE_GRADIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_GRADIENT, EaseGradientClass))
++
++typedef struct _EaseGradient EaseGradient;
++typedef struct _EaseGradientClass EaseGradientClass;
++
++#define EASE_TYPE_GRADIENT_TYPE (ease_gradient_type_get_type ())
++
++#define EASE_TYPE_COLOR (ease_color_get_type ())
++#define EASE_COLOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_COLOR, EaseColor))
++#define EASE_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_COLOR, EaseColorClass))
++#define EASE_IS_COLOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_COLOR))
++#define EASE_IS_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_COLOR))
++#define EASE_COLOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_COLOR, EaseColorClass))
++
++typedef struct _EaseColor EaseColor;
++typedef struct _EaseColorClass EaseColorClass;
++typedef struct _Block5Data Block5Data;
++typedef struct _Block6Data Block6Data;
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseInspectorPane {
++ GtkVBox parent_instance;
++ EaseInspectorPanePrivate * priv;
++};
++
++struct _EaseInspectorPaneClass {
++ GtkVBoxClass parent_class;
++ void (*slide_updated) (EaseInspectorPane* self);
++};
++
++struct _EaseInspectorSlidePane {
++ EaseInspectorPane parent_instance;
++ EaseInspectorSlidePanePrivate * priv;
++};
++
++struct _EaseInspectorSlidePaneClass {
++ EaseInspectorPaneClass parent_class;
++};
++
++struct _EaseInspectorSlidePanePrivate {
++ GtkComboBox* background;
++ GtkListStore* store;
++ GtkComboBox* gradient_type;
++ GtkListStore* grad_store;
++ GtkVBox* box_color;
++ GtkVBox* box_gradient;
++ GtkVBox* box_image;
++ GtkHScale* grad_angle;
++ GtkColorButton* bg_color;
++ GtkColorButton* grad_color1;
++ GtkColorButton* grad_color2;
++ GtkFileChooserButton* bg_image;
++ gboolean silence_undo;
++};
++
++typedef enum {
++ EASE_BACKGROUND_TYPE_COLOR,
++ EASE_BACKGROUND_TYPE_GRADIENT,
++ EASE_BACKGROUND_TYPE_IMAGE
++} EaseBackgroundType;
++
++struct _Block4Data {
++ int _ref_count_;
++ EaseInspectorSlidePane * self;
++ EaseSlide* local;
++};
++
++typedef enum {
++ EASE_GRADIENT_TYPE_LINEAR,
++ EASE_GRADIENT_TYPE_LINEAR_MIRRORED,
++ EASE_GRADIENT_TYPE_RADIAL
++} EaseGradientType;
++
++struct _Block5Data {
++ int _ref_count_;
++ EaseInspectorSlidePane * self;
++ EaseSlide* local;
++};
++
++struct _Block6Data {
++ int _ref_count_;
++ EaseInspectorSlidePane * self;
++ EaseSlide* local;
++};
++
++
++static gpointer ease_inspector_slide_pane_parent_class = NULL;
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_inspector_pane_get_type (void) G_GNUC_CONST;
++GType ease_inspector_slide_pane_get_type (void) G_GNUC_CONST;
++#define EASE_INSPECTOR_SLIDE_PANE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_INSPECTOR_SLIDE_PANE, EaseInspectorSlidePanePrivate))
++enum {
++ EASE_INSPECTOR_SLIDE_PANE_DUMMY_PROPERTY
++};
++GtkListStore* ease_gradient_type_list_store (void);
++#define EASE_INSPECTOR_SLIDE_PANE_UI_FILE_PATH "inspector-slide.ui"
++#define EASE_INSPECTOR_SLIDE_PANE_BG_DIALOG_TITLE _ ("Select Background Image")
++EaseInspectorPane* ease_inspector_pane_construct (GType object_type);
++char* ease_data_path (const char* path);
++#define EASE_TEMP_UI_DIR "ui"
++GType ease_background_type_get_type (void) G_GNUC_CONST;
++char* ease_background_type_description (EaseBackgroundType self);
++EaseInspectorSlidePane* ease_inspector_slide_pane_new (void);
++EaseInspectorSlidePane* ease_inspector_slide_pane_construct (GType object_type);
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++GType ease_undo_action_get_type (void) G_GNUC_CONST;
++static void ease_inspector_slide_pane_emit_undo (EaseInspectorSlidePane* self, EaseUndoAction* action);
++GType ease_slide_get_type (void) G_GNUC_CONST;
++EaseSlide* ease_inspector_pane_get_slide (EaseInspectorPane* self);
++EaseUndoAction* ease_undo_action_new (GObject* obj, const char* prop);
++EaseUndoAction* ease_undo_action_construct (GType object_type, GObject* obj, const char* prop);
++const char* ease_slide_get_background_image (EaseSlide* self);
++GtkWindow* ease_widget_window (GtkWidget* widg);
++void ease_slide_set_background_image_source (EaseSlide* self, const char* value);
++GType ease_document_get_type (void) G_GNUC_CONST;
++EaseDocument* ease_slide_get_parent (EaseSlide* self);
++char* ease_document_add_media_file (EaseDocument* self, const char* file, GError** error);
++void ease_slide_set_background_image (EaseSlide* self, const char* value);
++EaseUndoItem* ease_undo_item_apply (EaseUndoItem* self);
++EaseBackgroundType ease_slide_get_background_type (EaseSlide* self);
++static void ease_inspector_slide_pane_display_bg_ui (EaseInspectorSlidePane* self, EaseBackgroundType type);
++static void _lambda62_ (EaseUndoAction* a, Block4Data* _data4_);
++static void __lambda62__ease_undo_item_applied (EaseUndoItem* _sender, EaseUndoAction* sender, gpointer self);
++void ease_undo_action_add (EaseUndoAction* self, GObject* obj, const char* prop);
++static Block4Data* block4_data_ref (Block4Data* _data4_);
++static void block4_data_unref (Block4Data* _data4_);
++void ease_inspector_slide_pane_on_background_changed (GtkWidget* sender, EaseInspectorSlidePane* self);
++GType ease_gradient_get_type (void) G_GNUC_CONST;
++EaseGradient* ease_slide_get_background_gradient (EaseSlide* self);
++GType ease_gradient_type_get_type (void) G_GNUC_CONST;
++void ease_gradient_set_mode (EaseGradient* self, EaseGradientType value);
++void ease_inspector_slide_pane_on_gradient_type_changed (GtkComboBox* sender, EaseInspectorSlidePane* self);
++GType ease_color_get_type (void) G_GNUC_CONST;
++EaseColor* ease_slide_get_background_color (EaseSlide* self);
++EaseUndoAction* ease_color_undo_action (EaseColor* self);
++void ease_color_set_gdk (EaseColor* self, GdkColor* value);
++EaseColor* ease_gradient_get_start (EaseGradient* self);
++EaseColor* ease_gradient_get_end (EaseGradient* self);
++void ease_inspector_slide_pane_on_color_set (GtkColorButton* sender, EaseInspectorSlidePane* self);
++const char* ease_slide_get_background_image_source (EaseSlide* self);
++static void _lambda63_ (EaseUndoAction* a, Block5Data* _data5_);
++static void __lambda63__ease_undo_item_applied (EaseUndoItem* _sender, EaseUndoAction* sender, gpointer self);
++static Block5Data* block5_data_ref (Block5Data* _data5_);
++static void block5_data_unref (Block5Data* _data5_);
++void ease_inspector_slide_pane_on_file_set (GtkFileChooserButton* sender, EaseInspectorSlidePane* self);
++void ease_gradient_flip (EaseGradient* self);
++void ease_color_get_gdk (EaseColor* self, GdkColor* result);
++void ease_inspector_slide_pane_on_reverse_gradient (GtkWidget* sender, EaseInspectorSlidePane* self);
++void ease_gradient_set_angle (EaseGradient* self, double value);
++static void _lambda64_ (EaseUndoAction* a, Block6Data* _data6_);
++static void __lambda64__ease_undo_item_applied (EaseUndoItem* _sender, EaseUndoAction* sender, gpointer self);
++static Block6Data* block6_data_ref (Block6Data* _data6_);
++static void block6_data_unref (Block6Data* _data6_);
++void ease_inspector_slide_pane_on_set_angle (GtkWidget* sender, EaseInspectorSlidePane* self);
++EaseGradientType ease_gradient_get_mode (EaseGradient* self);
++static void ease_inspector_slide_pane_real_slide_updated (EaseInspectorPane* base);
++EaseColor* ease_color_get_white (void);
++void ease_slide_set_background_color (EaseSlide* self, EaseColor* value);
++void ease_slide_set_background_type (EaseSlide* self, EaseBackgroundType value);
++EaseColor* ease_color_get_black (void);
++EaseGradient* ease_gradient_new (EaseColor* start_color, EaseColor* end_color);
++EaseGradient* ease_gradient_construct (GType object_type, EaseColor* start_color, EaseColor* end_color);
++void ease_slide_set_background_gradient (EaseSlide* self, EaseGradient* value);
++double ease_gradient_get_angle (EaseGradient* self);
++static void ease_inspector_slide_pane_finalize (GObject* obj);
++
++extern const EaseBackgroundType EASE_BACKGROUND_TYPE_TYPES[3];
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 42 "ease-inspector-slide-pane.vala"
++EaseInspectorSlidePane* ease_inspector_slide_pane_construct (GType object_type) {
++#line 294 "ease-inspector-slide-pane.c"
++ GError * _inner_error_;
++ EaseInspectorSlidePane * self;
++ GtkBuilder* builder;
++ GObject* _tmp2_;
++ GtkVBox* _tmp4_;
++ GObject* _tmp3_;
++ GtkVBox* _tmp6_;
++ GObject* _tmp5_;
++ GtkVBox* _tmp8_;
++ GObject* _tmp7_;
++ GtkColorButton* _tmp10_;
++ GObject* _tmp9_;
++ GtkColorButton* _tmp12_;
++ GObject* _tmp11_;
++ GtkColorButton* _tmp14_;
++ GObject* _tmp13_;
++ GtkFileChooserButton* _tmp16_;
++ GObject* _tmp15_;
++ GtkComboBox* _tmp18_;
++ GObject* _tmp17_;
++ GtkHScale* _tmp20_;
++ GObject* _tmp19_;
++ GtkComboBox* _tmp22_;
++ GObject* _tmp21_;
++ GtkListStore* _tmp23_;
++ GtkTreeIter iter = {0};
++ GtkCellRendererText* render;
++ _inner_error_ = NULL;
++#line 44 "ease-inspector-slide-pane.vala"
++ self = (EaseInspectorSlidePane*) ease_inspector_pane_construct (object_type);
++#line 47 "ease-inspector-slide-pane.vala"
++ builder = gtk_builder_new ();
++#line 327 "ease-inspector-slide-pane.c"
++ {
++ char* _tmp1_;
++ char* _tmp0_;
++#line 50 "ease-inspector-slide-pane.vala"
++ gtk_builder_add_from_file (builder, _tmp1_ = ease_data_path (_tmp0_ = g_build_filename (EASE_TEMP_UI_DIR, EASE_INSPECTOR_SLIDE_PANE_UI_FILE_PATH, NULL)), &_inner_error_);
++#line 333 "ease-inspector-slide-pane.c"
++ _g_free0 (_tmp1_);
++ _g_free0 (_tmp0_);
++ if (_inner_error_ != NULL) {
++ goto __catch13_g_error;
++ }
++ }
++ goto __finally13;
++ __catch13_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 53 "ease-inspector-slide-pane.vala"
++ g_error ("ease-inspector-slide-pane.vala:53: Error loading UI: %s", e->message);
++#line 349 "ease-inspector-slide-pane.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally13:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (builder);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++#line 56 "ease-inspector-slide-pane.vala"
++ gtk_builder_connect_signals (builder, self);
++#line 59 "ease-inspector-slide-pane.vala"
++ gtk_box_pack_start ((GtkBox*) self, (_tmp2_ = gtk_builder_get_object (builder, "root"), GTK_IS_WIDGET (_tmp2_) ? ((GtkWidget*) _tmp2_) : NULL), TRUE, TRUE, (guint) 0);
++#line 62 "ease-inspector-slide-pane.vala"
++ self->priv->box_color = (_tmp4_ = _g_object_ref0 ((_tmp3_ = gtk_builder_get_object (builder, "vbox-color"), GTK_IS_VBOX (_tmp3_) ? ((GtkVBox*) _tmp3_) : NULL)), _g_object_unref0 (self->priv->box_color), _tmp4_);
++#line 63 "ease-inspector-slide-pane.vala"
++ self->priv->box_gradient = (_tmp6_ = _g_object_ref0 ((_tmp5_ = gtk_builder_get_object (builder, "vbox-gradient"), GTK_IS_VBOX (_tmp5_) ? ((GtkVBox*) _tmp5_) : NULL)), _g_object_unref0 (self->priv->box_gradient), _tmp6_);
++#line 64 "ease-inspector-slide-pane.vala"
++ self->priv->box_image = (_tmp8_ = _g_object_ref0 ((_tmp7_ = gtk_builder_get_object (builder, "vbox-image"), GTK_IS_VBOX (_tmp7_) ? ((GtkVBox*) _tmp7_) : NULL)), _g_object_unref0 (self->priv->box_image), _tmp8_);
++#line 65 "ease-inspector-slide-pane.vala"
++ self->priv->bg_color = (_tmp10_ = _g_object_ref0 ((_tmp9_ = gtk_builder_get_object (builder, "color-color"), GTK_IS_COLOR_BUTTON (_tmp9_) ? ((GtkColorButton*) _tmp9_) : NULL)), _g_object_unref0 (self->priv->bg_color), _tmp10_);
++#line 66 "ease-inspector-slide-pane.vala"
++ self->priv->grad_color1 = (_tmp12_ = _g_object_ref0 ((_tmp11_ = gtk_builder_get_object (builder, "color-startgradient"), GTK_IS_COLOR_BUTTON (_tmp11_) ? ((GtkColorButton*) _tmp11_) : NULL)), _g_object_unref0 (self->priv->grad_color1), _tmp12_);
++#line 68 "ease-inspector-slide-pane.vala"
++ self->priv->grad_color2 = (_tmp14_ = _g_object_ref0 ((_tmp13_ = gtk_builder_get_object (builder, "color-endgradient"), GTK_IS_COLOR_BUTTON (_tmp13_) ? ((GtkColorButton*) _tmp13_) : NULL)), _g_object_unref0 (self->priv->grad_color2), _tmp14_);
++#line 70 "ease-inspector-slide-pane.vala"
++ self->priv->bg_image = (_tmp16_ = _g_object_ref0 ((_tmp15_ = gtk_builder_get_object (builder, "button-image"), GTK_IS_FILE_CHOOSER_BUTTON (_tmp15_) ? ((GtkFileChooserButton*) _tmp15_) : NULL)), _g_object_unref0 (self->priv->bg_image), _tmp16_);
++#line 72 "ease-inspector-slide-pane.vala"
++ self->priv->gradient_type = (_tmp18_ = _g_object_ref0 ((_tmp17_ = gtk_builder_get_object (builder, "combo-gradient"), GTK_IS_COMBO_BOX (_tmp17_) ? ((GtkComboBox*) _tmp17_) : NULL)), _g_object_unref0 (self->priv->gradient_type), _tmp18_);
++#line 74 "ease-inspector-slide-pane.vala"
++ self->priv->grad_angle = (_tmp20_ = _g_object_ref0 ((_tmp19_ = gtk_builder_get_object (builder, "hscale-angle"), GTK_IS_HSCALE (_tmp19_) ? ((GtkHScale*) _tmp19_) : NULL)), _g_object_unref0 (self->priv->grad_angle), _tmp20_);
++#line 77 "ease-inspector-slide-pane.vala"
++ gtk_combo_box_set_model (self->priv->gradient_type, (GtkTreeModel*) self->priv->grad_store);
++#line 80 "ease-inspector-slide-pane.vala"
++ self->priv->background = (_tmp22_ = _g_object_ref0 ((_tmp21_ = gtk_builder_get_object (builder, "combobox-style"), GTK_IS_COMBO_BOX (_tmp21_) ? ((GtkComboBox*) _tmp21_) : NULL)), _g_object_unref0 (self->priv->background), _tmp22_);
++#line 83 "ease-inspector-slide-pane.vala"
++ self->priv->store = (_tmp23_ = gtk_list_store_new (2, G_TYPE_STRING, EASE_TYPE_BACKGROUND_TYPE, NULL), _g_object_unref0 (self->priv->store), _tmp23_);
++#line 388 "ease-inspector-slide-pane.c"
++ {
++ EaseBackgroundType* b_collection;
++ int b_collection_length1;
++ int b_it;
++#line 85 "ease-inspector-slide-pane.vala"
++ b_collection = EASE_BACKGROUND_TYPE_TYPES;
++#line 395 "ease-inspector-slide-pane.c"
++ b_collection_length1 = G_N_ELEMENTS (EASE_BACKGROUND_TYPE_TYPES);
++ for (b_it = 0; b_it < G_N_ELEMENTS (EASE_BACKGROUND_TYPE_TYPES); b_it = b_it + 1) {
++ EaseBackgroundType b;
++ b = b_collection[b_it];
++ {
++ char* _tmp24_;
++#line 87 "ease-inspector-slide-pane.vala"
++ gtk_list_store_append (self->priv->store, &iter);
++#line 88 "ease-inspector-slide-pane.vala"
++ gtk_list_store_set (self->priv->store, &iter, 0, _tmp24_ = ease_background_type_description (b), 1, b, -1);
++#line 406 "ease-inspector-slide-pane.c"
++ _g_free0 (_tmp24_);
++ }
++ }
++ }
++#line 91 "ease-inspector-slide-pane.vala"
++ render = g_object_ref_sink ((GtkCellRendererText*) gtk_cell_renderer_text_new ());
++#line 93 "ease-inspector-slide-pane.vala"
++ gtk_cell_layout_pack_start ((GtkCellLayout*) self->priv->background, (GtkCellRenderer*) render, TRUE);
++#line 94 "ease-inspector-slide-pane.vala"
++ gtk_cell_layout_set_attributes ((GtkCellLayout*) self->priv->background, (GtkCellRenderer*) render, "text", 0, NULL);
++#line 96 "ease-inspector-slide-pane.vala"
++ gtk_combo_box_set_model (self->priv->background, (GtkTreeModel*) self->priv->store);
++#line 419 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (render);
++ _g_object_unref0 (builder);
++ return self;
++}
++
++
++#line 42 "ease-inspector-slide-pane.vala"
++EaseInspectorSlidePane* ease_inspector_slide_pane_new (void) {
++#line 42 "ease-inspector-slide-pane.vala"
++ return ease_inspector_slide_pane_construct (EASE_TYPE_INSPECTOR_SLIDE_PANE);
++#line 430 "ease-inspector-slide-pane.c"
++}
++
++
++#line 99 "ease-inspector-slide-pane.vala"
++static void ease_inspector_slide_pane_emit_undo (EaseInspectorSlidePane* self, EaseUndoAction* action) {
++#line 99 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 99 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (action != NULL);
++#line 101 "ease-inspector-slide-pane.vala"
++ if (!self->priv->silence_undo) {
++#line 101 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) action);
++#line 444 "ease-inspector-slide-pane.c"
++ }
++}
++
++
++#line 156 "ease-inspector-slide-pane.vala"
++static void _lambda62_ (EaseUndoAction* a, Block4Data* _data4_) {
++#line 451 "ease-inspector-slide-pane.c"
++ EaseInspectorSlidePane * self;
++ self = _data4_->self;
++#line 156 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (a != NULL);
++#line 157 "ease-inspector-slide-pane.vala"
++ if (_data4_->local == ease_inspector_pane_get_slide ((EaseInspectorPane*) self)) {
++#line 159 "ease-inspector-slide-pane.vala"
++ self->priv->silence_undo = TRUE;
++#line 160 "ease-inspector-slide-pane.vala"
++ gtk_combo_box_set_active (self->priv->background, (gint) ease_slide_get_background_type (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 161 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_display_bg_ui (self, ease_slide_get_background_type (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 162 "ease-inspector-slide-pane.vala"
++ self->priv->silence_undo = FALSE;
++#line 466 "ease-inspector-slide-pane.c"
++ }
++}
++
++
++#line 156 "ease-inspector-slide-pane.vala"
++static void __lambda62__ease_undo_item_applied (EaseUndoItem* _sender, EaseUndoAction* sender, gpointer self) {
++#line 473 "ease-inspector-slide-pane.c"
++ _lambda62_ (sender, self);
++}
++
++
++static Block4Data* block4_data_ref (Block4Data* _data4_) {
++ g_atomic_int_inc (&_data4_->_ref_count_);
++ return _data4_;
++}
++
++
++static void block4_data_unref (Block4Data* _data4_) {
++ if (g_atomic_int_dec_and_test (&_data4_->_ref_count_)) {
++ _g_object_unref0 (_data4_->self);
++ _g_object_unref0 (_data4_->local);
++ g_slice_free (Block4Data, _data4_);
++ }
++}
++
++
++#line 105 "ease-inspector-slide-pane.vala"
++void ease_inspector_slide_pane_on_background_changed (GtkWidget* sender, EaseInspectorSlidePane* self) {
++#line 495 "ease-inspector-slide-pane.c"
++ GError * _inner_error_;
++ Block4Data* _data4_;
++ GtkTreeIter itr = {0};
++ EaseBackgroundType type = 0;
++ EaseUndoAction* action;
++ gboolean _tmp1_ = FALSE;
++#line 105 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 504 "ease-inspector-slide-pane.c"
++ _inner_error_ = NULL;
++ _data4_ = g_slice_new0 (Block4Data);
++ _data4_->_ref_count_ = 1;
++ _data4_->self = g_object_ref (self);
++#line 108 "ease-inspector-slide-pane.vala"
++ gtk_tree_model_get_iter_first ((GtkTreeModel*) self->priv->store, &itr);
++#line 511 "ease-inspector-slide-pane.c"
++ {
++ gint i;
++#line 111 "ease-inspector-slide-pane.vala"
++ i = 0;
++#line 516 "ease-inspector-slide-pane.c"
++ {
++ gboolean _tmp0_;
++#line 111 "ease-inspector-slide-pane.vala"
++ _tmp0_ = TRUE;
++#line 111 "ease-inspector-slide-pane.vala"
++ while (TRUE) {
++#line 111 "ease-inspector-slide-pane.vala"
++ if (!_tmp0_) {
++#line 111 "ease-inspector-slide-pane.vala"
++ i++;
++#line 527 "ease-inspector-slide-pane.c"
++ }
++#line 111 "ease-inspector-slide-pane.vala"
++ _tmp0_ = FALSE;
++#line 111 "ease-inspector-slide-pane.vala"
++ if (!(i < gtk_combo_box_get_active (self->priv->background))) {
++#line 111 "ease-inspector-slide-pane.vala"
++ break;
++#line 535 "ease-inspector-slide-pane.c"
++ }
++#line 111 "ease-inspector-slide-pane.vala"
++ gtk_tree_model_iter_next ((GtkTreeModel*) self->priv->store, &itr);
++#line 539 "ease-inspector-slide-pane.c"
++ }
++ }
++ }
++#line 115 "ease-inspector-slide-pane.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->priv->store, &itr, 1, &type, -1);
++#line 118 "ease-inspector-slide-pane.vala"
++ action = ease_undo_action_new ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "background-type");
++#line 121 "ease-inspector-slide-pane.vala"
++ if (type == EASE_BACKGROUND_TYPE_IMAGE) {
++#line 121 "ease-inspector-slide-pane.vala"
++ _tmp1_ = ease_slide_get_background_image (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)) == NULL;
++#line 551 "ease-inspector-slide-pane.c"
++ } else {
++#line 121 "ease-inspector-slide-pane.vala"
++ _tmp1_ = FALSE;
++#line 555 "ease-inspector-slide-pane.c"
++ }
++#line 121 "ease-inspector-slide-pane.vala"
++ if (_tmp1_) {
++#line 559 "ease-inspector-slide-pane.c"
++ GtkWindow* _tmp2_;
++ GtkFileChooserDialog* _tmp3_;
++ GtkFileChooserDialog* dialog;
++#line 123 "ease-inspector-slide-pane.vala"
++ dialog = (_tmp3_ = g_object_ref_sink ((GtkFileChooserDialog*) gtk_file_chooser_dialog_new (EASE_INSPECTOR_SLIDE_PANE_BG_DIALOG_TITLE, _tmp2_ = ease_widget_window ((GtkWidget*) self), GTK_FILE_CHOOSER_ACTION_OPEN, "gtk-cancel", GTK_RESPONSE_CANCEL, "gtk-open", GTK_RESPONSE_ACCEPT, NULL)), _g_object_unref0 (_tmp2_), _tmp3_);
++#line 130 "ease-inspector-slide-pane.vala"
++ switch (gtk_dialog_run ((GtkDialog*) dialog)) {
++#line 567 "ease-inspector-slide-pane.c"
++ case GTK_RESPONSE_ACCEPT:
++ {
++ {
++ char* fname;
++ char* i;
++#line 135 "ease-inspector-slide-pane.vala"
++ fname = gtk_file_chooser_get_filename ((GtkFileChooser*) dialog);
++#line 136 "ease-inspector-slide-pane.vala"
++ ease_slide_set_background_image_source (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), fname);
++#line 137 "ease-inspector-slide-pane.vala"
++ i = ease_document_add_media_file (ease_slide_get_parent (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), fname, &_inner_error_);
++#line 579 "ease-inspector-slide-pane.c"
++ if (_inner_error_ != NULL) {
++ _g_free0 (fname);
++ goto __catch14_g_error;
++ }
++#line 138 "ease-inspector-slide-pane.vala"
++ ease_slide_set_background_image (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), i);
++#line 586 "ease-inspector-slide-pane.c"
++ _g_free0 (i);
++ _g_free0 (fname);
++ }
++ goto __finally14;
++ __catch14_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 142 "ease-inspector-slide-pane.vala"
++ g_critical ("ease-inspector-slide-pane.vala:142: Error adding background image: %s", e->message);
++#line 599 "ease-inspector-slide-pane.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally14:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (dialog);
++ _g_object_unref0 (action);
++ block4_data_unref (_data4_);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++#line 145 "ease-inspector-slide-pane.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 146 "ease-inspector-slide-pane.vala"
++ break;
++#line 616 "ease-inspector-slide-pane.c"
++ }
++ case GTK_RESPONSE_CANCEL:
++ {
++ EaseUndoItem* _tmp4_;
++#line 148 "ease-inspector-slide-pane.vala"
++ _tmp4_ = ease_undo_item_apply ((EaseUndoItem*) action);
++#line 623 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (_tmp4_);
++#line 149 "ease-inspector-slide-pane.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 627 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (dialog);
++ _g_object_unref0 (action);
++ block4_data_unref (_data4_);
++#line 150 "ease-inspector-slide-pane.vala"
++ return;
++#line 633 "ease-inspector-slide-pane.c"
++ }
++ }
++ _g_object_unref0 (dialog);
++ }
++ _data4_->local = _g_object_ref0 (ease_inspector_pane_get_slide ((EaseInspectorPane*) self));
++#line 156 "ease-inspector-slide-pane.vala"
++ g_signal_connect_data ((EaseUndoItem*) action, "applied", (GCallback) __lambda62__ease_undo_item_applied, block4_data_ref (_data4_), (GClosureNotify) block4_data_unref, 0);
++#line 167 "ease-inspector-slide-pane.vala"
++ switch (type) {
++#line 643 "ease-inspector-slide-pane.c"
++ case EASE_BACKGROUND_TYPE_COLOR:
++ {
++#line 170 "ease-inspector-slide-pane.vala"
++ ease_undo_action_add (action, (GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "background-color");
++#line 171 "ease-inspector-slide-pane.vala"
++ break;
++#line 650 "ease-inspector-slide-pane.c"
++ }
++ case EASE_BACKGROUND_TYPE_GRADIENT:
++ {
++#line 173 "ease-inspector-slide-pane.vala"
++ ease_undo_action_add (action, (GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "background-gradient");
++#line 174 "ease-inspector-slide-pane.vala"
++ break;
++#line 658 "ease-inspector-slide-pane.c"
++ }
++ case EASE_BACKGROUND_TYPE_IMAGE:
++ {
++#line 176 "ease-inspector-slide-pane.vala"
++ ease_undo_action_add (action, (GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "background-image");
++#line 177 "ease-inspector-slide-pane.vala"
++ break;
++#line 666 "ease-inspector-slide-pane.c"
++ }
++ }
++#line 179 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_emit_undo (self, action);
++#line 182 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_display_bg_ui (self, type);
++#line 673 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (action);
++ block4_data_unref (_data4_);
++}
++
++
++#line 186 "ease-inspector-slide-pane.vala"
++void ease_inspector_slide_pane_on_gradient_type_changed (GtkComboBox* sender, EaseInspectorSlidePane* self) {
++#line 681 "ease-inspector-slide-pane.c"
++ EaseUndoAction* _tmp0_;
++#line 186 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 188 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_emit_undo (self, _tmp0_ = ease_undo_action_new ((GObject*) ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), "mode"));
++#line 687 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (_tmp0_);
++#line 189 "ease-inspector-slide-pane.vala"
++ ease_gradient_set_mode (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), (EaseGradientType) gtk_combo_box_get_active (sender));
++#line 190 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "changed", ease_inspector_pane_get_slide ((EaseInspectorPane*) self));
++#line 693 "ease-inspector-slide-pane.c"
++}
++
++
++#line 194 "ease-inspector-slide-pane.vala"
++void ease_inspector_slide_pane_on_color_set (GtkColorButton* sender, EaseInspectorSlidePane* self) {
++#line 194 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 196 "ease-inspector-slide-pane.vala"
++ if (sender == self->priv->bg_color) {
++#line 703 "ease-inspector-slide-pane.c"
++ EaseUndoAction* _tmp0_;
++ GdkColor _tmp1_ = {0};
++ GdkColor _tmp2_;
++#line 198 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_emit_undo (self, _tmp0_ = ease_color_undo_action (ease_slide_get_background_color (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))));
++#line 709 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (_tmp0_);
++#line 199 "ease-inspector-slide-pane.vala"
++ ease_color_set_gdk (ease_slide_get_background_color (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), (_tmp2_ = (gtk_color_button_get_color (sender, &_tmp1_), _tmp1_), &_tmp2_));
++#line 713 "ease-inspector-slide-pane.c"
++ } else {
++#line 201 "ease-inspector-slide-pane.vala"
++ if (sender == self->priv->grad_color1) {
++#line 717 "ease-inspector-slide-pane.c"
++ EaseUndoAction* _tmp3_;
++ GdkColor _tmp4_ = {0};
++ GdkColor _tmp5_;
++#line 203 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_emit_undo (self, _tmp3_ = ease_color_undo_action (ease_gradient_get_start (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)))));
++#line 723 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (_tmp3_);
++#line 204 "ease-inspector-slide-pane.vala"
++ ease_color_set_gdk (ease_gradient_get_start (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))), (_tmp5_ = (gtk_color_button_get_color (sender, &_tmp4_), _tmp4_), &_tmp5_));
++#line 727 "ease-inspector-slide-pane.c"
++ } else {
++#line 206 "ease-inspector-slide-pane.vala"
++ if (sender == self->priv->grad_color2) {
++#line 731 "ease-inspector-slide-pane.c"
++ EaseUndoAction* _tmp6_;
++ GdkColor _tmp7_ = {0};
++ GdkColor _tmp8_;
++#line 208 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_emit_undo (self, _tmp6_ = ease_color_undo_action (ease_gradient_get_end (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)))));
++#line 737 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (_tmp6_);
++#line 209 "ease-inspector-slide-pane.vala"
++ ease_color_set_gdk (ease_gradient_get_end (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))), (_tmp8_ = (gtk_color_button_get_color (sender, &_tmp7_), _tmp7_), &_tmp8_));
++#line 741 "ease-inspector-slide-pane.c"
++ }
++ }
++ }
++#line 211 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "changed", ease_inspector_pane_get_slide ((EaseInspectorPane*) self));
++#line 747 "ease-inspector-slide-pane.c"
++}
++
++
++#line 224 "ease-inspector-slide-pane.vala"
++static void _lambda63_ (EaseUndoAction* a, Block5Data* _data5_) {
++#line 753 "ease-inspector-slide-pane.c"
++ EaseInspectorSlidePane * self;
++ self = _data5_->self;
++#line 224 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (a != NULL);
++#line 226 "ease-inspector-slide-pane.vala"
++ if (ease_slide_get_background_image_source (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)) != NULL) {
++#line 228 "ease-inspector-slide-pane.vala"
++ gtk_file_chooser_set_filename ((GtkFileChooser*) self->priv->bg_image, ease_slide_get_background_image_source (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 762 "ease-inspector-slide-pane.c"
++ } else {
++#line 232 "ease-inspector-slide-pane.vala"
++ gtk_file_chooser_unselect_all ((GtkFileChooser*) self->priv->bg_image);
++#line 766 "ease-inspector-slide-pane.c"
++ }
++#line 234 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name (_data5_->local, "changed", _data5_->local);
++#line 235 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_display_bg_ui (self, ease_slide_get_background_type (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 772 "ease-inspector-slide-pane.c"
++}
++
++
++#line 224 "ease-inspector-slide-pane.vala"
++static void __lambda63__ease_undo_item_applied (EaseUndoItem* _sender, EaseUndoAction* sender, gpointer self) {
++#line 778 "ease-inspector-slide-pane.c"
++ _lambda63_ (sender, self);
++}
++
++
++static Block5Data* block5_data_ref (Block5Data* _data5_) {
++ g_atomic_int_inc (&_data5_->_ref_count_);
++ return _data5_;
++}
++
++
++static void block5_data_unref (Block5Data* _data5_) {
++ if (g_atomic_int_dec_and_test (&_data5_->_ref_count_)) {
++ _g_object_unref0 (_data5_->self);
++ _g_object_unref0 (_data5_->local);
++ g_slice_free (Block5Data, _data5_);
++ }
++}
++
++
++#line 215 "ease-inspector-slide-pane.vala"
++void ease_inspector_slide_pane_on_file_set (GtkFileChooserButton* sender, EaseInspectorSlidePane* self) {
++#line 800 "ease-inspector-slide-pane.c"
++ GError * _inner_error_;
++ Block5Data* _data5_;
++ EaseUndoAction* action;
++#line 215 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 806 "ease-inspector-slide-pane.c"
++ _inner_error_ = NULL;
++ _data5_ = g_slice_new0 (Block5Data);
++ _data5_->_ref_count_ = 1;
++ _data5_->self = g_object_ref (self);
++#line 217 "ease-inspector-slide-pane.vala"
++ action = ease_undo_action_new ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "background-image");
++#line 218 "ease-inspector-slide-pane.vala"
++ ease_undo_action_add (action, (GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "background-image-source");
++#line 815 "ease-inspector-slide-pane.c"
++ _data5_->local = _g_object_ref0 (ease_inspector_pane_get_slide ((EaseInspectorPane*) self));
++#line 224 "ease-inspector-slide-pane.vala"
++ g_signal_connect_data ((EaseUndoItem*) action, "applied", (GCallback) __lambda63__ease_undo_item_applied, block5_data_ref (_data5_), (GClosureNotify) block5_data_unref, 0);
++#line 819 "ease-inspector-slide-pane.c"
++ {
++ char* _tmp0_;
++ char* _tmp1_;
++ char* _tmp2_;
++ char* i;
++#line 240 "ease-inspector-slide-pane.vala"
++ ease_slide_set_background_image_source (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), _tmp0_ = gtk_file_chooser_get_filename ((GtkFileChooser*) sender));
++#line 827 "ease-inspector-slide-pane.c"
++ _g_free0 (_tmp0_);
++#line 241 "ease-inspector-slide-pane.vala"
++ i = (_tmp2_ = ease_document_add_media_file (ease_slide_get_parent (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), _tmp1_ = gtk_file_chooser_get_filename ((GtkFileChooser*) sender), &_inner_error_), _g_free0 (_tmp1_), _tmp2_);
++#line 831 "ease-inspector-slide-pane.c"
++ if (_inner_error_ != NULL) {
++ goto __catch15_g_error;
++ }
++#line 242 "ease-inspector-slide-pane.vala"
++ ease_slide_set_background_image (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), i);
++#line 837 "ease-inspector-slide-pane.c"
++ _g_free0 (i);
++ }
++ goto __finally15;
++ __catch15_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 246 "ease-inspector-slide-pane.vala"
++ g_critical ("ease-inspector-slide-pane.vala:246: Error adding background image: %s", e->message);
++#line 849 "ease-inspector-slide-pane.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally15:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (action);
++ block5_data_unref (_data5_);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++#line 249 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "changed", ease_inspector_pane_get_slide ((EaseInspectorPane*) self));
++#line 251 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_emit_undo (self, action);
++#line 865 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (action);
++ block5_data_unref (_data5_);
++}
++
++
++#line 255 "ease-inspector-slide-pane.vala"
++void ease_inspector_slide_pane_on_reverse_gradient (GtkWidget* sender, EaseInspectorSlidePane* self) {
++#line 873 "ease-inspector-slide-pane.c"
++ EaseUndoAction* action;
++ GdkColor _tmp1_;
++ GdkColor _tmp0_ = {0};
++ GdkColor _tmp3_;
++ GdkColor _tmp2_ = {0};
++#line 255 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 258 "ease-inspector-slide-pane.vala"
++ action = ease_undo_action_new ((GObject*) ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), "start");
++#line 259 "ease-inspector-slide-pane.vala"
++ ease_undo_action_add (action, (GObject*) ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), "end");
++#line 262 "ease-inspector-slide-pane.vala"
++ ease_gradient_flip (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 265 "ease-inspector-slide-pane.vala"
++ gtk_color_button_set_color (self->priv->grad_color1, (_tmp1_ = (ease_color_get_gdk (ease_gradient_get_start (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))), &_tmp0_), _tmp0_), &_tmp1_));
++#line 266 "ease-inspector-slide-pane.vala"
++ gtk_color_button_set_color (self->priv->grad_color2, (_tmp3_ = (ease_color_get_gdk (ease_gradient_get_end (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))), &_tmp2_), _tmp2_), &_tmp3_));
++#line 267 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "changed", ease_inspector_pane_get_slide ((EaseInspectorPane*) self));
++#line 270 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_emit_undo (self, action);
++#line 895 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (action);
++}
++
++
++#line 284 "ease-inspector-slide-pane.vala"
++static void _lambda64_ (EaseUndoAction* a, Block6Data* _data6_) {
++#line 902 "ease-inspector-slide-pane.c"
++ EaseInspectorSlidePane * self;
++ self = _data6_->self;
++#line 284 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (a != NULL);
++#line 285 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name (_data6_->local, "changed", _data6_->local);
++#line 286 "ease-inspector-slide-pane.vala"
++ if (_data6_->local == ease_inspector_pane_get_slide ((EaseInspectorPane*) self)) {
++#line 286 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_display_bg_ui (self, ease_slide_get_background_type (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 913 "ease-inspector-slide-pane.c"
++ }
++}
++
++
++#line 284 "ease-inspector-slide-pane.vala"
++static void __lambda64__ease_undo_item_applied (EaseUndoItem* _sender, EaseUndoAction* sender, gpointer self) {
++#line 920 "ease-inspector-slide-pane.c"
++ _lambda64_ (sender, self);
++}
++
++
++static Block6Data* block6_data_ref (Block6Data* _data6_) {
++ g_atomic_int_inc (&_data6_->_ref_count_);
++ return _data6_;
++}
++
++
++static void block6_data_unref (Block6Data* _data6_) {
++ if (g_atomic_int_dec_and_test (&_data6_->_ref_count_)) {
++ _g_object_unref0 (_data6_->self);
++ _g_object_unref0 (_data6_->local);
++ g_slice_free (Block6Data, _data6_);
++ }
++}
++
++
++#line 274 "ease-inspector-slide-pane.vala"
++void ease_inspector_slide_pane_on_set_angle (GtkWidget* sender, EaseInspectorSlidePane* self) {
++#line 942 "ease-inspector-slide-pane.c"
++ Block6Data* _data6_;
++ EaseUndoAction* action;
++ GtkWidget* _tmp0_;
++#line 274 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 948 "ease-inspector-slide-pane.c"
++ _data6_ = g_slice_new0 (Block6Data);
++ _data6_->_ref_count_ = 1;
++ _data6_->self = g_object_ref (self);
++#line 276 "ease-inspector-slide-pane.vala"
++ action = ease_undo_action_new ((GObject*) ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), "angle");
++#line 277 "ease-inspector-slide-pane.vala"
++ ease_gradient_set_angle (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), gtk_adjustment_get_value (gtk_range_get_adjustment ((GtkRange*) (_tmp0_ = sender, GTK_IS_HSCALE (_tmp0_) ? ((GtkHScale*) _tmp0_) : NULL))));
++#line 279 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) action);
++#line 281 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "changed", ease_inspector_pane_get_slide ((EaseInspectorPane*) self));
++#line 960 "ease-inspector-slide-pane.c"
++ _data6_->local = _g_object_ref0 (ease_inspector_pane_get_slide ((EaseInspectorPane*) self));
++#line 284 "ease-inspector-slide-pane.vala"
++ g_signal_connect_data ((EaseUndoItem*) action, "applied", (GCallback) __lambda64__ease_undo_item_applied, block6_data_ref (_data6_), (GClosureNotify) block6_data_unref, 0);
++#line 964 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (action);
++ block6_data_unref (_data6_);
++}
++
++
++#line 290 "ease-inspector-slide-pane.vala"
++static void ease_inspector_slide_pane_real_slide_updated (EaseInspectorPane* base) {
++#line 972 "ease-inspector-slide-pane.c"
++ EaseInspectorSlidePane * self;
++ self = (EaseInspectorSlidePane*) base;
++#line 292 "ease-inspector-slide-pane.vala"
++ self->priv->silence_undo = TRUE;
++#line 295 "ease-inspector-slide-pane.vala"
++ gtk_combo_box_set_active (self->priv->background, (gint) ease_slide_get_background_type (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 298 "ease-inspector-slide-pane.vala"
++ if (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)) != NULL) {
++#line 300 "ease-inspector-slide-pane.vala"
++ gtk_combo_box_set_active (self->priv->gradient_type, (gint) ease_gradient_get_mode (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))));
++#line 983 "ease-inspector-slide-pane.c"
++ }
++#line 303 "ease-inspector-slide-pane.vala"
++ ease_inspector_slide_pane_display_bg_ui (self, ease_slide_get_background_type (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 305 "ease-inspector-slide-pane.vala"
++ self->priv->silence_undo = FALSE;
++#line 989 "ease-inspector-slide-pane.c"
++}
++
++
++#line 308 "ease-inspector-slide-pane.vala"
++static void ease_inspector_slide_pane_display_bg_ui (EaseInspectorSlidePane* self, EaseBackgroundType type) {
++#line 308 "ease-inspector-slide-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 310 "ease-inspector-slide-pane.vala"
++ switch (type) {
++#line 999 "ease-inspector-slide-pane.c"
++ case EASE_BACKGROUND_TYPE_COLOR:
++ {
++ GdkColor _tmp2_;
++ GdkColor _tmp1_ = {0};
++#line 313 "ease-inspector-slide-pane.vala"
++ gtk_widget_show_all ((GtkWidget*) self->priv->box_color);
++#line 314 "ease-inspector-slide-pane.vala"
++ gtk_widget_hide_all ((GtkWidget*) self->priv->box_gradient);
++#line 315 "ease-inspector-slide-pane.vala"
++ gtk_widget_hide_all ((GtkWidget*) self->priv->box_image);
++#line 317 "ease-inspector-slide-pane.vala"
++ if (ease_slide_get_background_color (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)) == NULL) {
++#line 1012 "ease-inspector-slide-pane.c"
++ EaseColor* _tmp0_;
++#line 319 "ease-inspector-slide-pane.vala"
++ ease_slide_set_background_color (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), _tmp0_ = ease_color_get_white ());
++#line 1016 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (_tmp0_);
++ }
++#line 321 "ease-inspector-slide-pane.vala"
++ ease_slide_set_background_type (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), EASE_BACKGROUND_TYPE_COLOR);
++#line 323 "ease-inspector-slide-pane.vala"
++ gtk_color_button_set_color (self->priv->bg_color, (_tmp2_ = (ease_color_get_gdk (ease_slide_get_background_color (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), &_tmp1_), _tmp1_), &_tmp2_));
++#line 325 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "changed", ease_inspector_pane_get_slide ((EaseInspectorPane*) self));
++#line 327 "ease-inspector-slide-pane.vala"
++ break;
++#line 1027 "ease-inspector-slide-pane.c"
++ }
++ case EASE_BACKGROUND_TYPE_GRADIENT:
++ {
++ GdkColor _tmp7_;
++ GdkColor _tmp6_ = {0};
++ GdkColor _tmp9_;
++ GdkColor _tmp8_ = {0};
++#line 330 "ease-inspector-slide-pane.vala"
++ gtk_widget_hide_all ((GtkWidget*) self->priv->box_color);
++#line 331 "ease-inspector-slide-pane.vala"
++ gtk_widget_show_all ((GtkWidget*) self->priv->box_gradient);
++#line 332 "ease-inspector-slide-pane.vala"
++ gtk_widget_hide_all ((GtkWidget*) self->priv->box_image);
++#line 334 "ease-inspector-slide-pane.vala"
++ if (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)) == NULL) {
++#line 1043 "ease-inspector-slide-pane.c"
++ EaseGradient* _tmp5_;
++ EaseColor* _tmp4_;
++ EaseColor* _tmp3_;
++#line 336 "ease-inspector-slide-pane.vala"
++ ease_slide_set_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), _tmp5_ = ease_gradient_new (_tmp3_ = ease_color_get_black (), _tmp4_ = ease_color_get_white ()));
++#line 1049 "ease-inspector-slide-pane.c"
++ _g_object_unref0 (_tmp5_);
++ _g_object_unref0 (_tmp4_);
++ _g_object_unref0 (_tmp3_);
++#line 338 "ease-inspector-slide-pane.vala"
++ gtk_combo_box_set_active (self->priv->gradient_type, (gint) ease_gradient_get_mode (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))));
++#line 1055 "ease-inspector-slide-pane.c"
++ }
++#line 340 "ease-inspector-slide-pane.vala"
++ ease_slide_set_background_type (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), EASE_BACKGROUND_TYPE_GRADIENT);
++#line 342 "ease-inspector-slide-pane.vala"
++ gtk_color_button_set_color (self->priv->grad_color1, (_tmp7_ = (ease_color_get_gdk (ease_gradient_get_start (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))), &_tmp6_), _tmp6_), &_tmp7_));
++#line 343 "ease-inspector-slide-pane.vala"
++ gtk_color_button_set_color (self->priv->grad_color2, (_tmp9_ = (ease_color_get_gdk (ease_gradient_get_end (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))), &_tmp8_), _tmp8_), &_tmp9_));
++#line 345 "ease-inspector-slide-pane.vala"
++ gtk_adjustment_set_value (gtk_range_get_adjustment ((GtkRange*) self->priv->grad_angle), ease_gradient_get_angle (ease_slide_get_background_gradient (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))));
++#line 347 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "changed", ease_inspector_pane_get_slide ((EaseInspectorPane*) self));
++#line 349 "ease-inspector-slide-pane.vala"
++ break;
++#line 1069 "ease-inspector-slide-pane.c"
++ }
++ case EASE_BACKGROUND_TYPE_IMAGE:
++ {
++#line 352 "ease-inspector-slide-pane.vala"
++ gtk_widget_hide_all ((GtkWidget*) self->priv->box_color);
++#line 353 "ease-inspector-slide-pane.vala"
++ gtk_widget_hide_all ((GtkWidget*) self->priv->box_gradient);
++#line 354 "ease-inspector-slide-pane.vala"
++ gtk_widget_show_all ((GtkWidget*) self->priv->box_image);
++#line 356 "ease-inspector-slide-pane.vala"
++ ease_slide_set_background_type (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), EASE_BACKGROUND_TYPE_IMAGE);
++#line 357 "ease-inspector-slide-pane.vala"
++ if (ease_slide_get_background_image_source (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)) != NULL) {
++#line 359 "ease-inspector-slide-pane.vala"
++ gtk_file_chooser_set_filename ((GtkFileChooser*) self->priv->bg_image, ease_slide_get_background_image_source (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 1085 "ease-inspector-slide-pane.c"
++ } else {
++#line 363 "ease-inspector-slide-pane.vala"
++ gtk_file_chooser_unselect_all ((GtkFileChooser*) self->priv->bg_image);
++#line 1089 "ease-inspector-slide-pane.c"
++ }
++#line 366 "ease-inspector-slide-pane.vala"
++ g_signal_emit_by_name (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "changed", ease_inspector_pane_get_slide ((EaseInspectorPane*) self));
++#line 368 "ease-inspector-slide-pane.vala"
++ break;
++#line 1095 "ease-inspector-slide-pane.c"
++ }
++ }
++}
++
++
++static void ease_inspector_slide_pane_class_init (EaseInspectorSlidePaneClass * klass) {
++ ease_inspector_slide_pane_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseInspectorSlidePanePrivate));
++ EASE_INSPECTOR_PANE_CLASS (klass)->slide_updated = ease_inspector_slide_pane_real_slide_updated;
++ G_OBJECT_CLASS (klass)->finalize = ease_inspector_slide_pane_finalize;
++}
++
++
++static void ease_inspector_slide_pane_instance_init (EaseInspectorSlidePane * self) {
++ self->priv = EASE_INSPECTOR_SLIDE_PANE_GET_PRIVATE (self);
++ self->priv->grad_store = ease_gradient_type_list_store ();
++}
++
++
++static void ease_inspector_slide_pane_finalize (GObject* obj) {
++ EaseInspectorSlidePane * self;
++ self = EASE_INSPECTOR_SLIDE_PANE (obj);
++ _g_object_unref0 (self->priv->background);
++ _g_object_unref0 (self->priv->store);
++ _g_object_unref0 (self->priv->gradient_type);
++ _g_object_unref0 (self->priv->grad_store);
++ _g_object_unref0 (self->priv->box_color);
++ _g_object_unref0 (self->priv->box_gradient);
++ _g_object_unref0 (self->priv->box_image);
++ _g_object_unref0 (self->priv->grad_angle);
++ _g_object_unref0 (self->priv->bg_color);
++ _g_object_unref0 (self->priv->grad_color1);
++ _g_object_unref0 (self->priv->grad_color2);
++ _g_object_unref0 (self->priv->bg_image);
++ G_OBJECT_CLASS (ease_inspector_slide_pane_parent_class)->finalize (obj);
++}
++
++
++GType ease_inspector_slide_pane_get_type (void) {
++ static volatile gsize ease_inspector_slide_pane_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_inspector_slide_pane_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseInspectorSlidePaneClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_inspector_slide_pane_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseInspectorSlidePane), 0, (GInstanceInitFunc) ease_inspector_slide_pane_instance_init, NULL };
++ GType ease_inspector_slide_pane_type_id;
++ ease_inspector_slide_pane_type_id = g_type_register_static (EASE_TYPE_INSPECTOR_PANE, "EaseInspectorSlidePane", &g_define_type_info, 0);
++ g_once_init_leave (&ease_inspector_slide_pane_type_id__volatile, ease_inspector_slide_pane_type_id);
++ }
++ return ease_inspector_slide_pane_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-inspector-transition-pane.c
index 0000000,0000000..9d5b7b5
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-inspector-transition-pane.c
@@@ -1,0 -1,0 +1,1311 @@@
++/* ease-inspector-transition-pane.c generated by valac, the Vala compiler
++ * generated from ease-inspector-transition-pane.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <clutter-gtk/clutter-gtk.h>
++#include <clutter/clutter.h>
++#include <float.h>
++#include <math.h>
++#include <glib/gi18n-lib.h>
++#include <stdlib.h>
++#include <string.h>
++#include <gdk/gdk.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_INSPECTOR_PANE (ease_inspector_pane_get_type ())
++#define EASE_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPane))
++#define EASE_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++#define EASE_IS_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_IS_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_INSPECTOR_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++
++typedef struct _EaseInspectorPane EaseInspectorPane;
++typedef struct _EaseInspectorPaneClass EaseInspectorPaneClass;
++typedef struct _EaseInspectorPanePrivate EaseInspectorPanePrivate;
++
++#define EASE_TYPE_INSPECTOR_TRANSITION_PANE (ease_inspector_transition_pane_get_type ())
++#define EASE_INSPECTOR_TRANSITION_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_TRANSITION_PANE, EaseInspectorTransitionPane))
++#define EASE_INSPECTOR_TRANSITION_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_TRANSITION_PANE, EaseInspectorTransitionPaneClass))
++#define EASE_IS_INSPECTOR_TRANSITION_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_TRANSITION_PANE))
++#define EASE_IS_INSPECTOR_TRANSITION_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_TRANSITION_PANE))
++#define EASE_INSPECTOR_TRANSITION_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_TRANSITION_PANE, EaseInspectorTransitionPaneClass))
++
++typedef struct _EaseInspectorTransitionPane EaseInspectorTransitionPane;
++typedef struct _EaseInspectorTransitionPaneClass EaseInspectorTransitionPaneClass;
++typedef struct _EaseInspectorTransitionPanePrivate EaseInspectorTransitionPanePrivate;
++
++#define EASE_TYPE_SLIDE_ACTOR (ease_slide_actor_get_type ())
++#define EASE_SLIDE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_ACTOR, EaseSlideActor))
++#define EASE_SLIDE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_ACTOR, EaseSlideActorClass))
++#define EASE_IS_SLIDE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_ACTOR))
++#define EASE_IS_SLIDE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_ACTOR))
++#define EASE_SLIDE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_ACTOR, EaseSlideActorClass))
++
++typedef struct _EaseSlideActor EaseSlideActor;
++typedef struct _EaseSlideActorClass EaseSlideActorClass;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++
++#define EASE_TYPE_UNDO_ACTION (ease_undo_action_get_type ())
++#define EASE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoAction))
++#define EASE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++#define EASE_IS_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ACTION))
++#define EASE_IS_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ACTION))
++#define EASE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++
++typedef struct _EaseUndoAction EaseUndoAction;
++typedef struct _EaseUndoActionClass EaseUndoActionClass;
++
++#define EASE_TYPE_TRANSITION (ease_transition_get_type ())
++
++#define EASE_TYPE_TRANSITION_VARIANT (ease_transition_variant_get_type ())
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseInspectorPane {
++ GtkVBox parent_instance;
++ EaseInspectorPanePrivate * priv;
++};
++
++struct _EaseInspectorPaneClass {
++ GtkVBoxClass parent_class;
++ void (*slide_updated) (EaseInspectorPane* self);
++};
++
++struct _EaseInspectorTransitionPane {
++ EaseInspectorPane parent_instance;
++ EaseInspectorTransitionPanePrivate * priv;
++ GtkComboBox* effect;
++ GtkComboBox* variant;
++};
++
++struct _EaseInspectorTransitionPaneClass {
++ EaseInspectorPaneClass parent_class;
++};
++
++struct _EaseInspectorTransitionPanePrivate {
++ GtkSpinButton* transition_time;
++ GtkAlignment* variant_align;
++ GtkComboBox* start_transition;
++ GtkSpinButton* delay;
++ GtkClutterEmbed* preview;
++ ClutterGroup* preview_group;
++ GtkAlignment* preview_align;
++ EaseSlideActor* current_slide;
++ EaseSlideActor* new_slide;
++ ClutterTimeline* preview_alarm;
++ EaseSlide* old_slide;
++ gboolean silence_undo;
++};
++
++typedef enum {
++ EASE_TRANSITION_NONE,
++ EASE_TRANSITION_FADE,
++ EASE_TRANSITION_SLIDE,
++ EASE_TRANSITION_DROP,
++ EASE_TRANSITION_PIVOT,
++ EASE_TRANSITION_FLIP,
++ EASE_TRANSITION_REVOLVING_DOOR,
++ EASE_TRANSITION_REVEAL,
++ EASE_TRANSITION_FALL,
++ EASE_TRANSITION_SLATS,
++ EASE_TRANSITION_OPEN_DOOR,
++ EASE_TRANSITION_EXPLODE,
++ EASE_TRANSITION_ASSEMBLE,
++ EASE_TRANSITION_ZOOM,
++ EASE_TRANSITION_PANEL,
++ EASE_TRANSITION_SPIN_CONTENTS,
++ EASE_TRANSITION_SPRING_CONTENTS,
++ EASE_TRANSITION_SWING_CONTENTS,
++ EASE_TRANSITION_SLIDE_CONTENTS,
++ EASE_TRANSITION_ZOOM_CONTENTS
++} EaseTransition;
++
++typedef enum {
++ EASE_TRANSITION_VARIANT_LEFT,
++ EASE_TRANSITION_VARIANT_RIGHT,
++ EASE_TRANSITION_VARIANT_UP,
++ EASE_TRANSITION_VARIANT_DOWN,
++ EASE_TRANSITION_VARIANT_BOTTOM,
++ EASE_TRANSITION_VARIANT_TOP,
++ EASE_TRANSITION_VARIANT_CENTER,
++ EASE_TRANSITION_VARIANT_TOP_LEFT,
++ EASE_TRANSITION_VARIANT_TOP_RIGHT,
++ EASE_TRANSITION_VARIANT_BOTTOM_LEFT,
++ EASE_TRANSITION_VARIANT_BOTTOM_RIGHT,
++ EASE_TRANSITION_VARIANT_TOP_TO_BOTTOM,
++ EASE_TRANSITION_VARIANT_BOTTOM_TO_TOP,
++ EASE_TRANSITION_VARIANT_LEFT_TO_RIGHT,
++ EASE_TRANSITION_VARIANT_RIGHT_TO_LEFT,
++ EASE_TRANSITION_VARIANT_IN,
++ EASE_TRANSITION_VARIANT_OUT
++} EaseTransitionVariant;
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++
++static gpointer ease_inspector_transition_pane_parent_class = NULL;
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_inspector_pane_get_type (void) G_GNUC_CONST;
++GType ease_inspector_transition_pane_get_type (void) G_GNUC_CONST;
++GType ease_slide_actor_get_type (void) G_GNUC_CONST;
++GType ease_slide_get_type (void) G_GNUC_CONST;
++#define EASE_INSPECTOR_TRANSITION_PANE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_INSPECTOR_TRANSITION_PANE, EaseInspectorTransitionPanePrivate))
++enum {
++ EASE_INSPECTOR_TRANSITION_PANE_DUMMY_PROPERTY
++};
++#define EASE_INSPECTOR_TRANSITION_PANE_PREVIEW_HEIGHT 150
++#define EASE_INSPECTOR_TRANSITION_PANE_PREVIEW_DELAY ((guint) 500)
++EaseInspectorPane* ease_inspector_pane_construct (GType object_type);
++GtkListStore* ease_transition_model (void);
++EaseSlide* ease_inspector_pane_get_slide (EaseInspectorPane* self);
++EaseUndoAction* ease_undo_action_new (GObject* obj, const char* prop);
++EaseUndoAction* ease_undo_action_construct (GType object_type, GObject* obj, const char* prop);
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++GType ease_undo_action_get_type (void) G_GNUC_CONST;
++void ease_undo_action_add (EaseUndoAction* self, GObject* obj, const char* prop);
++GType ease_transition_get_type (void) G_GNUC_CONST;
++void ease_slide_set_transition (EaseSlide* self, EaseTransition value);
++EaseTransition ease_slide_get_transition (EaseSlide* self);
++GtkListStore* ease_transition_variant_model (EaseTransition self);
++GType ease_transition_variant_get_type (void) G_GNUC_CONST;
++EaseTransitionVariant ease_slide_get_variant (EaseSlide* self);
++static void _lambda52_ (GtkComboBox* sender, EaseInspectorTransitionPane* self);
++static void __lambda52__gtk_combo_box_changed (GtkComboBox* _sender, gpointer self);
++void ease_slide_set_variant (EaseSlide* self, EaseTransitionVariant value);
++static void _lambda53_ (GtkComboBox* sender, EaseInspectorTransitionPane* self);
++static void __lambda53__gtk_combo_box_changed (GtkComboBox* _sender, gpointer self);
++void ease_slide_set_automatically_advance (EaseSlide* self, gboolean value);
++static void _lambda54_ (EaseInspectorTransitionPane* self);
++static void __lambda54__gtk_combo_box_changed (GtkComboBox* _sender, gpointer self);
++void ease_slide_set_transition_time (EaseSlide* self, double value);
++static void _lambda55_ (EaseInspectorTransitionPane* self);
++static void __lambda55__gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self);
++void ease_slide_set_advance_delay (EaseSlide* self, double value);
++static void _lambda56_ (EaseInspectorTransitionPane* self);
++static void __lambda56__gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self);
++GType ease_document_get_type (void) G_GNUC_CONST;
++EaseDocument* ease_slide_get_parent (EaseSlide* self);
++gint ease_document_get_width (EaseDocument* self);
++gint ease_document_get_height (EaseDocument* self);
++static void _lambda57_ (ClutterActorBox* box, ClutterAllocationFlags flags, EaseInspectorTransitionPane* self);
++static void __lambda57__clutter_actor_allocation_changed (ClutterActor* _sender, ClutterActorBox* p0, ClutterAllocationFlags p1, gpointer self);
++float ease_document_get_aspect (EaseDocument* self);
++static void _lambda58_ (GtkWidget* widget, GdkRectangle* allocation, EaseInspectorTransitionPane* self);
++static void __lambda58__gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self);
++EaseInspectorTransitionPane* ease_inspector_transition_pane_new (void);
++EaseInspectorTransitionPane* ease_inspector_transition_pane_construct (GType object_type);
++void ease_slide_actor_reset (EaseSlideActor* self, ClutterGroup* container);
++static void ease_inspector_transition_pane_animate_preview_start (EaseInspectorTransitionPane* self);
++static void _lambda59_ (EaseInspectorTransitionPane* self);
++static void __lambda59__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++static void ease_inspector_transition_pane_animate_preview (EaseInspectorTransitionPane* self);
++guint ease_slide_get_transition_msecs (EaseSlide* self);
++void ease_slide_actor_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container);
++static void ease_inspector_transition_pane_animate_preview_delay (EaseInspectorTransitionPane* self);
++static void _lambda60_ (EaseInspectorTransitionPane* self);
++static void __lambda60__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++static void _lambda61_ (EaseInspectorTransitionPane* self);
++static void __lambda61__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++double ease_slide_get_transition_time (EaseSlide* self);
++double ease_slide_get_advance_delay (EaseSlide* self);
++gboolean ease_slide_get_automatically_advance (EaseSlide* self);
++static void ease_inspector_transition_pane_on_slide_notify (EaseInspectorTransitionPane* self, GObject* obj, GParamSpec* spec);
++static void _ease_inspector_transition_pane_on_slide_notify_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++EaseSlideActor* ease_slide_actor_new_from_slide (EaseDocument* document, EaseSlide* s, gboolean clip, EaseActorContext ctx);
++EaseSlideActor* ease_slide_actor_construct_from_slide (GType object_type, EaseDocument* document, EaseSlide* s, gboolean clip, EaseActorContext ctx);
++gboolean ease_document_has_next_slide (EaseDocument* self, EaseSlide* slide);
++EaseSlide* ease_slide_get_next (EaseSlide* self);
++EaseSlideActor* ease_slide_actor_new_blank (EaseDocument* document, ClutterColor* color);
++EaseSlideActor* ease_slide_actor_construct_blank (GType object_type, EaseDocument* document, ClutterColor* color);
++static void ease_inspector_transition_pane_real_slide_updated (EaseInspectorPane* base);
++static void ease_inspector_transition_pane_finalize (GObject* obj);
++
++
++
++#line 140 "ease-inspector-transition-pane.vala"
++static void _lambda52_ (GtkComboBox* sender, EaseInspectorTransitionPane* self) {
++#line 295 "ease-inspector-transition-pane.c"
++ EaseUndoAction* action;
++ gboolean already_silenced;
++ GtkTreeIter itr = {0};
++ GtkListStore* _tmp0_;
++#line 140 "ease-inspector-transition-pane.vala"
++ g_return_if_fail (sender != NULL);
++#line 142 "ease-inspector-transition-pane.vala"
++ action = ease_undo_action_new ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "transition");
++#line 143 "ease-inspector-transition-pane.vala"
++ ease_undo_action_add (action, (GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "variant");
++#line 144 "ease-inspector-transition-pane.vala"
++ if (!self->priv->silence_undo) {
++#line 144 "ease-inspector-transition-pane.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) action);
++#line 310 "ease-inspector-transition-pane.c"
++ }
++#line 146 "ease-inspector-transition-pane.vala"
++ already_silenced = self->priv->silence_undo;
++#line 147 "ease-inspector-transition-pane.vala"
++ self->priv->silence_undo = TRUE;
++#line 151 "ease-inspector-transition-pane.vala"
++ if (gtk_combo_box_get_active_iter (sender, &itr)) {
++#line 318 "ease-inspector-transition-pane.c"
++ EaseTransition transition = 0;
++#line 154 "ease-inspector-transition-pane.vala"
++ gtk_tree_model_get (gtk_combo_box_get_model (sender), &itr, 1, &transition, -1);
++#line 155 "ease-inspector-transition-pane.vala"
++ ease_slide_set_transition (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), transition);
++#line 324 "ease-inspector-transition-pane.c"
++ } else {
++#line 159 "ease-inspector-transition-pane.vala"
++ g_critical ("ease-inspector-transition-pane.vala:159: Transition not found in model");
++#line 328 "ease-inspector-transition-pane.c"
++ }
++#line 163 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_model (self->variant, (GtkTreeModel*) (_tmp0_ = ease_transition_variant_model (ease_slide_get_transition (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)))));
++#line 332 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp0_);
++#line 166 "ease-inspector-transition-pane.vala"
++ if (gtk_tree_model_get_iter_first (gtk_combo_box_get_model (self->variant), &itr)) {
++#line 336 "ease-inspector-transition-pane.c"
++ EaseTransitionVariant v = 0;
++ {
++ gboolean _tmp1_;
++#line 169 "ease-inspector-transition-pane.vala"
++ _tmp1_ = TRUE;
++#line 169 "ease-inspector-transition-pane.vala"
++ while (TRUE) {
++#line 169 "ease-inspector-transition-pane.vala"
++ if (!_tmp1_) {
++#line 179 "ease-inspector-transition-pane.vala"
++ if (!gtk_tree_model_iter_next (gtk_combo_box_get_model (self->variant), &itr)) {
++#line 179 "ease-inspector-transition-pane.vala"
++ break;
++#line 350 "ease-inspector-transition-pane.c"
++ }
++ }
++#line 169 "ease-inspector-transition-pane.vala"
++ _tmp1_ = FALSE;
++#line 171 "ease-inspector-transition-pane.vala"
++ gtk_tree_model_get (gtk_combo_box_get_model (self->variant), &itr, 1, &v, -1);
++#line 172 "ease-inspector-transition-pane.vala"
++ if (v == ease_slide_get_variant (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))) {
++#line 174 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_active_iter (self->variant, &itr);
++#line 175 "ease-inspector-transition-pane.vala"
++ self->priv->silence_undo = already_silenced;
++#line 363 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (action);
++#line 176 "ease-inspector-transition-pane.vala"
++ return;
++#line 367 "ease-inspector-transition-pane.c"
++ }
++ }
++ }
++#line 182 "ease-inspector-transition-pane.vala"
++ gtk_tree_model_get_iter_first (gtk_combo_box_get_model (self->variant), &itr);
++#line 183 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_active_iter (self->variant, &itr);
++#line 375 "ease-inspector-transition-pane.c"
++ }
++#line 186 "ease-inspector-transition-pane.vala"
++ self->priv->silence_undo = already_silenced;
++#line 379 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (action);
++}
++
++
++#line 140 "ease-inspector-transition-pane.vala"
++static void __lambda52__gtk_combo_box_changed (GtkComboBox* _sender, gpointer self) {
++#line 386 "ease-inspector-transition-pane.c"
++ _lambda52_ (_sender, self);
++}
++
++
++#line 190 "ease-inspector-transition-pane.vala"
++static void _lambda53_ (GtkComboBox* sender, EaseInspectorTransitionPane* self) {
++#line 393 "ease-inspector-transition-pane.c"
++ GtkTreeIter itr = {0};
++#line 190 "ease-inspector-transition-pane.vala"
++ g_return_if_fail (sender != NULL);
++#line 191 "ease-inspector-transition-pane.vala"
++ if (!self->priv->silence_undo) {
++#line 399 "ease-inspector-transition-pane.c"
++ EaseUndoAction* _tmp0_;
++#line 191 "ease-inspector-transition-pane.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) (_tmp0_ = ease_undo_action_new ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "variant")));
++#line 403 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp0_);
++ }
++#line 194 "ease-inspector-transition-pane.vala"
++ if (gtk_combo_box_get_active_iter (sender, &itr)) {
++#line 408 "ease-inspector-transition-pane.c"
++ EaseTransitionVariant variant = 0;
++#line 197 "ease-inspector-transition-pane.vala"
++ gtk_tree_model_get (gtk_combo_box_get_model (sender), &itr, 1, &variant, -1);
++#line 198 "ease-inspector-transition-pane.vala"
++ ease_slide_set_variant (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), variant);
++#line 414 "ease-inspector-transition-pane.c"
++ } else {
++#line 202 "ease-inspector-transition-pane.vala"
++ g_critical ("ease-inspector-transition-pane.vala:202: Variant not found in model");
++#line 418 "ease-inspector-transition-pane.c"
++ }
++}
++
++
++#line 190 "ease-inspector-transition-pane.vala"
++static void __lambda53__gtk_combo_box_changed (GtkComboBox* _sender, gpointer self) {
++#line 425 "ease-inspector-transition-pane.c"
++ _lambda53_ (_sender, self);
++}
++
++
++#line 206 "ease-inspector-transition-pane.vala"
++static void _lambda54_ (EaseInspectorTransitionPane* self) {
++#line 207 "ease-inspector-transition-pane.vala"
++ if (!self->priv->silence_undo) {
++#line 434 "ease-inspector-transition-pane.c"
++ EaseUndoAction* _tmp0_;
++#line 207 "ease-inspector-transition-pane.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) (_tmp0_ = ease_undo_action_new ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "automatically-advance")));
++#line 438 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp0_);
++ }
++#line 209 "ease-inspector-transition-pane.vala"
++ if (gtk_combo_box_get_active (self->priv->start_transition) == 0) {
++#line 211 "ease-inspector-transition-pane.vala"
++ gtk_widget_set_sensitive ((GtkWidget*) self->priv->delay, FALSE);
++#line 212 "ease-inspector-transition-pane.vala"
++ ease_slide_set_automatically_advance (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), FALSE);
++#line 447 "ease-inspector-transition-pane.c"
++ } else {
++#line 216 "ease-inspector-transition-pane.vala"
++ gtk_widget_set_sensitive ((GtkWidget*) self->priv->delay, TRUE);
++#line 217 "ease-inspector-transition-pane.vala"
++ ease_slide_set_automatically_advance (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), TRUE);
++#line 453 "ease-inspector-transition-pane.c"
++ }
++}
++
++
++#line 206 "ease-inspector-transition-pane.vala"
++static void __lambda54__gtk_combo_box_changed (GtkComboBox* _sender, gpointer self) {
++#line 460 "ease-inspector-transition-pane.c"
++ _lambda54_ (self);
++}
++
++
++#line 221 "ease-inspector-transition-pane.vala"
++static void _lambda55_ (EaseInspectorTransitionPane* self) {
++#line 222 "ease-inspector-transition-pane.vala"
++ if (!self->priv->silence_undo) {
++#line 469 "ease-inspector-transition-pane.c"
++ EaseUndoAction* _tmp0_;
++#line 222 "ease-inspector-transition-pane.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) (_tmp0_ = ease_undo_action_new ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "transition-time")));
++#line 473 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp0_);
++ }
++#line 223 "ease-inspector-transition-pane.vala"
++ ease_slide_set_transition_time (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), gtk_spin_button_get_value (self->priv->transition_time));
++#line 478 "ease-inspector-transition-pane.c"
++}
++
++
++#line 221 "ease-inspector-transition-pane.vala"
++static void __lambda55__gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self) {
++#line 484 "ease-inspector-transition-pane.c"
++ _lambda55_ (self);
++}
++
++
++#line 226 "ease-inspector-transition-pane.vala"
++static void _lambda56_ (EaseInspectorTransitionPane* self) {
++#line 227 "ease-inspector-transition-pane.vala"
++ if (!self->priv->silence_undo) {
++#line 493 "ease-inspector-transition-pane.c"
++ EaseUndoAction* _tmp0_;
++#line 227 "ease-inspector-transition-pane.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) (_tmp0_ = ease_undo_action_new ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "advance-delay")));
++#line 497 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp0_);
++ }
++#line 228 "ease-inspector-transition-pane.vala"
++ ease_slide_set_advance_delay (ease_inspector_pane_get_slide ((EaseInspectorPane*) self), gtk_spin_button_get_value (self->priv->delay));
++#line 502 "ease-inspector-transition-pane.c"
++}
++
++
++#line 226 "ease-inspector-transition-pane.vala"
++static void __lambda56__gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self) {
++#line 508 "ease-inspector-transition-pane.c"
++ _lambda56_ (self);
++}
++
++
++#line 232 "ease-inspector-transition-pane.vala"
++static void _lambda57_ (ClutterActorBox* box, ClutterAllocationFlags flags, EaseInspectorTransitionPane* self) {
++#line 233 "ease-inspector-transition-pane.vala"
++ g_object_set ((ClutterActor*) self->priv->preview_group, "scale-x", (double) (((*box).x2 - (*box).x1) / ease_document_get_width (ease_slide_get_parent (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)))), NULL);
++#line 234 "ease-inspector-transition-pane.vala"
++ g_object_set ((ClutterActor*) self->priv->preview_group, "scale-y", (double) (((*box).y2 - (*box).y1) / ease_document_get_height (ease_slide_get_parent (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)))), NULL);
++#line 519 "ease-inspector-transition-pane.c"
++}
++
++
++#line 232 "ease-inspector-transition-pane.vala"
++static void __lambda57__clutter_actor_allocation_changed (ClutterActor* _sender, ClutterActorBox* p0, ClutterAllocationFlags p1, gpointer self) {
++#line 525 "ease-inspector-transition-pane.c"
++ _lambda57_ (p0, p1, self);
++}
++
++
++#line 238 "ease-inspector-transition-pane.vala"
++static void _lambda58_ (GtkWidget* widget, GdkRectangle* allocation, EaseInspectorTransitionPane* self) {
++#line 238 "ease-inspector-transition-pane.vala"
++ g_return_if_fail (widget != NULL);
++#line 239 "ease-inspector-transition-pane.vala"
++ if (ease_inspector_pane_get_slide ((EaseInspectorPane*) self) == NULL) {
++#line 239 "ease-inspector-transition-pane.vala"
++ return;
++#line 538 "ease-inspector-transition-pane.c"
++ }
++#line 241 "ease-inspector-transition-pane.vala"
++ g_object_set ((GtkWidget*) self->priv->preview_align, "height-request", (gint) ((*allocation).width / ease_document_get_aspect (ease_slide_get_parent (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)))), NULL);
++#line 542 "ease-inspector-transition-pane.c"
++}
++
++
++#line 238 "ease-inspector-transition-pane.vala"
++static void __lambda58__gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self) {
++#line 548 "ease-inspector-transition-pane.c"
++ _lambda58_ (_sender, allocation, self);
++}
++
++
++#line 49 "ease-inspector-transition-pane.vala"
++EaseInspectorTransitionPane* ease_inspector_transition_pane_construct (GType object_type) {
++#line 555 "ease-inspector-transition-pane.c"
++ EaseInspectorTransitionPane * self;
++ GtkClutterEmbed* _tmp0_;
++ ClutterColor _tmp1_ = {0};
++ ClutterColor _tmp2_;
++ GtkAlignment* _tmp3_;
++ GtkFrame* frame;
++ ClutterGroup* _tmp4_;
++ GtkVBox* vbox;
++ GtkHBox* hbox;
++ GtkAlignment* align;
++ GtkLabel* _tmp5_;
++ GtkComboBox* _tmp7_;
++ GtkListStore* _tmp6_;
++ GtkCellRendererText* render;
++ GtkAlignment* _tmp8_;
++ GtkVBox* _tmp9_;
++ GtkAlignment* _tmp10_;
++ GtkLabel* _tmp11_;
++ GtkSpinButton* _tmp12_;
++ GtkAlignment* _tmp13_;
++ GtkHBox* _tmp14_;
++ GtkVBox* _tmp15_;
++ GtkAlignment* _tmp16_;
++ GtkLabel* _tmp17_;
++ GtkComboBox* _tmp18_;
++ GtkCellRendererText* _tmp19_;
++ GtkAlignment* _tmp20_;
++ GtkVBox* _tmp21_;
++ GtkHBox* _tmp22_;
++ GtkAlignment* _tmp23_;
++ GtkLabel* _tmp24_;
++ GtkComboBox* _tmp25_;
++ GtkAlignment* _tmp26_;
++ GtkVBox* _tmp27_;
++ GtkAlignment* _tmp28_;
++ GtkLabel* _tmp29_;
++ GtkSpinButton* _tmp30_;
++ GtkAlignment* _tmp31_;
++#line 51 "ease-inspector-transition-pane.vala"
++ self = (EaseInspectorTransitionPane*) ease_inspector_pane_construct (object_type);
++#line 54 "ease-inspector-transition-pane.vala"
++ self->priv->preview = (_tmp0_ = g_object_ref_sink ((GtkClutterEmbed*) gtk_clutter_embed_new ()), _g_object_unref0 (self->priv->preview), _tmp0_);
++#line 55 "ease-inspector-transition-pane.vala"
++ clutter_stage_set_color (CLUTTER_STAGE (gtk_clutter_embed_get_stage (self->priv->preview)), (_tmp2_ = (_tmp1_.red = (guchar) 0, _tmp1_.green = (guchar) 0, _tmp1_.blue = (guchar) 0, _tmp1_.alpha = (guchar) 255, _tmp1_), &_tmp2_));
++#line 57 "ease-inspector-transition-pane.vala"
++ self->priv->preview_align = (_tmp3_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new (0.5f, 0.5f, (float) 1, (float) 1)), _g_object_unref0 (self->priv->preview_align), _tmp3_);
++#line 58 "ease-inspector-transition-pane.vala"
++ frame = g_object_ref_sink ((GtkFrame*) gtk_frame_new (NULL));
++#line 59 "ease-inspector-transition-pane.vala"
++ gtk_frame_set_shadow_type (frame, GTK_SHADOW_IN);
++#line 60 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) self->priv->preview_align, (GtkWidget*) self->priv->preview);
++#line 61 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) frame, (GtkWidget*) self->priv->preview_align);
++#line 63 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) self, (GtkWidget*) frame, FALSE, FALSE, (guint) 5);
++#line 64 "ease-inspector-transition-pane.vala"
++ self->priv->preview_group = (_tmp4_ = g_object_ref_sink ((ClutterGroup*) clutter_group_new ()), _g_object_unref0 (self->priv->preview_group), _tmp4_);
++#line 65 "ease-inspector-transition-pane.vala"
++ clutter_container_add_actor ((ClutterContainer*) CLUTTER_STAGE (gtk_clutter_embed_get_stage (self->priv->preview)), (ClutterActor*) self->priv->preview_group);
++#line 68 "ease-inspector-transition-pane.vala"
++ vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0));
++#line 69 "ease-inspector-transition-pane.vala"
++ hbox = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 0));
++#line 70 "ease-inspector-transition-pane.vala"
++ align = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 0, (float) 0));
++#line 71 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) (_tmp5_ = g_object_ref_sink ((GtkLabel*) gtk_label_new (_ ("Effect")))));
++#line 624 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp5_);
++#line 72 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0);
++#line 73 "ease-inspector-transition-pane.vala"
++ self->effect = (_tmp7_ = g_object_ref_sink ((GtkComboBox*) gtk_combo_box_new_with_model ((GtkTreeModel*) (_tmp6_ = ease_transition_model ()))), _g_object_unref0 (self->effect), _tmp7_);
++#line 630 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp6_);
++#line 74 "ease-inspector-transition-pane.vala"
++ render = g_object_ref_sink ((GtkCellRendererText*) gtk_cell_renderer_text_new ());
++#line 75 "ease-inspector-transition-pane.vala"
++ gtk_cell_layout_pack_start ((GtkCellLayout*) self->effect, (GtkCellRenderer*) render, TRUE);
++#line 76 "ease-inspector-transition-pane.vala"
++ gtk_cell_layout_set_attributes ((GtkCellLayout*) self->effect, (GtkCellRenderer*) render, "text", 0, NULL);
++#line 77 "ease-inspector-transition-pane.vala"
++ align = (_tmp8_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 1, (float) 1)), _g_object_unref0 (align), _tmp8_);
++#line 78 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) self->effect);
++#line 79 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0);
++#line 80 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) vbox, TRUE, TRUE, (guint) 5);
++#line 83 "ease-inspector-transition-pane.vala"
++ vbox = (_tmp9_ = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)), _g_object_unref0 (vbox), _tmp9_);
++#line 84 "ease-inspector-transition-pane.vala"
++ align = (_tmp10_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 0, (float) 0)), _g_object_unref0 (align), _tmp10_);
++#line 85 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) (_tmp11_ = g_object_ref_sink ((GtkLabel*) gtk_label_new (_ ("Duration")))));
++#line 652 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp11_);
++#line 86 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0);
++#line 87 "ease-inspector-transition-pane.vala"
++ self->priv->transition_time = (_tmp12_ = g_object_ref_sink ((GtkSpinButton*) gtk_spin_button_new_with_range ((double) 0, (double) 10, 0.25)), _g_object_unref0 (self->priv->transition_time), _tmp12_);
++#line 88 "ease-inspector-transition-pane.vala"
++ gtk_spin_button_set_digits (self->priv->transition_time, (guint) 2);
++#line 89 "ease-inspector-transition-pane.vala"
++ align = (_tmp13_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, 0.5f, (float) 1, (float) 1)), _g_object_unref0 (align), _tmp13_);
++#line 90 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) self->priv->transition_time);
++#line 91 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) align, TRUE, TRUE, (guint) 0);
++#line 92 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) vbox, FALSE, FALSE, (guint) 5);
++#line 93 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) self, (GtkWidget*) hbox, FALSE, FALSE, (guint) 5);
++#line 96 "ease-inspector-transition-pane.vala"
++ hbox = (_tmp14_ = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 0)), _g_object_unref0 (hbox), _tmp14_);
++#line 97 "ease-inspector-transition-pane.vala"
++ vbox = (_tmp15_ = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)), _g_object_unref0 (vbox), _tmp15_);
++#line 98 "ease-inspector-transition-pane.vala"
++ align = (_tmp16_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 0, (float) 0)), _g_object_unref0 (align), _tmp16_);
++#line 99 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) (_tmp17_ = g_object_ref_sink ((GtkLabel*) gtk_label_new (_ ("Direction")))));
++#line 678 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp17_);
++#line 100 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0);
++#line 101 "ease-inspector-transition-pane.vala"
++ self->variant = (_tmp18_ = g_object_ref_sink ((GtkComboBox*) gtk_combo_box_new ()), _g_object_unref0 (self->variant), _tmp18_);
++#line 102 "ease-inspector-transition-pane.vala"
++ render = (_tmp19_ = g_object_ref_sink ((GtkCellRendererText*) gtk_cell_renderer_text_new ()), _g_object_unref0 (render), _tmp19_);
++#line 103 "ease-inspector-transition-pane.vala"
++ gtk_cell_layout_pack_start ((GtkCellLayout*) self->variant, (GtkCellRenderer*) render, TRUE);
++#line 104 "ease-inspector-transition-pane.vala"
++ gtk_cell_layout_set_attributes ((GtkCellLayout*) self->variant, (GtkCellRenderer*) render, "text", 0, NULL);
++#line 105 "ease-inspector-transition-pane.vala"
++ self->priv->variant_align = (_tmp20_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 1, (float) 1)), _g_object_unref0 (self->priv->variant_align), _tmp20_);
++#line 106 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) self->priv->variant_align, (GtkWidget*) self->variant);
++#line 107 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) self->priv->variant_align, FALSE, FALSE, (guint) 0);
++#line 108 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) vbox, TRUE, TRUE, (guint) 5);
++#line 109 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) self, (GtkWidget*) hbox, FALSE, FALSE, (guint) 5);
++#line 112 "ease-inspector-transition-pane.vala"
++ vbox = (_tmp21_ = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)), _g_object_unref0 (vbox), _tmp21_);
++#line 113 "ease-inspector-transition-pane.vala"
++ hbox = (_tmp22_ = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 0)), _g_object_unref0 (hbox), _tmp22_);
++#line 114 "ease-inspector-transition-pane.vala"
++ align = (_tmp23_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 0, (float) 0)), _g_object_unref0 (align), _tmp23_);
++#line 115 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) (_tmp24_ = g_object_ref_sink ((GtkLabel*) gtk_label_new (_ ("Start Transition")))));
++#line 708 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp24_);
++#line 116 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0);
++#line 117 "ease-inspector-transition-pane.vala"
++ self->priv->start_transition = (_tmp25_ = g_object_ref_sink ((GtkComboBox*) gtk_combo_box_new_text ()), _g_object_unref0 (self->priv->start_transition), _tmp25_);
++#line 118 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_append_text (self->priv->start_transition, _ ("Manually"));
++#line 119 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_append_text (self->priv->start_transition, _ ("Automatically"));
++#line 120 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_active (self->priv->start_transition, 0);
++#line 121 "ease-inspector-transition-pane.vala"
++ align = (_tmp26_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 1, (float) 1)), _g_object_unref0 (align), _tmp26_);
++#line 122 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) self->priv->start_transition);
++#line 123 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0);
++#line 124 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) vbox, TRUE, TRUE, (guint) 5);
++#line 127 "ease-inspector-transition-pane.vala"
++ vbox = (_tmp27_ = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0)), _g_object_unref0 (vbox), _tmp27_);
++#line 128 "ease-inspector-transition-pane.vala"
++ align = (_tmp28_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 0, (float) 0)), _g_object_unref0 (align), _tmp28_);
++#line 129 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) (_tmp29_ = g_object_ref_sink ((GtkLabel*) gtk_label_new (_ ("Delay")))));
++#line 734 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp29_);
++#line 130 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0);
++#line 131 "ease-inspector-transition-pane.vala"
++ self->priv->delay = (_tmp30_ = g_object_ref_sink ((GtkSpinButton*) gtk_spin_button_new_with_range ((double) 0, (double) 10, 0.25)), _g_object_unref0 (self->priv->delay), _tmp30_);
++#line 132 "ease-inspector-transition-pane.vala"
++ gtk_spin_button_set_digits (self->priv->delay, (guint) 2);
++#line 133 "ease-inspector-transition-pane.vala"
++ align = (_tmp31_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, 0.5f, (float) 1, (float) 1)), _g_object_unref0 (align), _tmp31_);
++#line 134 "ease-inspector-transition-pane.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) self->priv->delay);
++#line 135 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) align, TRUE, TRUE, (guint) 0);
++#line 136 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) vbox, FALSE, FALSE, (guint) 5);
++#line 137 "ease-inspector-transition-pane.vala"
++ gtk_box_pack_start ((GtkBox*) self, (GtkWidget*) hbox, FALSE, FALSE, (guint) 5);
++#line 140 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object (self->effect, "changed", (GCallback) __lambda52__gtk_combo_box_changed, self, 0);
++#line 190 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object (self->variant, "changed", (GCallback) __lambda53__gtk_combo_box_changed, self, 0);
++#line 206 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object (self->priv->start_transition, "changed", (GCallback) __lambda54__gtk_combo_box_changed, self, 0);
++#line 221 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object (self->priv->transition_time, "value-changed", (GCallback) __lambda55__gtk_spin_button_value_changed, self, 0);
++#line 226 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object (self->priv->delay, "value-changed", (GCallback) __lambda56__gtk_spin_button_value_changed, self, 0);
++#line 232 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object (gtk_clutter_embed_get_stage (self->priv->preview), "allocation-changed", (GCallback) __lambda57__clutter_actor_allocation_changed, self, 0);
++#line 238 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object ((GtkWidget*) self->priv->preview_align, "size-allocate", (GCallback) __lambda58__gtk_widget_size_allocate, self, 0);
++#line 766 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (render);
++ _g_object_unref0 (align);
++ _g_object_unref0 (hbox);
++ _g_object_unref0 (vbox);
++ _g_object_unref0 (frame);
++ return self;
++}
++
++
++#line 49 "ease-inspector-transition-pane.vala"
++EaseInspectorTransitionPane* ease_inspector_transition_pane_new (void) {
++#line 49 "ease-inspector-transition-pane.vala"
++ return ease_inspector_transition_pane_construct (EASE_TYPE_INSPECTOR_TRANSITION_PANE);
++#line 780 "ease-inspector-transition-pane.c"
++}
++
++
++#line 253 "ease-inspector-transition-pane.vala"
++static void _lambda59_ (EaseInspectorTransitionPane* self) {
++#line 254 "ease-inspector-transition-pane.vala"
++ ease_inspector_transition_pane_animate_preview_start (self);
++#line 788 "ease-inspector-transition-pane.c"
++}
++
++
++#line 253 "ease-inspector-transition-pane.vala"
++static void __lambda59__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 794 "ease-inspector-transition-pane.c"
++ _lambda59_ (self);
++}
++
++
++#line 246 "ease-inspector-transition-pane.vala"
++static void ease_inspector_transition_pane_animate_preview (EaseInspectorTransitionPane* self) {
++#line 801 "ease-inspector-transition-pane.c"
++ ClutterTimeline* _tmp0_;
++#line 246 "ease-inspector-transition-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 248 "ease-inspector-transition-pane.vala"
++ ease_slide_actor_reset (self->priv->current_slide, self->priv->preview_group);
++#line 249 "ease-inspector-transition-pane.vala"
++ ease_slide_actor_reset (self->priv->new_slide, self->priv->preview_group);
++#line 250 "ease-inspector-transition-pane.vala"
++ clutter_actor_set_opacity ((ClutterActor*) self->priv->new_slide, (guint) 0);
++#line 252 "ease-inspector-transition-pane.vala"
++ self->priv->preview_alarm = (_tmp0_ = clutter_timeline_new (EASE_INSPECTOR_TRANSITION_PANE_PREVIEW_DELAY), _g_object_unref0 (self->priv->preview_alarm), _tmp0_);
++#line 253 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object (self->priv->preview_alarm, "completed", (GCallback) __lambda59__clutter_timeline_completed, self, 0);
++#line 256 "ease-inspector-transition-pane.vala"
++ clutter_timeline_start (self->priv->preview_alarm);
++#line 817 "ease-inspector-transition-pane.c"
++}
++
++
++#line 272 "ease-inspector-transition-pane.vala"
++static void _lambda60_ (EaseInspectorTransitionPane* self) {
++#line 273 "ease-inspector-transition-pane.vala"
++ ease_inspector_transition_pane_animate_preview_delay (self);
++#line 825 "ease-inspector-transition-pane.c"
++}
++
++
++#line 272 "ease-inspector-transition-pane.vala"
++static void __lambda60__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 831 "ease-inspector-transition-pane.c"
++ _lambda60_ (self);
++}
++
++
++#line 259 "ease-inspector-transition-pane.vala"
++static void ease_inspector_transition_pane_animate_preview_start (EaseInspectorTransitionPane* self) {
++#line 838 "ease-inspector-transition-pane.c"
++ ClutterTimeline* _tmp0_;
++#line 259 "ease-inspector-transition-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 261 "ease-inspector-transition-pane.vala"
++ if (ease_slide_get_transition_msecs (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)) == 0) {
++#line 263 "ease-inspector-transition-pane.vala"
++ ease_inspector_transition_pane_animate_preview (self);
++#line 264 "ease-inspector-transition-pane.vala"
++ return;
++#line 848 "ease-inspector-transition-pane.c"
++ }
++#line 267 "ease-inspector-transition-pane.vala"
++ clutter_actor_set_opacity ((ClutterActor*) self->priv->new_slide, (guint) 255);
++#line 269 "ease-inspector-transition-pane.vala"
++ ease_slide_actor_transition (self->priv->current_slide, self->priv->new_slide, self->priv->preview_group);
++#line 271 "ease-inspector-transition-pane.vala"
++ self->priv->preview_alarm = (_tmp0_ = clutter_timeline_new (ease_slide_get_transition_msecs (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))), _g_object_unref0 (self->priv->preview_alarm), _tmp0_);
++#line 272 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object (self->priv->preview_alarm, "completed", (GCallback) __lambda60__clutter_timeline_completed, self, 0);
++#line 275 "ease-inspector-transition-pane.vala"
++ clutter_timeline_start (self->priv->preview_alarm);
++#line 860 "ease-inspector-transition-pane.c"
++}
++
++
++#line 281 "ease-inspector-transition-pane.vala"
++static void _lambda61_ (EaseInspectorTransitionPane* self) {
++#line 282 "ease-inspector-transition-pane.vala"
++ ease_inspector_transition_pane_animate_preview (self);
++#line 868 "ease-inspector-transition-pane.c"
++}
++
++
++#line 281 "ease-inspector-transition-pane.vala"
++static void __lambda61__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 874 "ease-inspector-transition-pane.c"
++ _lambda61_ (self);
++}
++
++
++#line 278 "ease-inspector-transition-pane.vala"
++static void ease_inspector_transition_pane_animate_preview_delay (EaseInspectorTransitionPane* self) {
++#line 881 "ease-inspector-transition-pane.c"
++ ClutterTimeline* _tmp0_;
++#line 278 "ease-inspector-transition-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 280 "ease-inspector-transition-pane.vala"
++ self->priv->preview_alarm = (_tmp0_ = clutter_timeline_new (EASE_INSPECTOR_TRANSITION_PANE_PREVIEW_DELAY), _g_object_unref0 (self->priv->preview_alarm), _tmp0_);
++#line 281 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object (self->priv->preview_alarm, "completed", (GCallback) __lambda61__clutter_timeline_completed, self, 0);
++#line 284 "ease-inspector-transition-pane.vala"
++ clutter_timeline_start (self->priv->preview_alarm);
++#line 891 "ease-inspector-transition-pane.c"
++}
++
++
++#line 287 "ease-inspector-transition-pane.vala"
++static void ease_inspector_transition_pane_on_slide_notify (EaseInspectorTransitionPane* self, GObject* obj, GParamSpec* spec) {
++#line 897 "ease-inspector-transition-pane.c"
++ gboolean already_silenced;
++ GtkTreeIter itr = {0};
++ GQuark _tmp4_;
++ const char* _tmp3_;
++ static GQuark _tmp4__label0 = 0;
++ static GQuark _tmp4__label1 = 0;
++ static GQuark _tmp4__label2 = 0;
++ static GQuark _tmp4__label3 = 0;
++ static GQuark _tmp4__label4 = 0;
++#line 287 "ease-inspector-transition-pane.vala"
++ g_return_if_fail (self != NULL);
++#line 287 "ease-inspector-transition-pane.vala"
++ g_return_if_fail (obj != NULL);
++#line 287 "ease-inspector-transition-pane.vala"
++ g_return_if_fail (spec != NULL);
++#line 289 "ease-inspector-transition-pane.vala"
++ already_silenced = self->priv->silence_undo;
++#line 290 "ease-inspector-transition-pane.vala"
++ self->priv->silence_undo = TRUE;
++#line 917 "ease-inspector-transition-pane.c"
++ _tmp3_ = spec->name;
++ _tmp4_ = (NULL == _tmp3_) ? 0 : g_quark_from_string (_tmp3_);
++ if (_tmp4_ == ((0 != _tmp4__label0) ? _tmp4__label0 : (_tmp4__label0 = g_quark_from_static_string ("transition"))))
++ switch (0) {
++ default:
++ {
++#line 295 "ease-inspector-transition-pane.vala"
++ if (gtk_tree_model_get_iter_first (gtk_combo_box_get_model (self->effect), &itr)) {
++#line 926 "ease-inspector-transition-pane.c"
++ gboolean set;
++ EaseTransition t = 0;
++#line 297 "ease-inspector-transition-pane.vala"
++ set = FALSE;
++#line 931 "ease-inspector-transition-pane.c"
++ {
++ gboolean _tmp0_;
++#line 299 "ease-inspector-transition-pane.vala"
++ _tmp0_ = TRUE;
++#line 299 "ease-inspector-transition-pane.vala"
++ while (TRUE) {
++#line 299 "ease-inspector-transition-pane.vala"
++ if (!_tmp0_) {
++#line 309 "ease-inspector-transition-pane.vala"
++ if (!gtk_tree_model_iter_next (gtk_combo_box_get_model (self->effect), &itr)) {
++#line 309 "ease-inspector-transition-pane.vala"
++ break;
++#line 944 "ease-inspector-transition-pane.c"
++ }
++ }
++#line 299 "ease-inspector-transition-pane.vala"
++ _tmp0_ = FALSE;
++#line 301 "ease-inspector-transition-pane.vala"
++ gtk_tree_model_get (gtk_combo_box_get_model (self->effect), &itr, 1, &t, -1);
++#line 302 "ease-inspector-transition-pane.vala"
++ if (t == ease_slide_get_transition (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))) {
++#line 304 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_active_iter (self->effect, &itr);
++#line 305 "ease-inspector-transition-pane.vala"
++ set = TRUE;
++#line 306 "ease-inspector-transition-pane.vala"
++ break;
++#line 959 "ease-inspector-transition-pane.c"
++ }
++ }
++ }
++#line 312 "ease-inspector-transition-pane.vala"
++ if (!set) {
++#line 314 "ease-inspector-transition-pane.vala"
++ gtk_tree_model_get_iter_first (gtk_combo_box_get_model (self->effect), &itr);
++#line 315 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_active_iter (self->effect, &itr);
++#line 969 "ease-inspector-transition-pane.c"
++ }
++ }
++#line 318 "ease-inspector-transition-pane.vala"
++ break;
++#line 974 "ease-inspector-transition-pane.c"
++ }
++ } else if (_tmp4_ == ((0 != _tmp4__label1) ? _tmp4__label1 : (_tmp4__label1 = g_quark_from_static_string ("variant"))))
++ switch (0) {
++ default:
++ {
++#line 320 "ease-inspector-transition-pane.vala"
++ if (gtk_tree_model_get_iter_first (gtk_combo_box_get_model (self->variant), &itr)) {
++#line 982 "ease-inspector-transition-pane.c"
++ EaseTransitionVariant v = 0;
++ {
++ gboolean _tmp1_;
++#line 323 "ease-inspector-transition-pane.vala"
++ _tmp1_ = TRUE;
++#line 323 "ease-inspector-transition-pane.vala"
++ while (TRUE) {
++#line 323 "ease-inspector-transition-pane.vala"
++ if (!_tmp1_) {
++#line 333 "ease-inspector-transition-pane.vala"
++ if (!gtk_tree_model_iter_next (gtk_combo_box_get_model (self->variant), &itr)) {
++#line 333 "ease-inspector-transition-pane.vala"
++ break;
++#line 996 "ease-inspector-transition-pane.c"
++ }
++ }
++#line 323 "ease-inspector-transition-pane.vala"
++ _tmp1_ = FALSE;
++#line 325 "ease-inspector-transition-pane.vala"
++ gtk_tree_model_get (gtk_combo_box_get_model (self->variant), &itr, 1, &v, -1);
++#line 326 "ease-inspector-transition-pane.vala"
++ if (v == ease_slide_get_variant (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))) {
++#line 328 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_active_iter (self->variant, &itr);
++#line 329 "ease-inspector-transition-pane.vala"
++ self->priv->silence_undo = already_silenced;
++#line 330 "ease-inspector-transition-pane.vala"
++ return;
++#line 1011 "ease-inspector-transition-pane.c"
++ }
++ }
++ }
++#line 336 "ease-inspector-transition-pane.vala"
++ gtk_tree_model_get_iter_first (gtk_combo_box_get_model (self->variant), &itr);
++#line 337 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_active_iter (self->variant, &itr);
++#line 1019 "ease-inspector-transition-pane.c"
++ }
++#line 339 "ease-inspector-transition-pane.vala"
++ break;
++#line 1023 "ease-inspector-transition-pane.c"
++ }
++ } else if (_tmp4_ == ((0 != _tmp4__label2) ? _tmp4__label2 : (_tmp4__label2 = g_quark_from_static_string ("transition-time"))))
++ switch (0) {
++ default:
++ {
++#line 341 "ease-inspector-transition-pane.vala"
++ gtk_spin_button_set_value (self->priv->transition_time, ease_slide_get_transition_time (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 342 "ease-inspector-transition-pane.vala"
++ break;
++#line 1033 "ease-inspector-transition-pane.c"
++ }
++ } else if (_tmp4_ == ((0 != _tmp4__label3) ? _tmp4__label3 : (_tmp4__label3 = g_quark_from_static_string ("advance-delay"))))
++ switch (0) {
++ default:
++ {
++#line 344 "ease-inspector-transition-pane.vala"
++ gtk_spin_button_set_value (self->priv->delay, ease_slide_get_advance_delay (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 345 "ease-inspector-transition-pane.vala"
++ break;
++#line 1043 "ease-inspector-transition-pane.c"
++ }
++ } else if (_tmp4_ == ((0 != _tmp4__label4) ? _tmp4__label4 : (_tmp4__label4 = g_quark_from_static_string ("start-transition"))))
++ switch (0) {
++ default:
++ {
++ gint _tmp2_ = 0;
++#line 347 "ease-inspector-transition-pane.vala"
++ if (ease_slide_get_automatically_advance (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))) {
++#line 348 "ease-inspector-transition-pane.vala"
++ _tmp2_ = 1;
++#line 1054 "ease-inspector-transition-pane.c"
++ } else {
++#line 348 "ease-inspector-transition-pane.vala"
++ _tmp2_ = 0;
++#line 1058 "ease-inspector-transition-pane.c"
++ }
++#line 347 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_active (self->priv->start_transition, _tmp2_);
++#line 349 "ease-inspector-transition-pane.vala"
++ gtk_spin_button_set_value (self->priv->delay, ease_slide_get_advance_delay (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 350 "ease-inspector-transition-pane.vala"
++ gtk_widget_set_sensitive ((GtkWidget*) self->priv->delay, ease_slide_get_automatically_advance (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 351 "ease-inspector-transition-pane.vala"
++ break;
++#line 1068 "ease-inspector-transition-pane.c"
++ }
++ }
++#line 353 "ease-inspector-transition-pane.vala"
++ self->priv->silence_undo = already_silenced;
++#line 1073 "ease-inspector-transition-pane.c"
++}
++
++
++#line 287 "ease-inspector-transition-pane.vala"
++static void _ease_inspector_transition_pane_on_slide_notify_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 1079 "ease-inspector-transition-pane.c"
++ ease_inspector_transition_pane_on_slide_notify (self, _sender, pspec);
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 356 "ease-inspector-transition-pane.vala"
++static void ease_inspector_transition_pane_real_slide_updated (EaseInspectorPane* base) {
++#line 1091 "ease-inspector-transition-pane.c"
++ EaseInspectorTransitionPane * self;
++ EaseSlide* _tmp10_;
++ GtkTreeIter itr = {0};
++ gint _tmp12_ = 0;
++ GtkAllocation alloc = {0};
++ EaseSlideActor* _tmp13_;
++ EaseSlideActor* _tmp14_;
++ EaseSlideActor* _tmp20_;
++ self = (EaseInspectorTransitionPane*) base;
++#line 358 "ease-inspector-transition-pane.vala"
++ self->priv->silence_undo = TRUE;
++#line 361 "ease-inspector-transition-pane.vala"
++ if (self->priv->old_slide != NULL) {
++#line 1105 "ease-inspector-transition-pane.c"
++ GQuark _tmp1_;
++ guint _tmp0_;
++ GQuark _tmp3_;
++ guint _tmp2_;
++ GQuark _tmp5_;
++ guint _tmp4_;
++ GQuark _tmp7_;
++ guint _tmp6_;
++ GQuark _tmp9_;
++ guint _tmp8_;
++#line 363 "ease-inspector-transition-pane.vala"
++ g_signal_parse_name ("notify::transition-time", G_TYPE_OBJECT, &_tmp0_, &_tmp1_, TRUE);
++#line 363 "ease-inspector-transition-pane.vala"
++ g_signal_handlers_disconnect_matched ((GObject*) self->priv->old_slide, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, _tmp1_, NULL, (GCallback) _ease_inspector_transition_pane_on_slide_notify_g_object_notify, self);
++#line 364 "ease-inspector-transition-pane.vala"
++ g_signal_parse_name ("notify::variant", G_TYPE_OBJECT, &_tmp2_, &_tmp3_, TRUE);
++#line 364 "ease-inspector-transition-pane.vala"
++ g_signal_handlers_disconnect_matched ((GObject*) self->priv->old_slide, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp2_, _tmp3_, NULL, (GCallback) _ease_inspector_transition_pane_on_slide_notify_g_object_notify, self);
++#line 365 "ease-inspector-transition-pane.vala"
++ g_signal_parse_name ("notify::transition", G_TYPE_OBJECT, &_tmp4_, &_tmp5_, TRUE);
++#line 365 "ease-inspector-transition-pane.vala"
++ g_signal_handlers_disconnect_matched ((GObject*) self->priv->old_slide, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp4_, _tmp5_, NULL, (GCallback) _ease_inspector_transition_pane_on_slide_notify_g_object_notify, self);
++#line 366 "ease-inspector-transition-pane.vala"
++ g_signal_parse_name ("notify::advance-delay", G_TYPE_OBJECT, &_tmp6_, &_tmp7_, TRUE);
++#line 366 "ease-inspector-transition-pane.vala"
++ g_signal_handlers_disconnect_matched ((GObject*) self->priv->old_slide, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp6_, _tmp7_, NULL, (GCallback) _ease_inspector_transition_pane_on_slide_notify_g_object_notify, self);
++#line 367 "ease-inspector-transition-pane.vala"
++ g_signal_parse_name ("notify::start-transition", G_TYPE_OBJECT, &_tmp8_, &_tmp9_, TRUE);
++#line 367 "ease-inspector-transition-pane.vala"
++ g_signal_handlers_disconnect_matched ((GObject*) self->priv->old_slide, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp8_, _tmp9_, NULL, (GCallback) _ease_inspector_transition_pane_on_slide_notify_g_object_notify, self);
++#line 1136 "ease-inspector-transition-pane.c"
++ }
++#line 369 "ease-inspector-transition-pane.vala"
++ self->priv->old_slide = (_tmp10_ = _g_object_ref0 (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), _g_object_unref0 (self->priv->old_slide), _tmp10_);
++#line 372 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "notify::transition-time", (GCallback) _ease_inspector_transition_pane_on_slide_notify_g_object_notify, self, 0);
++#line 373 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "notify::variant", (GCallback) _ease_inspector_transition_pane_on_slide_notify_g_object_notify, self, 0);
++#line 374 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "notify::transition", (GCallback) _ease_inspector_transition_pane_on_slide_notify_g_object_notify, self, 0);
++#line 375 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "notify::advance-delay", (GCallback) _ease_inspector_transition_pane_on_slide_notify_g_object_notify, self, 0);
++#line 376 "ease-inspector-transition-pane.vala"
++ g_signal_connect_object ((GObject*) ease_inspector_pane_get_slide ((EaseInspectorPane*) self), "notify::start-transition", (GCallback) _ease_inspector_transition_pane_on_slide_notify_g_object_notify, self, 0);
++#line 379 "ease-inspector-transition-pane.vala"
++ gtk_spin_button_set_value (self->priv->transition_time, ease_slide_get_transition_time (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 383 "ease-inspector-transition-pane.vala"
++ if (gtk_tree_model_get_iter_first (gtk_combo_box_get_model (self->effect), &itr)) {
++#line 1154 "ease-inspector-transition-pane.c"
++ gboolean set;
++ EaseTransition t = 0;
++#line 385 "ease-inspector-transition-pane.vala"
++ set = FALSE;
++#line 1159 "ease-inspector-transition-pane.c"
++ {
++ gboolean _tmp11_;
++#line 387 "ease-inspector-transition-pane.vala"
++ _tmp11_ = TRUE;
++#line 387 "ease-inspector-transition-pane.vala"
++ while (TRUE) {
++#line 387 "ease-inspector-transition-pane.vala"
++ if (!_tmp11_) {
++#line 397 "ease-inspector-transition-pane.vala"
++ if (!gtk_tree_model_iter_next (gtk_combo_box_get_model (self->effect), &itr)) {
++#line 397 "ease-inspector-transition-pane.vala"
++ break;
++#line 1172 "ease-inspector-transition-pane.c"
++ }
++ }
++#line 387 "ease-inspector-transition-pane.vala"
++ _tmp11_ = FALSE;
++#line 389 "ease-inspector-transition-pane.vala"
++ gtk_tree_model_get (gtk_combo_box_get_model (self->effect), &itr, 1, &t, -1);
++#line 390 "ease-inspector-transition-pane.vala"
++ if (t == ease_slide_get_transition (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))) {
++#line 392 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_active_iter (self->effect, &itr);
++#line 393 "ease-inspector-transition-pane.vala"
++ set = TRUE;
++#line 394 "ease-inspector-transition-pane.vala"
++ break;
++#line 1187 "ease-inspector-transition-pane.c"
++ }
++ }
++ }
++#line 400 "ease-inspector-transition-pane.vala"
++ if (!set) {
++#line 402 "ease-inspector-transition-pane.vala"
++ gtk_tree_model_get_iter_first (gtk_combo_box_get_model (self->effect), &itr);
++#line 403 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_active_iter (self->effect, &itr);
++#line 1197 "ease-inspector-transition-pane.c"
++ }
++ }
++#line 408 "ease-inspector-transition-pane.vala"
++ if (ease_slide_get_automatically_advance (ease_inspector_pane_get_slide ((EaseInspectorPane*) self))) {
++#line 408 "ease-inspector-transition-pane.vala"
++ _tmp12_ = 1;
++#line 1204 "ease-inspector-transition-pane.c"
++ } else {
++#line 408 "ease-inspector-transition-pane.vala"
++ _tmp12_ = 0;
++#line 1208 "ease-inspector-transition-pane.c"
++ }
++#line 408 "ease-inspector-transition-pane.vala"
++ gtk_combo_box_set_active (self->priv->start_transition, _tmp12_);
++#line 409 "ease-inspector-transition-pane.vala"
++ gtk_spin_button_set_value (self->priv->delay, ease_slide_get_advance_delay (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 410 "ease-inspector-transition-pane.vala"
++ gtk_widget_set_sensitive ((GtkWidget*) self->priv->delay, ease_slide_get_automatically_advance (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)));
++#line 1216 "ease-inspector-transition-pane.c"
++ memset (&alloc, 0, sizeof (GtkAllocation));
++#line 414 "ease-inspector-transition-pane.vala"
++ gtk_widget_get_allocation ((GtkWidget*) self->priv->preview_align, &alloc);
++#line 415 "ease-inspector-transition-pane.vala"
++ g_object_set ((GtkWidget*) self->priv->preview_align, "height-request", (gint) (alloc.width / ease_document_get_aspect (ease_slide_get_parent (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)))), NULL);
++#line 418 "ease-inspector-transition-pane.vala"
++ clutter_group_remove_all (self->priv->preview_group);
++#line 421 "ease-inspector-transition-pane.vala"
++ self->priv->current_slide = (_tmp13_ = g_object_ref_sink (ease_slide_actor_new_from_slide (ease_slide_get_parent (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), ease_inspector_pane_get_slide ((EaseInspectorPane*) self), TRUE, EASE_ACTOR_CONTEXT_PRESENTATION)), _g_object_unref0 (self->priv->current_slide), _tmp13_);
++#line 1226 "ease-inspector-transition-pane.c"
++ _tmp14_ = NULL;
++#line 424 "ease-inspector-transition-pane.vala"
++ if (ease_document_has_next_slide (ease_slide_get_parent (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), ease_inspector_pane_get_slide ((EaseInspectorPane*) self))) {
++#line 1230 "ease-inspector-transition-pane.c"
++ EaseSlideActor* _tmp16_;
++ EaseSlide* _tmp15_;
++#line 425 "ease-inspector-transition-pane.vala"
++ _tmp14_ = (_tmp16_ = g_object_ref_sink (ease_slide_actor_new_from_slide (ease_slide_get_parent (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), _tmp15_ = ease_slide_get_next (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), TRUE, EASE_ACTOR_CONTEXT_PRESENTATION)), _g_object_unref0 (_tmp14_), _tmp16_);
++#line 1235 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp15_);
++ } else {
++ EaseSlideActor* _tmp19_;
++ ClutterColor _tmp18_;
++ ClutterColor _tmp17_ = {0};
++#line 427 "ease-inspector-transition-pane.vala"
++ _tmp14_ = (_tmp19_ = g_object_ref_sink (ease_slide_actor_new_blank (ease_slide_get_parent (ease_inspector_pane_get_slide ((EaseInspectorPane*) self)), (_tmp18_ = (_tmp17_.red = (guchar) 0, _tmp17_.green = (guchar) 0, _tmp17_.blue = (guchar) 0, _tmp17_.alpha = (guchar) 255, _tmp17_), &_tmp18_))), _g_object_unref0 (_tmp14_), _tmp19_);
++#line 1243 "ease-inspector-transition-pane.c"
++ }
++#line 424 "ease-inspector-transition-pane.vala"
++ self->priv->new_slide = (_tmp20_ = _g_object_ref0 (_tmp14_), _g_object_unref0 (self->priv->new_slide), _tmp20_);
++#line 429 "ease-inspector-transition-pane.vala"
++ clutter_container_add_actor ((ClutterContainer*) self->priv->preview_group, (ClutterActor*) self->priv->current_slide);
++#line 430 "ease-inspector-transition-pane.vala"
++ clutter_container_add_actor ((ClutterContainer*) self->priv->preview_group, (ClutterActor*) self->priv->new_slide);
++#line 433 "ease-inspector-transition-pane.vala"
++ if (self->priv->preview_alarm != NULL) {
++#line 435 "ease-inspector-transition-pane.vala"
++ clutter_timeline_stop (self->priv->preview_alarm);
++#line 1255 "ease-inspector-transition-pane.c"
++ }
++#line 437 "ease-inspector-transition-pane.vala"
++ ease_inspector_transition_pane_animate_preview (self);
++#line 439 "ease-inspector-transition-pane.vala"
++ self->priv->silence_undo = FALSE;
++#line 1261 "ease-inspector-transition-pane.c"
++ _g_object_unref0 (_tmp14_);
++}
++
++
++static void ease_inspector_transition_pane_class_init (EaseInspectorTransitionPaneClass * klass) {
++ ease_inspector_transition_pane_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseInspectorTransitionPanePrivate));
++ EASE_INSPECTOR_PANE_CLASS (klass)->slide_updated = ease_inspector_transition_pane_real_slide_updated;
++ G_OBJECT_CLASS (klass)->finalize = ease_inspector_transition_pane_finalize;
++}
++
++
++static void ease_inspector_transition_pane_instance_init (EaseInspectorTransitionPane * self) {
++ self->priv = EASE_INSPECTOR_TRANSITION_PANE_GET_PRIVATE (self);
++}
++
++
++static void ease_inspector_transition_pane_finalize (GObject* obj) {
++ EaseInspectorTransitionPane * self;
++ self = EASE_INSPECTOR_TRANSITION_PANE (obj);
++ _g_object_unref0 (self->effect);
++ _g_object_unref0 (self->priv->transition_time);
++ _g_object_unref0 (self->variant);
++ _g_object_unref0 (self->priv->variant_align);
++ _g_object_unref0 (self->priv->start_transition);
++ _g_object_unref0 (self->priv->delay);
++ _g_object_unref0 (self->priv->preview);
++ _g_object_unref0 (self->priv->preview_group);
++ _g_object_unref0 (self->priv->preview_align);
++ _g_object_unref0 (self->priv->current_slide);
++ _g_object_unref0 (self->priv->new_slide);
++ _g_object_unref0 (self->priv->preview_alarm);
++ _g_object_unref0 (self->priv->old_slide);
++ G_OBJECT_CLASS (ease_inspector_transition_pane_parent_class)->finalize (obj);
++}
++
++
++GType ease_inspector_transition_pane_get_type (void) {
++ static volatile gsize ease_inspector_transition_pane_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_inspector_transition_pane_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseInspectorTransitionPaneClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_inspector_transition_pane_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseInspectorTransitionPane), 0, (GInstanceInitFunc) ease_inspector_transition_pane_instance_init, NULL };
++ GType ease_inspector_transition_pane_type_id;
++ ease_inspector_transition_pane_type_id = g_type_register_static (EASE_TYPE_INSPECTOR_PANE, "EaseInspectorTransitionPane", &g_define_type_info, 0);
++ g_once_init_leave (&ease_inspector_transition_pane_type_id__volatile, ease_inspector_transition_pane_type_id);
++ }
++ return ease_inspector_transition_pane_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-inspector-window.c
index 0000000,0000000..575a1f6
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-inspector-window.c
@@@ -1,0 -1,0 +1,232 @@@
++/* ease-inspector-window.c generated by valac, the Vala compiler
++ * generated from ease-inspector-window.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++
++
++#define EASE_TYPE_INSPECTOR_WINDOW (ease_inspector_window_get_type ())
++#define EASE_INSPECTOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_WINDOW, EaseInspectorWindow))
++#define EASE_INSPECTOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_WINDOW, EaseInspectorWindowClass))
++#define EASE_IS_INSPECTOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_WINDOW))
++#define EASE_IS_INSPECTOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_WINDOW))
++#define EASE_INSPECTOR_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_WINDOW, EaseInspectorWindowClass))
++
++typedef struct _EaseInspectorWindow EaseInspectorWindow;
++typedef struct _EaseInspectorWindowClass EaseInspectorWindowClass;
++typedef struct _EaseInspectorWindowPrivate EaseInspectorWindowPrivate;
++
++#define EASE_TYPE_INSPECTOR (ease_inspector_get_type ())
++#define EASE_INSPECTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR, EaseInspector))
++#define EASE_INSPECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR, EaseInspectorClass))
++#define EASE_IS_INSPECTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR))
++#define EASE_IS_INSPECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR))
++#define EASE_INSPECTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR, EaseInspectorClass))
++
++typedef struct _EaseInspector EaseInspector;
++typedef struct _EaseInspectorClass EaseInspectorClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++
++struct _EaseInspectorWindow {
++ GtkWindow parent_instance;
++ EaseInspectorWindowPrivate * priv;
++};
++
++struct _EaseInspectorWindowClass {
++ GtkWindowClass parent_class;
++};
++
++struct _EaseInspectorWindowPrivate {
++ EaseInspector* inspector;
++};
++
++
++static EaseInspectorWindow* ease_inspector_window_instance;
++static EaseInspectorWindow* ease_inspector_window_instance = NULL;
++static EaseSlide* ease_inspector_window_slide_priv;
++static EaseSlide* ease_inspector_window_slide_priv = NULL;
++static gpointer ease_inspector_window_parent_class = NULL;
++
++GType ease_inspector_window_get_type (void) G_GNUC_CONST;
++GType ease_inspector_get_type (void) G_GNUC_CONST;
++#define EASE_INSPECTOR_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_INSPECTOR_WINDOW, EaseInspectorWindowPrivate))
++enum {
++ EASE_INSPECTOR_WINDOW_DUMMY_PROPERTY
++};
++GType ease_slide_get_type (void) G_GNUC_CONST;
++EaseInspector* ease_inspector_new (void);
++EaseInspector* ease_inspector_construct (GType object_type);
++EaseInspectorWindow* ease_inspector_window_new (void);
++EaseInspectorWindow* ease_inspector_window_construct (GType object_type);
++void ease_inspector_window_toggle (void);
++EaseSlide* ease_inspector_window_get_slide (void);
++void ease_inspector_set_slide (EaseInspector* self, EaseSlide* value);
++void ease_inspector_window_set_slide (EaseSlide* value);
++static void ease_inspector_window_finalize (GObject* obj);
++static void ease_inspector_window_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_inspector_window_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++
++
++
++#line 26 "ease-inspector-window.vala"
++EaseInspectorWindow* ease_inspector_window_construct (GType object_type) {
++#line 102 "ease-inspector-window.c"
++ EaseInspectorWindow * self;
++ EaseInspector* _tmp0_;
++ self = g_object_newv (object_type, 0, NULL);
++#line 28 "ease-inspector-window.vala"
++ self->priv->inspector = (_tmp0_ = g_object_ref_sink (ease_inspector_new ()), _g_object_unref0 (self->priv->inspector), _tmp0_);
++#line 30 "ease-inspector-window.vala"
++ gtk_container_add ((GtkContainer*) self, (GtkWidget*) self->priv->inspector);
++#line 110 "ease-inspector-window.c"
++ return self;
++}
++
++
++#line 26 "ease-inspector-window.vala"
++EaseInspectorWindow* ease_inspector_window_new (void) {
++#line 26 "ease-inspector-window.vala"
++ return ease_inspector_window_construct (EASE_TYPE_INSPECTOR_WINDOW);
++#line 119 "ease-inspector-window.c"
++}
++
++
++#line 39 "ease-inspector-window.vala"
++void ease_inspector_window_toggle (void) {
++#line 41 "ease-inspector-window.vala"
++ if (ease_inspector_window_instance == NULL) {
++#line 127 "ease-inspector-window.c"
++ EaseInspectorWindow* _tmp0_;
++#line 43 "ease-inspector-window.vala"
++ ease_inspector_window_instance = (_tmp0_ = g_object_ref_sink (ease_inspector_window_new ()), _g_object_unref0 (ease_inspector_window_instance), _tmp0_);
++#line 131 "ease-inspector-window.c"
++ }
++#line 46 "ease-inspector-window.vala"
++ if (gtk_widget_get_visible ((GtkWidget*) ease_inspector_window_instance)) {
++#line 48 "ease-inspector-window.vala"
++ gtk_widget_hide ((GtkWidget*) ease_inspector_window_instance);
++#line 137 "ease-inspector-window.c"
++ } else {
++#line 52 "ease-inspector-window.vala"
++ gtk_widget_show_all ((GtkWidget*) ease_inspector_window_instance);
++#line 53 "ease-inspector-window.vala"
++ gtk_window_present ((GtkWindow*) ease_inspector_window_instance);
++#line 143 "ease-inspector-window.c"
++ }
++}
++
++
++EaseSlide* ease_inspector_window_get_slide (void) {
++ EaseSlide* result;
++ result = ease_inspector_window_slide_priv;
++#line 64 "ease-inspector-window.vala"
++ return result;
++#line 153 "ease-inspector-window.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++void ease_inspector_window_set_slide (EaseSlide* value) {
++#line 67 "ease-inspector-window.vala"
++ if (ease_inspector_window_slide_priv != value) {
++#line 165 "ease-inspector-window.c"
++ EaseSlide* _tmp0_;
++#line 69 "ease-inspector-window.vala"
++ ease_inspector_set_slide (ease_inspector_window_instance->priv->inspector, value);
++#line 70 "ease-inspector-window.vala"
++ ease_inspector_window_slide_priv = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (ease_inspector_window_slide_priv), _tmp0_);
++#line 171 "ease-inspector-window.c"
++ }
++}
++
++
++static void ease_inspector_window_class_init (EaseInspectorWindowClass * klass) {
++ ease_inspector_window_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseInspectorWindowPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_inspector_window_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_inspector_window_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_inspector_window_finalize;
++}
++
++
++static void ease_inspector_window_instance_init (EaseInspectorWindow * self) {
++ self->priv = EASE_INSPECTOR_WINDOW_GET_PRIVATE (self);
++}
++
++
++static void ease_inspector_window_finalize (GObject* obj) {
++ EaseInspectorWindow * self;
++ self = EASE_INSPECTOR_WINDOW (obj);
++ _g_object_unref0 (self->priv->inspector);
++ G_OBJECT_CLASS (ease_inspector_window_parent_class)->finalize (obj);
++}
++
++
++GType ease_inspector_window_get_type (void) {
++ static volatile gsize ease_inspector_window_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_inspector_window_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseInspectorWindowClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_inspector_window_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseInspectorWindow), 0, (GInstanceInitFunc) ease_inspector_window_instance_init, NULL };
++ GType ease_inspector_window_type_id;
++ ease_inspector_window_type_id = g_type_register_static (GTK_TYPE_WINDOW, "EaseInspectorWindow", &g_define_type_info, 0);
++ g_once_init_leave (&ease_inspector_window_type_id__volatile, ease_inspector_window_type_id);
++ }
++ return ease_inspector_window_type_id__volatile;
++}
++
++
++static void ease_inspector_window_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseInspectorWindow * self;
++ self = EASE_INSPECTOR_WINDOW (object);
++ switch (property_id) {
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_inspector_window_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseInspectorWindow * self;
++ self = EASE_INSPECTOR_WINDOW (object);
++ switch (property_id) {
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
diff --cc ease-core/ease-inspector.c
index 0000000,0000000..39c1927
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-inspector.c
@@@ -1,0 -1,0 +1,319 @@@
++/* ease-inspector.c generated by valac, the Vala compiler
++ * generated from ease-inspector.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_INSPECTOR (ease_inspector_get_type ())
++#define EASE_INSPECTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR, EaseInspector))
++#define EASE_INSPECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR, EaseInspectorClass))
++#define EASE_IS_INSPECTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR))
++#define EASE_IS_INSPECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR))
++#define EASE_INSPECTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR, EaseInspectorClass))
++
++typedef struct _EaseInspector EaseInspector;
++typedef struct _EaseInspectorClass EaseInspectorClass;
++typedef struct _EaseInspectorPrivate EaseInspectorPrivate;
++
++#define EASE_TYPE_INSPECTOR_PANE (ease_inspector_pane_get_type ())
++#define EASE_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPane))
++#define EASE_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++#define EASE_IS_INSPECTOR_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_IS_INSPECTOR_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_PANE))
++#define EASE_INSPECTOR_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_PANE, EaseInspectorPaneClass))
++
++typedef struct _EaseInspectorPane EaseInspectorPane;
++typedef struct _EaseInspectorPaneClass EaseInspectorPaneClass;
++
++#define EASE_TYPE_INSPECTOR_ELEMENT_PANE (ease_inspector_element_pane_get_type ())
++#define EASE_INSPECTOR_ELEMENT_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_ELEMENT_PANE, EaseInspectorElementPane))
++#define EASE_INSPECTOR_ELEMENT_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_ELEMENT_PANE, EaseInspectorElementPaneClass))
++#define EASE_IS_INSPECTOR_ELEMENT_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_ELEMENT_PANE))
++#define EASE_IS_INSPECTOR_ELEMENT_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_ELEMENT_PANE))
++#define EASE_INSPECTOR_ELEMENT_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_ELEMENT_PANE, EaseInspectorElementPaneClass))
++
++typedef struct _EaseInspectorElementPane EaseInspectorElementPane;
++typedef struct _EaseInspectorElementPaneClass EaseInspectorElementPaneClass;
++
++#define EASE_TYPE_INSPECTOR_TRANSITION_PANE (ease_inspector_transition_pane_get_type ())
++#define EASE_INSPECTOR_TRANSITION_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_TRANSITION_PANE, EaseInspectorTransitionPane))
++#define EASE_INSPECTOR_TRANSITION_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_TRANSITION_PANE, EaseInspectorTransitionPaneClass))
++#define EASE_IS_INSPECTOR_TRANSITION_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_TRANSITION_PANE))
++#define EASE_IS_INSPECTOR_TRANSITION_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_TRANSITION_PANE))
++#define EASE_INSPECTOR_TRANSITION_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_TRANSITION_PANE, EaseInspectorTransitionPaneClass))
++
++typedef struct _EaseInspectorTransitionPane EaseInspectorTransitionPane;
++typedef struct _EaseInspectorTransitionPaneClass EaseInspectorTransitionPaneClass;
++
++#define EASE_TYPE_INSPECTOR_SLIDE_PANE (ease_inspector_slide_pane_get_type ())
++#define EASE_INSPECTOR_SLIDE_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_INSPECTOR_SLIDE_PANE, EaseInspectorSlidePane))
++#define EASE_INSPECTOR_SLIDE_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_INSPECTOR_SLIDE_PANE, EaseInspectorSlidePaneClass))
++#define EASE_IS_INSPECTOR_SLIDE_PANE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_INSPECTOR_SLIDE_PANE))
++#define EASE_IS_INSPECTOR_SLIDE_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_INSPECTOR_SLIDE_PANE))
++#define EASE_INSPECTOR_SLIDE_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_INSPECTOR_SLIDE_PANE, EaseInspectorSlidePaneClass))
++
++typedef struct _EaseInspectorSlidePane EaseInspectorSlidePane;
++typedef struct _EaseInspectorSlidePaneClass EaseInspectorSlidePaneClass;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseInspector {
++ GtkNotebook parent_instance;
++ EaseInspectorPrivate * priv;
++ EaseInspectorElementPane* element_pane;
++};
++
++struct _EaseInspectorClass {
++ GtkNotebookClass parent_class;
++};
++
++struct _EaseInspectorPrivate {
++ EaseInspectorTransitionPane* transition_pane;
++ EaseInspectorSlidePane* slide_pane;
++ EaseSlide* slide_priv;
++};
++
++
++static gpointer ease_inspector_parent_class = NULL;
++static EaseUndoSourceIface* ease_inspector_ease_undo_source_parent_iface = NULL;
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_inspector_get_type (void) G_GNUC_CONST;
++GType ease_inspector_pane_get_type (void) G_GNUC_CONST;
++GType ease_inspector_element_pane_get_type (void) G_GNUC_CONST;
++GType ease_inspector_transition_pane_get_type (void) G_GNUC_CONST;
++GType ease_inspector_slide_pane_get_type (void) G_GNUC_CONST;
++GType ease_slide_get_type (void) G_GNUC_CONST;
++#define EASE_INSPECTOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_INSPECTOR, EaseInspectorPrivate))
++enum {
++ EASE_INSPECTOR_DUMMY_PROPERTY,
++ EASE_INSPECTOR_SLIDE
++};
++#define EASE_INSPECTOR_REQUEST_WIDTH 200
++#define EASE_INSPECTOR_REQUEST_HEIGHT 0
++EaseInspectorTransitionPane* ease_inspector_transition_pane_new (void);
++EaseInspectorTransitionPane* ease_inspector_transition_pane_construct (GType object_type);
++EaseInspectorElementPane* ease_inspector_element_pane_new (void);
++EaseInspectorElementPane* ease_inspector_element_pane_construct (GType object_type);
++EaseInspectorSlidePane* ease_inspector_slide_pane_new (void);
++EaseInspectorSlidePane* ease_inspector_slide_pane_construct (GType object_type);
++static void ease_inspector_append (EaseInspector* self, EaseInspectorPane* i, const char* stock_id);
++EaseInspector* ease_inspector_new (void);
++EaseInspector* ease_inspector_construct (GType object_type);
++void ease_undo_source_listen (EaseUndoSource* self, EaseUndoSource* source);
++EaseSlide* ease_inspector_get_slide (EaseInspector* self);
++void ease_inspector_pane_set_slide (EaseInspectorPane* self, EaseSlide* value);
++void ease_inspector_set_slide (EaseInspector* self, EaseSlide* value);
++static void ease_inspector_finalize (GObject* obj);
++static void ease_inspector_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_inspector_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++
++
++
++#line 46 "ease-inspector.vala"
++EaseInspector* ease_inspector_construct (GType object_type) {
++#line 158 "ease-inspector.c"
++ EaseInspector * self;
++ EaseInspectorTransitionPane* _tmp0_;
++ EaseInspectorElementPane* _tmp1_;
++ EaseInspectorSlidePane* _tmp2_;
++ self = g_object_newv (object_type, 0, NULL);
++#line 48 "ease-inspector.vala"
++ gtk_widget_set_size_request ((GtkWidget*) self, EASE_INSPECTOR_REQUEST_WIDTH, EASE_INSPECTOR_REQUEST_HEIGHT);
++#line 50 "ease-inspector.vala"
++ self->priv->transition_pane = (_tmp0_ = g_object_ref_sink (ease_inspector_transition_pane_new ()), _g_object_unref0 (self->priv->transition_pane), _tmp0_);
++#line 51 "ease-inspector.vala"
++ self->element_pane = (_tmp1_ = g_object_ref_sink (ease_inspector_element_pane_new ()), _g_object_unref0 (self->element_pane), _tmp1_);
++#line 52 "ease-inspector.vala"
++ self->priv->slide_pane = (_tmp2_ = g_object_ref_sink (ease_inspector_slide_pane_new ()), _g_object_unref0 (self->priv->slide_pane), _tmp2_);
++#line 55 "ease-inspector.vala"
++ ease_inspector_append (self, (EaseInspectorPane*) self->priv->slide_pane, "gtk-page-setup");
++#line 56 "ease-inspector.vala"
++ ease_inspector_append (self, (EaseInspectorPane*) self->element_pane, "gtk-index");
++#line 57 "ease-inspector.vala"
++ ease_inspector_append (self, (EaseInspectorPane*) self->priv->transition_pane, "gtk-media-forward");
++#line 58 "ease-inspector.vala"
++ gtk_widget_show ((GtkWidget*) self->priv->slide_pane);
++#line 59 "ease-inspector.vala"
++ gtk_widget_show_all ((GtkWidget*) self->element_pane);
++#line 60 "ease-inspector.vala"
++ gtk_widget_show_all ((GtkWidget*) self->priv->transition_pane);
++#line 184 "ease-inspector.c"
++ return self;
++}
++
++
++#line 46 "ease-inspector.vala"
++EaseInspector* ease_inspector_new (void) {
++#line 46 "ease-inspector.vala"
++ return ease_inspector_construct (EASE_TYPE_INSPECTOR);
++#line 193 "ease-inspector.c"
++}
++
++
++#line 63 "ease-inspector.vala"
++static void ease_inspector_append (EaseInspector* self, EaseInspectorPane* i, const char* stock_id) {
++#line 199 "ease-inspector.c"
++ GtkImage* _tmp0_;
++#line 63 "ease-inspector.vala"
++ g_return_if_fail (self != NULL);
++#line 63 "ease-inspector.vala"
++ g_return_if_fail (i != NULL);
++#line 63 "ease-inspector.vala"
++ g_return_if_fail (stock_id != NULL);
++#line 65 "ease-inspector.vala"
++ gtk_notebook_append_page ((GtkNotebook*) self, (GtkWidget*) i, (GtkWidget*) (_tmp0_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_SMALL_TOOLBAR))));
++#line 209 "ease-inspector.c"
++ _g_object_unref0 (_tmp0_);
++#line 67 "ease-inspector.vala"
++ ease_undo_source_listen ((EaseUndoSource*) self, (EaseUndoSource*) i);
++#line 213 "ease-inspector.c"
++}
++
++
++EaseSlide* ease_inspector_get_slide (EaseInspector* self) {
++ EaseSlide* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->slide_priv;
++#line 38 "ease-inspector.vala"
++ return result;
++#line 223 "ease-inspector.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++void ease_inspector_set_slide (EaseInspector* self, EaseSlide* value) {
++ EaseSlide* _tmp0_;
++ g_return_if_fail (self != NULL);
++#line 40 "ease-inspector.vala"
++ self->priv->slide_priv = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->slide_priv), _tmp0_);
++#line 41 "ease-inspector.vala"
++ ease_inspector_pane_set_slide ((EaseInspectorPane*) self->priv->transition_pane, value);
++#line 42 "ease-inspector.vala"
++ ease_inspector_pane_set_slide ((EaseInspectorPane*) self->priv->slide_pane, value);
++#line 241 "ease-inspector.c"
++ g_object_notify ((GObject *) self, "slide");
++}
++
++
++static void ease_inspector_class_init (EaseInspectorClass * klass) {
++ ease_inspector_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseInspectorPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_inspector_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_inspector_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_inspector_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_INSPECTOR_SLIDE, g_param_spec_object ("slide", "slide", "slide", EASE_TYPE_SLIDE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++}
++
++
++static void ease_inspector_ease_undo_source_interface_init (EaseUndoSourceIface * iface) {
++ ease_inspector_ease_undo_source_parent_iface = g_type_interface_peek_parent (iface);
++}
++
++
++static void ease_inspector_instance_init (EaseInspector * self) {
++ self->priv = EASE_INSPECTOR_GET_PRIVATE (self);
++}
++
++
++static void ease_inspector_finalize (GObject* obj) {
++ EaseInspector * self;
++ self = EASE_INSPECTOR (obj);
++ _g_object_unref0 (self->priv->transition_pane);
++ _g_object_unref0 (self->priv->slide_pane);
++ _g_object_unref0 (self->element_pane);
++ _g_object_unref0 (self->priv->slide_priv);
++ G_OBJECT_CLASS (ease_inspector_parent_class)->finalize (obj);
++}
++
++
++GType ease_inspector_get_type (void) {
++ static volatile gsize ease_inspector_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_inspector_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseInspectorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_inspector_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseInspector), 0, (GInstanceInitFunc) ease_inspector_instance_init, NULL };
++ static const GInterfaceInfo ease_undo_source_info = { (GInterfaceInitFunc) ease_inspector_ease_undo_source_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
++ GType ease_inspector_type_id;
++ ease_inspector_type_id = g_type_register_static (GTK_TYPE_NOTEBOOK, "EaseInspector", &g_define_type_info, 0);
++ g_type_add_interface_static (ease_inspector_type_id, EASE_TYPE_UNDO_SOURCE, &ease_undo_source_info);
++ g_once_init_leave (&ease_inspector_type_id__volatile, ease_inspector_type_id);
++ }
++ return ease_inspector_type_id__volatile;
++}
++
++
++static void ease_inspector_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseInspector * self;
++ self = EASE_INSPECTOR (object);
++ switch (property_id) {
++ case EASE_INSPECTOR_SLIDE:
++ g_value_set_object (value, ease_inspector_get_slide (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_inspector_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseInspector * self;
++ self = EASE_INSPECTOR (object);
++ switch (property_id) {
++ case EASE_INSPECTOR_SLIDE:
++ ease_inspector_set_slide (self, g_value_get_object (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
diff --cc ease-core/ease-iterables.c
index 0000000,0000000..6042cb1
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-iterables.c
@@@ -1,0 -1,0 +1,460 @@@
++/* ease-iterables.c generated by valac, the Vala compiler
++ * generated from ease-iterables.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <gobject/gvaluecollector.h>
++
++
++#define EASE_ITERABLE_TYPE_TREE_MODEL (ease_iterable_tree_model_get_type ())
++#define EASE_ITERABLE_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_ITERABLE_TYPE_TREE_MODEL, EaseIterableTreeModel))
++#define EASE_ITERABLE_IS_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_ITERABLE_TYPE_TREE_MODEL))
++#define EASE_ITERABLE_TREE_MODEL_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_ITERABLE_TYPE_TREE_MODEL, EaseIterableTreeModelIface))
++
++typedef struct _EaseIterableTreeModel EaseIterableTreeModel;
++typedef struct _EaseIterableTreeModelIface EaseIterableTreeModelIface;
++
++#define EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR (ease_iterable_tree_model_iterator_get_type ())
++#define EASE_ITERABLE_TREE_MODEL_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR, EaseIterableTreeModelIterator))
++#define EASE_ITERABLE_TREE_MODEL_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR, EaseIterableTreeModelIteratorClass))
++#define EASE_ITERABLE_TREE_MODEL_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR))
++#define EASE_ITERABLE_TREE_MODEL_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR))
++#define EASE_ITERABLE_TREE_MODEL_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR, EaseIterableTreeModelIteratorClass))
++
++typedef struct _EaseIterableTreeModelIterator EaseIterableTreeModelIterator;
++typedef struct _EaseIterableTreeModelIteratorClass EaseIterableTreeModelIteratorClass;
++typedef struct _EaseIterableTreeModelIteratorPrivate EaseIterableTreeModelIteratorPrivate;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++typedef struct _EaseIterableTreeModelParamSpecIterator EaseIterableTreeModelParamSpecIterator;
++
++#define EASE_ITERABLE_TYPE_LIST_STORE (ease_iterable_list_store_get_type ())
++#define EASE_ITERABLE_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStore))
++#define EASE_ITERABLE_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStoreClass))
++#define EASE_ITERABLE_IS_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_ITERABLE_TYPE_LIST_STORE))
++#define EASE_ITERABLE_IS_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_ITERABLE_TYPE_LIST_STORE))
++#define EASE_ITERABLE_LIST_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStoreClass))
++
++typedef struct _EaseIterableListStore EaseIterableListStore;
++typedef struct _EaseIterableListStoreClass EaseIterableListStoreClass;
++typedef struct _EaseIterableListStorePrivate EaseIterableListStorePrivate;
++
++struct _EaseIterableTreeModelIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseIterableTreeModelIterator {
++ GTypeInstance parent_instance;
++ volatile int ref_count;
++ EaseIterableTreeModelIteratorPrivate * priv;
++};
++
++struct _EaseIterableTreeModelIteratorClass {
++ GTypeClass parent_class;
++ void (*finalize) (EaseIterableTreeModelIterator *self);
++};
++
++struct _EaseIterableTreeModelIteratorPrivate {
++ GtkTreeIter itr;
++ EaseIterableTreeModel* model;
++ gboolean more;
++};
++
++struct _EaseIterableTreeModelParamSpecIterator {
++ GParamSpec parent_instance;
++};
++
++struct _EaseIterableListStore {
++ GtkListStore parent_instance;
++ EaseIterableListStorePrivate * priv;
++};
++
++struct _EaseIterableListStoreClass {
++ GtkListStoreClass parent_class;
++};
++
++
++static gpointer ease_iterable_tree_model_iterator_parent_class = NULL;
++static gpointer ease_iterable_list_store_parent_class = NULL;
++static EaseIterableTreeModelIface* ease_iterable_list_store_ease_iterable_tree_model_parent_iface = NULL;
++
++GType ease_iterable_tree_model_get_type (void) G_GNUC_CONST;
++EaseIterableTreeModelIterator* ease_iterable_tree_model_iterator_new (EaseIterableTreeModel* _self_);
++EaseIterableTreeModelIterator* ease_iterable_tree_model_iterator_construct (GType object_type, EaseIterableTreeModel* _self_);
++gpointer ease_iterable_tree_model_iterator_ref (gpointer instance);
++void ease_iterable_tree_model_iterator_unref (gpointer instance);
++GParamSpec* ease_iterable_tree_model_param_spec_iterator (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
++void ease_iterable_tree_model_value_set_iterator (GValue* value, gpointer v_object);
++void ease_iterable_tree_model_value_take_iterator (GValue* value, gpointer v_object);
++gpointer ease_iterable_tree_model_value_get_iterator (const GValue* value);
++GType ease_iterable_tree_model_iterator_get_type (void) G_GNUC_CONST;
++EaseIterableTreeModelIterator* ease_iterable_tree_model_iterator (EaseIterableTreeModel* self);
++#define EASE_ITERABLE_TREE_MODEL_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR, EaseIterableTreeModelIteratorPrivate))
++enum {
++ EASE_ITERABLE_TREE_MODEL_ITERATOR_DUMMY_PROPERTY
++};
++gboolean ease_iterable_tree_model_iterator_next (EaseIterableTreeModelIterator* self);
++void ease_iterable_tree_model_iterator_get (EaseIterableTreeModelIterator* self, GtkTreeIter* result);
++static void ease_iterable_tree_model_iterator_finalize (EaseIterableTreeModelIterator* obj);
++GType ease_iterable_list_store_get_type (void) G_GNUC_CONST;
++enum {
++ EASE_ITERABLE_LIST_STORE_DUMMY_PROPERTY,
++ EASE_ITERABLE_LIST_STORE_SIZE
++};
++EaseIterableListStore* ease_iterable_list_store_new (GType* types, int types_length1);
++EaseIterableListStore* ease_iterable_list_store_construct (GType object_type, GType* types, int types_length1);
++gint ease_iterable_list_store_get_size (EaseIterableListStore* self);
++static void ease_iterable_list_store_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++
++
++
++#line 26 "ease-iterables.vala"
++EaseIterableTreeModelIterator* ease_iterable_tree_model_iterator (EaseIterableTreeModel* self) {
++#line 131 "ease-iterables.c"
++ EaseIterableTreeModelIterator* result = NULL;
++ result = ease_iterable_tree_model_iterator_new (self);
++#line 28 "ease-iterables.vala"
++ return result;
++#line 136 "ease-iterables.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 37 "ease-iterables.vala"
++EaseIterableTreeModelIterator* ease_iterable_tree_model_iterator_construct (GType object_type, EaseIterableTreeModel* _self_) {
++#line 147 "ease-iterables.c"
++ EaseIterableTreeModelIterator* self;
++ EaseIterableTreeModel* _tmp0_;
++#line 37 "ease-iterables.vala"
++ g_return_val_if_fail (_self_ != NULL, NULL);
++#line 152 "ease-iterables.c"
++ self = (EaseIterableTreeModelIterator*) g_type_create_instance (object_type);
++#line 39 "ease-iterables.vala"
++ self->priv->more = gtk_tree_model_get_iter_first ((GtkTreeModel*) _self_, &self->priv->itr);
++#line 40 "ease-iterables.vala"
++ self->priv->model = (_tmp0_ = _g_object_ref0 (_self_), _g_object_unref0 (self->priv->model), _tmp0_);
++#line 158 "ease-iterables.c"
++ return self;
++}
++
++
++#line 37 "ease-iterables.vala"
++EaseIterableTreeModelIterator* ease_iterable_tree_model_iterator_new (EaseIterableTreeModel* _self_) {
++#line 37 "ease-iterables.vala"
++ return ease_iterable_tree_model_iterator_construct (EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR, _self_);
++#line 167 "ease-iterables.c"
++}
++
++
++#line 43 "ease-iterables.vala"
++gboolean ease_iterable_tree_model_iterator_next (EaseIterableTreeModelIterator* self) {
++#line 173 "ease-iterables.c"
++ gboolean result = FALSE;
++#line 43 "ease-iterables.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 177 "ease-iterables.c"
++ result = self->priv->more;
++#line 45 "ease-iterables.vala"
++ return result;
++#line 181 "ease-iterables.c"
++}
++
++
++#line 48 "ease-iterables.vala"
++void ease_iterable_tree_model_iterator_get (EaseIterableTreeModelIterator* self, GtkTreeIter* result) {
++#line 187 "ease-iterables.c"
++ GtkTreeIter ret;
++#line 48 "ease-iterables.vala"
++ g_return_if_fail (self != NULL);
++#line 50 "ease-iterables.vala"
++ ret = self->priv->itr;
++#line 51 "ease-iterables.vala"
++ self->priv->more = gtk_tree_model_iter_next ((GtkTreeModel*) self->priv->model, &self->priv->itr);
++#line 195 "ease-iterables.c"
++ *result = ret;
++#line 52 "ease-iterables.vala"
++ return;
++#line 199 "ease-iterables.c"
++}
++
++
++static void ease_iterable_tree_model_value_iterator_init (GValue* value) {
++ value->data[0].v_pointer = NULL;
++}
++
++
++static void ease_iterable_tree_model_value_iterator_free_value (GValue* value) {
++ if (value->data[0].v_pointer) {
++ ease_iterable_tree_model_iterator_unref (value->data[0].v_pointer);
++ }
++}
++
++
++static void ease_iterable_tree_model_value_iterator_copy_value (const GValue* src_value, GValue* dest_value) {
++ if (src_value->data[0].v_pointer) {
++ dest_value->data[0].v_pointer = ease_iterable_tree_model_iterator_ref (src_value->data[0].v_pointer);
++ } else {
++ dest_value->data[0].v_pointer = NULL;
++ }
++}
++
++
++static gpointer ease_iterable_tree_model_value_iterator_peek_pointer (const GValue* value) {
++ return value->data[0].v_pointer;
++}
++
++
++static gchar* ease_iterable_tree_model_value_iterator_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
++ if (collect_values[0].v_pointer) {
++ EaseIterableTreeModelIterator* object;
++ object = collect_values[0].v_pointer;
++ if (object->parent_instance.g_class == NULL) {
++ return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
++ } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
++ return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
++ }
++ value->data[0].v_pointer = ease_iterable_tree_model_iterator_ref (object);
++ } else {
++ value->data[0].v_pointer = NULL;
++ }
++ return NULL;
++}
++
++
++static gchar* ease_iterable_tree_model_value_iterator_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
++ EaseIterableTreeModelIterator** object_p;
++ object_p = collect_values[0].v_pointer;
++ if (!object_p) {
++ return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
++ }
++ if (!value->data[0].v_pointer) {
++ *object_p = NULL;
++ } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
++ *object_p = value->data[0].v_pointer;
++ } else {
++ *object_p = ease_iterable_tree_model_iterator_ref (value->data[0].v_pointer);
++ }
++ return NULL;
++}
++
++
++GParamSpec* ease_iterable_tree_model_param_spec_iterator (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
++ EaseIterableTreeModelParamSpecIterator* spec;
++ g_return_val_if_fail (g_type_is_a (object_type, EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR), NULL);
++ spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
++ G_PARAM_SPEC (spec)->value_type = object_type;
++ return G_PARAM_SPEC (spec);
++}
++
++
++gpointer ease_iterable_tree_model_value_get_iterator (const GValue* value) {
++ g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR), NULL);
++ return value->data[0].v_pointer;
++}
++
++
++void ease_iterable_tree_model_value_set_iterator (GValue* value, gpointer v_object) {
++ EaseIterableTreeModelIterator* old;
++ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR));
++ old = value->data[0].v_pointer;
++ if (v_object) {
++ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR));
++ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
++ value->data[0].v_pointer = v_object;
++ ease_iterable_tree_model_iterator_ref (value->data[0].v_pointer);
++ } else {
++ value->data[0].v_pointer = NULL;
++ }
++ if (old) {
++ ease_iterable_tree_model_iterator_unref (old);
++ }
++}
++
++
++void ease_iterable_tree_model_value_take_iterator (GValue* value, gpointer v_object) {
++ EaseIterableTreeModelIterator* old;
++ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR));
++ old = value->data[0].v_pointer;
++ if (v_object) {
++ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR));
++ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
++ value->data[0].v_pointer = v_object;
++ } else {
++ value->data[0].v_pointer = NULL;
++ }
++ if (old) {
++ ease_iterable_tree_model_iterator_unref (old);
++ }
++}
++
++
++static void ease_iterable_tree_model_iterator_class_init (EaseIterableTreeModelIteratorClass * klass) {
++ ease_iterable_tree_model_iterator_parent_class = g_type_class_peek_parent (klass);
++ EASE_ITERABLE_TREE_MODEL_ITERATOR_CLASS (klass)->finalize = ease_iterable_tree_model_iterator_finalize;
++ g_type_class_add_private (klass, sizeof (EaseIterableTreeModelIteratorPrivate));
++}
++
++
++static void ease_iterable_tree_model_iterator_instance_init (EaseIterableTreeModelIterator * self) {
++ self->priv = EASE_ITERABLE_TREE_MODEL_ITERATOR_GET_PRIVATE (self);
++ self->ref_count = 1;
++}
++
++
++static void ease_iterable_tree_model_iterator_finalize (EaseIterableTreeModelIterator* obj) {
++ EaseIterableTreeModelIterator * self;
++ self = EASE_ITERABLE_TREE_MODEL_ITERATOR (obj);
++ _g_object_unref0 (self->priv->model);
++}
++
++
++GType ease_iterable_tree_model_iterator_get_type (void) {
++ static volatile gsize ease_iterable_tree_model_iterator_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_iterable_tree_model_iterator_type_id__volatile)) {
++ static const GTypeValueTable g_define_type_value_table = { ease_iterable_tree_model_value_iterator_init, ease_iterable_tree_model_value_iterator_free_value, ease_iterable_tree_model_value_iterator_copy_value, ease_iterable_tree_model_value_iterator_peek_pointer, "p", ease_iterable_tree_model_value_iterator_collect_value, "p", ease_iterable_tree_model_value_iterator_lcopy_value };
++ static const GTypeInfo g_define_type_info = { sizeof (EaseIterableTreeModelIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_iterable_tree_model_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseIterableTreeModelIterator), 0, (GInstanceInitFunc) ease_iterable_tree_model_iterator_instance_init, &g_define_type_value_table };
++ static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
++ GType ease_iterable_tree_model_iterator_type_id;
++ ease_iterable_tree_model_iterator_type_id = g_type_register_fundamental (g_type_fundamental_next (), "EaseIterableTreeModelIterator", &g_define_type_info, &g_define_type_fundamental_info, 0);
++ g_once_init_leave (&ease_iterable_tree_model_iterator_type_id__volatile, ease_iterable_tree_model_iterator_type_id);
++ }
++ return ease_iterable_tree_model_iterator_type_id__volatile;
++}
++
++
++gpointer ease_iterable_tree_model_iterator_ref (gpointer instance) {
++ EaseIterableTreeModelIterator* self;
++ self = instance;
++ g_atomic_int_inc (&self->ref_count);
++ return instance;
++}
++
++
++void ease_iterable_tree_model_iterator_unref (gpointer instance) {
++ EaseIterableTreeModelIterator* self;
++ self = instance;
++ if (g_atomic_int_dec_and_test (&self->ref_count)) {
++ EASE_ITERABLE_TREE_MODEL_ITERATOR_GET_CLASS (self)->finalize (self);
++ g_type_free_instance ((GTypeInstance *) self);
++ }
++}
++
++
++static void ease_iterable_tree_model_base_init (EaseIterableTreeModelIface * iface) {
++ static gboolean initialized = FALSE;
++ if (!initialized) {
++ initialized = TRUE;
++ }
++}
++
++
++GType ease_iterable_tree_model_get_type (void) {
++ static volatile gsize ease_iterable_tree_model_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_iterable_tree_model_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseIterableTreeModelIface), (GBaseInitFunc) ease_iterable_tree_model_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
++ GType ease_iterable_tree_model_type_id;
++ ease_iterable_tree_model_type_id = g_type_register_static (G_TYPE_INTERFACE, "EaseIterableTreeModel", &g_define_type_info, 0);
++ g_type_interface_add_prerequisite (ease_iterable_tree_model_type_id, GTK_TYPE_TREE_MODEL);
++ g_once_init_leave (&ease_iterable_tree_model_type_id__volatile, ease_iterable_tree_model_type_id);
++ }
++ return ease_iterable_tree_model_type_id__volatile;
++}
++
++
++#line 65 "ease-iterables.vala"
++EaseIterableListStore* ease_iterable_list_store_construct (GType object_type, GType* types, int types_length1) {
++#line 388 "ease-iterables.c"
++ EaseIterableListStore * self;
++ self = g_object_newv (object_type, 0, NULL);
++#line 67 "ease-iterables.vala"
++ gtk_list_store_set_column_types ((GtkListStore*) self, types_length1, types);
++#line 393 "ease-iterables.c"
++ return self;
++}
++
++
++#line 65 "ease-iterables.vala"
++EaseIterableListStore* ease_iterable_list_store_new (GType* types, int types_length1) {
++#line 65 "ease-iterables.vala"
++ return ease_iterable_list_store_construct (EASE_ITERABLE_TYPE_LIST_STORE, types, types_length1);
++#line 402 "ease-iterables.c"
++}
++
++
++gint ease_iterable_list_store_get_size (EaseIterableListStore* self) {
++ gint result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = gtk_tree_model_iter_n_children ((GtkTreeModel*) self, NULL);
++#line 73 "ease-iterables.vala"
++ return result;
++#line 412 "ease-iterables.c"
++}
++
++
++static void ease_iterable_list_store_class_init (EaseIterableListStoreClass * klass) {
++ ease_iterable_list_store_parent_class = g_type_class_peek_parent (klass);
++ G_OBJECT_CLASS (klass)->get_property = ease_iterable_list_store_get_property;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ITERABLE_LIST_STORE_SIZE, g_param_spec_int ("size", "size", "size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++}
++
++
++static void ease_iterable_list_store_ease_iterable_tree_model_interface_init (EaseIterableTreeModelIface * iface) {
++ ease_iterable_list_store_ease_iterable_tree_model_parent_iface = g_type_interface_peek_parent (iface);
++}
++
++
++static void ease_iterable_list_store_instance_init (EaseIterableListStore * self) {
++}
++
++
++GType ease_iterable_list_store_get_type (void) {
++ static volatile gsize ease_iterable_list_store_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_iterable_list_store_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseIterableListStoreClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_iterable_list_store_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseIterableListStore), 0, (GInstanceInitFunc) ease_iterable_list_store_instance_init, NULL };
++ static const GInterfaceInfo ease_iterable_tree_model_info = { (GInterfaceInitFunc) ease_iterable_list_store_ease_iterable_tree_model_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
++ GType ease_iterable_list_store_type_id;
++ ease_iterable_list_store_type_id = g_type_register_static (GTK_TYPE_LIST_STORE, "EaseIterableListStore", &g_define_type_info, 0);
++ g_type_add_interface_static (ease_iterable_list_store_type_id, EASE_ITERABLE_TYPE_TREE_MODEL, &ease_iterable_tree_model_info);
++ g_once_init_leave (&ease_iterable_list_store_type_id__volatile, ease_iterable_list_store_type_id);
++ }
++ return ease_iterable_list_store_type_id__volatile;
++}
++
++
++static void ease_iterable_list_store_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseIterableListStore * self;
++ self = EASE_ITERABLE_LIST_STORE (object);
++ switch (property_id) {
++ case EASE_ITERABLE_LIST_STORE_SIZE:
++ g_value_set_int (value, ease_iterable_list_store_get_size (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
diff --cc ease-core/ease-main.c
index 0000000,0000000..afaff8c
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-main.c
@@@ -1,0 -1,0 +1,672 @@@
++/* ease-main.c generated by valac, the Vala compiler
++ * generated from ease-main.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gee.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++#include <glib/gi18n-lib.h>
++#include <clutter/clutter.h>
++#include <stdio.h>
++
++
++#define EASE_TYPE_MAIN (ease_main_get_type ())
++#define EASE_MAIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_MAIN, EaseMain))
++#define EASE_MAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_MAIN, EaseMainClass))
++#define EASE_IS_MAIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_MAIN))
++#define EASE_IS_MAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_MAIN))
++#define EASE_MAIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_MAIN, EaseMainClass))
++
++typedef struct _EaseMain EaseMain;
++typedef struct _EaseMainClass EaseMainClass;
++typedef struct _EaseMainPrivate EaseMainPrivate;
++
++#define EASE_TYPE_EDITOR_WINDOW (ease_editor_window_get_type ())
++#define EASE_EDITOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindow))
++#define EASE_EDITOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindowClass))
++#define EASE_IS_EDITOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_WINDOW))
++#define EASE_IS_EDITOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_WINDOW))
++#define EASE_EDITOR_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindowClass))
++
++typedef struct _EaseEditorWindow EaseEditorWindow;
++typedef struct _EaseEditorWindowClass EaseEditorWindowClass;
++
++#define EASE_TYPE_WELCOME_WINDOW (ease_welcome_window_get_type ())
++#define EASE_WELCOME_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_WELCOME_WINDOW, EaseWelcomeWindow))
++#define EASE_WELCOME_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_WELCOME_WINDOW, EaseWelcomeWindowClass))
++#define EASE_IS_WELCOME_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_WELCOME_WINDOW))
++#define EASE_IS_WELCOME_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_WELCOME_WINDOW))
++#define EASE_WELCOME_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_WELCOME_WINDOW, EaseWelcomeWindowClass))
++
++typedef struct _EaseWelcomeWindow EaseWelcomeWindow;
++typedef struct _EaseWelcomeWindowClass EaseWelcomeWindowClass;
++
++#define EASE_TYPE_PLAYER (ease_player_get_type ())
++#define EASE_PLAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_PLAYER, EasePlayer))
++#define EASE_PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_PLAYER, EasePlayerClass))
++#define EASE_IS_PLAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_PLAYER))
++#define EASE_IS_PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_PLAYER))
++#define EASE_PLAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_PLAYER, EasePlayerClass))
++
++typedef struct _EasePlayer EasePlayer;
++typedef struct _EasePlayerClass EasePlayerClass;
++#define _g_option_context_free0(var) ((var == NULL) ? NULL : (var = (g_option_context_free (var), NULL)))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++typedef struct _EaseEditorWindowPrivate EaseEditorWindowPrivate;
++
++#define EASE_TYPE_SCROLLABLE_EMBED (ease_scrollable_embed_get_type ())
++#define EASE_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbed))
++#define EASE_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++#define EASE_IS_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_IS_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_SCROLLABLE_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++
++typedef struct _EaseScrollableEmbed EaseScrollableEmbed;
++typedef struct _EaseScrollableEmbedClass EaseScrollableEmbedClass;
++
++#define EASE_TYPE_EDITOR_EMBED (ease_editor_embed_get_type ())
++#define EASE_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbed))
++#define EASE_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++#define EASE_IS_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_EMBED))
++#define EASE_IS_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_EMBED))
++#define EASE_EDITOR_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++
++typedef struct _EaseEditorEmbed EaseEditorEmbed;
++typedef struct _EaseEditorEmbedClass EaseEditorEmbedClass;
++
++#define EASE_TYPE_SLIDE_BUTTON_PANEL (ease_slide_button_panel_get_type ())
++#define EASE_SLIDE_BUTTON_PANEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_BUTTON_PANEL, EaseSlideButtonPanel))
++#define EASE_SLIDE_BUTTON_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_BUTTON_PANEL, EaseSlideButtonPanelClass))
++#define EASE_IS_SLIDE_BUTTON_PANEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_BUTTON_PANEL))
++#define EASE_IS_SLIDE_BUTTON_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_BUTTON_PANEL))
++#define EASE_SLIDE_BUTTON_PANEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_BUTTON_PANEL, EaseSlideButtonPanelClass))
++
++typedef struct _EaseSlideButtonPanel EaseSlideButtonPanel;
++typedef struct _EaseSlideButtonPanelClass EaseSlideButtonPanelClass;
++
++#define EASE_TYPE_ZOOM_SLIDER (ease_zoom_slider_get_type ())
++#define EASE_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ZOOM_SLIDER, EaseZoomSlider))
++#define EASE_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ZOOM_SLIDER, EaseZoomSliderClass))
++#define EASE_IS_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ZOOM_SLIDER))
++#define EASE_IS_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ZOOM_SLIDER))
++#define EASE_ZOOM_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ZOOM_SLIDER, EaseZoomSliderClass))
++
++typedef struct _EaseZoomSlider EaseZoomSlider;
++typedef struct _EaseZoomSliderClass EaseZoomSliderClass;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++
++struct _EaseMain {
++ GObject parent_instance;
++ EaseMainPrivate * priv;
++};
++
++struct _EaseMainClass {
++ GObjectClass parent_class;
++};
++
++struct _EaseEditorWindow {
++ GtkWindow parent_instance;
++ EaseEditorWindowPrivate * priv;
++ EaseEditorEmbed* embed;
++ EaseSlideButtonPanel* slide_button_panel;
++ EaseZoomSlider* zoom_slider;
++ EaseDocument* document;
++ EaseSlide* slide;
++};
++
++struct _EaseEditorWindowClass {
++ GtkWindowClass parent_class;
++};
++
++
++static GeeArrayList* ease_main_windows;
++static GeeArrayList* ease_main_windows = NULL;
++static EaseWelcomeWindow* ease_main_welcome;
++static EaseWelcomeWindow* ease_main_welcome = NULL;
++static char* ease_main_play_filename;
++static char* ease_main_play_filename = NULL;
++static char** ease_main_filenames;
++static gint ease_main_filenames_length1;
++static char** ease_main_filenames = NULL;
++static gint ease_main_filenames_length1 = 0;
++static gint _ease_main_filenames_size_ = 0;
++extern gboolean ease_main_presentation_windowed;
++gboolean ease_main_presentation_windowed = FALSE;
++static EasePlayer* ease_main_player;
++static EasePlayer* ease_main_player = NULL;
++static gpointer ease_main_parent_class = NULL;
++
++GType ease_main_get_type (void) G_GNUC_CONST;
++enum {
++ EASE_MAIN_DUMMY_PROPERTY
++};
++GType ease_editor_window_get_type (void) G_GNUC_CONST;
++GType ease_welcome_window_get_type (void) G_GNUC_CONST;
++GType ease_player_get_type (void) G_GNUC_CONST;
++void ease_main_open_file (const char* path);
++EaseDocument* ease_document_new_from_saved (const char* file_path, GError** error);
++EaseDocument* ease_document_construct_from_saved (GType object_type, const char* file_path, GError** error);
++GType ease_document_get_type (void) G_GNUC_CONST;
++EasePlayer* ease_player_new (EaseDocument* doc);
++EasePlayer* ease_player_construct (GType object_type, EaseDocument* doc);
++ClutterStage* ease_player_get_stage (EasePlayer* self);
++static void _lambda89_ (void);
++static void __lambda89__clutter_actor_hide (ClutterActor* _sender, gpointer self);
++void ease_error_dialog (const char* title, const char* message);
++void ease_main_show_welcome (void);
++void ease_temp_clean (void);
++gint ease_main_main (char** args, int args_length1);
++GType ease_scrollable_embed_get_type (void) G_GNUC_CONST;
++GType ease_editor_embed_get_type (void) G_GNUC_CONST;
++GType ease_slide_button_panel_get_type (void) G_GNUC_CONST;
++GType ease_zoom_slider_get_type (void) G_GNUC_CONST;
++GType ease_slide_get_type (void) G_GNUC_CONST;
++const char* ease_document_get_path (EaseDocument* self);
++void ease_main_add_window (EaseEditorWindow* win);
++EaseEditorWindow* ease_editor_window_new (EaseDocument* doc);
++EaseEditorWindow* ease_editor_window_construct (GType object_type, EaseDocument* doc);
++void ease_main_remove_window (EaseEditorWindow* win);
++EaseWelcomeWindow* ease_welcome_window_new (void);
++EaseWelcomeWindow* ease_welcome_window_construct (GType object_type);
++void ease_main_remove_welcome (void);
++static void _lambda90_ (void);
++static void __lambda90__gtk_widget_hide (GtkWidget* _sender, gpointer self);
++EaseMain* ease_main_new (void);
++EaseMain* ease_main_construct (GType object_type);
++static void ease_main_finalize (GObject* obj);
++static int _vala_strcmp0 (const char * str1, const char * str2);
++
++static const GOptionEntry EASE_MAIN_options[4] = {{"play", 'p', 0, G_OPTION_ARG_FILENAME, &ease_main_play_filename, "Play the specified file", "FILE"}, {"window", 'w', 0, G_OPTION_ARG_NONE, &ease_main_presentation_windowed, "Display presentations in a window", NULL}, {"", (gchar) 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &ease_main_filenames, NULL, "FILE..."}, {NULL}};
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 101 "ease-main.vala"
++static void _lambda89_ (void) {
++#line 102 "ease-main.vala"
++ gtk_main_quit ();
++#line 231 "ease-main.c"
++}
++
++
++#line 101 "ease-main.vala"
++static void __lambda89__clutter_actor_hide (ClutterActor* _sender, gpointer self) {
++#line 237 "ease-main.c"
++ _lambda89_ ();
++}
++
++
++#line 47 "ease-main.vala"
++gint ease_main_main (char** args, int args_length1) {
++#line 244 "ease-main.c"
++ gint result = 0;
++ GError * _inner_error_;
++ GOptionContext* context;
++ GeeArrayList* _tmp1_;
++ ClutterBackend* backend;
++ GtkSettings* settings;
++ gint _tmp2_;
++ gint _tmp3_;
++ gboolean _tmp6_ = FALSE;
++ _inner_error_ = NULL;
++#line 50 "ease-main.vala"
++ context = g_option_context_new (_ (" - a presentation editor"));
++#line 53 "ease-main.vala"
++ g_option_context_add_main_entries (context, EASE_MAIN_options, NULL);
++#line 56 "ease-main.vala"
++ g_option_context_add_group (context, gtk_get_option_group (TRUE));
++#line 57 "ease-main.vala"
++ g_option_context_add_group (context, clutter_get_option_group ());
++#line 263 "ease-main.c"
++ {
++ gboolean _tmp0_;
++#line 61 "ease-main.vala"
++ _tmp0_ = g_option_context_parse (context, &args_length1, &args, &_inner_error_);
++#line 268 "ease-main.c"
++ if (_inner_error_ != NULL) {
++ if (_inner_error_->domain == G_OPTION_ERROR) {
++ goto __catch30_g_option_error;
++ }
++ _g_option_context_free0 (context);
++ g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return 0;
++ }
++#line 61 "ease-main.vala"
++ if (!_tmp0_) {
++#line 280 "ease-main.c"
++ result = 1;
++ _g_option_context_free0 (context);
++#line 63 "ease-main.vala"
++ return result;
++#line 285 "ease-main.c"
++ }
++ }
++ goto __finally30;
++ __catch30_g_option_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 68 "ease-main.vala"
++ fprintf (stdout, _ ("error parsing options: %s\n"), e->message);
++#line 297 "ease-main.c"
++ result = 1;
++ _g_error_free0 (e);
++ _g_option_context_free0 (context);
++#line 69 "ease-main.vala"
++ return result;
++#line 303 "ease-main.c"
++ }
++ }
++ __finally30:
++ if (_inner_error_ != NULL) {
++ _g_option_context_free0 (context);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return 0;
++ }
++#line 73 "ease-main.vala"
++ ease_main_windows = (_tmp1_ = gee_array_list_new (EASE_TYPE_EDITOR_WINDOW, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL), _g_object_unref0 (ease_main_windows), _tmp1_);
++#line 76 "ease-main.vala"
++ backend = _g_object_ref0 (clutter_get_default_backend ());
++#line 77 "ease-main.vala"
++ settings = _g_object_ref0 (gtk_settings_get_default ());
++#line 78 "ease-main.vala"
++ clutter_backend_set_double_click_time (backend, (guint) (g_object_get (settings, "gtk-double-click-time", &_tmp2_, NULL), _tmp2_));
++#line 79 "ease-main.vala"
++ clutter_backend_set_double_click_distance (backend, (guint) (g_object_get (settings, "gtk-double-click-distance", &_tmp3_, NULL), _tmp3_));
++#line 82 "ease-main.vala"
++ if (ease_main_filenames != NULL) {
++#line 325 "ease-main.c"
++ {
++ gint i;
++#line 84 "ease-main.vala"
++ i = 0;
++#line 330 "ease-main.c"
++ {
++ gboolean _tmp4_;
++#line 84 "ease-main.vala"
++ _tmp4_ = TRUE;
++#line 84 "ease-main.vala"
++ while (TRUE) {
++#line 84 "ease-main.vala"
++ if (!_tmp4_) {
++#line 84 "ease-main.vala"
++ i++;
++#line 341 "ease-main.c"
++ }
++#line 84 "ease-main.vala"
++ _tmp4_ = FALSE;
++#line 84 "ease-main.vala"
++ if (!(ease_main_filenames[i] != NULL)) {
++#line 84 "ease-main.vala"
++ break;
++#line 349 "ease-main.c"
++ }
++#line 86 "ease-main.vala"
++ ease_main_open_file (ease_main_filenames[i]);
++#line 353 "ease-main.c"
++ }
++ }
++ }
++ }
++#line 91 "ease-main.vala"
++ if (ease_main_play_filename != NULL) {
++#line 360 "ease-main.c"
++ {
++ EaseDocument* doc;
++ EasePlayer* _tmp5_;
++#line 95 "ease-main.vala"
++ doc = ease_document_new_from_saved (ease_main_play_filename, &_inner_error_);
++#line 366 "ease-main.c"
++ if (_inner_error_ != NULL) {
++ goto __catch31_g_error;
++ }
++#line 96 "ease-main.vala"
++ ease_main_player = (_tmp5_ = ease_player_new (doc), _g_object_unref0 (ease_main_player), _tmp5_);
++#line 99 "ease-main.vala"
++ if (ease_main_filenames == NULL) {
++#line 101 "ease-main.vala"
++ g_signal_connect ((ClutterActor*) ease_player_get_stage (ease_main_player), "hide", (GCallback) __lambda89__clutter_actor_hide, NULL);
++#line 376 "ease-main.c"
++ }
++ _g_object_unref0 (doc);
++ }
++ goto __finally31;
++ __catch31_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 108 "ease-main.vala"
++ ease_error_dialog (_ ("Error Playing Document"), e->message);
++#line 389 "ease-main.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally31:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (settings);
++ _g_object_unref0 (backend);
++ _g_option_context_free0 (context);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return 0;
++ }
++ }
++#line 113 "ease-main.vala"
++ if (ease_main_filenames == NULL) {
++#line 113 "ease-main.vala"
++ _tmp6_ = ease_main_play_filename == NULL;
++#line 407 "ease-main.c"
++ } else {
++#line 113 "ease-main.vala"
++ _tmp6_ = FALSE;
++#line 411 "ease-main.c"
++ }
++#line 113 "ease-main.vala"
++ if (_tmp6_) {
++#line 115 "ease-main.vala"
++ ease_main_show_welcome ();
++#line 417 "ease-main.c"
++ }
++#line 118 "ease-main.vala"
++ gtk_main ();
++#line 120 "ease-main.vala"
++ ease_temp_clean ();
++#line 423 "ease-main.c"
++ result = 0;
++ _g_object_unref0 (settings);
++ _g_object_unref0 (backend);
++ _g_option_context_free0 (context);
++#line 122 "ease-main.vala"
++ return result;
++#line 430 "ease-main.c"
++}
++
++
++#line 47 "ease-main.vala"
++int main (int argc, char ** argv) {
++#line 436 "ease-main.c"
++ g_thread_init (NULL);
++#line 47 "ease-main.vala"
++ g_type_init ();
++#line 47 "ease-main.vala"
++ return ease_main_main (argv, argc);
++#line 442 "ease-main.c"
++}
++
++
++#line 134 "ease-main.vala"
++void ease_main_open_file (const char* path) {
++#line 448 "ease-main.c"
++ GError * _inner_error_;
++#line 134 "ease-main.vala"
++ g_return_if_fail (path != NULL);
++#line 452 "ease-main.c"
++ _inner_error_ = NULL;
++ {
++ GeeIterator* _w_it;
++#line 136 "ease-main.vala"
++ _w_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) ease_main_windows);
++#line 136 "ease-main.vala"
++ while (TRUE) {
++#line 460 "ease-main.c"
++ EaseEditorWindow* w;
++#line 136 "ease-main.vala"
++ if (!gee_iterator_next (_w_it)) {
++#line 136 "ease-main.vala"
++ break;
++#line 466 "ease-main.c"
++ }
++#line 136 "ease-main.vala"
++ w = (EaseEditorWindow*) gee_iterator_get (_w_it);
++#line 138 "ease-main.vala"
++ if (_vala_strcmp0 (ease_document_get_path (w->document), path) == 0) {
++#line 140 "ease-main.vala"
++ gtk_window_present ((GtkWindow*) w);
++#line 474 "ease-main.c"
++ _g_object_unref0 (w);
++ _g_object_unref0 (_w_it);
++#line 142 "ease-main.vala"
++ return;
++#line 479 "ease-main.c"
++ }
++ _g_object_unref0 (w);
++ }
++ _g_object_unref0 (_w_it);
++ }
++ {
++ EaseDocument* doc;
++ EaseEditorWindow* _tmp0_;
++#line 148 "ease-main.vala"
++ doc = ease_document_new_from_saved (path, &_inner_error_);
++#line 490 "ease-main.c"
++ if (_inner_error_ != NULL) {
++ goto __catch32_g_error;
++ }
++#line 149 "ease-main.vala"
++ ease_main_add_window (_tmp0_ = g_object_ref_sink (ease_editor_window_new (doc)));
++#line 496 "ease-main.c"
++ _g_object_unref0 (_tmp0_);
++ _g_object_unref0 (doc);
++ }
++ goto __finally32;
++ __catch32_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 153 "ease-main.vala"
++ ease_error_dialog (_ ("Error Opening Document"), e->message);
++#line 509 "ease-main.c"
++ _g_error_free0 (e);
++#line 154 "ease-main.vala"
++ return;
++#line 513 "ease-main.c"
++ }
++ }
++ __finally32:
++ if (_inner_error_ != NULL) {
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++}
++
++
++#line 168 "ease-main.vala"
++void ease_main_remove_window (EaseEditorWindow* win) {
++#line 527 "ease-main.c"
++ gboolean _tmp0_ = FALSE;
++#line 168 "ease-main.vala"
++ g_return_if_fail (win != NULL);
++#line 170 "ease-main.vala"
++ gee_abstract_collection_remove ((GeeAbstractCollection*) ease_main_windows, win);
++#line 171 "ease-main.vala"
++ if (gee_collection_get_size ((GeeCollection*) ease_main_windows) == 0) {
++#line 171 "ease-main.vala"
++ _tmp0_ = ease_main_welcome == NULL;
++#line 537 "ease-main.c"
++ } else {
++#line 171 "ease-main.vala"
++ _tmp0_ = FALSE;
++#line 541 "ease-main.c"
++ }
++#line 171 "ease-main.vala"
++ if (_tmp0_) {
++#line 173 "ease-main.vala"
++ gtk_main_quit ();
++#line 547 "ease-main.c"
++ }
++}
++
++
++#line 186 "ease-main.vala"
++void ease_main_add_window (EaseEditorWindow* win) {
++#line 186 "ease-main.vala"
++ g_return_if_fail (win != NULL);
++#line 188 "ease-main.vala"
++ gee_abstract_collection_add ((GeeAbstractCollection*) ease_main_windows, win);
++#line 558 "ease-main.c"
++}
++
++
++#line 203 "ease-main.vala"
++static void _lambda90_ (void) {
++#line 203 "ease-main.vala"
++ ease_main_remove_welcome ();
++#line 566 "ease-main.c"
++}
++
++
++#line 203 "ease-main.vala"
++static void __lambda90__gtk_widget_hide (GtkWidget* _sender, gpointer self) {
++#line 572 "ease-main.c"
++ _lambda90_ ();
++}
++
++
++#line 198 "ease-main.vala"
++void ease_main_show_welcome (void) {
++#line 200 "ease-main.vala"
++ if (ease_main_welcome == NULL) {
++#line 581 "ease-main.c"
++ EaseWelcomeWindow* _tmp0_;
++#line 202 "ease-main.vala"
++ ease_main_welcome = (_tmp0_ = g_object_ref_sink (ease_welcome_window_new ()), _g_object_unref0 (ease_main_welcome), _tmp0_);
++#line 203 "ease-main.vala"
++ g_signal_connect ((GtkWidget*) ease_main_welcome, "hide", (GCallback) __lambda90__gtk_widget_hide, NULL);
++#line 587 "ease-main.c"
++ } else {
++#line 207 "ease-main.vala"
++ gtk_window_present ((GtkWindow*) ease_main_welcome);
++#line 591 "ease-main.c"
++ }
++}
++
++
++#line 219 "ease-main.vala"
++void ease_main_remove_welcome (void) {
++#line 598 "ease-main.c"
++ EaseWelcomeWindow* _tmp0_;
++#line 221 "ease-main.vala"
++ gtk_widget_hide_all ((GtkWidget*) ease_main_welcome);
++#line 222 "ease-main.vala"
++ ease_main_welcome = (_tmp0_ = NULL, _g_object_unref0 (ease_main_welcome), _tmp0_);
++#line 223 "ease-main.vala"
++ if (gee_collection_get_size ((GeeCollection*) ease_main_windows) == 0) {
++#line 225 "ease-main.vala"
++ gtk_main_quit ();
++#line 608 "ease-main.c"
++ }
++}
++
++
++#line 18 "ease-main.vala"
++EaseMain* ease_main_construct (GType object_type) {
++#line 615 "ease-main.c"
++ EaseMain * self;
++#line 18 "ease-main.vala"
++ self = (EaseMain*) g_object_new (object_type, NULL);
++#line 619 "ease-main.c"
++ return self;
++}
++
++
++#line 18 "ease-main.vala"
++EaseMain* ease_main_new (void) {
++#line 18 "ease-main.vala"
++ return ease_main_construct (EASE_TYPE_MAIN);
++#line 628 "ease-main.c"
++}
++
++
++static void ease_main_class_init (EaseMainClass * klass) {
++ ease_main_parent_class = g_type_class_peek_parent (klass);
++ G_OBJECT_CLASS (klass)->finalize = ease_main_finalize;
++}
++
++
++static void ease_main_instance_init (EaseMain * self) {
++}
++
++
++static void ease_main_finalize (GObject* obj) {
++ EaseMain * self;
++ self = EASE_MAIN (obj);
++ G_OBJECT_CLASS (ease_main_parent_class)->finalize (obj);
++}
++
++
++GType ease_main_get_type (void) {
++ static volatile gsize ease_main_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_main_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseMainClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_main_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseMain), 0, (GInstanceInitFunc) ease_main_instance_init, NULL };
++ GType ease_main_type_id;
++ ease_main_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseMain", &g_define_type_info, 0);
++ g_once_init_leave (&ease_main_type_id__volatile, ease_main_type_id);
++ }
++ return ease_main_type_id__volatile;
++}
++
++
++static int _vala_strcmp0 (const char * str1, const char * str2) {
++ if (str1 == NULL) {
++ return -(str1 != str2);
++ }
++ if (str2 == NULL) {
++ return str1 != str2;
++ }
++ return strcmp (str1, str2);
++}
++
++
++
++
diff --cc ease-core/ease-main.vala
index 470b1f9,0000000..470b1f9
mode 100644,000000..100644
--- a/ease-core/ease-main.vala
+++ b/ease-core/ease-main.vala
diff --cc ease-core/ease-media-element.c
index 0000000,0000000..b2c0a67
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-media-element.c
@@@ -1,0 -1,0 +1,361 @@@
++/* ease-media-element.c generated by valac, the Vala compiler
++ * generated from ease-media-element.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <json-glib/json-glib.h>
++#include <stdlib.h>
++#include <string.h>
++#include <float.h>
++#include <math.h>
++#include <cairo.h>
++#include <clutter/clutter.h>
++#include <gtk/gtk.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++typedef struct _EaseElementPrivate EaseElementPrivate;
++
++#define EASE_TYPE_HTML_EXPORTER (ease_html_exporter_get_type ())
++#define EASE_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporter))
++#define EASE_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++#define EASE_IS_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_HTML_EXPORTER))
++#define EASE_IS_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_HTML_EXPORTER))
++#define EASE_HTML_EXPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++
++typedef struct _EaseHTMLExporter EaseHTMLExporter;
++typedef struct _EaseHTMLExporterClass EaseHTMLExporterClass;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++#define EASE_TYPE_ACTOR (ease_actor_get_type ())
++#define EASE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ACTOR, EaseActor))
++#define EASE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ACTOR, EaseActorClass))
++#define EASE_IS_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ACTOR))
++#define EASE_IS_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ACTOR))
++#define EASE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ACTOR, EaseActorClass))
++
++typedef struct _EaseActor EaseActor;
++typedef struct _EaseActorClass EaseActorClass;
++
++#define EASE_TYPE_MEDIA_ELEMENT (ease_media_element_get_type ())
++#define EASE_MEDIA_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElement))
++#define EASE_MEDIA_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElementClass))
++#define EASE_IS_MEDIA_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_MEDIA_ELEMENT))
++#define EASE_IS_MEDIA_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_MEDIA_ELEMENT))
++#define EASE_MEDIA_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElementClass))
++
++typedef struct _EaseMediaElement EaseMediaElement;
++typedef struct _EaseMediaElementClass EaseMediaElementClass;
++typedef struct _EaseMediaElementPrivate EaseMediaElementPrivate;
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _json_object_unref0(var) ((var == NULL) ? NULL : (var = (json_object_unref (var), NULL)))
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++struct _EaseElement {
++ GObject parent_instance;
++ EaseElementPrivate * priv;
++};
++
++struct _EaseElementClass {
++ GObjectClass parent_class;
++ JsonObject* (*to_json) (EaseElement* self);
++ void (*to_html) (EaseElement* self, char** html, EaseHTMLExporter* exporter, double amount);
++ void (*write_html) (EaseElement* self, char** html, EaseHTMLExporter* exporter);
++ void (*cairo_render) (EaseElement* self, cairo_t* context, GError** error);
++ EaseActor* (*actor) (EaseElement* self, EaseActorContext c);
++ GtkWidget* (*inspector_widget) (EaseElement* self);
++ GList* (*tool_items) (EaseElement* self);
++ gboolean (*set_color) (EaseElement* self, ClutterColor* c);
++ ClutterColor* (*get_color) (EaseElement* self);
++};
++
++struct _EaseMediaElement {
++ EaseElement parent_instance;
++ EaseMediaElementPrivate * priv;
++};
++
++struct _EaseMediaElementClass {
++ EaseElementClass parent_class;
++};
++
++struct _EaseMediaElementPrivate {
++ char* _filename;
++ char* _source_filename;
++};
++
++
++static gpointer ease_media_element_parent_class = NULL;
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++GType ease_html_exporter_get_type (void) G_GNUC_CONST;
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++GType ease_actor_get_type (void) G_GNUC_CONST;
++GType ease_media_element_get_type (void) G_GNUC_CONST;
++#define EASE_MEDIA_ELEMENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElementPrivate))
++enum {
++ EASE_MEDIA_ELEMENT_DUMMY_PROPERTY,
++ EASE_MEDIA_ELEMENT_FILENAME,
++ EASE_MEDIA_ELEMENT_SOURCE_FILENAME,
++ EASE_MEDIA_ELEMENT_FULL_FILENAME
++};
++EaseElement* ease_element_construct_from_json (GType object_type, JsonObject* obj);
++#define EASE_THEME_MEDIA_FILENAME "media-filename"
++void ease_media_element_set_filename (EaseMediaElement* self, const char* value);
++#define EASE_THEME_MEDIA_SOURCE_FILENAME "media-source-filename"
++void ease_media_element_set_source_filename (EaseMediaElement* self, const char* value);
++EaseMediaElement* ease_media_element_construct_from_json (GType object_type, JsonObject* obj);
++JsonObject* ease_element_to_json (EaseElement* self);
++const char* ease_media_element_get_filename (EaseMediaElement* self);
++const char* ease_media_element_get_source_filename (EaseMediaElement* self);
++static JsonObject* ease_media_element_real_to_json (EaseElement* base);
++EaseElement* ease_element_construct (GType object_type);
++EaseMediaElement* ease_media_element_construct (GType object_type);
++GType ease_slide_get_type (void) G_GNUC_CONST;
++EaseSlide* ease_element_get_parent (EaseElement* self);
++GType ease_document_get_type (void) G_GNUC_CONST;
++EaseDocument* ease_slide_get_parent (EaseSlide* self);
++const char* ease_document_get_path (EaseDocument* self);
++char* ease_media_element_get_full_filename (EaseMediaElement* self);
++static void ease_media_element_finalize (GObject* obj);
++static void ease_media_element_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_media_element_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++
++
++
++#line 26 "ease-media-element.vala"
++EaseMediaElement* ease_media_element_construct_from_json (GType object_type, JsonObject* obj) {
++#line 192 "ease-media-element.c"
++ EaseMediaElement * self;
++#line 26 "ease-media-element.vala"
++ g_return_val_if_fail (obj != NULL, NULL);
++#line 28 "ease-media-element.vala"
++ self = (EaseMediaElement*) ease_element_construct_from_json (object_type, obj);
++#line 29 "ease-media-element.vala"
++ ease_media_element_set_filename (self, json_object_get_string_member (obj, EASE_THEME_MEDIA_FILENAME));
++#line 30 "ease-media-element.vala"
++ ease_media_element_set_source_filename (self, json_object_get_string_member (obj, EASE_THEME_MEDIA_SOURCE_FILENAME));
++#line 202 "ease-media-element.c"
++ return self;
++}
++
++
++#line 33 "ease-media-element.vala"
++static JsonObject* ease_media_element_real_to_json (EaseElement* base) {
++#line 209 "ease-media-element.c"
++ EaseMediaElement * self;
++ JsonObject* result = NULL;
++ JsonObject* obj;
++ self = (EaseMediaElement*) base;
++#line 35 "ease-media-element.vala"
++ obj = EASE_ELEMENT_CLASS (ease_media_element_parent_class)->to_json (EASE_ELEMENT (self));
++#line 37 "ease-media-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_MEDIA_FILENAME, self->priv->_filename);
++#line 38 "ease-media-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_MEDIA_SOURCE_FILENAME, self->priv->_source_filename);
++#line 220 "ease-media-element.c"
++ result = obj;
++#line 40 "ease-media-element.vala"
++ return result;
++#line 224 "ease-media-element.c"
++}
++
++
++#line 21 "ease-media-element.vala"
++EaseMediaElement* ease_media_element_construct (GType object_type) {
++#line 230 "ease-media-element.c"
++ EaseMediaElement * self;
++#line 21 "ease-media-element.vala"
++ self = (EaseMediaElement*) ease_element_construct (object_type);
++#line 234 "ease-media-element.c"
++ return self;
++}
++
++
++const char* ease_media_element_get_filename (EaseMediaElement* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_filename;
++#line 46 "ease-media-element.vala"
++ return result;
++#line 245 "ease-media-element.c"
++}
++
++
++void ease_media_element_set_filename (EaseMediaElement* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_filename = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_filename), _tmp0_);
++ g_object_notify ((GObject *) self, "filename");
++}
++
++
++const char* ease_media_element_get_source_filename (EaseMediaElement* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_source_filename;
++#line 51 "ease-media-element.vala"
++ return result;
++#line 263 "ease-media-element.c"
++}
++
++
++void ease_media_element_set_source_filename (EaseMediaElement* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_source_filename = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_source_filename), _tmp0_);
++ g_object_notify ((GObject *) self, "source-filename");
++}
++
++
++char* ease_media_element_get_full_filename (EaseMediaElement* self) {
++ char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = g_build_filename (ease_document_get_path (ease_slide_get_parent (ease_element_get_parent ((EaseElement*) self))), self->priv->_filename, NULL);
++#line 60 "ease-media-element.vala"
++ return result;
++#line 281 "ease-media-element.c"
++}
++
++
++static void ease_media_element_class_init (EaseMediaElementClass * klass) {
++ ease_media_element_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseMediaElementPrivate));
++ EASE_ELEMENT_CLASS (klass)->to_json = ease_media_element_real_to_json;
++ G_OBJECT_CLASS (klass)->get_property = ease_media_element_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_media_element_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_media_element_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_MEDIA_ELEMENT_FILENAME, g_param_spec_string ("filename", "filename", "filename", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_MEDIA_ELEMENT_SOURCE_FILENAME, g_param_spec_string ("source-filename", "source-filename", "source-filename", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_MEDIA_ELEMENT_FULL_FILENAME, g_param_spec_string ("full-filename", "full-filename", "full-filename", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++}
++
++
++static void ease_media_element_instance_init (EaseMediaElement * self) {
++ self->priv = EASE_MEDIA_ELEMENT_GET_PRIVATE (self);
++}
++
++
++static void ease_media_element_finalize (GObject* obj) {
++ EaseMediaElement * self;
++ self = EASE_MEDIA_ELEMENT (obj);
++ _g_free0 (self->priv->_filename);
++ _g_free0 (self->priv->_source_filename);
++ G_OBJECT_CLASS (ease_media_element_parent_class)->finalize (obj);
++}
++
++
++GType ease_media_element_get_type (void) {
++ static volatile gsize ease_media_element_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_media_element_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseMediaElementClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_media_element_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseMediaElement), 0, (GInstanceInitFunc) ease_media_element_instance_init, NULL };
++ GType ease_media_element_type_id;
++ ease_media_element_type_id = g_type_register_static (EASE_TYPE_ELEMENT, "EaseMediaElement", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
++ g_once_init_leave (&ease_media_element_type_id__volatile, ease_media_element_type_id);
++ }
++ return ease_media_element_type_id__volatile;
++}
++
++
++static void ease_media_element_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseMediaElement * self;
++ self = EASE_MEDIA_ELEMENT (object);
++ switch (property_id) {
++ case EASE_MEDIA_ELEMENT_FILENAME:
++ g_value_set_string (value, ease_media_element_get_filename (self));
++ break;
++ case EASE_MEDIA_ELEMENT_SOURCE_FILENAME:
++ g_value_set_string (value, ease_media_element_get_source_filename (self));
++ break;
++ case EASE_MEDIA_ELEMENT_FULL_FILENAME:
++ g_value_take_string (value, ease_media_element_get_full_filename (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_media_element_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseMediaElement * self;
++ self = EASE_MEDIA_ELEMENT (object);
++ switch (property_id) {
++ case EASE_MEDIA_ELEMENT_FILENAME:
++ ease_media_element_set_filename (self, g_value_get_string (value));
++ break;
++ case EASE_MEDIA_ELEMENT_SOURCE_FILENAME:
++ ease_media_element_set_source_filename (self, g_value_get_string (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
diff --cc ease-core/ease-player.c
index 0000000,0000000..9fdd1a0
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-player.c
@@@ -1,0 -1,0 +1,919 @@@
++/* ease-player.c generated by valac, the Vala compiler
++ * generated from ease-player.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <clutter/clutter.h>
++#include <float.h>
++#include <math.h>
++#include <glib/gi18n-lib.h>
++#include <gtk/gtk.h>
++
++
++#define EASE_TYPE_PLAYER (ease_player_get_type ())
++#define EASE_PLAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_PLAYER, EasePlayer))
++#define EASE_PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_PLAYER, EasePlayerClass))
++#define EASE_IS_PLAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_PLAYER))
++#define EASE_IS_PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_PLAYER))
++#define EASE_PLAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_PLAYER, EasePlayerClass))
++
++typedef struct _EasePlayer EasePlayer;
++typedef struct _EasePlayerClass EasePlayerClass;
++typedef struct _EasePlayerPrivate EasePlayerPrivate;
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++
++#define EASE_TYPE_SLIDE_ACTOR (ease_slide_actor_get_type ())
++#define EASE_SLIDE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_ACTOR, EaseSlideActor))
++#define EASE_SLIDE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_ACTOR, EaseSlideActorClass))
++#define EASE_IS_SLIDE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_ACTOR))
++#define EASE_IS_SLIDE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_ACTOR))
++#define EASE_SLIDE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_ACTOR, EaseSlideActorClass))
++
++typedef struct _EaseSlideActor EaseSlideActor;
++typedef struct _EaseSlideActorClass EaseSlideActorClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++typedef struct _EaseDocumentPrivate EaseDocumentPrivate;
++
++#define EASE_ITERABLE_TYPE_LIST_STORE (ease_iterable_list_store_get_type ())
++#define EASE_ITERABLE_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStore))
++#define EASE_ITERABLE_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStoreClass))
++#define EASE_ITERABLE_IS_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_ITERABLE_TYPE_LIST_STORE))
++#define EASE_ITERABLE_IS_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_ITERABLE_TYPE_LIST_STORE))
++#define EASE_ITERABLE_LIST_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStoreClass))
++
++typedef struct _EaseIterableListStore EaseIterableListStore;
++typedef struct _EaseIterableListStoreClass EaseIterableListStoreClass;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++struct _EasePlayer {
++ GObject parent_instance;
++ EasePlayerPrivate * priv;
++};
++
++struct _EasePlayerClass {
++ GObjectClass parent_class;
++};
++
++struct _EasePlayerPrivate {
++ EaseDocument* _document;
++ gint _slide_index;
++ ClutterStage* _stage;
++ gboolean _can_animate;
++ gboolean dragging;
++ EaseSlideActor* current_slide;
++ EaseSlideActor* old_slide;
++ ClutterGroup* container;
++ ClutterTimeline* advance_alarm;
++ float scale;
++ ClutterGroup* shader;
++ ClutterRectangle* shader_top;
++ ClutterRectangle* shader_bottom;
++ ClutterRectangle* shader_left;
++ ClutterRectangle* shader_right;
++};
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseDocument {
++ GObject parent_instance;
++ EaseDocumentPrivate * priv;
++ EaseIterableListStore* slides;
++};
++
++struct _EaseDocumentClass {
++ GObjectClass parent_class;
++};
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++
++static gpointer ease_player_parent_class = NULL;
++
++GType ease_player_get_type (void) G_GNUC_CONST;
++GType ease_document_get_type (void) G_GNUC_CONST;
++GType ease_slide_actor_get_type (void) G_GNUC_CONST;
++#define EASE_PLAYER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_PLAYER, EasePlayerPrivate))
++enum {
++ EASE_PLAYER_DUMMY_PROPERTY,
++ EASE_PLAYER_DOCUMENT,
++ EASE_PLAYER_SLIDE_INDEX,
++ EASE_PLAYER_STAGE
++};
++#define EASE_PLAYER_FADE_IN_TIME ((guint) 1000)
++#define EASE_PLAYER_FOCUS_OPACITY ((guint) 100)
++#define EASE_PLAYER_FOCUS_RADIUS ((guint) 40)
++void ease_player_set_document (EasePlayer* self, EaseDocument* value);
++void ease_player_set_slide_index (EasePlayer* self, gint value);
++void ease_player_set_stage (EasePlayer* self, ClutterStage* value);
++EaseDocument* ease_player_get_document (EasePlayer* self);
++gint ease_document_get_width (EaseDocument* self);
++ClutterStage* ease_player_get_stage (EasePlayer* self);
++gint ease_document_get_height (EaseDocument* self);
++void ease_player_on_key_press (EasePlayer* self, ClutterKeyEvent* event);
++static gboolean _lambda73_ (ClutterKeyEvent* ev, EasePlayer* self);
++static gboolean __lambda73__clutter_actor_key_press_event (ClutterActor* _sender, ClutterKeyEvent* event, gpointer self);
++void ease_player_on_button_press (EasePlayer* self, ClutterButtonEvent* event);
++static gboolean _lambda75_ (ClutterButtonEvent* ev, EasePlayer* self);
++static gboolean __lambda75__clutter_actor_button_press_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self);
++void ease_player_on_motion (EasePlayer* self, ClutterMotionEvent* event);
++static gboolean _lambda76_ (ClutterMotionEvent* ev, EasePlayer* self);
++static gboolean __lambda76__clutter_actor_motion_event (ClutterActor* _sender, ClutterMotionEvent* event, gpointer self);
++void ease_player_on_button_release (EasePlayer* self, ClutterButtonEvent* event);
++static gboolean _lambda77_ (ClutterButtonEvent* ev, EasePlayer* self);
++static gboolean __lambda77__clutter_actor_button_release_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self);
++static void ease_player_set_can_animate (EasePlayer* self, gboolean value);
++void ease_player_advance (EasePlayer* self);
++EasePlayer* ease_player_new (EaseDocument* doc);
++EasePlayer* ease_player_construct (GType object_type, EaseDocument* doc);
++static void ease_player_retreat (EasePlayer* self);
++static gboolean ease_player_get_can_animate (EasePlayer* self);
++gint ease_player_get_slide_index (EasePlayer* self);
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_iterable_list_store_get_type (void) G_GNUC_CONST;
++gint ease_iterable_list_store_get_size (EaseIterableListStore* self);
++GType ease_slide_get_type (void) G_GNUC_CONST;
++EaseSlide* ease_document_get_slide (EaseDocument* self, gint index);
++static void ease_player_create_current_slide (EasePlayer* self, EaseSlide* slide);
++void ease_slide_actor_stack (EaseSlideActor* self, ClutterActor* container);
++static void ease_player_animation_complete (EasePlayer* self);
++static void _ease_player_animation_complete_clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++EaseSlide* ease_slide_actor_get_slide (EaseSlideActor* self);
++double ease_slide_get_transition_time (EaseSlide* self);
++void ease_slide_actor_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container);
++ClutterTimeline* ease_slide_actor_get_animation_time (EaseSlideActor* self);
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++EaseSlideActor* ease_slide_actor_new_from_slide (EaseDocument* document, EaseSlide* s, gboolean clip, EaseActorContext ctx);
++EaseSlideActor* ease_slide_actor_construct_from_slide (GType object_type, EaseDocument* document, EaseSlide* s, gboolean clip, EaseActorContext ctx);
++gboolean ease_slide_get_automatically_advance (EaseSlide* self);
++double ease_slide_get_advance_delay (EaseSlide* self);
++static void _lambda74_ (EasePlayer* self);
++static void __lambda74__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++static void ease_player_finalize (GObject* obj);
++static void ease_player_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_player_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++
++
++
++#line 79 "ease-player.vala"
++static gboolean _lambda73_ (ClutterKeyEvent* ev, EasePlayer* self) {
++#line 211 "ease-player.c"
++ gboolean result = FALSE;
++#line 81 "ease-player.vala"
++ ease_player_on_key_press (self, ev);
++#line 215 "ease-player.c"
++ result = TRUE;
++#line 82 "ease-player.vala"
++ return result;
++#line 219 "ease-player.c"
++}
++
++
++#line 79 "ease-player.vala"
++static gboolean __lambda73__clutter_actor_key_press_event (ClutterActor* _sender, ClutterKeyEvent* event, gpointer self) {
++#line 225 "ease-player.c"
++ gboolean result;
++ result = _lambda73_ (event, self);
++ return result;
++}
++
++
++#line 86 "ease-player.vala"
++static gboolean _lambda75_ (ClutterButtonEvent* ev, EasePlayer* self) {
++#line 234 "ease-player.c"
++ gboolean result = FALSE;
++#line 88 "ease-player.vala"
++ ease_player_on_button_press (self, ev);
++#line 238 "ease-player.c"
++ result = TRUE;
++#line 89 "ease-player.vala"
++ return result;
++#line 242 "ease-player.c"
++}
++
++
++#line 86 "ease-player.vala"
++static gboolean __lambda75__clutter_actor_button_press_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self) {
++#line 248 "ease-player.c"
++ gboolean result;
++ result = _lambda75_ (event, self);
++ return result;
++}
++
++
++#line 92 "ease-player.vala"
++static gboolean _lambda76_ (ClutterMotionEvent* ev, EasePlayer* self) {
++#line 257 "ease-player.c"
++ gboolean result = FALSE;
++#line 94 "ease-player.vala"
++ ease_player_on_motion (self, ev);
++#line 261 "ease-player.c"
++ result = TRUE;
++#line 95 "ease-player.vala"
++ return result;
++#line 265 "ease-player.c"
++}
++
++
++#line 92 "ease-player.vala"
++static gboolean __lambda76__clutter_actor_motion_event (ClutterActor* _sender, ClutterMotionEvent* event, gpointer self) {
++#line 271 "ease-player.c"
++ gboolean result;
++ result = _lambda76_ (event, self);
++ return result;
++}
++
++
++#line 98 "ease-player.vala"
++static gboolean _lambda77_ (ClutterButtonEvent* ev, EasePlayer* self) {
++#line 280 "ease-player.c"
++ gboolean result = FALSE;
++#line 100 "ease-player.vala"
++ ease_player_on_button_release (self, ev);
++#line 284 "ease-player.c"
++ result = TRUE;
++#line 101 "ease-player.vala"
++ return result;
++#line 288 "ease-player.c"
++}
++
++
++#line 98 "ease-player.vala"
++static gboolean __lambda77__clutter_actor_button_release_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self) {
++#line 294 "ease-player.c"
++ gboolean result;
++ result = _lambda77_ (event, self);
++ return result;
++}
++
++
++#line 58 "ease-player.vala"
++EasePlayer* ease_player_construct (GType object_type, EaseDocument* doc) {
++#line 303 "ease-player.c"
++ EasePlayer * self;
++ ClutterStage* _tmp0_;
++ gboolean _tmp1_ = FALSE;
++ ClutterColor _tmp3_ = {0};
++ ClutterColor _tmp4_;
++ ClutterRectangle* _tmp7_;
++ ClutterColor _tmp6_;
++ ClutterColor _tmp5_ = {0};
++ ClutterRectangle* _tmp10_;
++ ClutterColor _tmp9_;
++ ClutterColor _tmp8_ = {0};
++ ClutterRectangle* _tmp13_;
++ ClutterColor _tmp12_;
++ ClutterColor _tmp11_ = {0};
++ ClutterRectangle* _tmp16_;
++ ClutterColor _tmp15_;
++ ClutterColor _tmp14_ = {0};
++ ClutterGroup* _tmp17_;
++ ClutterGroup* _tmp18_;
++#line 58 "ease-player.vala"
++ g_return_val_if_fail (doc != NULL, NULL);
++#line 58 "ease-player.vala"
++ self = (EasePlayer*) g_object_new (object_type, NULL);
++#line 60 "ease-player.vala"
++ ease_player_set_document (self, doc);
++#line 61 "ease-player.vala"
++ ease_player_set_slide_index (self, -1);
++#line 63 "ease-player.vala"
++ ease_player_set_stage (self, _tmp0_ = g_object_ref_sink ((ClutterStage*) clutter_stage_new ()));
++#line 333 "ease-player.c"
++ _g_object_unref0 (_tmp0_);
++#line 64 "ease-player.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->_stage, ease_document_get_width (self->priv->_document) * self->priv->scale);
++#line 65 "ease-player.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->_stage, ease_document_get_height (self->priv->_document) * self->priv->scale);
++#line 66 "ease-player.vala"
++ clutter_stage_set_title (self->priv->_stage, _ ("Ease Presentation"));
++#line 67 "ease-player.vala"
++ clutter_stage_set_use_fog (self->priv->_stage, FALSE);
++#line 70 "ease-player.vala"
++ if (clutter_actor_get_width ((ClutterActor*) self->priv->_stage) < ease_document_get_width (self->priv->_document)) {
++#line 70 "ease-player.vala"
++ _tmp1_ = TRUE;
++#line 347 "ease-player.c"
++ } else {
++#line 70 "ease-player.vala"
++ _tmp1_ = clutter_actor_get_height ((ClutterActor*) self->priv->_stage) < ease_document_get_height (self->priv->_document);
++#line 351 "ease-player.c"
++ }
++#line 70 "ease-player.vala"
++ if (_tmp1_) {
++#line 355 "ease-player.c"
++ float x;
++ float y;
++ float _tmp2_ = 0.0F;
++#line 72 "ease-player.vala"
++ x = ((float) clutter_actor_get_width ((ClutterActor*) self->priv->_stage)) / ease_document_get_width (self->priv->_document);
++#line 73 "ease-player.vala"
++ y = ((float) clutter_actor_get_height ((ClutterActor*) self->priv->_stage)) / ease_document_get_height (self->priv->_document);
++#line 75 "ease-player.vala"
++ if (x < y) {
++#line 75 "ease-player.vala"
++ _tmp2_ = x;
++#line 367 "ease-player.c"
++ } else {
++#line 75 "ease-player.vala"
++ _tmp2_ = y;
++#line 371 "ease-player.c"
++ }
++#line 75 "ease-player.vala"
++ self->priv->scale = _tmp2_;
++#line 375 "ease-player.c"
++ }
++#line 79 "ease-player.vala"
++ g_signal_connect_object ((ClutterActor*) self->priv->_stage, "key-press-event", (GCallback) __lambda73__clutter_actor_key_press_event, self, 0);
++#line 86 "ease-player.vala"
++ g_signal_connect_object ((ClutterActor*) self->priv->_stage, "button-press-event", (GCallback) __lambda75__clutter_actor_button_press_event, self, 0);
++#line 92 "ease-player.vala"
++ g_signal_connect_object ((ClutterActor*) self->priv->_stage, "motion-event", (GCallback) __lambda76__clutter_actor_motion_event, self, 0);
++#line 98 "ease-player.vala"
++ g_signal_connect_object ((ClutterActor*) self->priv->_stage, "button-release-event", (GCallback) __lambda77__clutter_actor_button_release_event, self, 0);
++#line 108 "ease-player.vala"
++ clutter_stage_set_color (self->priv->_stage, (_tmp4_ = (_tmp3_.red = (guchar) 0, _tmp3_.green = (guchar) 0, _tmp3_.blue = (guchar) 0, _tmp3_.alpha = (guchar) 255, _tmp3_), &_tmp4_));
++#line 109 "ease-player.vala"
++ clutter_grab_keyboard ((ClutterActor*) self->priv->_stage);
++#line 112 "ease-player.vala"
++ self->priv->shader_top = (_tmp7_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new_with_color ((_tmp6_ = (clutter_color_from_string (&_tmp5_, "black"), _tmp5_), &_tmp6_))), _g_object_unref0 (self->priv->shader_top), _tmp7_);
++#line 113 "ease-player.vala"
++ self->priv->shader_right = (_tmp10_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new_with_color ((_tmp9_ = (clutter_color_from_string (&_tmp8_, "black"), _tmp8_), &_tmp9_))), _g_object_unref0 (self->priv->shader_right), _tmp10_);
++#line 114 "ease-player.vala"
++ self->priv->shader_bottom = (_tmp13_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new_with_color ((_tmp12_ = (clutter_color_from_string (&_tmp11_, "black"), _tmp11_), &_tmp12_))), _g_object_unref0 (self->priv->shader_bottom), _tmp13_);
++#line 115 "ease-player.vala"
++ self->priv->shader_left = (_tmp16_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new_with_color ((_tmp15_ = (clutter_color_from_string (&_tmp14_, "black"), _tmp14_), &_tmp15_))), _g_object_unref0 (self->priv->shader_left), _tmp16_);
++#line 117 "ease-player.vala"
++ self->priv->shader = (_tmp17_ = g_object_ref_sink ((ClutterGroup*) clutter_group_new ()), _g_object_unref0 (self->priv->shader), _tmp17_);
++#line 118 "ease-player.vala"
++ clutter_actor_set_opacity ((ClutterActor*) self->priv->shader, (guint) 0);
++#line 124 "ease-player.vala"
++ clutter_container_add ((ClutterContainer*) self->priv->shader, self->priv->shader_top, self->priv->shader_right, self->priv->shader_bottom, self->priv->shader_left, NULL);
++#line 129 "ease-player.vala"
++ clutter_container_add ((ClutterContainer*) self->priv->_stage, self->priv->shader, NULL);
++#line 130 "ease-player.vala"
++ clutter_actor_set_clip ((ClutterActor*) self->priv->_stage, (float) 0, (float) 0, (float) ease_document_get_width (doc), (float) ease_document_get_height (doc));
++#line 133 "ease-player.vala"
++ self->priv->container = (_tmp18_ = g_object_ref_sink ((ClutterGroup*) clutter_group_new ()), _g_object_unref0 (self->priv->container), _tmp18_);
++#line 134 "ease-player.vala"
++ clutter_container_add_actor ((ClutterContainer*) self->priv->_stage, (ClutterActor*) self->priv->container);
++#line 135 "ease-player.vala"
++ g_object_set ((ClutterActor*) self->priv->container, "scale-x", (double) self->priv->scale, NULL);
++#line 136 "ease-player.vala"
++ g_object_set ((ClutterActor*) self->priv->container, "scale-y", (double) self->priv->scale, NULL);
++#line 139 "ease-player.vala"
++ clutter_actor_show_all ((ClutterActor*) self->priv->_stage);
++#line 140 "ease-player.vala"
++ clutter_stage_set_fullscreen (self->priv->_stage, TRUE);
++#line 142 "ease-player.vala"
++ ease_player_set_can_animate (self, TRUE);
++#line 143 "ease-player.vala"
++ ease_player_advance (self);
++#line 423 "ease-player.c"
++ return self;
++}
++
++
++#line 58 "ease-player.vala"
++EasePlayer* ease_player_new (EaseDocument* doc) {
++#line 58 "ease-player.vala"
++ return ease_player_construct (EASE_TYPE_PLAYER, doc);
++#line 432 "ease-player.c"
++}
++
++
++#line 146 "ease-player.vala"
++void ease_player_on_motion (EasePlayer* self, ClutterMotionEvent* event) {
++#line 146 "ease-player.vala"
++ g_return_if_fail (self != NULL);
++#line 148 "ease-player.vala"
++ if (self->priv->dragging) {
++#line 150 "ease-player.vala"
++ clutter_actor_set_size ((ClutterActor*) self->priv->shader_top, clutter_actor_get_width ((ClutterActor*) self->priv->_stage), (*event).y - EASE_PLAYER_FOCUS_RADIUS);
++#line 151 "ease-player.vala"
++ clutter_actor_set_size ((ClutterActor*) self->priv->shader_bottom, clutter_actor_get_width ((ClutterActor*) self->priv->_stage), (clutter_actor_get_height ((ClutterActor*) self->priv->_stage) - (*event).y) - EASE_PLAYER_FOCUS_RADIUS);
++#line 152 "ease-player.vala"
++ clutter_actor_set_size ((ClutterActor*) self->priv->shader_left, (*event).x - EASE_PLAYER_FOCUS_RADIUS, (float) (EASE_PLAYER_FOCUS_RADIUS * 2));
++#line 153 "ease-player.vala"
++ clutter_actor_set_size ((ClutterActor*) self->priv->shader_right, (clutter_actor_get_width ((ClutterActor*) self->priv->_stage) - (*event).x) - EASE_PLAYER_FOCUS_RADIUS, (float) (2 * EASE_PLAYER_FOCUS_RADIUS));
++#line 155 "ease-player.vala"
++ clutter_actor_set_position ((ClutterActor*) self->priv->shader_left, (float) 0, (*event).y - EASE_PLAYER_FOCUS_RADIUS);
++#line 156 "ease-player.vala"
++ clutter_actor_set_position ((ClutterActor*) self->priv->shader_right, (*event).x + EASE_PLAYER_FOCUS_RADIUS, (*event).y - EASE_PLAYER_FOCUS_RADIUS);
++#line 157 "ease-player.vala"
++ clutter_actor_set_position ((ClutterActor*) self->priv->shader_bottom, (float) 0, (*event).y + EASE_PLAYER_FOCUS_RADIUS);
++#line 158 "ease-player.vala"
++ clutter_actor_show_all ((ClutterActor*) self->priv->shader);
++#line 159 "ease-player.vala"
++ clutter_container_raise_child ((ClutterContainer*) self->priv->_stage, (ClutterActor*) self->priv->shader, NULL);
++#line 460 "ease-player.c"
++ } else {
++ }
++}
++
++
++#line 165 "ease-player.vala"
++void ease_player_on_button_release (EasePlayer* self, ClutterButtonEvent* event) {
++#line 165 "ease-player.vala"
++ g_return_if_fail (self != NULL);
++#line 167 "ease-player.vala"
++ self->priv->dragging = FALSE;
++#line 169 "ease-player.vala"
++ clutter_actor_animate ((ClutterActor*) self->priv->shader, (gulong) CLUTTER_LINEAR, (guint) 150, "opacity", 0, NULL);
++#line 474 "ease-player.c"
++}
++
++
++#line 173 "ease-player.vala"
++void ease_player_on_button_press (EasePlayer* self, ClutterButtonEvent* event) {
++#line 173 "ease-player.vala"
++ g_return_if_fail (self != NULL);
++#line 175 "ease-player.vala"
++ self->priv->dragging = TRUE;
++#line 176 "ease-player.vala"
++ g_debug ("ease-player.vala:176: Got a mouse click at %f, %f", (double) (*event).x, (double) (*event).y);
++#line 177 "ease-player.vala"
++ clutter_actor_set_size ((ClutterActor*) self->priv->shader_top, clutter_actor_get_width ((ClutterActor*) self->priv->_stage), (*event).y - EASE_PLAYER_FOCUS_RADIUS);
++#line 178 "ease-player.vala"
++ clutter_actor_set_size ((ClutterActor*) self->priv->shader_bottom, clutter_actor_get_width ((ClutterActor*) self->priv->_stage), (clutter_actor_get_height ((ClutterActor*) self->priv->_stage) - (*event).y) - EASE_PLAYER_FOCUS_RADIUS);
++#line 179 "ease-player.vala"
++ clutter_actor_set_size ((ClutterActor*) self->priv->shader_left, (*event).x - EASE_PLAYER_FOCUS_RADIUS, (float) (EASE_PLAYER_FOCUS_RADIUS * 2));
++#line 180 "ease-player.vala"
++ clutter_actor_set_size ((ClutterActor*) self->priv->shader_right, (clutter_actor_get_width ((ClutterActor*) self->priv->_stage) - (*event).x) - EASE_PLAYER_FOCUS_RADIUS, (float) (2 * EASE_PLAYER_FOCUS_RADIUS));
++#line 182 "ease-player.vala"
++ clutter_actor_set_position ((ClutterActor*) self->priv->shader_left, (float) 0, (*event).y - EASE_PLAYER_FOCUS_RADIUS);
++#line 183 "ease-player.vala"
++ clutter_actor_set_position ((ClutterActor*) self->priv->shader_right, (*event).x + EASE_PLAYER_FOCUS_RADIUS, (*event).y - EASE_PLAYER_FOCUS_RADIUS);
++#line 184 "ease-player.vala"
++ clutter_actor_set_position ((ClutterActor*) self->priv->shader_bottom, (float) 0, (*event).y + EASE_PLAYER_FOCUS_RADIUS);
++#line 185 "ease-player.vala"
++ clutter_actor_show_all ((ClutterActor*) self->priv->shader);
++#line 186 "ease-player.vala"
++ clutter_container_raise_child ((ClutterContainer*) self->priv->_stage, (ClutterActor*) self->priv->shader, NULL);
++#line 187 "ease-player.vala"
++ clutter_actor_animate ((ClutterActor*) self->priv->shader, (gulong) CLUTTER_LINEAR, (guint) 150, "opacity", EASE_PLAYER_FOCUS_OPACITY, NULL);
++#line 506 "ease-player.c"
++}
++
++
++#line 191 "ease-player.vala"
++void ease_player_on_key_press (EasePlayer* self, ClutterKeyEvent* event) {
++#line 191 "ease-player.vala"
++ g_return_if_fail (self != NULL);
++#line 195 "ease-player.vala"
++ g_debug ("ease-player.vala:195: Got a key press, keyval = %u", (*event).keyval);
++#line 196 "ease-player.vala"
++ switch ((*event).keyval) {
++#line 518 "ease-player.c"
++ case 0xff1b:
++ {
++#line 199 "ease-player.vala"
++ g_debug ("ease-player.vala:199: Quitting player.");
++#line 200 "ease-player.vala"
++ clutter_actor_hide ((ClutterActor*) self->priv->_stage);
++#line 201 "ease-player.vala"
++ break;
++#line 527 "ease-player.c"
++ }
++ case 0xff53:
++ {
++#line 204 "ease-player.vala"
++ g_debug ("ease-player.vala:204: Advancing to next slide.");
++#line 205 "ease-player.vala"
++ ease_player_advance (self);
++#line 206 "ease-player.vala"
++ break;
++#line 537 "ease-player.c"
++ }
++ case 0xff51:
++ {
++#line 209 "ease-player.vala"
++ g_debug ("ease-player.vala:209: Retreating to previous slide");
++#line 210 "ease-player.vala"
++ ease_player_retreat (self);
++#line 211 "ease-player.vala"
++ break;
++#line 547 "ease-player.c"
++ }
++ default:
++ {
++#line 213 "ease-player.vala"
++ g_debug ("ease-player.vala:213: Key not handled.");
++#line 214 "ease-player.vala"
++ break;
++#line 555 "ease-player.c"
++ }
++ }
++}
++
++
++#line 306 "ease-player.vala"
++static void _ease_player_animation_complete_clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 563 "ease-player.c"
++ ease_player_animation_complete (self);
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 218 "ease-player.vala"
++void ease_player_advance (EasePlayer* self) {
++#line 575 "ease-player.c"
++ gint _tmp1_;
++ EaseSlide* slide;
++#line 218 "ease-player.vala"
++ g_return_if_fail (self != NULL);
++#line 221 "ease-player.vala"
++ if (!self->priv->_can_animate) {
++#line 223 "ease-player.vala"
++ return;
++#line 584 "ease-player.c"
++ }
++#line 227 "ease-player.vala"
++ if (self->priv->advance_alarm != NULL) {
++#line 588 "ease-player.c"
++ ClutterTimeline* _tmp0_;
++#line 229 "ease-player.vala"
++ clutter_timeline_stop (self->priv->advance_alarm);
++#line 230 "ease-player.vala"
++ self->priv->advance_alarm = (_tmp0_ = NULL, _g_object_unref0 (self->priv->advance_alarm), _tmp0_);
++#line 594 "ease-player.c"
++ }
++#line 233 "ease-player.vala"
++ _tmp1_ = self->priv->_slide_index;
++#line 233 "ease-player.vala"
++ ease_player_set_slide_index (self, _tmp1_ + 1);
++#line 233 "ease-player.vala"
++ _tmp1_;
++#line 234 "ease-player.vala"
++ if (self->priv->_slide_index == ease_iterable_list_store_get_size (self->priv->_document->slides)) {
++#line 236 "ease-player.vala"
++ clutter_actor_hide_all ((ClutterActor*) self->priv->_stage);
++#line 237 "ease-player.vala"
++ g_signal_emit_by_name (self, "complete");
++#line 238 "ease-player.vala"
++ return;
++#line 610 "ease-player.c"
++ }
++#line 241 "ease-player.vala"
++ slide = ease_document_get_slide (self->priv->_document, self->priv->_slide_index);
++#line 244 "ease-player.vala"
++ if (self->priv->_slide_index == 0) {
++#line 616 "ease-player.c"
++ ClutterTimeline* _tmp2_;
++#line 246 "ease-player.vala"
++ ease_player_create_current_slide (self, slide);
++#line 247 "ease-player.vala"
++ ease_slide_actor_stack (self->priv->current_slide, (ClutterActor*) self->priv->container);
++#line 248 "ease-player.vala"
++ clutter_actor_set_opacity ((ClutterActor*) self->priv->current_slide, (guint) 0);
++#line 249 "ease-player.vala"
++ clutter_actor_animate ((ClutterActor*) self->priv->current_slide, (gulong) CLUTTER_EASE_IN_SINE, EASE_PLAYER_FADE_IN_TIME, "opacity", 255, NULL);
++#line 252 "ease-player.vala"
++ self->priv->advance_alarm = (_tmp2_ = clutter_timeline_new (EASE_PLAYER_FADE_IN_TIME), _g_object_unref0 (self->priv->advance_alarm), _tmp2_);
++#line 253 "ease-player.vala"
++ g_signal_connect_object (self->priv->advance_alarm, "completed", (GCallback) _ease_player_animation_complete_clutter_timeline_completed, self, 0);
++#line 254 "ease-player.vala"
++ clutter_timeline_start (self->priv->advance_alarm);
++#line 256 "ease-player.vala"
++ ease_player_set_can_animate (self, FALSE);
++#line 634 "ease-player.c"
++ } else {
++ EaseSlideActor* _tmp3_;
++#line 262 "ease-player.vala"
++ self->priv->old_slide = (_tmp3_ = _g_object_ref0 (self->priv->current_slide), _g_object_unref0 (self->priv->old_slide), _tmp3_);
++#line 263 "ease-player.vala"
++ ease_player_create_current_slide (self, slide);
++#line 264 "ease-player.vala"
++ clutter_container_add_actor ((ClutterContainer*) self->priv->container, (ClutterActor*) self->priv->current_slide);
++#line 266 "ease-player.vala"
++ if (ease_slide_get_transition_time (ease_slide_actor_get_slide (self->priv->old_slide)) > 0) {
++#line 268 "ease-player.vala"
++ ease_slide_actor_transition (self->priv->old_slide, self->priv->current_slide, self->priv->container);
++#line 269 "ease-player.vala"
++ g_signal_connect_object (ease_slide_actor_get_animation_time (self->priv->old_slide), "completed", (GCallback) _ease_player_animation_complete_clutter_timeline_completed, self, 0);
++#line 270 "ease-player.vala"
++ ease_player_set_can_animate (self, FALSE);
++#line 651 "ease-player.c"
++ } else {
++#line 274 "ease-player.vala"
++ ease_player_animation_complete (self);
++#line 655 "ease-player.c"
++ }
++ }
++ _g_object_unref0 (slide);
++}
++
++
++#line 279 "ease-player.vala"
++static void ease_player_retreat (EasePlayer* self) {
++#line 664 "ease-player.c"
++ gint _tmp0_;
++ EaseSlide* _tmp1_;
++#line 279 "ease-player.vala"
++ g_return_if_fail (self != NULL);
++#line 281 "ease-player.vala"
++ if (self->priv->_slide_index == 0) {
++#line 282 "ease-player.vala"
++ return;
++#line 673 "ease-player.c"
++ }
++#line 285 "ease-player.vala"
++ if (ease_slide_actor_get_animation_time (self->priv->old_slide) != NULL) {
++#line 286 "ease-player.vala"
++ clutter_timeline_stop (ease_slide_actor_get_animation_time (self->priv->old_slide));
++#line 679 "ease-player.c"
++ }
++#line 289 "ease-player.vala"
++ _tmp0_ = self->priv->_slide_index;
++#line 289 "ease-player.vala"
++ ease_player_set_slide_index (self, _tmp0_ - 1);
++#line 289 "ease-player.vala"
++ _tmp0_;
++#line 290 "ease-player.vala"
++ ease_player_set_can_animate (self, TRUE);
++#line 292 "ease-player.vala"
++ clutter_group_remove_all (self->priv->container);
++#line 293 "ease-player.vala"
++ ease_player_create_current_slide (self, _tmp1_ = ease_document_get_slide (self->priv->_document, self->priv->_slide_index));
++#line 693 "ease-player.c"
++ _g_object_unref0 (_tmp1_);
++#line 294 "ease-player.vala"
++ ease_slide_actor_stack (self->priv->current_slide, (ClutterActor*) self->priv->container);
++#line 295 "ease-player.vala"
++ clutter_container_add_actor ((ClutterContainer*) self->priv->container, (ClutterActor*) self->priv->current_slide);
++#line 699 "ease-player.c"
++}
++
++
++#line 298 "ease-player.vala"
++static void ease_player_create_current_slide (EasePlayer* self, EaseSlide* slide) {
++#line 705 "ease-player.c"
++ EaseSlideActor* _tmp0_;
++#line 298 "ease-player.vala"
++ g_return_if_fail (self != NULL);
++#line 298 "ease-player.vala"
++ g_return_if_fail (slide != NULL);
++#line 302 "ease-player.vala"
++ self->priv->current_slide = (_tmp0_ = g_object_ref_sink (ease_slide_actor_new_from_slide (self->priv->_document, slide, TRUE, EASE_ACTOR_CONTEXT_PRESENTATION)), _g_object_unref0 (self->priv->current_slide), _tmp0_);
++#line 713 "ease-player.c"
++}
++
++
++#line 319 "ease-player.vala"
++static void _lambda74_ (EasePlayer* self) {
++#line 320 "ease-player.vala"
++ ease_player_advance (self);
++#line 721 "ease-player.c"
++}
++
++
++#line 319 "ease-player.vala"
++static void __lambda74__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 727 "ease-player.c"
++ _lambda74_ (self);
++}
++
++
++#line 306 "ease-player.vala"
++static void ease_player_animation_complete (EasePlayer* self) {
++#line 306 "ease-player.vala"
++ g_return_if_fail (self != NULL);
++#line 308 "ease-player.vala"
++ clutter_group_remove_all (self->priv->container);
++#line 310 "ease-player.vala"
++ ease_player_set_can_animate (self, TRUE);
++#line 311 "ease-player.vala"
++ ease_slide_actor_stack (self->priv->current_slide, (ClutterActor*) self->priv->container);
++#line 314 "ease-player.vala"
++ if (ease_slide_get_automatically_advance (ease_slide_actor_get_slide (self->priv->current_slide))) {
++#line 744 "ease-player.c"
++ guint time;
++ ClutterTimeline* _tmp0_;
++#line 316 "ease-player.vala"
++ time = (guint) (1000 * ease_slide_get_advance_delay (ease_slide_actor_get_slide (self->priv->current_slide)));
++#line 318 "ease-player.vala"
++ self->priv->advance_alarm = (_tmp0_ = clutter_timeline_new (time), _g_object_unref0 (self->priv->advance_alarm), _tmp0_);
++#line 319 "ease-player.vala"
++ g_signal_connect_object (self->priv->advance_alarm, "completed", (GCallback) __lambda74__clutter_timeline_completed, self, 0);
++#line 322 "ease-player.vala"
++ clutter_timeline_start (self->priv->advance_alarm);
++#line 755 "ease-player.c"
++ }
++}
++
++
++EaseDocument* ease_player_get_document (EasePlayer* self) {
++ EaseDocument* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_document;
++#line 26 "ease-player.vala"
++ return result;
++#line 766 "ease-player.c"
++}
++
++
++void ease_player_set_document (EasePlayer* self, EaseDocument* value) {
++ EaseDocument* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_document = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_document), _tmp0_);
++ g_object_notify ((GObject *) self, "document");
++}
++
++
++gint ease_player_get_slide_index (EasePlayer* self) {
++ gint result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->_slide_index;
++#line 27 "ease-player.vala"
++ return result;
++#line 784 "ease-player.c"
++}
++
++
++void ease_player_set_slide_index (EasePlayer* self, gint value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_slide_index = value;
++ g_object_notify ((GObject *) self, "slide-index");
++}
++
++
++ClutterStage* ease_player_get_stage (EasePlayer* self) {
++ ClutterStage* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_stage;
++#line 28 "ease-player.vala"
++ return result;
++#line 801 "ease-player.c"
++}
++
++
++void ease_player_set_stage (EasePlayer* self, ClutterStage* value) {
++ ClutterStage* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_stage = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_stage), _tmp0_);
++ g_object_notify ((GObject *) self, "stage");
++}
++
++
++static gboolean ease_player_get_can_animate (EasePlayer* self) {
++ gboolean result;
++ g_return_val_if_fail (self != NULL, FALSE);
++ result = self->priv->_can_animate;
++#line 29 "ease-player.vala"
++ return result;
++#line 819 "ease-player.c"
++}
++
++
++static void ease_player_set_can_animate (EasePlayer* self, gboolean value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_can_animate = value;
++}
++
++
++static void ease_player_class_init (EasePlayerClass * klass) {
++ ease_player_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EasePlayerPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_player_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_player_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_player_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_PLAYER_DOCUMENT, g_param_spec_object ("document", "document", "document", EASE_TYPE_DOCUMENT, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_PLAYER_SLIDE_INDEX, g_param_spec_int ("slide-index", "slide-index", "slide-index", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_PLAYER_STAGE, g_param_spec_object ("stage", "stage", "stage", CLUTTER_TYPE_STAGE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_signal_new ("complete", EASE_TYPE_PLAYER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
++}
++
++
++static void ease_player_instance_init (EasePlayer * self) {
++ self->priv = EASE_PLAYER_GET_PRIVATE (self);
++ self->priv->dragging = FALSE;
++ self->priv->scale = (float) 1;
++}
++
++
++static void ease_player_finalize (GObject* obj) {
++ EasePlayer * self;
++ self = EASE_PLAYER (obj);
++ _g_object_unref0 (self->priv->_document);
++ _g_object_unref0 (self->priv->_stage);
++ _g_object_unref0 (self->priv->current_slide);
++ _g_object_unref0 (self->priv->old_slide);
++ _g_object_unref0 (self->priv->container);
++ _g_object_unref0 (self->priv->advance_alarm);
++ _g_object_unref0 (self->priv->shader);
++ _g_object_unref0 (self->priv->shader_top);
++ _g_object_unref0 (self->priv->shader_bottom);
++ _g_object_unref0 (self->priv->shader_left);
++ _g_object_unref0 (self->priv->shader_right);
++ G_OBJECT_CLASS (ease_player_parent_class)->finalize (obj);
++}
++
++
++GType ease_player_get_type (void) {
++ static volatile gsize ease_player_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_player_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EasePlayerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_player_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EasePlayer), 0, (GInstanceInitFunc) ease_player_instance_init, NULL };
++ GType ease_player_type_id;
++ ease_player_type_id = g_type_register_static (G_TYPE_OBJECT, "EasePlayer", &g_define_type_info, 0);
++ g_once_init_leave (&ease_player_type_id__volatile, ease_player_type_id);
++ }
++ return ease_player_type_id__volatile;
++}
++
++
++static void ease_player_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EasePlayer * self;
++ self = EASE_PLAYER (object);
++ switch (property_id) {
++ case EASE_PLAYER_DOCUMENT:
++ g_value_set_object (value, ease_player_get_document (self));
++ break;
++ case EASE_PLAYER_SLIDE_INDEX:
++ g_value_set_int (value, ease_player_get_slide_index (self));
++ break;
++ case EASE_PLAYER_STAGE:
++ g_value_set_object (value, ease_player_get_stage (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_player_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EasePlayer * self;
++ self = EASE_PLAYER (object);
++ switch (property_id) {
++ case EASE_PLAYER_DOCUMENT:
++ ease_player_set_document (self, g_value_get_object (value));
++ break;
++ case EASE_PLAYER_SLIDE_INDEX:
++ ease_player_set_slide_index (self, g_value_get_int (value));
++ break;
++ case EASE_PLAYER_STAGE:
++ ease_player_set_stage (self, g_value_get_object (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
diff --cc ease-core/ease-scrollable-embed.c
index 0000000,0000000..335a4bb
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-scrollable-embed.c
@@@ -1,0 -1,0 +1,544 @@@
++/* ease-scrollable-embed.c generated by valac, the Vala compiler
++ * generated from ease-scrollable-embed.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <clutter-gtk/clutter-gtk.h>
++#include <clutter/clutter.h>
++#include <float.h>
++#include <math.h>
++#include <gdk/gdk.h>
++
++
++#define EASE_TYPE_SCROLLABLE_EMBED (ease_scrollable_embed_get_type ())
++#define EASE_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbed))
++#define EASE_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++#define EASE_IS_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_IS_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_SCROLLABLE_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++
++typedef struct _EaseScrollableEmbed EaseScrollableEmbed;
++typedef struct _EaseScrollableEmbedClass EaseScrollableEmbedClass;
++typedef struct _EaseScrollableEmbedPrivate EaseScrollableEmbedPrivate;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++struct _EaseScrollableEmbed {
++ GtkHBox parent_instance;
++ EaseScrollableEmbedPrivate * priv;
++};
++
++struct _EaseScrollableEmbedClass {
++ GtkHBoxClass parent_class;
++};
++
++struct _EaseScrollableEmbedPrivate {
++ GtkClutterEmbed* embed;
++ GtkClutterViewport* viewport;
++ ClutterStage* stage;
++ ClutterGroup* _contents;
++ GtkHScrollbar* h_scrollbar;
++ GtkVScrollbar* v_scrollbar;
++ GtkAlignment* h_padder;
++ GtkAlignment* v_padder;
++ GtkAdjustment* h_adjust;
++ GtkAdjustment* v_adjust;
++ GtkAdjustment* z_adjust;
++ gboolean _has_horizontal;
++};
++
++
++static gpointer ease_scrollable_embed_parent_class = NULL;
++
++GType ease_scrollable_embed_get_type (void) G_GNUC_CONST;
++#define EASE_SCROLLABLE_EMBED_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedPrivate))
++enum {
++ EASE_SCROLLABLE_EMBED_DUMMY_PROPERTY,
++ EASE_SCROLLABLE_EMBED_CONTENTS,
++ EASE_SCROLLABLE_EMBED_HAS_HORIZONTAL,
++ EASE_SCROLLABLE_EMBED_WIDTH,
++ EASE_SCROLLABLE_EMBED_HEIGHT
++};
++#define EASE_SCROLLABLE_EMBED_FRAME_PADDING 2
++static void ease_scrollable_embed_set_has_horizontal (EaseScrollableEmbed* self, gboolean value);
++static void ease_scrollable_embed_set_contents (EaseScrollableEmbed* self, ClutterGroup* value);
++ClutterGroup* ease_scrollable_embed_get_contents (EaseScrollableEmbed* self);
++gboolean ease_scrollable_embed_get_has_horizontal (EaseScrollableEmbed* self);
++static void _lambda15_ (GtkWidget* sender, GdkRectangle* rect, EaseScrollableEmbed* self);
++static void __lambda15__gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self);
++static void _lambda16_ (EaseScrollableEmbed* self);
++static void __lambda16__gtk_widget_realize (GtkWidget* _sender, gpointer self);
++static gboolean _lambda17_ (GdkEventButton* event, EaseScrollableEmbed* self);
++static gboolean __lambda17__gtk_widget_button_press_event (GtkWidget* _sender, GdkEventButton* event, gpointer self);
++double ease_dmin (double a, double b);
++double ease_dmax (double a, double b);
++static gboolean _lambda18_ (GdkEventScroll* event, EaseScrollableEmbed* self);
++static gboolean __lambda18__gtk_widget_scroll_event (GtkWidget* _sender, GdkEventScroll* event, gpointer self);
++static void ease_scrollable_embed_embed_allocate (EaseScrollableEmbed* self, GtkWidget* sender, GdkRectangle* rect);
++static void _ease_scrollable_embed_embed_allocate_gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self);
++EaseScrollableEmbed* ease_scrollable_embed_new (gboolean horizontal, gboolean has_frame);
++EaseScrollableEmbed* ease_scrollable_embed_construct (GType object_type, gboolean horizontal, gboolean has_frame);
++ClutterStage* ease_scrollable_embed_get_stage (EaseScrollableEmbed* self);
++void ease_scrollable_embed_key_focus (EaseScrollableEmbed* self);
++float ease_scrollable_embed_get_width (EaseScrollableEmbed* self);
++float ease_scrollable_embed_get_height (EaseScrollableEmbed* self);
++static void ease_scrollable_embed_finalize (GObject* obj);
++static void ease_scrollable_embed_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_scrollable_embed_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 126 "ease-scrollable-embed.vala"
++static void _lambda15_ (GtkWidget* sender, GdkRectangle* rect, EaseScrollableEmbed* self) {
++#line 126 "ease-scrollable-embed.vala"
++ g_return_if_fail (sender != NULL);
++#line 127 "ease-scrollable-embed.vala"
++ g_object_set ((GtkWidget*) self->priv->h_padder, "width-request", EASE_SCROLLABLE_EMBED_FRAME_PADDING, NULL);
++#line 128 "ease-scrollable-embed.vala"
++ g_object_set ((GtkWidget*) self->priv->v_padder, "height-request", (*rect).height + EASE_SCROLLABLE_EMBED_FRAME_PADDING, NULL);
++#line 122 "ease-scrollable-embed.c"
++}
++
++
++#line 126 "ease-scrollable-embed.vala"
++static void __lambda15__gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self) {
++#line 128 "ease-scrollable-embed.c"
++ _lambda15_ (_sender, allocation, self);
++}
++
++
++#line 141 "ease-scrollable-embed.vala"
++static void _lambda16_ (EaseScrollableEmbed* self) {
++#line 142 "ease-scrollable-embed.vala"
++ gdk_window_set_events (gtk_widget_get_window ((GtkWidget*) self), GDK_ALL_EVENTS_MASK);
++#line 137 "ease-scrollable-embed.c"
++}
++
++
++#line 141 "ease-scrollable-embed.vala"
++static void __lambda16__gtk_widget_realize (GtkWidget* _sender, gpointer self) {
++#line 143 "ease-scrollable-embed.c"
++ _lambda16_ (self);
++}
++
++
++#line 145 "ease-scrollable-embed.vala"
++static gboolean _lambda17_ (GdkEventButton* event, EaseScrollableEmbed* self) {
++#line 150 "ease-scrollable-embed.c"
++ gboolean result = FALSE;
++ result = FALSE;
++#line 146 "ease-scrollable-embed.vala"
++ return result;
++#line 155 "ease-scrollable-embed.c"
++}
++
++
++#line 145 "ease-scrollable-embed.vala"
++static gboolean __lambda17__gtk_widget_button_press_event (GtkWidget* _sender, GdkEventButton* event, gpointer self) {
++#line 161 "ease-scrollable-embed.c"
++ gboolean result;
++ result = _lambda17_ (event, self);
++ return result;
++}
++
++
++#line 149 "ease-scrollable-embed.vala"
++static gboolean _lambda18_ (GdkEventScroll* event, EaseScrollableEmbed* self) {
++#line 170 "ease-scrollable-embed.c"
++ gboolean result = FALSE;
++#line 150 "ease-scrollable-embed.vala"
++ switch ((*event).direction) {
++#line 174 "ease-scrollable-embed.c"
++ case GDK_SCROLL_UP:
++ {
++#line 153 "ease-scrollable-embed.vala"
++ gtk_adjustment_set_value (self->priv->v_adjust, ease_dmin (gtk_adjustment_get_upper (self->priv->v_adjust), ease_dmax (gtk_adjustment_get_lower (self->priv->v_adjust), gtk_adjustment_get_value (self->priv->v_adjust) - gtk_adjustment_get_step_increment (self->priv->v_adjust))));
++#line 157 "ease-scrollable-embed.vala"
++ break;
++#line 181 "ease-scrollable-embed.c"
++ }
++ case GDK_SCROLL_DOWN:
++ {
++#line 159 "ease-scrollable-embed.vala"
++ gtk_adjustment_set_value (self->priv->v_adjust, ease_dmin (gtk_adjustment_get_upper (self->priv->v_adjust), ease_dmax (gtk_adjustment_get_lower (self->priv->v_adjust), gtk_adjustment_get_value (self->priv->v_adjust) + gtk_adjustment_get_step_increment (self->priv->v_adjust))));
++#line 163 "ease-scrollable-embed.vala"
++ break;
++#line 189 "ease-scrollable-embed.c"
++ }
++ }
++ result = FALSE;
++#line 165 "ease-scrollable-embed.vala"
++ return result;
++#line 195 "ease-scrollable-embed.c"
++}
++
++
++#line 149 "ease-scrollable-embed.vala"
++static gboolean __lambda18__gtk_widget_scroll_event (GtkWidget* _sender, GdkEventScroll* event, gpointer self) {
++#line 201 "ease-scrollable-embed.c"
++ gboolean result;
++ result = _lambda18_ (event, self);
++ return result;
++}
++
++
++#line 184 "ease-scrollable-embed.vala"
++static void _ease_scrollable_embed_embed_allocate_gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self) {
++#line 210 "ease-scrollable-embed.c"
++ ease_scrollable_embed_embed_allocate (self, _sender, allocation);
++}
++
++
++#line 66 "ease-scrollable-embed.vala"
++EaseScrollableEmbed* ease_scrollable_embed_construct (GType object_type, gboolean horizontal, gboolean has_frame) {
++#line 217 "ease-scrollable-embed.c"
++ EaseScrollableEmbed * self;
++ GtkClutterEmbed* _tmp0_;
++ GtkAdjustment* _tmp1_;
++ GtkHScrollbar* _tmp2_;
++ GtkAdjustment* _tmp3_;
++ GtkVScrollbar* _tmp4_;
++ GtkAdjustment* _tmp5_;
++ GtkClutterViewport* _tmp6_;
++ ClutterGroup* _tmp7_;
++ ClutterStage* _tmp8_;
++ GtkVBox* vbox;
++ self = g_object_newv (object_type, 0, NULL);
++#line 68 "ease-scrollable-embed.vala"
++ ease_scrollable_embed_set_has_horizontal (self, horizontal);
++#line 70 "ease-scrollable-embed.vala"
++ self->priv->embed = (_tmp0_ = g_object_ref_sink ((GtkClutterEmbed*) gtk_clutter_embed_new ()), _g_object_unref0 (self->priv->embed), _tmp0_);
++#line 71 "ease-scrollable-embed.vala"
++ self->priv->h_adjust = (_tmp1_ = g_object_ref_sink ((GtkAdjustment*) gtk_adjustment_new ((double) 0, (double) 0, (double) 1, 0.1, 0.1, 0.1)), _g_object_unref0 (self->priv->h_adjust), _tmp1_);
++#line 72 "ease-scrollable-embed.vala"
++ self->priv->h_scrollbar = (_tmp2_ = g_object_ref_sink ((GtkHScrollbar*) gtk_hscrollbar_new (self->priv->h_adjust)), _g_object_unref0 (self->priv->h_scrollbar), _tmp2_);
++#line 73 "ease-scrollable-embed.vala"
++ self->priv->v_adjust = (_tmp3_ = g_object_ref_sink ((GtkAdjustment*) gtk_adjustment_new ((double) 0, (double) 0, (double) 1, 0.1, 0.1, 0.1)), _g_object_unref0 (self->priv->v_adjust), _tmp3_);
++#line 74 "ease-scrollable-embed.vala"
++ self->priv->v_scrollbar = (_tmp4_ = g_object_ref_sink ((GtkVScrollbar*) gtk_vscrollbar_new (self->priv->v_adjust)), _g_object_unref0 (self->priv->v_scrollbar), _tmp4_);
++#line 75 "ease-scrollable-embed.vala"
++ self->priv->z_adjust = (_tmp5_ = g_object_ref_sink ((GtkAdjustment*) gtk_adjustment_new ((double) 0, (double) 0, (double) 1, 0.1, 0.1, 0.1)), _g_object_unref0 (self->priv->z_adjust), _tmp5_);
++#line 78 "ease-scrollable-embed.vala"
++ self->priv->viewport = (_tmp6_ = g_object_ref_sink ((GtkClutterViewport*) gtk_clutter_viewport_new (self->priv->h_adjust, self->priv->v_adjust, self->priv->z_adjust)), _g_object_unref0 (self->priv->viewport), _tmp6_);
++#line 79 "ease-scrollable-embed.vala"
++ ease_scrollable_embed_set_contents (self, _tmp7_ = g_object_ref_sink ((ClutterGroup*) clutter_group_new ()));
++#line 248 "ease-scrollable-embed.c"
++ _g_object_unref0 (_tmp7_);
++#line 81 "ease-scrollable-embed.vala"
++ self->priv->stage = (_tmp8_ = _g_object_ref0 (CLUTTER_STAGE (gtk_clutter_embed_get_stage (self->priv->embed))), _g_object_unref0 (self->priv->stage), _tmp8_);
++#line 82 "ease-scrollable-embed.vala"
++ clutter_container_add_actor ((ClutterContainer*) self->priv->stage, (ClutterActor*) self->priv->viewport);
++#line 83 "ease-scrollable-embed.vala"
++ g_object_set (self->priv->viewport, "child", (ClutterActor*) self->priv->_contents, NULL);
++#line 86 "ease-scrollable-embed.vala"
++ vbox = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0));
++#line 87 "ease-scrollable-embed.vala"
++ if (has_frame) {
++#line 260 "ease-scrollable-embed.c"
++ GtkFrame* frame;
++ GtkAlignment* align;
++ gint _tmp9_ = 0;
++#line 90 "ease-scrollable-embed.vala"
++ frame = g_object_ref_sink ((GtkFrame*) gtk_frame_new (NULL));
++#line 91 "ease-scrollable-embed.vala"
++ gtk_frame_set_shadow_type (frame, GTK_SHADOW_IN);
++#line 92 "ease-scrollable-embed.vala"
++ gtk_container_add ((GtkContainer*) frame, (GtkWidget*) self->priv->embed);
++#line 95 "ease-scrollable-embed.vala"
++ align = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 1, (float) 1));
++#line 96 "ease-scrollable-embed.vala"
++ if (horizontal) {
++#line 96 "ease-scrollable-embed.vala"
++ _tmp9_ = EASE_SCROLLABLE_EMBED_FRAME_PADDING;
++#line 276 "ease-scrollable-embed.c"
++ } else {
++#line 96 "ease-scrollable-embed.vala"
++ _tmp9_ = 0;
++#line 280 "ease-scrollable-embed.c"
++ }
++#line 96 "ease-scrollable-embed.vala"
++ gtk_alignment_set_padding (align, (guint) 0, (guint) _tmp9_, (guint) 0, (guint) EASE_SCROLLABLE_EMBED_FRAME_PADDING);
++#line 98 "ease-scrollable-embed.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) frame);
++#line 100 "ease-scrollable-embed.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) align, TRUE, TRUE, (guint) 0);
++#line 288 "ease-scrollable-embed.c"
++ _g_object_unref0 (align);
++ _g_object_unref0 (frame);
++ } else {
++#line 104 "ease-scrollable-embed.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) self->priv->embed, TRUE, TRUE, (guint) 0);
++#line 294 "ease-scrollable-embed.c"
++ }
++#line 107 "ease-scrollable-embed.vala"
++ if (self->priv->_has_horizontal) {
++#line 298 "ease-scrollable-embed.c"
++ GtkAlignment* _tmp10_;
++ GtkHBox* hscroll_box;
++ GtkAlignment* _tmp11_;
++ GtkVBox* vscroll_box;
++#line 110 "ease-scrollable-embed.vala"
++ self->priv->h_padder = (_tmp10_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 0, (float) 0)), _g_object_unref0 (self->priv->h_padder), _tmp10_);
++#line 112 "ease-scrollable-embed.vala"
++ hscroll_box = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 0));
++#line 113 "ease-scrollable-embed.vala"
++ gtk_box_pack_start ((GtkBox*) hscroll_box, (GtkWidget*) self->priv->h_scrollbar, TRUE, TRUE, (guint) 0);
++#line 114 "ease-scrollable-embed.vala"
++ gtk_box_pack_start ((GtkBox*) hscroll_box, (GtkWidget*) self->priv->h_padder, FALSE, FALSE, (guint) 0);
++#line 115 "ease-scrollable-embed.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) hscroll_box, FALSE, FALSE, (guint) 0);
++#line 119 "ease-scrollable-embed.vala"
++ self->priv->v_padder = (_tmp11_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, (float) 0, (float) 0, (float) 0)), _g_object_unref0 (self->priv->v_padder), _tmp11_);
++#line 121 "ease-scrollable-embed.vala"
++ vscroll_box = g_object_ref_sink ((GtkVBox*) gtk_vbox_new (FALSE, 0));
++#line 122 "ease-scrollable-embed.vala"
++ gtk_box_pack_start ((GtkBox*) vscroll_box, (GtkWidget*) self->priv->v_scrollbar, TRUE, TRUE, (guint) 0);
++#line 123 "ease-scrollable-embed.vala"
++ gtk_box_pack_start ((GtkBox*) vscroll_box, (GtkWidget*) self->priv->v_padder, FALSE, FALSE, (guint) 0);
++#line 124 "ease-scrollable-embed.vala"
++ gtk_box_pack_end ((GtkBox*) self, (GtkWidget*) vscroll_box, FALSE, FALSE, (guint) 0);
++#line 126 "ease-scrollable-embed.vala"
++ g_signal_connect_object ((GtkWidget*) self->priv->h_scrollbar, "size-allocate", (GCallback) __lambda15__gtk_widget_size_allocate, self, 0);
++#line 325 "ease-scrollable-embed.c"
++ _g_object_unref0 (vscroll_box);
++ _g_object_unref0 (hscroll_box);
++ } else {
++#line 133 "ease-scrollable-embed.vala"
++ gtk_box_pack_end ((GtkBox*) self, (GtkWidget*) self->priv->v_scrollbar, FALSE, FALSE, (guint) 0);
++#line 331 "ease-scrollable-embed.c"
++ }
++#line 136 "ease-scrollable-embed.vala"
++ gtk_box_pack_start ((GtkBox*) self, (GtkWidget*) vbox, TRUE, TRUE, (guint) 0);
++#line 138 "ease-scrollable-embed.vala"
++ clutter_actor_show_all ((ClutterActor*) self->priv->stage);
++#line 141 "ease-scrollable-embed.vala"
++ g_signal_connect_object ((GtkWidget*) self, "realize", (GCallback) __lambda16__gtk_widget_realize, self, 0);
++#line 145 "ease-scrollable-embed.vala"
++ g_signal_connect_object ((GtkWidget*) self, "button-press-event", (GCallback) __lambda17__gtk_widget_button_press_event, self, 0);
++#line 149 "ease-scrollable-embed.vala"
++ g_signal_connect_object ((GtkWidget*) self, "scroll-event", (GCallback) __lambda18__gtk_widget_scroll_event, self, 0);
++#line 169 "ease-scrollable-embed.vala"
++ g_signal_connect_object ((GtkWidget*) self->priv->embed, "size-allocate", (GCallback) _ease_scrollable_embed_embed_allocate_gtk_widget_size_allocate, self, 0);
++#line 345 "ease-scrollable-embed.c"
++ _g_object_unref0 (vbox);
++ return self;
++}
++
++
++#line 66 "ease-scrollable-embed.vala"
++EaseScrollableEmbed* ease_scrollable_embed_new (gboolean horizontal, gboolean has_frame) {
++#line 66 "ease-scrollable-embed.vala"
++ return ease_scrollable_embed_construct (EASE_TYPE_SCROLLABLE_EMBED, horizontal, has_frame);
++#line 355 "ease-scrollable-embed.c"
++}
++
++
++#line 176 "ease-scrollable-embed.vala"
++ClutterStage* ease_scrollable_embed_get_stage (EaseScrollableEmbed* self) {
++#line 361 "ease-scrollable-embed.c"
++ ClutterStage* result = NULL;
++#line 176 "ease-scrollable-embed.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 365 "ease-scrollable-embed.c"
++ result = _g_object_ref0 (CLUTTER_STAGE (gtk_clutter_embed_get_stage (self->priv->embed)));
++#line 178 "ease-scrollable-embed.vala"
++ return result;
++#line 369 "ease-scrollable-embed.c"
++}
++
++
++#line 184 "ease-scrollable-embed.vala"
++static void ease_scrollable_embed_embed_allocate (EaseScrollableEmbed* self, GtkWidget* sender, GdkRectangle* rect) {
++#line 184 "ease-scrollable-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 184 "ease-scrollable-embed.vala"
++ g_return_if_fail (sender != NULL);
++#line 187 "ease-scrollable-embed.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->stage, (float) ((GtkWidget*) self)->allocation.width);
++#line 188 "ease-scrollable-embed.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->stage, (float) ((GtkWidget*) self)->allocation.height);
++#line 189 "ease-scrollable-embed.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->viewport, (float) ((GtkWidget*) self)->allocation.width);
++#line 190 "ease-scrollable-embed.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->viewport, (float) ((GtkWidget*) self)->allocation.height);
++#line 387 "ease-scrollable-embed.c"
++}
++
++
++#line 196 "ease-scrollable-embed.vala"
++void ease_scrollable_embed_key_focus (EaseScrollableEmbed* self) {
++#line 196 "ease-scrollable-embed.vala"
++ g_return_if_fail (self != NULL);
++#line 198 "ease-scrollable-embed.vala"
++ gtk_widget_grab_focus ((GtkWidget*) self->priv->embed);
++#line 397 "ease-scrollable-embed.c"
++}
++
++
++ClutterGroup* ease_scrollable_embed_get_contents (EaseScrollableEmbed* self) {
++ ClutterGroup* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_contents;
++#line 30 "ease-scrollable-embed.vala"
++ return result;
++#line 407 "ease-scrollable-embed.c"
++}
++
++
++static void ease_scrollable_embed_set_contents (EaseScrollableEmbed* self, ClutterGroup* value) {
++ ClutterGroup* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_contents = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_contents), _tmp0_);
++ g_object_notify ((GObject *) self, "contents");
++}
++
++
++gboolean ease_scrollable_embed_get_has_horizontal (EaseScrollableEmbed* self) {
++ gboolean result;
++ g_return_val_if_fail (self != NULL, FALSE);
++ result = self->priv->_has_horizontal;
++#line 44 "ease-scrollable-embed.vala"
++ return result;
++#line 425 "ease-scrollable-embed.c"
++}
++
++
++static void ease_scrollable_embed_set_has_horizontal (EaseScrollableEmbed* self, gboolean value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_has_horizontal = value;
++ g_object_notify ((GObject *) self, "has-horizontal");
++}
++
++
++float ease_scrollable_embed_get_width (EaseScrollableEmbed* self) {
++ float result;
++ g_return_val_if_fail (self != NULL, 0.0F);
++ result = clutter_actor_get_width ((ClutterActor*) self->priv->stage);
++#line 49 "ease-scrollable-embed.vala"
++ return result;
++#line 442 "ease-scrollable-embed.c"
++}
++
++
++float ease_scrollable_embed_get_height (EaseScrollableEmbed* self) {
++ float result;
++ g_return_val_if_fail (self != NULL, 0.0F);
++ result = clutter_actor_get_height ((ClutterActor*) self->priv->stage);
++#line 54 "ease-scrollable-embed.vala"
++ return result;
++#line 452 "ease-scrollable-embed.c"
++}
++
++
++static void ease_scrollable_embed_class_init (EaseScrollableEmbedClass * klass) {
++ ease_scrollable_embed_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseScrollableEmbedPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_scrollable_embed_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_scrollable_embed_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_scrollable_embed_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SCROLLABLE_EMBED_CONTENTS, g_param_spec_object ("contents", "contents", "contents", CLUTTER_TYPE_GROUP, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SCROLLABLE_EMBED_HAS_HORIZONTAL, g_param_spec_boolean ("has-horizontal", "has-horizontal", "has-horizontal", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SCROLLABLE_EMBED_WIDTH, g_param_spec_float ("width", "width", "width", -G_MAXFLOAT, G_MAXFLOAT, 0.0F, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SCROLLABLE_EMBED_HEIGHT, g_param_spec_float ("height", "height", "height", -G_MAXFLOAT, G_MAXFLOAT, 0.0F, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++}
++
++
++static void ease_scrollable_embed_instance_init (EaseScrollableEmbed * self) {
++ self->priv = EASE_SCROLLABLE_EMBED_GET_PRIVATE (self);
++}
++
++
++static void ease_scrollable_embed_finalize (GObject* obj) {
++ EaseScrollableEmbed * self;
++ self = EASE_SCROLLABLE_EMBED (obj);
++ _g_object_unref0 (self->priv->embed);
++ _g_object_unref0 (self->priv->viewport);
++ _g_object_unref0 (self->priv->stage);
++ _g_object_unref0 (self->priv->_contents);
++ _g_object_unref0 (self->priv->h_scrollbar);
++ _g_object_unref0 (self->priv->v_scrollbar);
++ _g_object_unref0 (self->priv->h_padder);
++ _g_object_unref0 (self->priv->v_padder);
++ _g_object_unref0 (self->priv->h_adjust);
++ _g_object_unref0 (self->priv->v_adjust);
++ _g_object_unref0 (self->priv->z_adjust);
++ G_OBJECT_CLASS (ease_scrollable_embed_parent_class)->finalize (obj);
++}
++
++
++GType ease_scrollable_embed_get_type (void) {
++ static volatile gsize ease_scrollable_embed_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_scrollable_embed_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseScrollableEmbedClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_scrollable_embed_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseScrollableEmbed), 0, (GInstanceInitFunc) ease_scrollable_embed_instance_init, NULL };
++ GType ease_scrollable_embed_type_id;
++ ease_scrollable_embed_type_id = g_type_register_static (GTK_TYPE_HBOX, "EaseScrollableEmbed", &g_define_type_info, 0);
++ g_once_init_leave (&ease_scrollable_embed_type_id__volatile, ease_scrollable_embed_type_id);
++ }
++ return ease_scrollable_embed_type_id__volatile;
++}
++
++
++static void ease_scrollable_embed_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseScrollableEmbed * self;
++ self = EASE_SCROLLABLE_EMBED (object);
++ switch (property_id) {
++ case EASE_SCROLLABLE_EMBED_CONTENTS:
++ g_value_set_object (value, ease_scrollable_embed_get_contents (self));
++ break;
++ case EASE_SCROLLABLE_EMBED_HAS_HORIZONTAL:
++ g_value_set_boolean (value, ease_scrollable_embed_get_has_horizontal (self));
++ break;
++ case EASE_SCROLLABLE_EMBED_WIDTH:
++ g_value_set_float (value, ease_scrollable_embed_get_width (self));
++ break;
++ case EASE_SCROLLABLE_EMBED_HEIGHT:
++ g_value_set_float (value, ease_scrollable_embed_get_height (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_scrollable_embed_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseScrollableEmbed * self;
++ self = EASE_SCROLLABLE_EMBED (object);
++ switch (property_id) {
++ case EASE_SCROLLABLE_EMBED_CONTENTS:
++ ease_scrollable_embed_set_contents (self, g_value_get_object (value));
++ break;
++ case EASE_SCROLLABLE_EMBED_HAS_HORIZONTAL:
++ ease_scrollable_embed_set_has_horizontal (self, g_value_get_boolean (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
diff --cc ease-core/ease-selection-rectangle.c
index 0000000,0000000..9120c06
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-selection-rectangle.c
@@@ -1,0 -1,0 +1,249 @@@
++/* ease-selection-rectangle.c generated by valac, the Vala compiler
++ * generated from ease-selection-rectangle.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <clutter/clutter.h>
++#include <float.h>
++#include <math.h>
++
++
++#define EASE_TYPE_SELECTION_RECTANGLE (ease_selection_rectangle_get_type ())
++#define EASE_SELECTION_RECTANGLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SELECTION_RECTANGLE, EaseSelectionRectangle))
++#define EASE_SELECTION_RECTANGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SELECTION_RECTANGLE, EaseSelectionRectangleClass))
++#define EASE_IS_SELECTION_RECTANGLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SELECTION_RECTANGLE))
++#define EASE_IS_SELECTION_RECTANGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SELECTION_RECTANGLE))
++#define EASE_SELECTION_RECTANGLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SELECTION_RECTANGLE, EaseSelectionRectangleClass))
++
++typedef struct _EaseSelectionRectangle EaseSelectionRectangle;
++typedef struct _EaseSelectionRectangleClass EaseSelectionRectangleClass;
++typedef struct _EaseSelectionRectanglePrivate EaseSelectionRectanglePrivate;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++struct _EaseSelectionRectangle {
++ ClutterGroup parent_instance;
++ EaseSelectionRectanglePrivate * priv;
++};
++
++struct _EaseSelectionRectangleClass {
++ ClutterGroupClass parent_class;
++};
++
++struct _EaseSelectionRectanglePrivate {
++ ClutterRectangle* top;
++ ClutterRectangle* bottom;
++ ClutterRectangle* left;
++ ClutterRectangle* right;
++};
++
++
++static gpointer ease_selection_rectangle_parent_class = NULL;
++
++GType ease_selection_rectangle_get_type (void) G_GNUC_CONST;
++#define EASE_SELECTION_RECTANGLE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_SELECTION_RECTANGLE, EaseSelectionRectanglePrivate))
++enum {
++ EASE_SELECTION_RECTANGLE_DUMMY_PROPERTY
++};
++#define EASE_SELECTION_RECTANGLE_HEIGHT 6
++#define EASE_SELECTION_RECTANGLE_BORDER 2
++static void ease_selection_rectangle_make (EaseSelectionRectangle* self, ClutterRectangle** rect);
++static void _lambda65_ (GObject* _self_, GParamSpec* pspec, EaseSelectionRectangle* self);
++static void __lambda65__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static void _lambda66_ (GObject* _self_, GParamSpec* pspec, EaseSelectionRectangle* self);
++static void __lambda66__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++EaseSelectionRectangle* ease_selection_rectangle_new (void);
++EaseSelectionRectangle* ease_selection_rectangle_construct (GType object_type);
++static void ease_selection_rectangle_finalize (GObject* obj);
++
++static const ClutterColor EASE_SELECTION_RECTANGLE_INNER_COLOR = {(guchar) 255, (guchar) 255, (guchar) 255, (guchar) 255};
++static const ClutterColor EASE_SELECTION_RECTANGLE_OUTER_COLOR = {(guchar) 0, (guchar) 0, (guchar) 0, (guchar) 255};
++
++
++#line 52 "ease-selection-rectangle.vala"
++static void _lambda65_ (GObject* _self_, GParamSpec* pspec, EaseSelectionRectangle* self) {
++#line 52 "ease-selection-rectangle.vala"
++ g_return_if_fail (_self_ != NULL);
++#line 52 "ease-selection-rectangle.vala"
++ g_return_if_fail (pspec != NULL);
++#line 53 "ease-selection-rectangle.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->top, clutter_actor_get_width ((ClutterActor*) self));
++#line 54 "ease-selection-rectangle.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->bottom, clutter_actor_get_width ((ClutterActor*) self));
++#line 55 "ease-selection-rectangle.vala"
++ clutter_actor_set_x ((ClutterActor*) self->priv->right, clutter_actor_get_width ((ClutterActor*) self));
++#line 92 "ease-selection-rectangle.c"
++}
++
++
++#line 52 "ease-selection-rectangle.vala"
++static void __lambda65__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 98 "ease-selection-rectangle.c"
++ _lambda65_ (_sender, pspec, self);
++}
++
++
++#line 58 "ease-selection-rectangle.vala"
++static void _lambda66_ (GObject* _self_, GParamSpec* pspec, EaseSelectionRectangle* self) {
++#line 58 "ease-selection-rectangle.vala"
++ g_return_if_fail (_self_ != NULL);
++#line 58 "ease-selection-rectangle.vala"
++ g_return_if_fail (pspec != NULL);
++#line 59 "ease-selection-rectangle.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->left, clutter_actor_get_height ((ClutterActor*) self));
++#line 60 "ease-selection-rectangle.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->right, clutter_actor_get_height ((ClutterActor*) self));
++#line 61 "ease-selection-rectangle.vala"
++ clutter_actor_set_y ((ClutterActor*) self->priv->bottom, clutter_actor_get_height ((ClutterActor*) self));
++#line 115 "ease-selection-rectangle.c"
++}
++
++
++#line 58 "ease-selection-rectangle.vala"
++static void __lambda66__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 121 "ease-selection-rectangle.c"
++ _lambda66_ (_sender, pspec, self);
++}
++
++
++#line 33 "ease-selection-rectangle.vala"
++EaseSelectionRectangle* ease_selection_rectangle_construct (GType object_type) {
++#line 128 "ease-selection-rectangle.c"
++ EaseSelectionRectangle * self;
++ ClutterRectangle* _tmp1_;
++ ClutterRectangle* _tmp0_ = NULL;
++ ClutterRectangle* _tmp3_;
++ ClutterRectangle* _tmp2_ = NULL;
++ ClutterRectangle* _tmp5_;
++ ClutterRectangle* _tmp4_ = NULL;
++ ClutterRectangle* _tmp7_;
++ ClutterRectangle* _tmp6_ = NULL;
++ self = g_object_newv (object_type, 0, NULL);
++#line 35 "ease-selection-rectangle.vala"
++ ease_selection_rectangle_make (self, &_tmp0_);
++#line 35 "ease-selection-rectangle.vala"
++ self->priv->top = (_tmp1_ = _tmp0_, _g_object_unref0 (self->priv->top), _tmp1_);
++#line 36 "ease-selection-rectangle.vala"
++ ease_selection_rectangle_make (self, &_tmp2_);
++#line 36 "ease-selection-rectangle.vala"
++ self->priv->bottom = (_tmp3_ = _tmp2_, _g_object_unref0 (self->priv->bottom), _tmp3_);
++#line 37 "ease-selection-rectangle.vala"
++ ease_selection_rectangle_make (self, &_tmp4_);
++#line 37 "ease-selection-rectangle.vala"
++ self->priv->left = (_tmp5_ = _tmp4_, _g_object_unref0 (self->priv->left), _tmp5_);
++#line 38 "ease-selection-rectangle.vala"
++ ease_selection_rectangle_make (self, &_tmp6_);
++#line 38 "ease-selection-rectangle.vala"
++ self->priv->right = (_tmp7_ = _tmp6_, _g_object_unref0 (self->priv->right), _tmp7_);
++#line 40 "ease-selection-rectangle.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->top, (float) EASE_SELECTION_RECTANGLE_HEIGHT);
++#line 41 "ease-selection-rectangle.vala"
++ g_object_set ((ClutterActor*) self->priv->top, "anchor-y", (float) (EASE_SELECTION_RECTANGLE_HEIGHT / 2), NULL);
++#line 43 "ease-selection-rectangle.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->bottom, (float) EASE_SELECTION_RECTANGLE_HEIGHT);
++#line 44 "ease-selection-rectangle.vala"
++ g_object_set ((ClutterActor*) self->priv->bottom, "anchor-y", (float) (EASE_SELECTION_RECTANGLE_HEIGHT / 2), NULL);
++#line 46 "ease-selection-rectangle.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->left, (float) EASE_SELECTION_RECTANGLE_HEIGHT);
++#line 47 "ease-selection-rectangle.vala"
++ g_object_set ((ClutterActor*) self->priv->left, "anchor-x", (float) (EASE_SELECTION_RECTANGLE_HEIGHT / 2), NULL);
++#line 49 "ease-selection-rectangle.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->right, (float) EASE_SELECTION_RECTANGLE_HEIGHT);
++#line 50 "ease-selection-rectangle.vala"
++ g_object_set ((ClutterActor*) self->priv->right, "anchor-x", (float) (EASE_SELECTION_RECTANGLE_HEIGHT / 2), NULL);
++#line 52 "ease-selection-rectangle.vala"
++ g_signal_connect_object ((GObject*) self, "notify::width", (GCallback) __lambda65__g_object_notify, self, 0);
++#line 58 "ease-selection-rectangle.vala"
++ g_signal_connect_object ((GObject*) self, "notify::height", (GCallback) __lambda66__g_object_notify, self, 0);
++#line 175 "ease-selection-rectangle.c"
++ return self;
++}
++
++
++#line 33 "ease-selection-rectangle.vala"
++EaseSelectionRectangle* ease_selection_rectangle_new (void) {
++#line 33 "ease-selection-rectangle.vala"
++ return ease_selection_rectangle_construct (EASE_TYPE_SELECTION_RECTANGLE);
++#line 184 "ease-selection-rectangle.c"
++}
++
++
++#line 65 "ease-selection-rectangle.vala"
++static void ease_selection_rectangle_make (EaseSelectionRectangle* self, ClutterRectangle** rect) {
++#line 190 "ease-selection-rectangle.c"
++ ClutterRectangle* _tmp0_;
++ ClutterColor _tmp1_;
++ ClutterColor _tmp2_;
++#line 65 "ease-selection-rectangle.vala"
++ g_return_if_fail (self != NULL);
++#line 196 "ease-selection-rectangle.c"
++ if (rect != NULL) {
++ *rect = NULL;
++ }
++#line 67 "ease-selection-rectangle.vala"
++ *rect = (_tmp0_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new ()), _g_object_unref0 (*rect), _tmp0_);
++#line 68 "ease-selection-rectangle.vala"
++ clutter_rectangle_set_color (*rect, (_tmp1_ = EASE_SELECTION_RECTANGLE_INNER_COLOR, &_tmp1_));
++#line 69 "ease-selection-rectangle.vala"
++ clutter_rectangle_set_border_color (*rect, (_tmp2_ = EASE_SELECTION_RECTANGLE_OUTER_COLOR, &_tmp2_));
++#line 70 "ease-selection-rectangle.vala"
++ clutter_rectangle_set_border_width (*rect, (guint) EASE_SELECTION_RECTANGLE_BORDER);
++#line 71 "ease-selection-rectangle.vala"
++ clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) (*rect));
++#line 210 "ease-selection-rectangle.c"
++}
++
++
++static void ease_selection_rectangle_class_init (EaseSelectionRectangleClass * klass) {
++ ease_selection_rectangle_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseSelectionRectanglePrivate));
++ G_OBJECT_CLASS (klass)->finalize = ease_selection_rectangle_finalize;
++}
++
++
++static void ease_selection_rectangle_instance_init (EaseSelectionRectangle * self) {
++ self->priv = EASE_SELECTION_RECTANGLE_GET_PRIVATE (self);
++}
++
++
++static void ease_selection_rectangle_finalize (GObject* obj) {
++ EaseSelectionRectangle * self;
++ self = EASE_SELECTION_RECTANGLE (obj);
++ _g_object_unref0 (self->priv->top);
++ _g_object_unref0 (self->priv->bottom);
++ _g_object_unref0 (self->priv->left);
++ _g_object_unref0 (self->priv->right);
++ G_OBJECT_CLASS (ease_selection_rectangle_parent_class)->finalize (obj);
++}
++
++
++GType ease_selection_rectangle_get_type (void) {
++ static volatile gsize ease_selection_rectangle_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_selection_rectangle_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseSelectionRectangleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_selection_rectangle_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseSelectionRectangle), 0, (GInstanceInitFunc) ease_selection_rectangle_instance_init, NULL };
++ GType ease_selection_rectangle_type_id;
++ ease_selection_rectangle_type_id = g_type_register_static (CLUTTER_TYPE_GROUP, "EaseSelectionRectangle", &g_define_type_info, 0);
++ g_once_init_leave (&ease_selection_rectangle_type_id__volatile, ease_selection_rectangle_type_id);
++ }
++ return ease_selection_rectangle_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-slide-actor.c
index 0000000,0000000..594af0a
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-slide-actor.c
@@@ -1,0 -1,0 +1,3670 @@@
++/* ease-slide-actor.c generated by valac, the Vala compiler
++ * generated from ease-slide-actor.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <clutter/clutter.h>
++#include <float.h>
++#include <math.h>
++#include <gee.h>
++#include <gtk/gtk.h>
++#include <cairo.h>
++#include <cogl/cogl.h>
++#include <stdlib.h>
++#include <string.h>
++
++
++#define EASE_TYPE_SLIDE_ACTOR (ease_slide_actor_get_type ())
++#define EASE_SLIDE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_ACTOR, EaseSlideActor))
++#define EASE_SLIDE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_ACTOR, EaseSlideActorClass))
++#define EASE_IS_SLIDE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_ACTOR))
++#define EASE_IS_SLIDE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_ACTOR))
++#define EASE_SLIDE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_ACTOR, EaseSlideActorClass))
++
++typedef struct _EaseSlideActor EaseSlideActor;
++typedef struct _EaseSlideActorClass EaseSlideActorClass;
++typedef struct _EaseSlideActorPrivate EaseSlideActorPrivate;
++
++#define EASE_TYPE_CLUTTER_ITERABLE_GROUP (ease_clutter_iterable_group_get_type ())
++#define EASE_CLUTTER_ITERABLE_GROUP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_CLUTTER_ITERABLE_GROUP, EaseClutterIterableGroup))
++#define EASE_CLUTTER_ITERABLE_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_CLUTTER_ITERABLE_GROUP, EaseClutterIterableGroupClass))
++#define EASE_IS_CLUTTER_ITERABLE_GROUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_CLUTTER_ITERABLE_GROUP))
++#define EASE_IS_CLUTTER_ITERABLE_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_CLUTTER_ITERABLE_GROUP))
++#define EASE_CLUTTER_ITERABLE_GROUP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_CLUTTER_ITERABLE_GROUP, EaseClutterIterableGroupClass))
++
++typedef struct _EaseClutterIterableGroup EaseClutterIterableGroup;
++typedef struct _EaseClutterIterableGroupClass EaseClutterIterableGroupClass;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++typedef struct _EaseSlidePrivate EaseSlidePrivate;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++
++#define EASE_TYPE_ACTOR (ease_actor_get_type ())
++#define EASE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ACTOR, EaseActor))
++#define EASE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ACTOR, EaseActorClass))
++#define EASE_IS_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ACTOR))
++#define EASE_IS_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ACTOR))
++#define EASE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ACTOR, EaseActorClass))
++
++typedef struct _EaseActor EaseActor;
++typedef struct _EaseActorClass EaseActorClass;
++
++#define EASE_TYPE_CLUTTER_ITERABLE_CONTAINER (ease_clutter_iterable_container_get_type ())
++#define EASE_CLUTTER_ITERABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_CLUTTER_ITERABLE_CONTAINER, EaseClutterIterableContainer))
++#define EASE_IS_CLUTTER_ITERABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_CLUTTER_ITERABLE_CONTAINER))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_CLUTTER_ITERABLE_CONTAINER, EaseClutterIterableContainerIface))
++
++typedef struct _EaseClutterIterableContainer EaseClutterIterableContainer;
++typedef struct _EaseClutterIterableContainerIface EaseClutterIterableContainerIface;
++
++#define EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR (ease_clutter_iterable_container_iterator_get_type ())
++#define EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR, EaseClutterIterableContainerIterator))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR, EaseClutterIterableContainerIteratorClass))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR))
++#define EASE_CLUTTER_ITERABLE_CONTAINER_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_CLUTTER_ITERABLE_CONTAINER_TYPE_ITERATOR, EaseClutterIterableContainerIteratorClass))
++
++typedef struct _EaseClutterIterableContainerIterator EaseClutterIterableContainerIterator;
++typedef struct _EaseClutterIterableContainerIteratorClass EaseClutterIterableContainerIteratorClass;
++#define _ease_clutter_iterable_container_iterator_unref0(var) ((var == NULL) ? NULL : (var = (ease_clutter_iterable_container_iterator_unref (var), NULL)))
++typedef struct _EaseActorPrivate EaseActorPrivate;
++
++#define EASE_TYPE_SCROLLABLE_EMBED (ease_scrollable_embed_get_type ())
++#define EASE_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbed))
++#define EASE_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++#define EASE_IS_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_IS_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_SCROLLABLE_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++
++typedef struct _EaseScrollableEmbed EaseScrollableEmbed;
++typedef struct _EaseScrollableEmbedClass EaseScrollableEmbedClass;
++
++#define EASE_TYPE_EDITOR_EMBED (ease_editor_embed_get_type ())
++#define EASE_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbed))
++#define EASE_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++#define EASE_IS_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_EMBED))
++#define EASE_IS_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_EMBED))
++#define EASE_EDITOR_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++
++typedef struct _EaseEditorEmbed EaseEditorEmbed;
++typedef struct _EaseEditorEmbedClass EaseEditorEmbedClass;
++#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL)))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++
++#define EASE_TYPE_TRANSITION (ease_transition_get_type ())
++
++#define EASE_TYPE_TRANSITION_VARIANT (ease_transition_variant_get_type ())
++typedef struct _Block7Data Block7Data;
++typedef struct _Block8Data Block8Data;
++typedef struct _Block9Data Block9Data;
++typedef struct _Block10Data Block10Data;
++typedef struct _Block11Data Block11Data;
++typedef struct _Block12Data Block12Data;
++#define _g_free0(var) (var = (g_free (var), NULL))
++typedef struct _Block13Data Block13Data;
++typedef struct _Block14Data Block14Data;
++typedef struct _Block15Data Block15Data;
++typedef struct _Block16Data Block16Data;
++typedef struct _Block17Data Block17Data;
++typedef struct _Block18Data Block18Data;
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++struct _EaseSlideActor {
++ ClutterGroup parent_instance;
++ EaseSlideActorPrivate * priv;
++ ClutterCairoTexture* background;
++ EaseClutterIterableGroup* contents;
++ EaseActorContext context;
++};
++
++struct _EaseSlideActorClass {
++ ClutterGroupClass parent_class;
++};
++
++struct _EaseSlideActorPrivate {
++ EaseSlide* _slide;
++ float width_px;
++ float height_px;
++ ClutterTimeline* _animation_time;
++ ClutterAlpha* _animation_alpha;
++ ClutterTimeline* time1;
++ ClutterTimeline* time2;
++ ClutterAlpha* alpha1;
++ ClutterAlpha* alpha2;
++};
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseSlide {
++ GObject parent_instance;
++ EaseSlidePrivate * priv;
++ GeeArrayList* elements;
++};
++
++struct _EaseSlideClass {
++ GObjectClass parent_class;
++};
++
++struct _EaseClutterIterableContainerIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseActor {
++ ClutterGroup parent_instance;
++ EaseActorPrivate * priv;
++ ClutterActor* contents;
++ EaseElement* element;
++ EaseActorContext context;
++ gboolean is_background;
++};
++
++struct _EaseActorClass {
++ ClutterGroupClass parent_class;
++ void (*edit) (EaseActor* self, EaseEditorEmbed* sender);
++ void (*end_edit) (EaseActor* self, EaseEditorEmbed* sender);
++};
++
++typedef enum {
++ EASE_TRANSITION_NONE,
++ EASE_TRANSITION_FADE,
++ EASE_TRANSITION_SLIDE,
++ EASE_TRANSITION_DROP,
++ EASE_TRANSITION_PIVOT,
++ EASE_TRANSITION_FLIP,
++ EASE_TRANSITION_REVOLVING_DOOR,
++ EASE_TRANSITION_REVEAL,
++ EASE_TRANSITION_FALL,
++ EASE_TRANSITION_SLATS,
++ EASE_TRANSITION_OPEN_DOOR,
++ EASE_TRANSITION_EXPLODE,
++ EASE_TRANSITION_ASSEMBLE,
++ EASE_TRANSITION_ZOOM,
++ EASE_TRANSITION_PANEL,
++ EASE_TRANSITION_SPIN_CONTENTS,
++ EASE_TRANSITION_SPRING_CONTENTS,
++ EASE_TRANSITION_SWING_CONTENTS,
++ EASE_TRANSITION_SLIDE_CONTENTS,
++ EASE_TRANSITION_ZOOM_CONTENTS
++} EaseTransition;
++
++typedef enum {
++ EASE_TRANSITION_VARIANT_LEFT,
++ EASE_TRANSITION_VARIANT_RIGHT,
++ EASE_TRANSITION_VARIANT_UP,
++ EASE_TRANSITION_VARIANT_DOWN,
++ EASE_TRANSITION_VARIANT_BOTTOM,
++ EASE_TRANSITION_VARIANT_TOP,
++ EASE_TRANSITION_VARIANT_CENTER,
++ EASE_TRANSITION_VARIANT_TOP_LEFT,
++ EASE_TRANSITION_VARIANT_TOP_RIGHT,
++ EASE_TRANSITION_VARIANT_BOTTOM_LEFT,
++ EASE_TRANSITION_VARIANT_BOTTOM_RIGHT,
++ EASE_TRANSITION_VARIANT_TOP_TO_BOTTOM,
++ EASE_TRANSITION_VARIANT_BOTTOM_TO_TOP,
++ EASE_TRANSITION_VARIANT_LEFT_TO_RIGHT,
++ EASE_TRANSITION_VARIANT_RIGHT_TO_LEFT,
++ EASE_TRANSITION_VARIANT_IN,
++ EASE_TRANSITION_VARIANT_OUT
++} EaseTransitionVariant;
++
++struct _Block7Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ float xpos;
++ float ypos;
++ float angle;
++ EaseSlideActor* new_slide;
++};
++
++struct _Block8Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ ClutterRotateAxis axis;
++ float positive;
++ float x_point;
++ float y_point;
++ EaseSlideActor* new_slide;
++};
++
++struct _Block9Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ ClutterRotateAxis axis;
++ float positive;
++ float x_point;
++ float y_point;
++ EaseSlideActor* new_slide;
++};
++
++struct _Block10Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ ClutterGroup** groups;
++ gint groups_length1;
++ gint _groups_size_;
++ float width;
++ EaseSlideActor* new_slide;
++ ClutterGroup* container;
++};
++
++struct _Block11Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ float width;
++ ClutterGroup* left_group;
++ ClutterGroup* right_group;
++ ClutterGroup* container;
++};
++
++struct _Block12Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ EaseSlideActor* new_slide;
++};
++
++struct _Block13Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ float pos;
++ char* property;
++ EaseSlideActor* new_slide;
++ guint length;
++};
++
++struct _Block14Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ float angle;
++ EaseSlideActor* new_slide;
++};
++
++struct _Block15Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ EaseSlideActor* new_slide;
++};
++
++struct _Block16Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ EaseSlideActor* new_slide;
++};
++
++struct _Block17Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ gint count;
++ ClutterClone** particles;
++ gint particles_length1;
++ gint _particles_size_;
++ ClutterGroup* container;
++};
++
++struct _Block18Data {
++ int _ref_count_;
++ EaseSlideActor * self;
++ gint count;
++ ClutterClone** particles;
++ gint particles_length1;
++ gint _particles_size_;
++ EaseSlideActor* new_slide;
++ ClutterGroup* container;
++};
++
++
++static gpointer ease_slide_actor_parent_class = NULL;
++
++GType ease_slide_actor_get_type (void) G_GNUC_CONST;
++GType ease_clutter_iterable_group_get_type (void) G_GNUC_CONST;
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++GType ease_slide_get_type (void) G_GNUC_CONST;
++#define EASE_SLIDE_ACTOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_SLIDE_ACTOR, EaseSlideActorPrivate))
++enum {
++ EASE_SLIDE_ACTOR_DUMMY_PROPERTY,
++ EASE_SLIDE_ACTOR_SLIDE,
++ EASE_SLIDE_ACTOR_ANIMATION_TIME
++};
++#define EASE_SLIDE_ACTOR_EASE_SLIDE ((gint) CLUTTER_EASE_IN_OUT_SINE)
++#define EASE_SLIDE_ACTOR_EASE_DROP ((gint) CLUTTER_EASE_OUT_BOUNCE)
++#define EASE_SLIDE_ACTOR_EASE_PIVOT ((gint) CLUTTER_EASE_OUT_SINE)
++#define EASE_SLIDE_ACTOR_FLIP_DEPTH ((float) (-400))
++#define EASE_SLIDE_ACTOR_PANEL_SCALE 0.75f
++#define EASE_SLIDE_ACTOR_OPEN_DEPTH ((float) (-3000))
++#define EASE_SLIDE_ACTOR_OPEN_MOVE 0.15f
++#define EASE_SLIDE_ACTOR_OPEN_TIME 0.8f
++#define EASE_SLIDE_ACTOR_SLAT_COUNT 8
++#define EASE_SLIDE_ACTOR_REFLECTION_OPACITY 70
++#define EASE_SLIDE_ACTOR_EXPLODE_PARTICLES 10
++#define EASE_SLIDE_ACTOR_ASSEMBLE_TILES 12
++EaseSlideActor* ease_slide_actor_new_with_dimensions (float w, float h, EaseSlide* s, gboolean clip, EaseActorContext ctx);
++EaseSlideActor* ease_slide_actor_construct_with_dimensions (GType object_type, float w, float h, EaseSlide* s, gboolean clip, EaseActorContext ctx);
++GType ease_document_get_type (void) G_GNUC_CONST;
++gint ease_document_get_width (EaseDocument* self);
++gint ease_document_get_height (EaseDocument* self);
++EaseSlideActor* ease_slide_actor_new_from_slide (EaseDocument* document, EaseSlide* s, gboolean clip, EaseActorContext ctx);
++EaseSlideActor* ease_slide_actor_construct_from_slide (GType object_type, EaseDocument* document, EaseSlide* s, gboolean clip, EaseActorContext ctx);
++void ease_slide_actor_set_slide (EaseSlideActor* self, EaseSlide* value);
++static void ease_slide_actor_set_background (EaseSlideActor* self);
++EaseClutterIterableGroup* ease_clutter_iterable_group_new (void);
++EaseClutterIterableGroup* ease_clutter_iterable_group_construct (GType object_type);
++EaseSlide* ease_slide_actor_get_slide (EaseSlideActor* self);
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++GType ease_actor_get_type (void) G_GNUC_CONST;
++EaseActor* ease_element_actor (EaseElement* self, EaseActorContext c);
++static void _lambda28_ (EaseSlide* s, EaseSlideActor* self);
++static void __lambda28__ease_slide_background_changed (EaseSlide* _sender, EaseSlide* _self_, gpointer self);
++void ease_slide_actor_on_element_added (EaseSlideActor* self, EaseSlide* slide, EaseElement* element, gint index);
++static void _ease_slide_actor_on_element_added_ease_slide_element_added (EaseSlide* _sender, EaseSlide* _self_, EaseElement* element, gint index, gpointer self);
++void ease_slide_actor_on_element_removed (EaseSlideActor* self, EaseSlide* slide, EaseElement* element, gint index);
++static void _ease_slide_actor_on_element_removed_ease_slide_element_removed (EaseSlide* _sender, EaseSlide* _self_, EaseElement* element, gint index, gpointer self);
++EaseSlideActor* ease_slide_actor_new_blank (EaseDocument* document, ClutterColor* color);
++EaseSlideActor* ease_slide_actor_construct_blank (GType object_type, EaseDocument* document, ClutterColor* color);
++GType ease_clutter_iterable_container_get_type (void) G_GNUC_CONST;
++gpointer ease_clutter_iterable_container_iterator_ref (gpointer instance);
++void ease_clutter_iterable_container_iterator_unref (gpointer instance);
++GParamSpec* ease_clutter_iterable_container_param_spec_iterator (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
++void ease_clutter_iterable_container_value_set_iterator (GValue* value, gpointer v_object);
++void ease_clutter_iterable_container_value_take_iterator (GValue* value, gpointer v_object);
++gpointer ease_clutter_iterable_container_value_get_iterator (const GValue* value);
++GType ease_clutter_iterable_container_iterator_get_type (void) G_GNUC_CONST;
++EaseClutterIterableContainerIterator* ease_clutter_iterable_container_iterator (EaseClutterIterableContainer* self);
++gboolean ease_clutter_iterable_container_iterator_next (EaseClutterIterableContainerIterator* self);
++ClutterActor* ease_clutter_iterable_container_iterator_get (EaseClutterIterableContainerIterator* self);
++GType ease_scrollable_embed_get_type (void) G_GNUC_CONST;
++GType ease_editor_embed_get_type (void) G_GNUC_CONST;
++static void ease_slide_actor_reset_actor (EaseSlideActor* self, ClutterActor* actor);
++void ease_slide_actor_stack (EaseSlideActor* self, ClutterActor* container);
++void ease_slide_actor_reset (EaseSlideActor* self, ClutterGroup* container);
++void ease_actor_reposition (EaseActor* self);
++void ease_slide_actor_relayout (EaseSlideActor* self);
++void ease_slide_cairo_render_background (EaseSlide* self, cairo_t* cr, gint w, gint h, GError** error);
++void ease_slide_actor_unstack (EaseSlideActor* self, EaseSlideActor* other, ClutterActor* container);
++static void ease_slide_actor_prepare_slide_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container);
++static void ease_slide_actor_prepare_stack_transition (EaseSlideActor* self, gboolean current_on_top, EaseSlideActor* new_slide, ClutterGroup* container);
++double ease_dmax (double a, double b);
++double ease_slide_get_transition_time (EaseSlide* self);
++void ease_slide_actor_set_animation_time (EaseSlideActor* self, ClutterTimeline* value);
++GType ease_transition_get_type (void) G_GNUC_CONST;
++EaseTransition ease_slide_get_transition (EaseSlide* self);
++static void ease_slide_actor_slide_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_drop_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_pivot_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_open_door_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_reveal_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_slats_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_flip_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_revolving_door_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_fall_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_spin_contents_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_swing_contents_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_zoom_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_slide_contents_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_spring_contents_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_zoom_contents_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_panel_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_explode_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_assemble_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++static void ease_slide_actor_fade_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length);
++ClutterTimeline* ease_slide_actor_get_animation_time (EaseSlideActor* self);
++void ease_slide_actor_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container);
++GType ease_transition_variant_get_type (void) G_GNUC_CONST;
++EaseTransitionVariant ease_slide_get_variant (EaseSlide* self);
++EaseDocument* ease_slide_get_parent (EaseSlide* self);
++static void ease_slide_actor_set_animation_alpha (EaseSlideActor* self, ClutterAlpha* value);
++static ClutterAlpha* ease_slide_actor_get_animation_alpha (EaseSlideActor* self);
++static void _lambda29_ (gint m, Block7Data* _data7_);
++static void __lambda29__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static Block7Data* block7_data_ref (Block7Data* _data7_);
++static void block7_data_unref (Block7Data* _data7_);
++static void _lambda34_ (gint m, Block8Data* _data8_);
++static void __lambda34__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static void _lambda35_ (gint m, Block8Data* _data8_);
++static void __lambda35__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static void _lambda36_ (Block8Data* _data8_);
++static void __lambda36__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++static Block8Data* block8_data_ref (Block8Data* _data8_);
++static void block8_data_unref (Block8Data* _data8_);
++static void _lambda37_ (gint m, Block9Data* _data9_);
++static void __lambda37__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static Block9Data* block9_data_ref (Block9Data* _data9_);
++static void block9_data_unref (Block9Data* _data9_);
++static void _lambda38_ (gint m, EaseSlideActor* self);
++static void __lambda38__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static void _lambda32_ (gint m, Block10Data* _data10_);
++static void __lambda32__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static void _lambda33_ (Block10Data* _data10_);
++static void __lambda33__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++static Block10Data* block10_data_ref (Block10Data* _data10_);
++static void block10_data_unref (Block10Data* _data10_);
++static void _lambda30_ (gint m, Block11Data* _data11_);
++static void __lambda30__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static void _lambda31_ (Block11Data* _data11_);
++static void __lambda31__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++static Block11Data* block11_data_ref (Block11Data* _data11_);
++static void block11_data_unref (Block11Data* _data11_);
++static void _lambda43_ (gint m, Block12Data* _data12_);
++static void __lambda43__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static Block12Data* block12_data_ref (Block12Data* _data12_);
++static void block12_data_unref (Block12Data* _data12_);
++static void _lambda46_ (gint m, EaseSlideActor* self);
++static void __lambda46__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static void _lambda47_ (Block13Data* _data13_);
++static void __lambda47__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++static void _lambda49_ (gint m, Block13Data* _data13_);
++static void __lambda49__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static void _lambda48_ (Block13Data* _data13_);
++static void __lambda48__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++static Block13Data* block13_data_ref (Block13Data* _data13_);
++static void block13_data_unref (Block13Data* _data13_);
++static void _lambda39_ (EaseSlideActor* self);
++static void __lambda39__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++static void _lambda40_ (gint m, Block14Data* _data14_);
++static void __lambda40__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static void _lambda41_ (gint m, Block14Data* _data14_);
++static void __lambda41__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static Block14Data* block14_data_ref (Block14Data* _data14_);
++static void block14_data_unref (Block14Data* _data14_);
++static guint8 ease_slide_actor_clamp_opacity (double o);
++static void _lambda42_ (gint m, Block15Data* _data15_);
++static void __lambda42__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static Block15Data* block15_data_ref (Block15Data* _data15_);
++static void block15_data_unref (Block15Data* _data15_);
++static void _lambda44_ (gint m, Block16Data* _data16_);
++static void __lambda44__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static void _lambda45_ (gint m, Block16Data* _data16_);
++static void __lambda45__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self);
++static Block16Data* block16_data_ref (Block16Data* _data16_);
++static void block16_data_unref (Block16Data* _data16_);
++float ease_document_get_aspect (EaseDocument* self);
++static guint ease_slide_actor_explode_time (EaseSlideActor* self, guint time);
++static float ease_slide_actor_explode_dist (EaseSlideActor* self);
++static float ease_slide_actor_explode_depth (EaseSlideActor* self);
++static void _lambda50_ (Block17Data* _data17_);
++static void __lambda50__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++static Block17Data* block17_data_ref (Block17Data* _data17_);
++static void block17_data_unref (Block17Data* _data17_);
++static float ease_slide_actor_assemble_extra (EaseSlideActor* self);
++static void _lambda51_ (Block18Data* _data18_);
++static void __lambda51__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++static Block18Data* block18_data_ref (Block18Data* _data18_);
++static void block18_data_unref (Block18Data* _data18_);
++double ease_dmin (double a, double b);
++EaseSlideActor* ease_slide_actor_new (void);
++EaseSlideActor* ease_slide_actor_construct (GType object_type);
++static void ease_slide_actor_finalize (GObject* obj);
++static void ease_slide_actor_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_slide_actor_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
++static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
++
++
++
++#line 153 "ease-slide-actor.vala"
++EaseSlideActor* ease_slide_actor_construct_from_slide (GType object_type, EaseDocument* document, EaseSlide* s, gboolean clip, EaseActorContext ctx) {
++#line 568 "ease-slide-actor.c"
++ EaseSlideActor * self;
++#line 153 "ease-slide-actor.vala"
++ g_return_val_if_fail (document != NULL, NULL);
++#line 153 "ease-slide-actor.vala"
++ g_return_val_if_fail (s != NULL, NULL);
++#line 156 "ease-slide-actor.vala"
++ self = (EaseSlideActor*) ease_slide_actor_construct_with_dimensions (object_type, (float) ease_document_get_width (document), (float) ease_document_get_height (document), s, clip, ctx);
++#line 576 "ease-slide-actor.c"
++ return self;
++}
++
++
++#line 153 "ease-slide-actor.vala"
++EaseSlideActor* ease_slide_actor_new_from_slide (EaseDocument* document, EaseSlide* s, gboolean clip, EaseActorContext ctx) {
++#line 153 "ease-slide-actor.vala"
++ return ease_slide_actor_construct_from_slide (EASE_TYPE_SLIDE_ACTOR, document, s, clip, ctx);
++#line 585 "ease-slide-actor.c"
++}
++
++
++#line 196 "ease-slide-actor.vala"
++static void _lambda28_ (EaseSlide* s, EaseSlideActor* self) {
++#line 196 "ease-slide-actor.vala"
++ g_return_if_fail (s != NULL);
++#line 196 "ease-slide-actor.vala"
++ ease_slide_actor_set_background (self);
++#line 595 "ease-slide-actor.c"
++}
++
++
++#line 196 "ease-slide-actor.vala"
++static void __lambda28__ease_slide_background_changed (EaseSlide* _sender, EaseSlide* _self_, gpointer self) {
++#line 601 "ease-slide-actor.c"
++ _lambda28_ (_self_, self);
++}
++
++
++#line 226 "ease-slide-actor.vala"
++static void _ease_slide_actor_on_element_added_ease_slide_element_added (EaseSlide* _sender, EaseSlide* _self_, EaseElement* element, gint index, gpointer self) {
++#line 608 "ease-slide-actor.c"
++ ease_slide_actor_on_element_added (self, _self_, element, index);
++}
++
++
++#line 247 "ease-slide-actor.vala"
++static void _ease_slide_actor_on_element_removed_ease_slide_element_removed (EaseSlide* _sender, EaseSlide* _self_, EaseElement* element, gint index, gpointer self) {
++#line 615 "ease-slide-actor.c"
++ ease_slide_actor_on_element_removed (self, _self_, element, index);
++}
++
++
++#line 169 "ease-slide-actor.vala"
++EaseSlideActor* ease_slide_actor_construct_with_dimensions (GType object_type, float w, float h, EaseSlide* s, gboolean clip, EaseActorContext ctx) {
++#line 622 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ EaseClutterIterableGroup* _tmp0_;
++#line 169 "ease-slide-actor.vala"
++ g_return_val_if_fail (s != NULL, NULL);
++#line 627 "ease-slide-actor.c"
++ self = g_object_newv (object_type, 0, NULL);
++#line 172 "ease-slide-actor.vala"
++ ease_slide_actor_set_slide (self, s);
++#line 173 "ease-slide-actor.vala"
++ self->context = ctx;
++#line 174 "ease-slide-actor.vala"
++ self->priv->width_px = w;
++#line 175 "ease-slide-actor.vala"
++ self->priv->height_px = h;
++#line 178 "ease-slide-actor.vala"
++ if (clip) {
++#line 180 "ease-slide-actor.vala"
++ clutter_actor_set_clip ((ClutterActor*) self, (float) 0, (float) 0, w, h);
++#line 641 "ease-slide-actor.c"
++ }
++#line 184 "ease-slide-actor.vala"
++ ease_slide_actor_set_background (self);
++#line 185 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) self->background);
++#line 187 "ease-slide-actor.vala"
++ self->contents = (_tmp0_ = g_object_ref_sink (ease_clutter_iterable_group_new ()), _g_object_unref0 (self->contents), _tmp0_);
++#line 649 "ease-slide-actor.c"
++ {
++ GeeIterator* _e_it;
++#line 189 "ease-slide-actor.vala"
++ _e_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) self->priv->_slide->elements);
++#line 189 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 656 "ease-slide-actor.c"
++ EaseElement* e;
++ EaseActor* _tmp1_;
++#line 189 "ease-slide-actor.vala"
++ if (!gee_iterator_next (_e_it)) {
++#line 189 "ease-slide-actor.vala"
++ break;
++#line 663 "ease-slide-actor.c"
++ }
++#line 189 "ease-slide-actor.vala"
++ e = (EaseElement*) gee_iterator_get (_e_it);
++#line 191 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) self->contents, (ClutterActor*) (_tmp1_ = ease_element_actor (e, self->context)));
++#line 669 "ease-slide-actor.c"
++ _g_object_unref0 (_tmp1_);
++ _g_object_unref0 (e);
++ }
++ _g_object_unref0 (_e_it);
++ }
++#line 194 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) self->contents);
++#line 196 "ease-slide-actor.vala"
++ g_signal_connect_object (self->priv->_slide, "background-changed", (GCallback) __lambda28__ease_slide_background_changed, self, 0);
++#line 198 "ease-slide-actor.vala"
++ g_signal_connect_object (self->priv->_slide, "element-added", (GCallback) _ease_slide_actor_on_element_added_ease_slide_element_added, self, 0);
++#line 199 "ease-slide-actor.vala"
++ g_signal_connect_object (self->priv->_slide, "element-removed", (GCallback) _ease_slide_actor_on_element_removed_ease_slide_element_removed, self, 0);
++#line 683 "ease-slide-actor.c"
++ return self;
++}
++
++
++#line 169 "ease-slide-actor.vala"
++EaseSlideActor* ease_slide_actor_new_with_dimensions (float w, float h, EaseSlide* s, gboolean clip, EaseActorContext ctx) {
++#line 169 "ease-slide-actor.vala"
++ return ease_slide_actor_construct_with_dimensions (EASE_TYPE_SLIDE_ACTOR, w, h, s, clip, ctx);
++#line 692 "ease-slide-actor.c"
++}
++
++
++#line 210 "ease-slide-actor.vala"
++EaseSlideActor* ease_slide_actor_construct_blank (GType object_type, EaseDocument* document, ClutterColor* color) {
++#line 698 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ ClutterCairoTexture* _tmp0_;
++ EaseClutterIterableGroup* _tmp1_;
++#line 210 "ease-slide-actor.vala"
++ g_return_val_if_fail (document != NULL, NULL);
++#line 704 "ease-slide-actor.c"
++ self = g_object_newv (object_type, 0, NULL);
++#line 213 "ease-slide-actor.vala"
++ self->background = (_tmp0_ = g_object_ref_sink ((ClutterCairoTexture*) clutter_cairo_texture_new ((guint) ease_document_get_width (document), (guint) ease_document_get_height (document))), _g_object_unref0 (self->background), _tmp0_);
++#line 216 "ease-slide-actor.vala"
++ self->contents = (_tmp1_ = g_object_ref_sink (ease_clutter_iterable_group_new ()), _g_object_unref0 (self->contents), _tmp1_);
++#line 219 "ease-slide-actor.vala"
++ clutter_actor_set_width ((ClutterActor*) self->background, self->priv->width_px);
++#line 220 "ease-slide-actor.vala"
++ clutter_actor_set_height ((ClutterActor*) self->background, self->priv->height_px);
++#line 714 "ease-slide-actor.c"
++ return self;
++}
++
++
++#line 210 "ease-slide-actor.vala"
++EaseSlideActor* ease_slide_actor_new_blank (EaseDocument* document, ClutterColor* color) {
++#line 210 "ease-slide-actor.vala"
++ return ease_slide_actor_construct_blank (EASE_TYPE_SLIDE_ACTOR, document, color);
++#line 723 "ease-slide-actor.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 226 "ease-slide-actor.vala"
++void ease_slide_actor_on_element_added (EaseSlideActor* self, EaseSlide* slide, EaseElement* element, gint index) {
++#line 734 "ease-slide-actor.c"
++ EaseActor* actor;
++ gint i;
++ ClutterActor* raise;
++ EaseActor* _tmp1_;
++#line 226 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 226 "ease-slide-actor.vala"
++ g_return_if_fail (slide != NULL);
++#line 226 "ease-slide-actor.vala"
++ g_return_if_fail (element != NULL);
++#line 228 "ease-slide-actor.vala"
++ actor = ease_element_actor (element, self->context);
++#line 229 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) self->contents, (ClutterActor*) actor);
++#line 230 "ease-slide-actor.vala"
++ clutter_container_lower_child ((ClutterContainer*) self->contents, (ClutterActor*) actor, NULL);
++#line 233 "ease-slide-actor.vala"
++ i = 0;
++#line 753 "ease-slide-actor.c"
++ raise = NULL;
++ {
++ EaseClutterIterableContainerIterator* _a_it;
++#line 235 "ease-slide-actor.vala"
++ _a_it = ease_clutter_iterable_container_iterator ((EaseClutterIterableContainer*) self->contents);
++#line 235 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 761 "ease-slide-actor.c"
++ ClutterActor* a;
++ ClutterActor* _tmp0_;
++#line 235 "ease-slide-actor.vala"
++ if (!ease_clutter_iterable_container_iterator_next (_a_it)) {
++#line 235 "ease-slide-actor.vala"
++ break;
++#line 768 "ease-slide-actor.c"
++ }
++#line 235 "ease-slide-actor.vala"
++ a = ease_clutter_iterable_container_iterator_get (_a_it);
++#line 237 "ease-slide-actor.vala"
++ if (i >= index) {
++#line 774 "ease-slide-actor.c"
++ _g_object_unref0 (a);
++#line 237 "ease-slide-actor.vala"
++ break;
++#line 778 "ease-slide-actor.c"
++ }
++#line 238 "ease-slide-actor.vala"
++ raise = (_tmp0_ = _g_object_ref0 (a), _g_object_unref0 (raise), _tmp0_);
++#line 782 "ease-slide-actor.c"
++ _g_object_unref0 (a);
++ }
++ _ease_clutter_iterable_container_iterator_unref0 (_a_it);
++ }
++#line 241 "ease-slide-actor.vala"
++ g_signal_emit_by_name (self, "ease-actor-added", (_tmp1_ = actor, EASE_IS_ACTOR (_tmp1_) ? ((EaseActor*) _tmp1_) : NULL));
++#line 789 "ease-slide-actor.c"
++ _g_object_unref0 (raise);
++ _g_object_unref0 (actor);
++}
++
++
++#line 247 "ease-slide-actor.vala"
++void ease_slide_actor_on_element_removed (EaseSlideActor* self, EaseSlide* slide, EaseElement* element, gint index) {
++#line 247 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 247 "ease-slide-actor.vala"
++ g_return_if_fail (slide != NULL);
++#line 247 "ease-slide-actor.vala"
++ g_return_if_fail (element != NULL);
++#line 803 "ease-slide-actor.c"
++ {
++ EaseClutterIterableContainerIterator* _a_it;
++#line 249 "ease-slide-actor.vala"
++ _a_it = ease_clutter_iterable_container_iterator ((EaseClutterIterableContainer*) self->contents);
++#line 249 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 810 "ease-slide-actor.c"
++ ClutterActor* a;
++ ClutterActor* _tmp0_;
++#line 249 "ease-slide-actor.vala"
++ if (!ease_clutter_iterable_container_iterator_next (_a_it)) {
++#line 249 "ease-slide-actor.vala"
++ break;
++#line 817 "ease-slide-actor.c"
++ }
++#line 249 "ease-slide-actor.vala"
++ a = ease_clutter_iterable_container_iterator_get (_a_it);
++#line 251 "ease-slide-actor.vala"
++ if ((_tmp0_ = a, EASE_IS_ACTOR (_tmp0_) ? ((EaseActor*) _tmp0_) : NULL)->element == element) {
++#line 823 "ease-slide-actor.c"
++ ClutterActor* _tmp1_;
++#line 253 "ease-slide-actor.vala"
++ clutter_container_remove_actor ((ClutterContainer*) self->contents, a);
++#line 254 "ease-slide-actor.vala"
++ g_signal_emit_by_name (self, "ease-actor-removed", (_tmp1_ = a, EASE_IS_ACTOR (_tmp1_) ? ((EaseActor*) _tmp1_) : NULL));
++#line 829 "ease-slide-actor.c"
++ _g_object_unref0 (a);
++#line 255 "ease-slide-actor.vala"
++ break;
++#line 833 "ease-slide-actor.c"
++ }
++ _g_object_unref0 (a);
++ }
++ _ease_clutter_iterable_container_iterator_unref0 (_a_it);
++ }
++}
++
++
++#line 263 "ease-slide-actor.vala"
++void ease_slide_actor_reset (EaseSlideActor* self, ClutterGroup* container) {
++#line 263 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 263 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 265 "ease-slide-actor.vala"
++ ease_slide_actor_reset_actor (self, (ClutterActor*) self);
++#line 266 "ease-slide-actor.vala"
++ ease_slide_actor_reset_actor (self, (ClutterActor*) self->background);
++#line 267 "ease-slide-actor.vala"
++ ease_slide_actor_reset_actor (self, (ClutterActor*) self->contents);
++#line 268 "ease-slide-actor.vala"
++ ease_slide_actor_stack (self, (ClutterActor*) container);
++#line 856 "ease-slide-actor.c"
++}
++
++
++#line 276 "ease-slide-actor.vala"
++static void ease_slide_actor_reset_actor (EaseSlideActor* self, ClutterActor* actor) {
++#line 276 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 276 "ease-slide-actor.vala"
++ g_return_if_fail (actor != NULL);
++#line 278 "ease-slide-actor.vala"
++ clutter_actor_set_depth (actor, (float) 0);
++#line 279 "ease-slide-actor.vala"
++ clutter_actor_set_opacity (actor, (guint) 255);
++#line 280 "ease-slide-actor.vala"
++ g_object_set (actor, "rotation-angle-x", (double) 0, NULL);
++#line 281 "ease-slide-actor.vala"
++ g_object_set (actor, "rotation-angle-y", (double) 0, NULL);
++#line 282 "ease-slide-actor.vala"
++ g_object_set (actor, "rotation-angle-z", (double) 0, NULL);
++#line 283 "ease-slide-actor.vala"
++ g_object_set (actor, "scale-x", (double) 1, NULL);
++#line 284 "ease-slide-actor.vala"
++ g_object_set (actor, "scale-y", (double) 1, NULL);
++#line 285 "ease-slide-actor.vala"
++ clutter_actor_set_x (actor, (float) 0);
++#line 286 "ease-slide-actor.vala"
++ clutter_actor_set_y (actor, (float) 0);
++#line 884 "ease-slide-actor.c"
++}
++
++
++#line 293 "ease-slide-actor.vala"
++void ease_slide_actor_relayout (EaseSlideActor* self) {
++#line 293 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 295 "ease-slide-actor.vala"
++ ease_slide_actor_set_background (self);
++#line 894 "ease-slide-actor.c"
++ {
++ GList* itr;
++#line 297 "ease-slide-actor.vala"
++ itr = clutter_container_get_children ((ClutterContainer*) self->contents);
++#line 899 "ease-slide-actor.c"
++ {
++ gboolean _tmp0_;
++#line 297 "ease-slide-actor.vala"
++ _tmp0_ = TRUE;
++#line 297 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 297 "ease-slide-actor.vala"
++ if (!_tmp0_) {
++#line 299 "ease-slide-actor.vala"
++ itr = itr->next;
++#line 910 "ease-slide-actor.c"
++ }
++#line 297 "ease-slide-actor.vala"
++ _tmp0_ = FALSE;
++#line 298 "ease-slide-actor.vala"
++ if (!(itr != NULL)) {
++#line 298 "ease-slide-actor.vala"
++ break;
++#line 918 "ease-slide-actor.c"
++ }
++#line 301 "ease-slide-actor.vala"
++ ease_actor_reposition (EASE_ACTOR ((ClutterActor*) itr->data));
++#line 922 "ease-slide-actor.c"
++ }
++ }
++ }
++}
++
++
++#line 308 "ease-slide-actor.vala"
++static void ease_slide_actor_set_background (EaseSlideActor* self) {
++#line 931 "ease-slide-actor.c"
++ GError * _inner_error_;
++#line 308 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 935 "ease-slide-actor.c"
++ _inner_error_ = NULL;
++#line 310 "ease-slide-actor.vala"
++ if (self->background == NULL) {
++#line 939 "ease-slide-actor.c"
++ ClutterCairoTexture* _tmp0_;
++#line 312 "ease-slide-actor.vala"
++ self->background = (_tmp0_ = g_object_ref_sink ((ClutterCairoTexture*) clutter_cairo_texture_new ((guint) self->priv->width_px, (guint) self->priv->height_px)), _g_object_unref0 (self->background), _tmp0_);
++#line 943 "ease-slide-actor.c"
++ }
++ {
++ cairo_t* cr;
++#line 319 "ease-slide-actor.vala"
++ cr = clutter_cairo_texture_create (self->background);
++#line 320 "ease-slide-actor.vala"
++ ease_slide_cairo_render_background (self->priv->_slide, cr, (gint) self->priv->width_px, (gint) self->priv->height_px, &_inner_error_);
++#line 951 "ease-slide-actor.c"
++ if (_inner_error_ != NULL) {
++ _cairo_destroy0 (cr);
++ goto __catch16_g_error;
++ }
++ _cairo_destroy0 (cr);
++ }
++ goto __finally16;
++ __catch16_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 324 "ease-slide-actor.vala"
++ g_critical ("ease-slide-actor.vala:324: Error rendering slide actor background: %s", e->message);
++#line 967 "ease-slide-actor.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally16:
++ if (_inner_error_ != NULL) {
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++#line 327 "ease-slide-actor.vala"
++ clutter_actor_set_width ((ClutterActor*) self->background, self->priv->width_px);
++#line 328 "ease-slide-actor.vala"
++ clutter_actor_set_height ((ClutterActor*) self->background, self->priv->height_px);
++#line 981 "ease-slide-actor.c"
++}
++
++
++#line 348 "ease-slide-actor.vala"
++void ease_slide_actor_stack (EaseSlideActor* self, ClutterActor* container) {
++#line 348 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 348 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 350 "ease-slide-actor.vala"
++ if (clutter_actor_get_parent ((ClutterActor*) self->background) != CLUTTER_ACTOR (self)) {
++#line 352 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) self->background, (ClutterActor*) self);
++#line 995 "ease-slide-actor.c"
++ }
++#line 354 "ease-slide-actor.vala"
++ if (clutter_actor_get_parent ((ClutterActor*) self->contents) != CLUTTER_ACTOR (self)) {
++#line 356 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) self->contents, (ClutterActor*) self);
++#line 1001 "ease-slide-actor.c"
++ }
++#line 358 "ease-slide-actor.vala"
++ if (clutter_actor_get_parent ((ClutterActor*) self) != container) {
++#line 360 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) self, container);
++#line 1007 "ease-slide-actor.c"
++ }
++}
++
++
++#line 382 "ease-slide-actor.vala"
++void ease_slide_actor_unstack (EaseSlideActor* self, EaseSlideActor* other, ClutterActor* container) {
++#line 382 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 382 "ease-slide-actor.vala"
++ g_return_if_fail (other != NULL);
++#line 382 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 384 "ease-slide-actor.vala"
++ if (clutter_actor_get_parent ((ClutterActor*) other->background) != container) {
++#line 386 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) other->background, container);
++#line 1024 "ease-slide-actor.c"
++ }
++#line 388 "ease-slide-actor.vala"
++ if (clutter_actor_get_parent ((ClutterActor*) self->background) != container) {
++#line 390 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) self->background, container);
++#line 1030 "ease-slide-actor.c"
++ }
++#line 392 "ease-slide-actor.vala"
++ if (clutter_actor_get_parent ((ClutterActor*) self->contents) != container) {
++#line 394 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) self->contents, container);
++#line 1036 "ease-slide-actor.c"
++ }
++#line 396 "ease-slide-actor.vala"
++ if (clutter_actor_get_parent ((ClutterActor*) other->contents) != container) {
++#line 398 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) other->contents, container);
++#line 1042 "ease-slide-actor.c"
++ }
++}
++
++
++#line 412 "ease-slide-actor.vala"
++static void ease_slide_actor_prepare_slide_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container) {
++#line 412 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 412 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 412 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 415 "ease-slide-actor.vala"
++ ease_slide_actor_stack (new_slide, (ClutterActor*) container);
++#line 416 "ease-slide-actor.vala"
++ ease_slide_actor_stack (self, (ClutterActor*) container);
++#line 1059 "ease-slide-actor.c"
++}
++
++
++#line 425 "ease-slide-actor.vala"
++static void ease_slide_actor_prepare_stack_transition (EaseSlideActor* self, gboolean current_on_top, EaseSlideActor* new_slide, ClutterGroup* container) {
++#line 425 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 425 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 425 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 429 "ease-slide-actor.vala"
++ ease_slide_actor_unstack (self, new_slide, (ClutterActor*) container);
++#line 1073 "ease-slide-actor.c"
++}
++
++
++#line 441 "ease-slide-actor.vala"
++void ease_slide_actor_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container) {
++#line 1079 "ease-slide-actor.c"
++ guint length;
++ ClutterTimeline* _tmp0_;
++#line 441 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 441 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 441 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 444 "ease-slide-actor.vala"
++ length = (guint) ease_dmax ((double) 1, ease_slide_get_transition_time (self->priv->_slide) * 1000);
++#line 446 "ease-slide-actor.vala"
++ ease_slide_actor_set_animation_time (self, _tmp0_ = clutter_timeline_new (length));
++#line 1092 "ease-slide-actor.c"
++ _g_object_unref0 (_tmp0_);
++#line 448 "ease-slide-actor.vala"
++ switch (ease_slide_get_transition (self->priv->_slide)) {
++#line 1096 "ease-slide-actor.c"
++ case EASE_TRANSITION_SLIDE:
++ {
++#line 451 "ease-slide-actor.vala"
++ ease_slide_actor_slide_transition (self, new_slide, container, length);
++#line 452 "ease-slide-actor.vala"
++ break;
++#line 1103 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_DROP:
++ {
++#line 455 "ease-slide-actor.vala"
++ ease_slide_actor_drop_transition (self, new_slide, container, length);
++#line 456 "ease-slide-actor.vala"
++ break;
++#line 1111 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_PIVOT:
++ {
++#line 459 "ease-slide-actor.vala"
++ ease_slide_actor_pivot_transition (self, new_slide, container, length);
++#line 460 "ease-slide-actor.vala"
++ break;
++#line 1119 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_OPEN_DOOR:
++ {
++#line 463 "ease-slide-actor.vala"
++ ease_slide_actor_open_door_transition (self, new_slide, container, length);
++#line 464 "ease-slide-actor.vala"
++ break;
++#line 1127 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_REVEAL:
++ {
++#line 467 "ease-slide-actor.vala"
++ ease_slide_actor_reveal_transition (self, new_slide, container, length);
++#line 468 "ease-slide-actor.vala"
++ break;
++#line 1135 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_SLATS:
++ {
++#line 471 "ease-slide-actor.vala"
++ ease_slide_actor_slats_transition (self, new_slide, container, length);
++#line 472 "ease-slide-actor.vala"
++ break;
++#line 1143 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_FLIP:
++ {
++#line 475 "ease-slide-actor.vala"
++ ease_slide_actor_flip_transition (self, new_slide, container, length);
++#line 476 "ease-slide-actor.vala"
++ break;
++#line 1151 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_REVOLVING_DOOR:
++ {
++#line 479 "ease-slide-actor.vala"
++ ease_slide_actor_revolving_door_transition (self, new_slide, container, length);
++#line 480 "ease-slide-actor.vala"
++ break;
++#line 1159 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_FALL:
++ {
++#line 483 "ease-slide-actor.vala"
++ ease_slide_actor_fall_transition (self, new_slide, container, length);
++#line 484 "ease-slide-actor.vala"
++ break;
++#line 1167 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_SPIN_CONTENTS:
++ {
++#line 487 "ease-slide-actor.vala"
++ ease_slide_actor_spin_contents_transition (self, new_slide, container, length);
++#line 488 "ease-slide-actor.vala"
++ break;
++#line 1175 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_SWING_CONTENTS:
++ {
++#line 491 "ease-slide-actor.vala"
++ ease_slide_actor_swing_contents_transition (self, new_slide, container, length);
++#line 492 "ease-slide-actor.vala"
++ break;
++#line 1183 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_ZOOM:
++ {
++#line 495 "ease-slide-actor.vala"
++ ease_slide_actor_zoom_transition (self, new_slide, container, length);
++#line 496 "ease-slide-actor.vala"
++ break;
++#line 1191 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_SLIDE_CONTENTS:
++ {
++#line 499 "ease-slide-actor.vala"
++ ease_slide_actor_slide_contents_transition (self, new_slide, container, length);
++#line 500 "ease-slide-actor.vala"
++ break;
++#line 1199 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_SPRING_CONTENTS:
++ {
++#line 503 "ease-slide-actor.vala"
++ ease_slide_actor_spring_contents_transition (self, new_slide, container, length);
++#line 504 "ease-slide-actor.vala"
++ break;
++#line 1207 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_ZOOM_CONTENTS:
++ {
++#line 507 "ease-slide-actor.vala"
++ ease_slide_actor_zoom_contents_transition (self, new_slide, container, length);
++#line 508 "ease-slide-actor.vala"
++ break;
++#line 1215 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_PANEL:
++ {
++#line 511 "ease-slide-actor.vala"
++ ease_slide_actor_panel_transition (self, new_slide, container, length);
++#line 512 "ease-slide-actor.vala"
++ break;
++#line 1223 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_EXPLODE:
++ {
++#line 515 "ease-slide-actor.vala"
++ ease_slide_actor_explode_transition (self, new_slide, container, length);
++#line 516 "ease-slide-actor.vala"
++ break;
++#line 1231 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_ASSEMBLE:
++ {
++#line 519 "ease-slide-actor.vala"
++ ease_slide_actor_assemble_transition (self, new_slide, container, length);
++#line 520 "ease-slide-actor.vala"
++ break;
++#line 1239 "ease-slide-actor.c"
++ }
++ default:
++ {
++#line 523 "ease-slide-actor.vala"
++ ease_slide_actor_fade_transition (self, new_slide, container, length);
++#line 524 "ease-slide-actor.vala"
++ break;
++#line 1247 "ease-slide-actor.c"
++ }
++ }
++#line 527 "ease-slide-actor.vala"
++ clutter_timeline_start (self->priv->_animation_time);
++#line 1252 "ease-slide-actor.c"
++}
++
++
++#line 537 "ease-slide-actor.vala"
++static void ease_slide_actor_fade_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 537 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 537 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 537 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 540 "ease-slide-actor.vala"
++ ease_slide_actor_prepare_slide_transition (self, new_slide, container);
++#line 541 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) new_slide, (guint) 0);
++#line 542 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide, (gulong) CLUTTER_LINEAR, length, "opacity", 255, NULL);
++#line 1270 "ease-slide-actor.c"
++}
++
++
++#line 553 "ease-slide-actor.vala"
++static void ease_slide_actor_slide_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 553 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 553 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 553 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 556 "ease-slide-actor.vala"
++ switch (ease_slide_get_variant (self->priv->_slide)) {
++#line 1284 "ease-slide-actor.c"
++ case EASE_TRANSITION_VARIANT_UP:
++ {
++#line 559 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) new_slide, (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide)));
++#line 560 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "y", 0, NULL);
++#line 561 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "y", -clutter_actor_get_y ((ClutterActor*) new_slide), NULL);
++#line 562 "ease-slide-actor.vala"
++ break;
++#line 1295 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_DOWN:
++ {
++#line 565 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) new_slide, (float) (-ease_document_get_height (ease_slide_get_parent (self->priv->_slide))));
++#line 566 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "y", 0, NULL);
++#line 567 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "y", -clutter_actor_get_y ((ClutterActor*) new_slide), NULL);
++#line 568 "ease-slide-actor.vala"
++ break;
++#line 1307 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_LEFT:
++ {
++#line 571 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) new_slide, (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide)));
++#line 572 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "x", 0, NULL);
++#line 573 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "x", -clutter_actor_get_x ((ClutterActor*) new_slide), NULL);
++#line 574 "ease-slide-actor.vala"
++ break;
++#line 1319 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_RIGHT:
++ {
++#line 577 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) new_slide, (float) (-ease_document_get_width (ease_slide_get_parent (self->priv->_slide))));
++#line 578 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "x", 0, NULL);
++#line 579 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "x", -clutter_actor_get_x ((ClutterActor*) new_slide), NULL);
++#line 580 "ease-slide-actor.vala"
++ break;
++#line 1331 "ease-slide-actor.c"
++ }
++ }
++}
++
++
++#line 591 "ease-slide-actor.vala"
++static void ease_slide_actor_drop_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 591 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 591 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 591 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 594 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) new_slide, (float) (-ease_document_get_height (ease_slide_get_parent (self->priv->_slide))));
++#line 595 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide, (gulong) EASE_SLIDE_ACTOR_EASE_DROP, length, "y", 0, NULL);
++#line 1349 "ease-slide-actor.c"
++}
++
++
++#line 632 "ease-slide-actor.vala"
++static void _lambda29_ (gint m, Block7Data* _data7_) {
++#line 1355 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data7_->self;
++#line 633 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) _data7_->new_slide, CLUTTER_Z_AXIS, _data7_->angle * (1 - clutter_alpha_get_alpha (self->priv->_animation_alpha)), _data7_->xpos, _data7_->ypos, (float) 0);
++#line 1360 "ease-slide-actor.c"
++}
++
++
++#line 632 "ease-slide-actor.vala"
++static void __lambda29__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 1366 "ease-slide-actor.c"
++ _lambda29_ (frame_num, self);
++}
++
++
++static Block7Data* block7_data_ref (Block7Data* _data7_) {
++ g_atomic_int_inc (&_data7_->_ref_count_);
++ return _data7_;
++}
++
++
++static void block7_data_unref (Block7Data* _data7_) {
++ if (g_atomic_int_dec_and_test (&_data7_->_ref_count_)) {
++ _g_object_unref0 (_data7_->self);
++ _g_object_unref0 (_data7_->new_slide);
++ g_slice_free (Block7Data, _data7_);
++ }
++}
++
++
++#line 605 "ease-slide-actor.vala"
++static void ease_slide_actor_pivot_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 1388 "ease-slide-actor.c"
++ Block7Data* _data7_;
++ ClutterAlpha* _tmp0_;
++#line 605 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 605 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 605 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 1397 "ease-slide-actor.c"
++ _data7_ = g_slice_new0 (Block7Data);
++ _data7_->_ref_count_ = 1;
++ _data7_->self = g_object_ref (self);
++ _data7_->new_slide = _g_object_ref0 (new_slide);
++ _data7_->xpos = (float) 0;
++ _data7_->ypos = (float) 0;
++ _data7_->angle = (float) 90;
++#line 609 "ease-slide-actor.vala"
++ switch (ease_slide_get_variant (self->priv->_slide)) {
++#line 1407 "ease-slide-actor.c"
++ case EASE_TRANSITION_VARIANT_TOP_RIGHT:
++ {
++#line 612 "ease-slide-actor.vala"
++ _data7_->xpos = (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide));
++#line 613 "ease-slide-actor.vala"
++ _data7_->angle = (float) (-90);
++#line 614 "ease-slide-actor.vala"
++ break;
++#line 1416 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_BOTTOM_LEFT:
++ {
++#line 616 "ease-slide-actor.vala"
++ _data7_->ypos = (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide));
++#line 617 "ease-slide-actor.vala"
++ _data7_->angle = (float) (-90);
++#line 618 "ease-slide-actor.vala"
++ break;
++#line 1426 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_BOTTOM_RIGHT:
++ {
++#line 620 "ease-slide-actor.vala"
++ _data7_->xpos = (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide));
++#line 621 "ease-slide-actor.vala"
++ _data7_->ypos = (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide));
++#line 622 "ease-slide-actor.vala"
++ break;
++#line 1436 "ease-slide-actor.c"
++ }
++ }
++#line 626 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) _data7_->new_slide, CLUTTER_Z_AXIS, (double) _data7_->angle, _data7_->xpos, _data7_->ypos, (float) 0);
++#line 628 "ease-slide-actor.vala"
++ ease_slide_actor_set_animation_alpha (self, _tmp0_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->_animation_time, (gulong) EASE_SLIDE_ACTOR_EASE_PIVOT)));
++#line 1443 "ease-slide-actor.c"
++ _g_object_unref0 (_tmp0_);
++#line 632 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->_animation_time, "new-frame", (GCallback) __lambda29__clutter_timeline_new_frame, block7_data_ref (_data7_), (GClosureNotify) block7_data_unref, 0);
++#line 1447 "ease-slide-actor.c"
++ block7_data_unref (_data7_);
++}
++
++
++#line 696 "ease-slide-actor.vala"
++static void _lambda34_ (gint m, Block8Data* _data8_) {
++#line 1454 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data8_->self;
++#line 698 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) self, _data8_->axis, (_data8_->positive * 90) * clutter_alpha_get_alpha (self->priv->alpha1), _data8_->x_point, _data8_->y_point, (float) 0);
++#line 702 "ease-slide-actor.vala"
++ clutter_actor_set_depth ((ClutterActor*) self, (float) (EASE_SLIDE_ACTOR_FLIP_DEPTH * clutter_alpha_get_alpha (self->priv->alpha1)));
++#line 1461 "ease-slide-actor.c"
++}
++
++
++#line 696 "ease-slide-actor.vala"
++static void __lambda34__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 1467 "ease-slide-actor.c"
++ _lambda34_ (frame_num, self);
++}
++
++
++#line 706 "ease-slide-actor.vala"
++static void _lambda35_ (gint m, Block8Data* _data8_) {
++#line 1474 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data8_->self;
++#line 708 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) _data8_->new_slide, _data8_->axis, (_data8_->positive * (-90)) * (1 - clutter_alpha_get_alpha (self->priv->alpha2)), _data8_->x_point, _data8_->y_point, (float) 0);
++#line 712 "ease-slide-actor.vala"
++ clutter_actor_set_depth ((ClutterActor*) _data8_->new_slide, EASE_SLIDE_ACTOR_FLIP_DEPTH * ((float) (1 - clutter_alpha_get_alpha (self->priv->alpha2))));
++#line 715 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) _data8_->new_slide, (guint) 255);
++#line 1483 "ease-slide-actor.c"
++}
++
++
++#line 706 "ease-slide-actor.vala"
++static void __lambda35__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 1489 "ease-slide-actor.c"
++ _lambda35_ (frame_num, self);
++}
++
++
++#line 718 "ease-slide-actor.vala"
++static void _lambda36_ (Block8Data* _data8_) {
++#line 1496 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data8_->self;
++#line 720 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) self, (guint) 0);
++#line 723 "ease-slide-actor.vala"
++ clutter_actor_set_depth ((ClutterActor*) _data8_->new_slide, EASE_SLIDE_ACTOR_FLIP_DEPTH);
++#line 726 "ease-slide-actor.vala"
++ clutter_timeline_start (self->priv->time2);
++#line 1505 "ease-slide-actor.c"
++}
++
++
++#line 718 "ease-slide-actor.vala"
++static void __lambda36__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 1511 "ease-slide-actor.c"
++ _lambda36_ (self);
++}
++
++
++static Block8Data* block8_data_ref (Block8Data* _data8_) {
++ g_atomic_int_inc (&_data8_->_ref_count_);
++ return _data8_;
++}
++
++
++static void block8_data_unref (Block8Data* _data8_) {
++ if (g_atomic_int_dec_and_test (&_data8_->_ref_count_)) {
++ _g_object_unref0 (_data8_->self);
++ _g_object_unref0 (_data8_->new_slide);
++ g_slice_free (Block8Data, _data8_);
++ }
++}
++
++
++#line 646 "ease-slide-actor.vala"
++static void ease_slide_actor_flip_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 1533 "ease-slide-actor.c"
++ Block8Data* _data8_;
++ ClutterTimeline* _tmp0_;
++ ClutterTimeline* _tmp1_;
++ ClutterAlpha* _tmp2_;
++ ClutterAlpha* _tmp3_;
++#line 646 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 646 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 646 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 1545 "ease-slide-actor.c"
++ _data8_ = g_slice_new0 (Block8Data);
++ _data8_->_ref_count_ = 1;
++ _data8_->self = g_object_ref (self);
++ _data8_->new_slide = _g_object_ref0 (new_slide);
++#line 650 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) _data8_->new_slide, (guint) 0);
++#line 653 "ease-slide-actor.vala"
++ self->priv->time1 = (_tmp0_ = clutter_timeline_new (length / 2), _g_object_unref0 (self->priv->time1), _tmp0_);
++#line 654 "ease-slide-actor.vala"
++ self->priv->time2 = (_tmp1_ = clutter_timeline_new (length / 2), _g_object_unref0 (self->priv->time2), _tmp1_);
++#line 655 "ease-slide-actor.vala"
++ self->priv->alpha1 = (_tmp2_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->time1, (gulong) CLUTTER_EASE_IN_SINE)), _g_object_unref0 (self->priv->alpha1), _tmp2_);
++#line 657 "ease-slide-actor.vala"
++ self->priv->alpha2 = (_tmp3_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->time2, (gulong) CLUTTER_EASE_OUT_SINE)), _g_object_unref0 (self->priv->alpha2), _tmp3_);
++#line 1560 "ease-slide-actor.c"
++ _data8_->x_point = (float) 0;
++ _data8_->y_point = (float) 0;
++#line 669 "ease-slide-actor.vala"
++ switch (ease_slide_get_variant (self->priv->_slide)) {
++#line 1565 "ease-slide-actor.c"
++ case EASE_TRANSITION_VARIANT_BOTTOM_TO_TOP:
++ {
++#line 672 "ease-slide-actor.vala"
++ _data8_->axis = CLUTTER_X_AXIS;
++#line 673 "ease-slide-actor.vala"
++ _data8_->positive = (float) 1;
++#line 674 "ease-slide-actor.vala"
++ _data8_->y_point = (float) (ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) / 2);
++#line 675 "ease-slide-actor.vala"
++ break;
++#line 1576 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_TOP_TO_BOTTOM:
++ {
++#line 678 "ease-slide-actor.vala"
++ _data8_->axis = CLUTTER_X_AXIS;
++#line 679 "ease-slide-actor.vala"
++ _data8_->positive = (float) (-1);
++#line 680 "ease-slide-actor.vala"
++ break;
++#line 1586 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_LEFT_TO_RIGHT:
++ {
++#line 683 "ease-slide-actor.vala"
++ _data8_->axis = CLUTTER_Y_AXIS;
++#line 684 "ease-slide-actor.vala"
++ _data8_->positive = (float) 1;
++#line 685 "ease-slide-actor.vala"
++ _data8_->x_point = (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2);
++#line 686 "ease-slide-actor.vala"
++ break;
++#line 1598 "ease-slide-actor.c"
++ }
++ default:
++ {
++#line 689 "ease-slide-actor.vala"
++ _data8_->axis = CLUTTER_Y_AXIS;
++#line 690 "ease-slide-actor.vala"
++ _data8_->positive = (float) (-1);
++#line 691 "ease-slide-actor.vala"
++ _data8_->x_point = (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2);
++#line 692 "ease-slide-actor.vala"
++ break;
++#line 1610 "ease-slide-actor.c"
++ }
++ }
++#line 696 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->time1, "new-frame", (GCallback) __lambda34__clutter_timeline_new_frame, block8_data_ref (_data8_), (GClosureNotify) block8_data_unref, 0);
++#line 706 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->time2, "new-frame", (GCallback) __lambda35__clutter_timeline_new_frame, block8_data_ref (_data8_), (GClosureNotify) block8_data_unref, 0);
++#line 718 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->time1, "completed", (GCallback) __lambda36__clutter_timeline_completed, block8_data_ref (_data8_), (GClosureNotify) block8_data_unref, 0);
++#line 730 "ease-slide-actor.vala"
++ clutter_timeline_start (self->priv->time1);
++#line 1621 "ease-slide-actor.c"
++ block8_data_unref (_data8_);
++}
++
++
++#line 786 "ease-slide-actor.vala"
++static void _lambda37_ (gint m, Block9Data* _data9_) {
++#line 1628 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data9_->self;
++#line 788 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) _data9_->new_slide, _data9_->axis, (_data9_->positive * 90) * (1 - clutter_alpha_get_alpha (self->priv->_animation_alpha)), _data9_->x_point, _data9_->y_point, (float) 0);
++#line 793 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) self, _data9_->axis, (_data9_->positive * (-110)) * clutter_alpha_get_alpha (self->priv->_animation_alpha), _data9_->x_point, _data9_->y_point, (float) 0);
++#line 1635 "ease-slide-actor.c"
++}
++
++
++#line 786 "ease-slide-actor.vala"
++static void __lambda37__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 1641 "ease-slide-actor.c"
++ _lambda37_ (frame_num, self);
++}
++
++
++static Block9Data* block9_data_ref (Block9Data* _data9_) {
++ g_atomic_int_inc (&_data9_->_ref_count_);
++ return _data9_;
++}
++
++
++static void block9_data_unref (Block9Data* _data9_) {
++ if (g_atomic_int_dec_and_test (&_data9_->_ref_count_)) {
++ _g_object_unref0 (_data9_->self);
++ _g_object_unref0 (_data9_->new_slide);
++ g_slice_free (Block9Data, _data9_);
++ }
++}
++
++
++#line 740 "ease-slide-actor.vala"
++static void ease_slide_actor_revolving_door_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 1663 "ease-slide-actor.c"
++ Block9Data* _data9_;
++ ClutterAlpha* _tmp0_;
++#line 740 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 740 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 740 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 1672 "ease-slide-actor.c"
++ _data9_ = g_slice_new0 (Block9Data);
++ _data9_->_ref_count_ = 1;
++ _data9_->self = g_object_ref (self);
++ _data9_->new_slide = _g_object_ref0 (new_slide);
++#line 745 "ease-slide-actor.vala"
++ clutter_actor_set_depth ((ClutterActor*) self, (float) 1);
++#line 747 "ease-slide-actor.vala"
++ ease_slide_actor_set_animation_alpha (self, _tmp0_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->_animation_time, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE)));
++#line 1681 "ease-slide-actor.c"
++ _g_object_unref0 (_tmp0_);
++ _data9_->x_point = (float) 0;
++ _data9_->y_point = (float) 0;
++#line 758 "ease-slide-actor.vala"
++ switch (ease_slide_get_variant (self->priv->_slide)) {
++#line 1687 "ease-slide-actor.c"
++ case EASE_TRANSITION_VARIANT_LEFT:
++ {
++#line 761 "ease-slide-actor.vala"
++ _data9_->axis = CLUTTER_Y_AXIS;
++#line 762 "ease-slide-actor.vala"
++ _data9_->positive = (float) 1;
++#line 763 "ease-slide-actor.vala"
++ break;
++#line 1696 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_RIGHT:
++ {
++#line 766 "ease-slide-actor.vala"
++ _data9_->axis = CLUTTER_Y_AXIS;
++#line 767 "ease-slide-actor.vala"
++ _data9_->positive = (float) (-1);
++#line 768 "ease-slide-actor.vala"
++ _data9_->x_point = (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide));
++#line 769 "ease-slide-actor.vala"
++ break;
++#line 1708 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_TOP:
++ {
++#line 772 "ease-slide-actor.vala"
++ _data9_->axis = CLUTTER_X_AXIS;
++#line 773 "ease-slide-actor.vala"
++ _data9_->positive = (float) (-1);
++#line 774 "ease-slide-actor.vala"
++ break;
++#line 1718 "ease-slide-actor.c"
++ }
++ default:
++ {
++#line 777 "ease-slide-actor.vala"
++ _data9_->axis = CLUTTER_X_AXIS;
++#line 778 "ease-slide-actor.vala"
++ _data9_->positive = (float) 1;
++#line 779 "ease-slide-actor.vala"
++ _data9_->y_point = (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide));
++#line 780 "ease-slide-actor.vala"
++ break;
++#line 1730 "ease-slide-actor.c"
++ }
++ }
++#line 784 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) _data9_->new_slide, _data9_->axis, (double) (90 * _data9_->positive), _data9_->x_point, _data9_->y_point, (float) 0);
++#line 786 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->_animation_time, "new-frame", (GCallback) __lambda37__clutter_timeline_new_frame, block9_data_ref (_data9_), (GClosureNotify) block9_data_unref, 0);
++#line 1737 "ease-slide-actor.c"
++ block9_data_unref (_data9_);
++}
++
++
++#line 806 "ease-slide-actor.vala"
++static void ease_slide_actor_reveal_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 806 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 806 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 806 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 810 "ease-slide-actor.vala"
++ clutter_container_raise_child (CLUTTER_CONTAINER (clutter_actor_get_parent ((ClutterActor*) self)), (ClutterActor*) self, (ClutterActor*) new_slide);
++#line 812 "ease-slide-actor.vala"
++ switch (ease_slide_get_variant (self->priv->_slide)) {
++#line 1754 "ease-slide-actor.c"
++ case EASE_TRANSITION_VARIANT_TOP:
++ {
++#line 815 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) new_slide, (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide)));
++#line 816 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "y", -clutter_actor_get_y ((ClutterActor*) new_slide), NULL);
++#line 817 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) new_slide, (float) 0);
++#line 818 "ease-slide-actor.vala"
++ break;
++#line 1765 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_BOTTOM:
++ {
++#line 820 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) new_slide, (float) (-ease_document_get_height (ease_slide_get_parent (self->priv->_slide))));
++#line 821 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "y", -clutter_actor_get_y ((ClutterActor*) new_slide), NULL);
++#line 822 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) new_slide, (float) 0);
++#line 823 "ease-slide-actor.vala"
++ break;
++#line 1777 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_LEFT:
++ {
++#line 825 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) new_slide, (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide)));
++#line 826 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "x", -clutter_actor_get_x ((ClutterActor*) new_slide), NULL);
++#line 827 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) new_slide, (float) 0);
++#line 828 "ease-slide-actor.vala"
++ break;
++#line 1789 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_RIGHT:
++ {
++#line 830 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) new_slide, (float) (-ease_document_get_width (ease_slide_get_parent (self->priv->_slide))));
++#line 831 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "x", -clutter_actor_get_x ((ClutterActor*) new_slide), NULL);
++#line 832 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) new_slide, (float) 0);
++#line 833 "ease-slide-actor.vala"
++ break;
++#line 1801 "ease-slide-actor.c"
++ }
++ }
++}
++
++
++#line 851 "ease-slide-actor.vala"
++static void _lambda38_ (gint m, EaseSlideActor* self) {
++#line 852 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) self, CLUTTER_X_AXIS, (-90) * clutter_alpha_get_alpha (self->priv->_animation_alpha), (float) 0, (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide)), (float) 0);
++#line 1811 "ease-slide-actor.c"
++}
++
++
++#line 851 "ease-slide-actor.vala"
++static void __lambda38__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 1817 "ease-slide-actor.c"
++ _lambda38_ (frame_num, self);
++}
++
++
++#line 844 "ease-slide-actor.vala"
++static void ease_slide_actor_fall_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 1824 "ease-slide-actor.c"
++ ClutterAlpha* _tmp0_;
++#line 844 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 844 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 844 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 847 "ease-slide-actor.vala"
++ clutter_actor_set_depth ((ClutterActor*) self, (float) 1);
++#line 849 "ease-slide-actor.vala"
++ ease_slide_actor_set_animation_alpha (self, _tmp0_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->_animation_time, (gulong) CLUTTER_EASE_IN_QUART)));
++#line 1836 "ease-slide-actor.c"
++ _g_object_unref0 (_tmp0_);
++#line 851 "ease-slide-actor.vala"
++ g_signal_connect_object (self->priv->_animation_time, "new-frame", (GCallback) __lambda38__clutter_timeline_new_frame, self, 0);
++#line 1840 "ease-slide-actor.c"
++}
++
++
++#line 917 "ease-slide-actor.vala"
++static void _lambda32_ (gint m, Block10Data* _data10_) {
++#line 1846 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data10_->self;
++ {
++ gint i;
++#line 918 "ease-slide-actor.vala"
++ i = 0;
++#line 1853 "ease-slide-actor.c"
++ {
++ gboolean _tmp0_;
++#line 918 "ease-slide-actor.vala"
++ _tmp0_ = TRUE;
++#line 918 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 918 "ease-slide-actor.vala"
++ if (!_tmp0_) {
++#line 918 "ease-slide-actor.vala"
++ i++;
++#line 1864 "ease-slide-actor.c"
++ }
++#line 918 "ease-slide-actor.vala"
++ _tmp0_ = FALSE;
++#line 918 "ease-slide-actor.vala"
++ if (!(i < EASE_SLIDE_ACTOR_SLAT_COUNT)) {
++#line 918 "ease-slide-actor.vala"
++ break;
++#line 1872 "ease-slide-actor.c"
++ }
++#line 920 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) _data10_->groups[i], CLUTTER_Y_AXIS, 180 * clutter_alpha_get_alpha (self->priv->_animation_alpha), (i + 0.5f) * _data10_->width, (float) 0, (float) 0);
++#line 1876 "ease-slide-actor.c"
++ }
++ }
++ }
++}
++
++
++#line 917 "ease-slide-actor.vala"
++static void __lambda32__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 1885 "ease-slide-actor.c"
++ _lambda32_ (frame_num, self);
++}
++
++
++#line 927 "ease-slide-actor.vala"
++static void _lambda33_ (Block10Data* _data10_) {
++#line 1892 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data10_->self;
++ {
++ gint i;
++#line 929 "ease-slide-actor.vala"
++ i = 0;
++#line 1899 "ease-slide-actor.c"
++ {
++ gboolean _tmp0_;
++#line 929 "ease-slide-actor.vala"
++ _tmp0_ = TRUE;
++#line 929 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 929 "ease-slide-actor.vala"
++ if (!_tmp0_) {
++#line 929 "ease-slide-actor.vala"
++ i++;
++#line 1910 "ease-slide-actor.c"
++ }
++#line 929 "ease-slide-actor.vala"
++ _tmp0_ = FALSE;
++#line 929 "ease-slide-actor.vala"
++ if (!(i < EASE_SLIDE_ACTOR_SLAT_COUNT)) {
++#line 929 "ease-slide-actor.vala"
++ break;
++#line 1918 "ease-slide-actor.c"
++ }
++#line 931 "ease-slide-actor.vala"
++ clutter_container_remove_actor ((ClutterContainer*) _data10_->container, (ClutterActor*) _data10_->groups[i]);
++#line 1922 "ease-slide-actor.c"
++ }
++ }
++ }
++#line 935 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) _data10_->new_slide, (float) 0);
++#line 938 "ease-slide-actor.vala"
++ cogl_set_depth_test_enabled (FALSE);
++#line 1930 "ease-slide-actor.c"
++}
++
++
++#line 927 "ease-slide-actor.vala"
++static void __lambda33__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 1936 "ease-slide-actor.c"
++ _lambda33_ (self);
++}
++
++
++static Block10Data* block10_data_ref (Block10Data* _data10_) {
++ g_atomic_int_inc (&_data10_->_ref_count_);
++ return _data10_;
++}
++
++
++static void block10_data_unref (Block10Data* _data10_) {
++ if (g_atomic_int_dec_and_test (&_data10_->_ref_count_)) {
++ _g_object_unref0 (_data10_->self);
++ _data10_->groups = (_vala_array_free (_data10_->groups, _data10_->groups_length1, (GDestroyNotify) g_object_unref), NULL);
++ _g_object_unref0 (_data10_->new_slide);
++ _g_object_unref0 (_data10_->container);
++ g_slice_free (Block10Data, _data10_);
++ }
++}
++
++
++#line 865 "ease-slide-actor.vala"
++static void ease_slide_actor_slats_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 1960 "ease-slide-actor.c"
++ Block10Data* _data10_;
++ ClutterClone** _tmp0_;
++ gint _this_slats_size_;
++ gint this_slats_length1;
++ ClutterClone** this_slats;
++ ClutterClone** _tmp1_;
++ gint _new_slats_size_;
++ gint new_slats_length1;
++ ClutterClone** new_slats;
++ ClutterGroup** _tmp2_;
++ ClutterAlpha* _tmp7_;
++#line 865 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 865 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 865 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 1978 "ease-slide-actor.c"
++ _data10_ = g_slice_new0 (Block10Data);
++ _data10_->_ref_count_ = 1;
++ _data10_->self = g_object_ref (self);
++ _data10_->new_slide = _g_object_ref0 (new_slide);
++ _data10_->container = _g_object_ref0 (container);
++#line 869 "ease-slide-actor.vala"
++ cogl_set_depth_test_enabled (TRUE);
++#line 872 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) self, (ClutterActor*) _data10_->container);
++#line 873 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) _data10_->new_slide, (ClutterActor*) _data10_->container);
++#line 874 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) self, (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide)));
++#line 875 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) _data10_->new_slide, (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide)));
++#line 1994 "ease-slide-actor.c"
++ this_slats = (_tmp0_ = g_new0 (ClutterClone*, EASE_SLIDE_ACTOR_SLAT_COUNT + 1), this_slats_length1 = EASE_SLIDE_ACTOR_SLAT_COUNT, _this_slats_size_ = this_slats_length1, _tmp0_);
++ new_slats = (_tmp1_ = g_new0 (ClutterClone*, EASE_SLIDE_ACTOR_SLAT_COUNT + 1), new_slats_length1 = EASE_SLIDE_ACTOR_SLAT_COUNT, _new_slats_size_ = new_slats_length1, _tmp1_);
++ _data10_->groups = (_tmp2_ = g_new0 (ClutterGroup*, EASE_SLIDE_ACTOR_SLAT_COUNT + 1), _data10_->groups_length1 = EASE_SLIDE_ACTOR_SLAT_COUNT, _tmp2_);
++ _data10_->width = ((float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide))) / EASE_SLIDE_ACTOR_SLAT_COUNT;
++ {
++ gint i;
++#line 886 "ease-slide-actor.vala"
++ i = 0;
++#line 2003 "ease-slide-actor.c"
++ {
++ gboolean _tmp3_;
++#line 886 "ease-slide-actor.vala"
++ _tmp3_ = TRUE;
++#line 886 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 2010 "ease-slide-actor.c"
++ ClutterGroup* _tmp4_;
++ ClutterClone* _tmp5_;
++ ClutterClone* _tmp6_;
++#line 886 "ease-slide-actor.vala"
++ if (!_tmp3_) {
++#line 886 "ease-slide-actor.vala"
++ i++;
++#line 2018 "ease-slide-actor.c"
++ }
++#line 886 "ease-slide-actor.vala"
++ _tmp3_ = FALSE;
++#line 886 "ease-slide-actor.vala"
++ if (!(i < EASE_SLIDE_ACTOR_SLAT_COUNT)) {
++#line 886 "ease-slide-actor.vala"
++ break;
++#line 2026 "ease-slide-actor.c"
++ }
++#line 889 "ease-slide-actor.vala"
++ _data10_->groups[i] = (_tmp4_ = g_object_ref_sink ((ClutterGroup*) clutter_group_new ()), _g_object_unref0 (_data10_->groups[i]), _tmp4_);
++#line 890 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data10_->container, (ClutterActor*) _data10_->groups[i]);
++#line 893 "ease-slide-actor.vala"
++ this_slats[i] = (_tmp5_ = g_object_ref_sink ((ClutterClone*) clutter_clone_new ((ClutterActor*) self)), _g_object_unref0 (this_slats[i]), _tmp5_);
++#line 894 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data10_->groups[i], (ClutterActor*) this_slats[i]);
++#line 895 "ease-slide-actor.vala"
++ new_slats[i] = (_tmp6_ = g_object_ref_sink ((ClutterClone*) clutter_clone_new ((ClutterActor*) _data10_->new_slide)), _g_object_unref0 (new_slats[i]), _tmp6_);
++#line 896 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data10_->groups[i], (ClutterActor*) new_slats[i]);
++#line 899 "ease-slide-actor.vala"
++ clutter_actor_set_clip ((ClutterActor*) this_slats[i], _data10_->width * i, (float) 0, _data10_->width, (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide)));
++#line 901 "ease-slide-actor.vala"
++ clutter_actor_set_clip ((ClutterActor*) new_slats[i], _data10_->width * i, (float) 0, _data10_->width, (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide)));
++#line 905 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) new_slats[i], CLUTTER_Y_AXIS, (double) 180, (_data10_->width / 2) + (i * _data10_->width), (float) 0, (float) 0);
++#line 909 "ease-slide-actor.vala"
++ clutter_actor_set_depth ((ClutterActor*) new_slats[i], (float) (-2));
++#line 2048 "ease-slide-actor.c"
++ }
++ }
++ }
++#line 913 "ease-slide-actor.vala"
++ ease_slide_actor_set_animation_alpha (self, _tmp7_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->_animation_time, (gulong) CLUTTER_EASE_IN_OUT_BACK)));
++#line 2054 "ease-slide-actor.c"
++ _g_object_unref0 (_tmp7_);
++#line 917 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->_animation_time, "new-frame", (GCallback) __lambda32__clutter_timeline_new_frame, block10_data_ref (_data10_), (GClosureNotify) block10_data_unref, 0);
++#line 927 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->_animation_time, "completed", (GCallback) __lambda33__clutter_timeline_completed, block10_data_ref (_data10_), (GClosureNotify) block10_data_unref, 0);
++#line 2060 "ease-slide-actor.c"
++ new_slats = (_vala_array_free (new_slats, new_slats_length1, (GDestroyNotify) g_object_unref), NULL);
++ this_slats = (_vala_array_free (this_slats, this_slats_length1, (GDestroyNotify) g_object_unref), NULL);
++ block10_data_unref (_data10_);
++}
++
++
++#line 1023 "ease-slide-actor.vala"
++static void _lambda30_ (gint m, Block11Data* _data11_) {
++#line 2069 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data11_->self;
++#line 1024 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) _data11_->left_group, CLUTTER_Y_AXIS, 180 * clutter_alpha_get_alpha (self->priv->_animation_alpha), (float) 0, (float) 0, (float) 0);
++#line 1028 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) _data11_->right_group, CLUTTER_Y_AXIS, (-180) * clutter_alpha_get_alpha (self->priv->_animation_alpha), _data11_->width * 2, (float) 0, (float) 0);
++#line 2076 "ease-slide-actor.c"
++}
++
++
++#line 1023 "ease-slide-actor.vala"
++static void __lambda30__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 2082 "ease-slide-actor.c"
++ _lambda30_ (frame_num, self);
++}
++
++
++#line 1034 "ease-slide-actor.vala"
++static void _lambda31_ (Block11Data* _data11_) {
++#line 2089 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data11_->self;
++#line 1035 "ease-slide-actor.vala"
++ clutter_container_remove_actor ((ClutterContainer*) _data11_->container, (ClutterActor*) _data11_->left_group);
++#line 1036 "ease-slide-actor.vala"
++ clutter_container_remove_actor ((ClutterContainer*) _data11_->container, (ClutterActor*) _data11_->right_group);
++#line 2096 "ease-slide-actor.c"
++}
++
++
++#line 1034 "ease-slide-actor.vala"
++static void __lambda31__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 2102 "ease-slide-actor.c"
++ _lambda31_ (self);
++}
++
++
++static Block11Data* block11_data_ref (Block11Data* _data11_) {
++ g_atomic_int_inc (&_data11_->_ref_count_);
++ return _data11_;
++}
++
++
++static void block11_data_unref (Block11Data* _data11_) {
++ if (g_atomic_int_dec_and_test (&_data11_->_ref_count_)) {
++ _g_object_unref0 (_data11_->self);
++ _g_object_unref0 (_data11_->right_group);
++ _g_object_unref0 (_data11_->left_group);
++ _g_object_unref0 (_data11_->container);
++ g_slice_free (Block11Data, _data11_);
++ }
++}
++
++
++#line 949 "ease-slide-actor.vala"
++static void ease_slide_actor_open_door_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 2126 "ease-slide-actor.c"
++ Block11Data* _data11_;
++ ClutterClone* reflection;
++ ClutterClone* left;
++ ClutterClone* right;
++ ClutterClone* left_ref;
++ ClutterClone* right_ref;
++ ClutterTimeline* _tmp0_;
++ ClutterTimeline* _tmp1_;
++ ClutterAlpha* _tmp2_;
++#line 949 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 949 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 949 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 2142 "ease-slide-actor.c"
++ _data11_ = g_slice_new0 (Block11Data);
++ _data11_->_ref_count_ = 1;
++ _data11_->self = g_object_ref (self);
++ _data11_->container = _g_object_ref0 (container);
++#line 954 "ease-slide-actor.vala"
++ reflection = g_object_ref_sink ((ClutterClone*) clutter_clone_new ((ClutterActor*) new_slide));
++#line 955 "ease-slide-actor.vala"
++ g_object_set ((ClutterActor*) reflection, "rotation-angle-z", (double) 180, NULL);
++#line 956 "ease-slide-actor.vala"
++ g_object_set ((ClutterActor*) reflection, "rotation-angle-y", (double) 180, NULL);
++#line 957 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) reflection, (float) (2 * ease_document_get_height (ease_slide_get_parent (self->priv->_slide))));
++#line 958 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) reflection, (guint) EASE_SLIDE_ACTOR_REFLECTION_OPACITY);
++#line 961 "ease-slide-actor.vala"
++ clutter_actor_set_depth ((ClutterActor*) new_slide, EASE_SLIDE_ACTOR_OPEN_DEPTH);
++#line 962 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide, (gulong) CLUTTER_EASE_OUT_SINE, length, "depth", 0, NULL);
++#line 965 "ease-slide-actor.vala"
++ clutter_actor_set_depth ((ClutterActor*) reflection, EASE_SLIDE_ACTOR_OPEN_DEPTH);
++#line 966 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) reflection, (gulong) CLUTTER_EASE_OUT_SINE, length, "depth", 0, NULL);
++#line 968 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data11_->container, (ClutterActor*) reflection);
++#line 970 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self, (gulong) CLUTTER_LINEAR, length, "opacity", 0, NULL);
++#line 971 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) self, (ClutterActor*) _data11_->container);
++#line 972 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) self, (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide)));
++#line 2173 "ease-slide-actor.c"
++ _data11_->width = ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2.f;
++#line 976 "ease-slide-actor.vala"
++ left = g_object_ref_sink ((ClutterClone*) clutter_clone_new ((ClutterActor*) self));
++#line 977 "ease-slide-actor.vala"
++ right = g_object_ref_sink ((ClutterClone*) clutter_clone_new ((ClutterActor*) self));
++#line 979 "ease-slide-actor.vala"
++ clutter_actor_set_clip ((ClutterActor*) left, (float) 0, (float) 0, _data11_->width, (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide)));
++#line 980 "ease-slide-actor.vala"
++ clutter_actor_set_clip ((ClutterActor*) right, _data11_->width, (float) 0, _data11_->width, (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide)));
++#line 983 "ease-slide-actor.vala"
++ left_ref = g_object_ref_sink ((ClutterClone*) clutter_clone_new ((ClutterActor*) left));
++#line 984 "ease-slide-actor.vala"
++ right_ref = g_object_ref_sink ((ClutterClone*) clutter_clone_new ((ClutterActor*) right));
++#line 986 "ease-slide-actor.vala"
++ g_object_set ((ClutterActor*) left_ref, "rotation-angle-z", (double) 180, NULL);
++#line 987 "ease-slide-actor.vala"
++ g_object_set ((ClutterActor*) left_ref, "rotation-angle-y", (double) 180, NULL);
++#line 988 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) left_ref, (float) (2 * ease_document_get_height (ease_slide_get_parent (self->priv->_slide))));
++#line 989 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) left_ref, (guint) EASE_SLIDE_ACTOR_REFLECTION_OPACITY);
++#line 991 "ease-slide-actor.vala"
++ g_object_set ((ClutterActor*) right_ref, "rotation-angle-z", (double) 180, NULL);
++#line 992 "ease-slide-actor.vala"
++ g_object_set ((ClutterActor*) right_ref, "rotation-angle-y", (double) 180, NULL);
++#line 993 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) right_ref, (float) (2 * ease_document_get_height (ease_slide_get_parent (self->priv->_slide))));
++#line 994 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) right_ref, (guint) EASE_SLIDE_ACTOR_REFLECTION_OPACITY);
++#line 2203 "ease-slide-actor.c"
++ _data11_->left_group = g_object_ref_sink ((ClutterGroup*) clutter_group_new ());
++ _data11_->right_group = g_object_ref_sink ((ClutterGroup*) clutter_group_new ());
++#line 1001 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data11_->left_group, (ClutterActor*) left_ref);
++#line 1002 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data11_->left_group, (ClutterActor*) left);
++#line 1003 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data11_->right_group, (ClutterActor*) right_ref);
++#line 1004 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data11_->right_group, (ClutterActor*) right);
++#line 1007 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data11_->container, (ClutterActor*) _data11_->left_group);
++#line 1008 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data11_->container, (ClutterActor*) _data11_->right_group);
++#line 1011 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) _data11_->left_group, (gulong) CLUTTER_EASE_IN_OUT_SINE, length / 2, "x", clutter_actor_get_x ((ClutterActor*) left) - (_data11_->width * EASE_SLIDE_ACTOR_OPEN_MOVE), NULL);
++#line 1014 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) _data11_->right_group, (gulong) CLUTTER_EASE_IN_OUT_SINE, length / 2, "x", clutter_actor_get_x ((ClutterActor*) right) + (_data11_->width * EASE_SLIDE_ACTOR_OPEN_MOVE), NULL);
++#line 1018 "ease-slide-actor.vala"
++ self->priv->time1 = (_tmp0_ = clutter_timeline_new ((guint) ((gint) (EASE_SLIDE_ACTOR_OPEN_TIME * length))), _g_object_unref0 (self->priv->time1), _tmp0_);
++#line 1019 "ease-slide-actor.vala"
++ self->priv->time2 = (_tmp1_ = clutter_timeline_new (length), _g_object_unref0 (self->priv->time2), _tmp1_);
++#line 1020 "ease-slide-actor.vala"
++ ease_slide_actor_set_animation_alpha (self, _tmp2_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->time1, (gulong) CLUTTER_EASE_IN_SINE)));
++#line 2228 "ease-slide-actor.c"
++ _g_object_unref0 (_tmp2_);
++#line 1023 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->time1, "new-frame", (GCallback) __lambda30__clutter_timeline_new_frame, block11_data_ref (_data11_), (GClosureNotify) block11_data_unref, 0);
++#line 1034 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->time1, "completed", (GCallback) __lambda31__clutter_timeline_completed, block11_data_ref (_data11_), (GClosureNotify) block11_data_unref, 0);
++#line 1039 "ease-slide-actor.vala"
++ clutter_timeline_start (self->priv->time1);
++#line 1040 "ease-slide-actor.vala"
++ clutter_timeline_start (self->priv->time2);
++#line 2238 "ease-slide-actor.c"
++ _g_object_unref0 (right_ref);
++ _g_object_unref0 (left_ref);
++ _g_object_unref0 (right);
++ _g_object_unref0 (left);
++ _g_object_unref0 (reflection);
++ block11_data_unref (_data11_);
++}
++
++
++#line 1078 "ease-slide-actor.vala"
++static void _lambda43_ (gint m, Block12Data* _data12_) {
++#line 2250 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data12_->self;
++#line 1079 "ease-slide-actor.vala"
++ clutter_actor_set_scale ((ClutterActor*) _data12_->new_slide, clutter_alpha_get_alpha (self->priv->_animation_alpha), clutter_alpha_get_alpha (self->priv->_animation_alpha));
++#line 2255 "ease-slide-actor.c"
++}
++
++
++#line 1078 "ease-slide-actor.vala"
++static void __lambda43__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 2261 "ease-slide-actor.c"
++ _lambda43_ (frame_num, self);
++}
++
++
++static Block12Data* block12_data_ref (Block12Data* _data12_) {
++ g_atomic_int_inc (&_data12_->_ref_count_);
++ return _data12_;
++}
++
++
++static void block12_data_unref (Block12Data* _data12_) {
++ if (g_atomic_int_dec_and_test (&_data12_->_ref_count_)) {
++ _g_object_unref0 (_data12_->self);
++ _g_object_unref0 (_data12_->new_slide);
++ g_slice_free (Block12Data, _data12_);
++ }
++}
++
++
++#line 1050 "ease-slide-actor.vala"
++static void ease_slide_actor_zoom_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 2283 "ease-slide-actor.c"
++ Block12Data* _data12_;
++ ClutterAlpha* _tmp0_;
++#line 1050 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 1050 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 1050 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 2292 "ease-slide-actor.c"
++ _data12_ = g_slice_new0 (Block12Data);
++ _data12_->_ref_count_ = 1;
++ _data12_->self = g_object_ref (self);
++ _data12_->new_slide = _g_object_ref0 (new_slide);
++#line 1053 "ease-slide-actor.vala"
++ switch (ease_slide_get_variant (self->priv->_slide)) {
++#line 2299 "ease-slide-actor.c"
++ case EASE_TRANSITION_VARIANT_CENTER:
++ {
++#line 1056 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) _data12_->new_slide, (double) 0, (double) 0, (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2), (float) (ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) / 2));
++#line 1059 "ease-slide-actor.vala"
++ break;
++#line 2306 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_TOP_LEFT:
++ {
++#line 1061 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) _data12_->new_slide, (double) 0, (double) 0, (float) 0, (float) 0);
++#line 1062 "ease-slide-actor.vala"
++ break;
++#line 2314 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_TOP_RIGHT:
++ {
++#line 1064 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) _data12_->new_slide, (double) 0, (double) 0, (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide)), (float) 0);
++#line 1065 "ease-slide-actor.vala"
++ break;
++#line 2322 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_BOTTOM_LEFT:
++ {
++#line 1067 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) _data12_->new_slide, (double) 0, (double) 0, (float) 0, (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide)));
++#line 1068 "ease-slide-actor.vala"
++ break;
++#line 2330 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_BOTTOM_RIGHT:
++ {
++#line 1070 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) _data12_->new_slide, (double) 0, (double) 0, (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide)), (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide)));
++#line 1073 "ease-slide-actor.vala"
++ break;
++#line 2338 "ease-slide-actor.c"
++ }
++ }
++#line 1075 "ease-slide-actor.vala"
++ ease_slide_actor_set_animation_alpha (self, _tmp0_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->_animation_time, (gulong) CLUTTER_EASE_OUT_SINE)));
++#line 2343 "ease-slide-actor.c"
++ _g_object_unref0 (_tmp0_);
++#line 1078 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->_animation_time, "new-frame", (GCallback) __lambda43__clutter_timeline_new_frame, block12_data_ref (_data12_), (GClosureNotify) block12_data_unref, 0);
++#line 2347 "ease-slide-actor.c"
++ block12_data_unref (_data12_);
++}
++
++
++#line 1126 "ease-slide-actor.vala"
++static void _lambda46_ (gint m, EaseSlideActor* self) {
++#line 1127 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) self, EASE_SLIDE_ACTOR_PANEL_SCALE + ((1 - EASE_SLIDE_ACTOR_PANEL_SCALE) * (1 - clutter_alpha_get_alpha (self->priv->alpha1))), EASE_SLIDE_ACTOR_PANEL_SCALE + ((1 - EASE_SLIDE_ACTOR_PANEL_SCALE) * (1 - clutter_alpha_get_alpha (self->priv->alpha1))), (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2), (float) (ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) / 2));
++#line 2356 "ease-slide-actor.c"
++}
++
++
++#line 1126 "ease-slide-actor.vala"
++static void __lambda46__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 2362 "ease-slide-actor.c"
++ _lambda46_ (frame_num, self);
++}
++
++
++#line 1133 "ease-slide-actor.vala"
++static void _lambda47_ (Block13Data* _data13_) {
++#line 2369 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data13_->self;
++#line 1134 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self, (gulong) CLUTTER_EASE_IN_OUT_SINE, _data13_->length / 2, _data13_->property, -_data13_->pos, NULL);
++#line 1137 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) _data13_->new_slide, (gulong) CLUTTER_EASE_IN_OUT_SINE, _data13_->length / 2, _data13_->property, 0.0f, NULL);
++#line 2376 "ease-slide-actor.c"
++}
++
++
++#line 1133 "ease-slide-actor.vala"
++static void __lambda47__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 2382 "ease-slide-actor.c"
++ _lambda47_ (self);
++}
++
++
++#line 1141 "ease-slide-actor.vala"
++static void _lambda49_ (gint m, Block13Data* _data13_) {
++#line 2389 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data13_->self;
++#line 1142 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) _data13_->new_slide, EASE_SLIDE_ACTOR_PANEL_SCALE + ((1 - EASE_SLIDE_ACTOR_PANEL_SCALE) * clutter_alpha_get_alpha (self->priv->alpha1)), EASE_SLIDE_ACTOR_PANEL_SCALE + ((1 - EASE_SLIDE_ACTOR_PANEL_SCALE) * clutter_alpha_get_alpha (self->priv->alpha1)), (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2), (float) (ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) / 2));
++#line 2394 "ease-slide-actor.c"
++}
++
++
++#line 1141 "ease-slide-actor.vala"
++static void __lambda49__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 2400 "ease-slide-actor.c"
++ _lambda49_ (frame_num, self);
++}
++
++
++#line 1140 "ease-slide-actor.vala"
++static void _lambda48_ (Block13Data* _data13_) {
++#line 2407 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data13_->self;
++#line 1141 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->time1, "new-frame", (GCallback) __lambda49__clutter_timeline_new_frame, block13_data_ref (_data13_), (GClosureNotify) block13_data_unref, 0);
++#line 1149 "ease-slide-actor.vala"
++ clutter_timeline_start (self->priv->time1);
++#line 2414 "ease-slide-actor.c"
++}
++
++
++#line 1140 "ease-slide-actor.vala"
++static void __lambda48__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 2420 "ease-slide-actor.c"
++ _lambda48_ (self);
++}
++
++
++static Block13Data* block13_data_ref (Block13Data* _data13_) {
++ g_atomic_int_inc (&_data13_->_ref_count_);
++ return _data13_;
++}
++
++
++static void block13_data_unref (Block13Data* _data13_) {
++ if (g_atomic_int_dec_and_test (&_data13_->_ref_count_)) {
++ _g_object_unref0 (_data13_->self);
++ _g_free0 (_data13_->property);
++ _g_object_unref0 (_data13_->new_slide);
++ g_slice_free (Block13Data, _data13_);
++ }
++}
++
++
++#line 1090 "ease-slide-actor.vala"
++static void ease_slide_actor_panel_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 2443 "ease-slide-actor.c"
++ Block13Data* _data13_;
++ ClutterTimeline* _tmp4_;
++ ClutterTimeline* _tmp5_;
++ GValue _tmp7_;
++ GValue _tmp6_ = {0};
++ ClutterAlpha* _tmp8_;
++#line 1090 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 1090 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 1090 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 2456 "ease-slide-actor.c"
++ _data13_ = g_slice_new0 (Block13Data);
++ _data13_->_ref_count_ = 1;
++ _data13_->self = g_object_ref (self);
++ _data13_->new_slide = _g_object_ref0 (new_slide);
++ _data13_->length = length;
++ _data13_->pos = (float) 0;
++ _data13_->property = g_strdup ("");
++#line 1096 "ease-slide-actor.vala"
++ switch (ease_slide_get_variant (self->priv->_slide)) {
++#line 2466 "ease-slide-actor.c"
++ case EASE_TRANSITION_VARIANT_UP:
++ {
++ char* _tmp0_;
++#line 1099 "ease-slide-actor.vala"
++ _data13_->pos = (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide));
++#line 1100 "ease-slide-actor.vala"
++ _data13_->property = (_tmp0_ = g_strdup ("y"), _g_free0 (_data13_->property), _tmp0_);
++#line 1101 "ease-slide-actor.vala"
++ break;
++#line 2476 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_DOWN:
++ {
++ char* _tmp1_;
++#line 1103 "ease-slide-actor.vala"
++ _data13_->pos = (float) (-ease_document_get_height (ease_slide_get_parent (self->priv->_slide)));
++#line 1104 "ease-slide-actor.vala"
++ _data13_->property = (_tmp1_ = g_strdup ("y"), _g_free0 (_data13_->property), _tmp1_);
++#line 1105 "ease-slide-actor.vala"
++ break;
++#line 2487 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_LEFT:
++ {
++ char* _tmp2_;
++#line 1107 "ease-slide-actor.vala"
++ _data13_->pos = (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide));
++#line 1108 "ease-slide-actor.vala"
++ _data13_->property = (_tmp2_ = g_strdup ("x"), _g_free0 (_data13_->property), _tmp2_);
++#line 1109 "ease-slide-actor.vala"
++ break;
++#line 2498 "ease-slide-actor.c"
++ }
++ default:
++ {
++ char* _tmp3_;
++#line 1111 "ease-slide-actor.vala"
++ _data13_->pos = (float) (-ease_document_get_width (ease_slide_get_parent (self->priv->_slide)));
++#line 1112 "ease-slide-actor.vala"
++ _data13_->property = (_tmp3_ = g_strdup ("x"), _g_free0 (_data13_->property), _tmp3_);
++#line 1113 "ease-slide-actor.vala"
++ break;
++#line 2509 "ease-slide-actor.c"
++ }
++ }
++#line 1116 "ease-slide-actor.vala"
++ self->priv->time1 = (_tmp4_ = clutter_timeline_new (_data13_->length / 4), _g_object_unref0 (self->priv->time1), _tmp4_);
++#line 1117 "ease-slide-actor.vala"
++ self->priv->time2 = (_tmp5_ = clutter_timeline_new ((3 * _data13_->length) / 4), _g_object_unref0 (self->priv->time2), _tmp5_);
++#line 1118 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) _data13_->new_slide, (double) EASE_SLIDE_ACTOR_PANEL_SCALE, (double) EASE_SLIDE_ACTOR_PANEL_SCALE, (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2), (float) (ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) / 2));
++#line 1122 "ease-slide-actor.vala"
++ g_object_set_property ((GObject*) _data13_->new_slide, _data13_->property, (_tmp7_ = (g_value_init (&_tmp6_, G_TYPE_FLOAT), g_value_set_float (&_tmp6_, _data13_->pos), _tmp6_), &_tmp7_));
++#line 1123 "ease-slide-actor.vala"
++ self->priv->alpha1 = (_tmp8_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->time1, (gulong) CLUTTER_EASE_IN_OUT_SINE)), _g_object_unref0 (self->priv->alpha1), _tmp8_);
++#line 1126 "ease-slide-actor.vala"
++ g_signal_connect_object (self->priv->time1, "new-frame", (GCallback) __lambda46__clutter_timeline_new_frame, self, 0);
++#line 1133 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->time1, "completed", (GCallback) __lambda47__clutter_timeline_completed, block13_data_ref (_data13_), (GClosureNotify) block13_data_unref, 0);
++#line 1140 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->time2, "completed", (GCallback) __lambda48__clutter_timeline_completed, block13_data_ref (_data13_), (GClosureNotify) block13_data_unref, 0);
++#line 1151 "ease-slide-actor.vala"
++ clutter_timeline_start (self->priv->time1);
++#line 1152 "ease-slide-actor.vala"
++ clutter_timeline_start (self->priv->time2);
++#line 2532 "ease-slide-actor.c"
++ block13_data_unref (_data13_);
++}
++
++
++#line 1181 "ease-slide-actor.vala"
++static void _lambda39_ (EaseSlideActor* self) {
++#line 1182 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) self->contents, (guint) 0);
++#line 1183 "ease-slide-actor.vala"
++ clutter_timeline_start (self->priv->time2);
++#line 2543 "ease-slide-actor.c"
++}
++
++
++#line 1181 "ease-slide-actor.vala"
++static void __lambda39__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 2549 "ease-slide-actor.c"
++ _lambda39_ (self);
++}
++
++
++#line 1185 "ease-slide-actor.vala"
++static void _lambda40_ (gint m, Block14Data* _data14_) {
++#line 2556 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data14_->self;
++#line 1186 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) self->contents, CLUTTER_Y_AXIS, _data14_->angle * clutter_alpha_get_alpha (self->priv->alpha1), (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2), (float) 0, (float) 0);
++#line 2561 "ease-slide-actor.c"
++}
++
++
++#line 1185 "ease-slide-actor.vala"
++static void __lambda40__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 2567 "ease-slide-actor.c"
++ _lambda40_ (frame_num, self);
++}
++
++
++#line 1190 "ease-slide-actor.vala"
++static void _lambda41_ (gint m, Block14Data* _data14_) {
++#line 2574 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data14_->self;
++#line 1191 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) _data14_->new_slide->contents, (guint) 255);
++#line 1192 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) _data14_->new_slide->contents, CLUTTER_Y_AXIS, (-_data14_->angle) * (1 - clutter_alpha_get_alpha (self->priv->alpha2)), (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2), (float) 0, (float) 0);
++#line 2581 "ease-slide-actor.c"
++}
++
++
++#line 1190 "ease-slide-actor.vala"
++static void __lambda41__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 2587 "ease-slide-actor.c"
++ _lambda41_ (frame_num, self);
++}
++
++
++static Block14Data* block14_data_ref (Block14Data* _data14_) {
++ g_atomic_int_inc (&_data14_->_ref_count_);
++ return _data14_;
++}
++
++
++static void block14_data_unref (Block14Data* _data14_) {
++ if (g_atomic_int_dec_and_test (&_data14_->_ref_count_)) {
++ _g_object_unref0 (_data14_->self);
++ _g_object_unref0 (_data14_->new_slide);
++ g_slice_free (Block14Data, _data14_);
++ }
++}
++
++
++#line 1163 "ease-slide-actor.vala"
++static void ease_slide_actor_spin_contents_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 2609 "ease-slide-actor.c"
++ Block14Data* _data14_;
++ ClutterTimeline* _tmp0_;
++ ClutterTimeline* _tmp1_;
++ ClutterAlpha* _tmp2_;
++ ClutterAlpha* _tmp3_;
++ gint _tmp4_ = 0;
++#line 1163 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 1163 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 1163 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 2622 "ease-slide-actor.c"
++ _data14_ = g_slice_new0 (Block14Data);
++ _data14_->_ref_count_ = 1;
++ _data14_->self = g_object_ref (self);
++ _data14_->new_slide = _g_object_ref0 (new_slide);
++#line 1167 "ease-slide-actor.vala"
++ ease_slide_actor_prepare_stack_transition (self, FALSE, _data14_->new_slide, container);
++#line 1169 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) _data14_->new_slide->contents, (guint) 0);
++#line 1170 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->background, (gulong) CLUTTER_EASE_IN_OUT_SINE, length, "opacity", 0, NULL);
++#line 1172 "ease-slide-actor.vala"
++ self->priv->time1 = (_tmp0_ = clutter_timeline_new (length / 2), _g_object_unref0 (self->priv->time1), _tmp0_);
++#line 1173 "ease-slide-actor.vala"
++ self->priv->time2 = (_tmp1_ = clutter_timeline_new (length / 2), _g_object_unref0 (self->priv->time2), _tmp1_);
++#line 1174 "ease-slide-actor.vala"
++ self->priv->alpha1 = (_tmp2_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->time1, (gulong) CLUTTER_EASE_IN_SINE)), _g_object_unref0 (self->priv->alpha1), _tmp2_);
++#line 1177 "ease-slide-actor.vala"
++ self->priv->alpha2 = (_tmp3_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->time2, (gulong) CLUTTER_EASE_OUT_SINE)), _g_object_unref0 (self->priv->alpha2), _tmp3_);
++#line 1180 "ease-slide-actor.vala"
++ if (ease_slide_get_variant (self->priv->_slide) == EASE_TRANSITION_VARIANT_LEFT) {
++#line 1180 "ease-slide-actor.vala"
++ _tmp4_ = -90;
++#line 2645 "ease-slide-actor.c"
++ } else {
++#line 1180 "ease-slide-actor.vala"
++ _tmp4_ = 90;
++#line 2649 "ease-slide-actor.c"
++ }
++ _data14_->angle = (float) _tmp4_;
++#line 1181 "ease-slide-actor.vala"
++ g_signal_connect_object (self->priv->time1, "completed", (GCallback) __lambda39__clutter_timeline_completed, self, 0);
++#line 1185 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->time1, "new-frame", (GCallback) __lambda40__clutter_timeline_new_frame, block14_data_ref (_data14_), (GClosureNotify) block14_data_unref, 0);
++#line 1190 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->time2, "new-frame", (GCallback) __lambda41__clutter_timeline_new_frame, block14_data_ref (_data14_), (GClosureNotify) block14_data_unref, 0);
++#line 1196 "ease-slide-actor.vala"
++ clutter_timeline_start (self->priv->time1);
++#line 2660 "ease-slide-actor.c"
++ block14_data_unref (_data14_);
++}
++
++
++#line 1225 "ease-slide-actor.vala"
++static void _lambda42_ (gint m, Block15Data* _data15_) {
++#line 2667 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ GList* itr = NULL;
++ self = _data15_->self;
++#line 1227 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) self->contents, (guint) ease_slide_actor_clamp_opacity (455 - (555 * clutter_alpha_get_alpha (self->priv->alpha1))));
++#line 1228 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) _data15_->new_slide->contents, (guint) ease_slide_actor_clamp_opacity ((-100) + (400 * clutter_alpha_get_alpha (self->priv->alpha2))));
++#line 2675 "ease-slide-actor.c"
++ {
++ gboolean _tmp0_;
++#line 1230 "ease-slide-actor.vala"
++ itr = clutter_container_get_children ((ClutterContainer*) self->contents);
++#line 1230 "ease-slide-actor.vala"
++ _tmp0_ = TRUE;
++#line 1230 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 1230 "ease-slide-actor.vala"
++ if (!_tmp0_) {
++#line 1230 "ease-slide-actor.vala"
++ itr = itr->next;
++#line 2688 "ease-slide-actor.c"
++ }
++#line 1230 "ease-slide-actor.vala"
++ _tmp0_ = FALSE;
++#line 1230 "ease-slide-actor.vala"
++ if (!(itr != NULL)) {
++#line 1230 "ease-slide-actor.vala"
++ break;
++#line 2696 "ease-slide-actor.c"
++ }
++#line 1232 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) ((EaseActor*) ((ClutterActor*) itr->data)), CLUTTER_X_AXIS, 540 * clutter_alpha_get_alpha (self->priv->alpha1), (float) 0, (float) 0, (float) 0);
++#line 2700 "ease-slide-actor.c"
++ }
++ }
++ {
++ gboolean _tmp1_;
++#line 1236 "ease-slide-actor.vala"
++ itr = clutter_container_get_children ((ClutterContainer*) _data15_->new_slide->contents);
++#line 1236 "ease-slide-actor.vala"
++ _tmp1_ = TRUE;
++#line 1236 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 1236 "ease-slide-actor.vala"
++ if (!_tmp1_) {
++#line 1237 "ease-slide-actor.vala"
++ itr = itr->next;
++#line 2715 "ease-slide-actor.c"
++ }
++#line 1236 "ease-slide-actor.vala"
++ _tmp1_ = FALSE;
++#line 1237 "ease-slide-actor.vala"
++ if (!(itr != NULL)) {
++#line 1237 "ease-slide-actor.vala"
++ break;
++#line 2723 "ease-slide-actor.c"
++ }
++#line 1239 "ease-slide-actor.vala"
++ clutter_actor_set_rotation ((ClutterActor*) ((EaseActor*) ((ClutterActor*) itr->data)), CLUTTER_X_AXIS, (-540) * (1 - clutter_alpha_get_alpha (self->priv->alpha2)), (float) 0, (float) 0, (float) 0);
++#line 2727 "ease-slide-actor.c"
++ }
++ }
++}
++
++
++#line 1225 "ease-slide-actor.vala"
++static void __lambda42__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 2735 "ease-slide-actor.c"
++ _lambda42_ (frame_num, self);
++}
++
++
++static Block15Data* block15_data_ref (Block15Data* _data15_) {
++ g_atomic_int_inc (&_data15_->_ref_count_);
++ return _data15_;
++}
++
++
++static void block15_data_unref (Block15Data* _data15_) {
++ if (g_atomic_int_dec_and_test (&_data15_->_ref_count_)) {
++ _g_object_unref0 (_data15_->self);
++ _g_object_unref0 (_data15_->new_slide);
++ g_slice_free (Block15Data, _data15_);
++ }
++}
++
++
++#line 1207 "ease-slide-actor.vala"
++static void ease_slide_actor_swing_contents_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 2757 "ease-slide-actor.c"
++ Block15Data* _data15_;
++ ClutterAlpha* _tmp0_;
++ ClutterAlpha* _tmp1_;
++ ClutterAlpha* _tmp2_;
++#line 1207 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 1207 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 1207 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 2768 "ease-slide-actor.c"
++ _data15_ = g_slice_new0 (Block15Data);
++ _data15_->_ref_count_ = 1;
++ _data15_->self = g_object_ref (self);
++ _data15_->new_slide = _g_object_ref0 (new_slide);
++#line 1211 "ease-slide-actor.vala"
++ ease_slide_actor_prepare_stack_transition (self, FALSE, _data15_->new_slide, container);
++#line 1213 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) _data15_->new_slide->contents, (guint) 0);
++#line 1214 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->background, (gulong) CLUTTER_EASE_IN_OUT_SINE, length, "opacity", 0, NULL);
++#line 1216 "ease-slide-actor.vala"
++ self->priv->alpha1 = (_tmp0_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->_animation_time, (gulong) CLUTTER_EASE_IN_SINE)), _g_object_unref0 (self->priv->alpha1), _tmp0_);
++#line 1219 "ease-slide-actor.vala"
++ self->priv->alpha2 = (_tmp1_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->_animation_time, (gulong) CLUTTER_EASE_OUT_SINE)), _g_object_unref0 (self->priv->alpha2), _tmp1_);
++#line 1222 "ease-slide-actor.vala"
++ ease_slide_actor_set_animation_alpha (self, _tmp2_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->_animation_time, (gulong) CLUTTER_LINEAR)));
++#line 2785 "ease-slide-actor.c"
++ _g_object_unref0 (_tmp2_);
++#line 1225 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->_animation_time, "new-frame", (GCallback) __lambda42__clutter_timeline_new_frame, block15_data_ref (_data15_), (GClosureNotify) block15_data_unref, 0);
++#line 2789 "ease-slide-actor.c"
++ block15_data_unref (_data15_);
++}
++
++
++#line 1254 "ease-slide-actor.vala"
++static void ease_slide_actor_slide_contents_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 1254 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 1254 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 1254 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 1258 "ease-slide-actor.vala"
++ ease_slide_actor_prepare_stack_transition (self, FALSE, new_slide, container);
++#line 1260 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->background, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "opacity", 0, NULL);
++#line 1262 "ease-slide-actor.vala"
++ switch (ease_slide_get_variant (self->priv->_slide)) {
++#line 2808 "ease-slide-actor.c"
++ case EASE_TRANSITION_VARIANT_RIGHT:
++ {
++#line 1265 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) new_slide->contents, (float) (-ease_document_get_width (ease_slide_get_parent (self->priv->_slide))));
++#line 1266 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide->contents, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "x", 0, NULL);
++#line 1268 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->contents, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "x", -clutter_actor_get_x ((ClutterActor*) new_slide->contents), NULL);
++#line 1270 "ease-slide-actor.vala"
++ break;
++#line 2819 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_LEFT:
++ {
++#line 1272 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) new_slide->contents, (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide)));
++#line 1273 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide->contents, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "x", 0, NULL);
++#line 1275 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->contents, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "x", -clutter_actor_get_x ((ClutterActor*) new_slide->contents), NULL);
++#line 1277 "ease-slide-actor.vala"
++ break;
++#line 2831 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_UP:
++ {
++#line 1279 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) new_slide->contents, (float) ease_document_get_height (ease_slide_get_parent (self->priv->_slide)));
++#line 1280 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide->contents, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "y", 0, NULL);
++#line 1282 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->contents, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "y", -clutter_actor_get_y ((ClutterActor*) new_slide->contents), NULL);
++#line 1284 "ease-slide-actor.vala"
++ break;
++#line 2843 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_DOWN:
++ {
++#line 1286 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) new_slide->contents, (float) (-ease_document_get_height (ease_slide_get_parent (self->priv->_slide))));
++#line 1287 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide->contents, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "y", 0, NULL);
++#line 1289 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->contents, (gulong) EASE_SLIDE_ACTOR_EASE_SLIDE, length, "y", -clutter_actor_get_y ((ClutterActor*) new_slide->contents), NULL);
++#line 1291 "ease-slide-actor.vala"
++ break;
++#line 2855 "ease-slide-actor.c"
++ }
++ }
++}
++
++
++#line 1303 "ease-slide-actor.vala"
++static void ease_slide_actor_spring_contents_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 1303 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 1303 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 1303 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 1307 "ease-slide-actor.vala"
++ ease_slide_actor_prepare_stack_transition (self, FALSE, new_slide, container);
++#line 1309 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->background, (gulong) CLUTTER_EASE_IN_OUT_SINE, length, "opacity", 0, NULL);
++#line 1312 "ease-slide-actor.vala"
++ switch (ease_slide_get_variant (self->priv->_slide)) {
++#line 2875 "ease-slide-actor.c"
++ case EASE_TRANSITION_VARIANT_UP:
++ {
++#line 1315 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) new_slide->contents, ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) * 1.2f);
++#line 1316 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide->contents, (gulong) CLUTTER_EASE_IN_OUT_ELASTIC, length, "y", 0, NULL);
++#line 1318 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->contents, (gulong) CLUTTER_EASE_IN_OUT_ELASTIC, length, "y", (-ease_document_get_height (ease_slide_get_parent (self->priv->_slide))) * 1.2, NULL);
++#line 1320 "ease-slide-actor.vala"
++ break;
++#line 2886 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_DOWN:
++ {
++#line 1322 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) new_slide->contents, (-ease_document_get_height (ease_slide_get_parent (self->priv->_slide))) * 1.2f);
++#line 1323 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) new_slide->contents, (gulong) CLUTTER_EASE_IN_OUT_ELASTIC, length, "y", 0, NULL);
++#line 1325 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->contents, (gulong) CLUTTER_EASE_IN_OUT_ELASTIC, length, "y", ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) * 1.2, NULL);
++#line 1327 "ease-slide-actor.vala"
++ break;
++#line 2898 "ease-slide-actor.c"
++ }
++ }
++}
++
++
++#line 1362 "ease-slide-actor.vala"
++static void _lambda44_ (gint m, Block16Data* _data16_) {
++#line 2906 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data16_->self;
++#line 1363 "ease-slide-actor.vala"
++ clutter_actor_set_scale ((ClutterActor*) _data16_->new_slide->contents, clutter_alpha_get_alpha (self->priv->_animation_alpha), clutter_alpha_get_alpha (self->priv->_animation_alpha));
++#line 1366 "ease-slide-actor.vala"
++ clutter_actor_set_scale ((ClutterActor*) self->contents, 1.0 + (2 * clutter_alpha_get_alpha (self->priv->_animation_alpha)), 1.0 + (2 * clutter_alpha_get_alpha (self->priv->_animation_alpha)));
++#line 2913 "ease-slide-actor.c"
++}
++
++
++#line 1362 "ease-slide-actor.vala"
++static void __lambda44__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 2919 "ease-slide-actor.c"
++ _lambda44_ (frame_num, self);
++}
++
++
++#line 1382 "ease-slide-actor.vala"
++static void _lambda45_ (gint m, Block16Data* _data16_) {
++#line 2926 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data16_->self;
++#line 1383 "ease-slide-actor.vala"
++ clutter_actor_set_scale ((ClutterActor*) _data16_->new_slide->contents, 1.0 + (2 * (1 - clutter_alpha_get_alpha (self->priv->_animation_alpha))), 1.0 + (2 * (1 - clutter_alpha_get_alpha (self->priv->_animation_alpha))));
++#line 1385 "ease-slide-actor.vala"
++ clutter_actor_set_scale ((ClutterActor*) self->contents, 1 - clutter_alpha_get_alpha (self->priv->_animation_alpha), 1 - clutter_alpha_get_alpha (self->priv->_animation_alpha));
++#line 2933 "ease-slide-actor.c"
++}
++
++
++#line 1382 "ease-slide-actor.vala"
++static void __lambda45__clutter_timeline_new_frame (ClutterTimeline* _sender, gint frame_num, gpointer self) {
++#line 2939 "ease-slide-actor.c"
++ _lambda45_ (frame_num, self);
++}
++
++
++static Block16Data* block16_data_ref (Block16Data* _data16_) {
++ g_atomic_int_inc (&_data16_->_ref_count_);
++ return _data16_;
++}
++
++
++static void block16_data_unref (Block16Data* _data16_) {
++ if (g_atomic_int_dec_and_test (&_data16_->_ref_count_)) {
++ _g_object_unref0 (_data16_->self);
++ _g_object_unref0 (_data16_->new_slide);
++ g_slice_free (Block16Data, _data16_);
++ }
++}
++
++
++#line 1339 "ease-slide-actor.vala"
++static void ease_slide_actor_zoom_contents_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 2961 "ease-slide-actor.c"
++ Block16Data* _data16_;
++ ClutterAlpha* _tmp0_;
++#line 1339 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 1339 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 1339 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 2970 "ease-slide-actor.c"
++ _data16_ = g_slice_new0 (Block16Data);
++ _data16_->_ref_count_ = 1;
++ _data16_->self = g_object_ref (self);
++ _data16_->new_slide = _g_object_ref0 (new_slide);
++#line 1343 "ease-slide-actor.vala"
++ ease_slide_actor_prepare_stack_transition (self, ease_slide_get_variant (self->priv->_slide) == EASE_TRANSITION_VARIANT_OUT, _data16_->new_slide, container);
++#line 1346 "ease-slide-actor.vala"
++ ease_slide_actor_set_animation_alpha (self, _tmp0_ = g_object_ref_sink (clutter_alpha_new_full (self->priv->_animation_time, (gulong) CLUTTER_EASE_IN_OUT_SINE)));
++#line 2979 "ease-slide-actor.c"
++ _g_object_unref0 (_tmp0_);
++#line 1349 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->background, (gulong) CLUTTER_LINEAR, length, "opacity", 0, NULL);
++#line 1350 "ease-slide-actor.vala"
++ switch (ease_slide_get_variant (self->priv->_slide)) {
++#line 2985 "ease-slide-actor.c"
++ case EASE_TRANSITION_VARIANT_IN:
++ {
++#line 1353 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) _data16_->new_slide->contents, (double) 0, (double) 0, (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2), (float) (ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) / 2));
++#line 1357 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) self->contents, (double) 1, (double) 1, (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2), (float) (ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) / 2));
++#line 1361 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->contents, (gulong) CLUTTER_LINEAR, length / 2, "opacity", 0, NULL);
++#line 1362 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->_animation_time, "new-frame", (GCallback) __lambda44__clutter_timeline_new_frame, block16_data_ref (_data16_), (GClosureNotify) block16_data_unref, 0);
++#line 1369 "ease-slide-actor.vala"
++ break;
++#line 2998 "ease-slide-actor.c"
++ }
++ case EASE_TRANSITION_VARIANT_OUT:
++ {
++#line 1371 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) _data16_->new_slide->contents, (double) 0, (double) 0, (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2), (float) (ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) / 2));
++#line 1375 "ease-slide-actor.vala"
++ clutter_actor_set_scale_full ((ClutterActor*) self->contents, (double) 1, (double) 1, (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2), (float) (ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) / 2));
++#line 1379 "ease-slide-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) _data16_->new_slide->contents, (guint) 0);
++#line 1380 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) _data16_->new_slide->contents, (gulong) CLUTTER_EASE_IN_SINE, length / 2, "opacity", 255, NULL);
++#line 1382 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->_animation_time, "new-frame", (GCallback) __lambda45__clutter_timeline_new_frame, block16_data_ref (_data16_), (GClosureNotify) block16_data_unref, 0);
++#line 1388 "ease-slide-actor.vala"
++ break;
++#line 3014 "ease-slide-actor.c"
++ }
++ }
++ block16_data_unref (_data16_);
++}
++
++
++#line 1448 "ease-slide-actor.vala"
++static void _lambda50_ (Block17Data* _data17_) {
++#line 3023 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data17_->self;
++ {
++ gint j;
++#line 1449 "ease-slide-actor.vala"
++ j = 0;
++#line 3030 "ease-slide-actor.c"
++ {
++ gboolean _tmp0_;
++#line 1449 "ease-slide-actor.vala"
++ _tmp0_ = TRUE;
++#line 1449 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 1449 "ease-slide-actor.vala"
++ if (!_tmp0_) {
++#line 1449 "ease-slide-actor.vala"
++ j++;
++#line 3041 "ease-slide-actor.c"
++ }
++#line 1449 "ease-slide-actor.vala"
++ _tmp0_ = FALSE;
++#line 1449 "ease-slide-actor.vala"
++ if (!(j < _data17_->count)) {
++#line 1449 "ease-slide-actor.vala"
++ break;
++#line 3049 "ease-slide-actor.c"
++ }
++#line 1451 "ease-slide-actor.vala"
++ clutter_container_remove_actor ((ClutterContainer*) _data17_->container, (ClutterActor*) _data17_->particles[j]);
++#line 3053 "ease-slide-actor.c"
++ }
++ }
++ }
++}
++
++
++#line 1448 "ease-slide-actor.vala"
++static void __lambda50__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 3062 "ease-slide-actor.c"
++ _lambda50_ (self);
++}
++
++
++static Block17Data* block17_data_ref (Block17Data* _data17_) {
++ g_atomic_int_inc (&_data17_->_ref_count_);
++ return _data17_;
++}
++
++
++static void block17_data_unref (Block17Data* _data17_) {
++ if (g_atomic_int_dec_and_test (&_data17_->_ref_count_)) {
++ _g_object_unref0 (_data17_->self);
++ _data17_->particles = (_vala_array_free (_data17_->particles, _data17_->particles_length1, (GDestroyNotify) g_object_unref), NULL);
++ _g_object_unref0 (_data17_->container);
++ g_slice_free (Block17Data, _data17_);
++ }
++}
++
++
++#line 1399 "ease-slide-actor.vala"
++static void ease_slide_actor_explode_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 3085 "ease-slide-actor.c"
++ Block17Data* _data17_;
++ gint v_count;
++ ClutterClone** _tmp0_;
++ float size;
++ float center_x;
++ float center_y;
++ gint i = 0;
++#line 1399 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 1399 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 1399 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 3099 "ease-slide-actor.c"
++ _data17_ = g_slice_new0 (Block17Data);
++ _data17_->_ref_count_ = 1;
++ _data17_->self = g_object_ref (self);
++ _data17_->container = _g_object_ref0 (container);
++#line 1404 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) self, (ClutterActor*) _data17_->container);
++#line 1405 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) new_slide, (ClutterActor*) _data17_->container);
++#line 1406 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) self, (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide)));
++#line 1409 "ease-slide-actor.vala"
++ v_count = (gint) ceil ((double) ((1 / ease_document_get_aspect (ease_slide_get_parent (self->priv->_slide))) * EASE_SLIDE_ACTOR_EXPLODE_PARTICLES));
++#line 3112 "ease-slide-actor.c"
++ _data17_->count = EASE_SLIDE_ACTOR_EXPLODE_PARTICLES * v_count;
++ _data17_->particles = (_tmp0_ = g_new0 (ClutterClone*, _data17_->count + 1), _data17_->particles_length1 = _data17_->count, _tmp0_);
++#line 1414 "ease-slide-actor.vala"
++ size = ((float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide))) / EASE_SLIDE_ACTOR_EXPLODE_PARTICLES;
++#line 1415 "ease-slide-actor.vala"
++ center_x = (float) (ease_document_get_width (ease_slide_get_parent (self->priv->_slide)) / 2);
++#line 1416 "ease-slide-actor.vala"
++ center_y = (float) (ease_document_get_height (ease_slide_get_parent (self->priv->_slide)) / 2);
++#line 3121 "ease-slide-actor.c"
++ {
++ gint vpos;
++#line 1420 "ease-slide-actor.vala"
++ vpos = 0;
++#line 3126 "ease-slide-actor.c"
++ {
++ gboolean _tmp1_;
++#line 1420 "ease-slide-actor.vala"
++ _tmp1_ = TRUE;
++#line 1420 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 1420 "ease-slide-actor.vala"
++ if (!_tmp1_) {
++#line 1420 "ease-slide-actor.vala"
++ vpos++;
++#line 3137 "ease-slide-actor.c"
++ }
++#line 1420 "ease-slide-actor.vala"
++ _tmp1_ = FALSE;
++#line 1420 "ease-slide-actor.vala"
++ if (!(vpos < v_count)) {
++#line 1420 "ease-slide-actor.vala"
++ break;
++#line 3145 "ease-slide-actor.c"
++ }
++ {
++ gint hpos;
++#line 1422 "ease-slide-actor.vala"
++ hpos = 0;
++#line 3151 "ease-slide-actor.c"
++ {
++ gboolean _tmp2_;
++#line 1422 "ease-slide-actor.vala"
++ _tmp2_ = TRUE;
++#line 1422 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 3158 "ease-slide-actor.c"
++ ClutterClone* _tmp3_;
++ float atan;
++#line 1422 "ease-slide-actor.vala"
++ if (!_tmp2_) {
++#line 1422 "ease-slide-actor.vala"
++ hpos++;
++#line 3165 "ease-slide-actor.c"
++ }
++#line 1422 "ease-slide-actor.vala"
++ _tmp2_ = FALSE;
++#line 1422 "ease-slide-actor.vala"
++ if (!(hpos < EASE_SLIDE_ACTOR_EXPLODE_PARTICLES)) {
++#line 1422 "ease-slide-actor.vala"
++ break;
++#line 3173 "ease-slide-actor.c"
++ }
++#line 1425 "ease-slide-actor.vala"
++ i = (vpos * EASE_SLIDE_ACTOR_EXPLODE_PARTICLES) + hpos;
++#line 1426 "ease-slide-actor.vala"
++ _data17_->particles[i] = (_tmp3_ = g_object_ref_sink ((ClutterClone*) clutter_clone_new ((ClutterActor*) self)), _g_object_unref0 (_data17_->particles[i]), _tmp3_);
++#line 1429 "ease-slide-actor.vala"
++ clutter_actor_set_clip ((ClutterActor*) _data17_->particles[i], hpos * size, vpos * size, size, size);
++#line 1431 "ease-slide-actor.vala"
++ atan = atan2f (center_y - (vpos * size), center_x - (hpos * size));
++#line 1435 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) _data17_->particles[i], (gulong) CLUTTER_EASE_IN_SINE, ease_slide_actor_explode_time (self, length), "x", (-cosf (atan)) * ease_slide_actor_explode_dist (self), "y", (-sinf (atan)) * ease_slide_actor_explode_dist (self), "depth", ease_slide_actor_explode_depth (self), "opacity", 0, NULL);
++#line 1442 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data17_->container, (ClutterActor*) _data17_->particles[i]);
++#line 1443 "ease-slide-actor.vala"
++ clutter_actor_show ((ClutterActor*) _data17_->particles[i]);
++#line 3189 "ease-slide-actor.c"
++ }
++ }
++ }
++ }
++ }
++ }
++#line 1448 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->_animation_time, "completed", (GCallback) __lambda50__clutter_timeline_completed, block17_data_ref (_data17_), (GClosureNotify) block17_data_unref, 0);
++#line 3198 "ease-slide-actor.c"
++ block17_data_unref (_data17_);
++}
++
++
++#line 1523 "ease-slide-actor.vala"
++static void _lambda51_ (Block18Data* _data18_) {
++#line 3205 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = _data18_->self;
++#line 1524 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) _data18_->new_slide, (float) 0);
++#line 3210 "ease-slide-actor.c"
++ {
++ gint j;
++#line 1525 "ease-slide-actor.vala"
++ j = 0;
++#line 3215 "ease-slide-actor.c"
++ {
++ gboolean _tmp0_;
++#line 1525 "ease-slide-actor.vala"
++ _tmp0_ = TRUE;
++#line 1525 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 1525 "ease-slide-actor.vala"
++ if (!_tmp0_) {
++#line 1525 "ease-slide-actor.vala"
++ j++;
++#line 3226 "ease-slide-actor.c"
++ }
++#line 1525 "ease-slide-actor.vala"
++ _tmp0_ = FALSE;
++#line 1525 "ease-slide-actor.vala"
++ if (!(j < _data18_->count)) {
++#line 1525 "ease-slide-actor.vala"
++ break;
++#line 3234 "ease-slide-actor.c"
++ }
++#line 1527 "ease-slide-actor.vala"
++ if (clutter_actor_get_parent ((ClutterActor*) _data18_->particles[j]) == CLUTTER_ACTOR (_data18_->container)) {
++#line 1529 "ease-slide-actor.vala"
++ clutter_container_remove_actor ((ClutterContainer*) _data18_->container, (ClutterActor*) _data18_->particles[j]);
++#line 3240 "ease-slide-actor.c"
++ }
++ }
++ }
++ }
++}
++
++
++#line 1523 "ease-slide-actor.vala"
++static void __lambda51__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 3250 "ease-slide-actor.c"
++ _lambda51_ (self);
++}
++
++
++static Block18Data* block18_data_ref (Block18Data* _data18_) {
++ g_atomic_int_inc (&_data18_->_ref_count_);
++ return _data18_;
++}
++
++
++static void block18_data_unref (Block18Data* _data18_) {
++ if (g_atomic_int_dec_and_test (&_data18_->_ref_count_)) {
++ _g_object_unref0 (_data18_->self);
++ _data18_->particles = (_vala_array_free (_data18_->particles, _data18_->particles_length1, (GDestroyNotify) g_object_unref), NULL);
++ _g_object_unref0 (_data18_->new_slide);
++ _g_object_unref0 (_data18_->container);
++ g_slice_free (Block18Data, _data18_);
++ }
++}
++
++
++#line 1463 "ease-slide-actor.vala"
++static void ease_slide_actor_assemble_transition (EaseSlideActor* self, EaseSlideActor* new_slide, ClutterGroup* container, guint length) {
++#line 3274 "ease-slide-actor.c"
++ Block18Data* _data18_;
++ gint v_count;
++ ClutterClone** _tmp0_;
++ float size;
++ gint i = 0;
++#line 1463 "ease-slide-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 1463 "ease-slide-actor.vala"
++ g_return_if_fail (new_slide != NULL);
++#line 1463 "ease-slide-actor.vala"
++ g_return_if_fail (container != NULL);
++#line 3286 "ease-slide-actor.c"
++ _data18_ = g_slice_new0 (Block18Data);
++ _data18_->_ref_count_ = 1;
++ _data18_->self = g_object_ref (self);
++ _data18_->new_slide = _g_object_ref0 (new_slide);
++ _data18_->container = _g_object_ref0 (container);
++#line 1468 "ease-slide-actor.vala"
++ clutter_actor_reparent ((ClutterActor*) _data18_->new_slide, (ClutterActor*) _data18_->container);
++#line 1469 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) _data18_->new_slide, (float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide)));
++#line 1472 "ease-slide-actor.vala"
++ v_count = (gint) ceil ((double) ((1 / ease_document_get_aspect (ease_slide_get_parent (self->priv->_slide))) * EASE_SLIDE_ACTOR_ASSEMBLE_TILES));
++#line 3298 "ease-slide-actor.c"
++ _data18_->count = EASE_SLIDE_ACTOR_ASSEMBLE_TILES * v_count;
++ _data18_->particles = (_tmp0_ = g_new0 (ClutterClone*, _data18_->count + 1), _data18_->particles_length1 = _data18_->count, _tmp0_);
++#line 1477 "ease-slide-actor.vala"
++ size = ((float) ease_document_get_width (ease_slide_get_parent (self->priv->_slide))) / EASE_SLIDE_ACTOR_ASSEMBLE_TILES;
++#line 3303 "ease-slide-actor.c"
++ {
++ gint vpos;
++#line 1481 "ease-slide-actor.vala"
++ vpos = 0;
++#line 3308 "ease-slide-actor.c"
++ {
++ gboolean _tmp1_;
++#line 1481 "ease-slide-actor.vala"
++ _tmp1_ = TRUE;
++#line 1481 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 1481 "ease-slide-actor.vala"
++ if (!_tmp1_) {
++#line 1481 "ease-slide-actor.vala"
++ vpos++;
++#line 3319 "ease-slide-actor.c"
++ }
++#line 1481 "ease-slide-actor.vala"
++ _tmp1_ = FALSE;
++#line 1481 "ease-slide-actor.vala"
++ if (!(vpos < v_count)) {
++#line 1481 "ease-slide-actor.vala"
++ break;
++#line 3327 "ease-slide-actor.c"
++ }
++ {
++ gint hpos;
++#line 1483 "ease-slide-actor.vala"
++ hpos = 0;
++#line 3333 "ease-slide-actor.c"
++ {
++ gboolean _tmp2_;
++#line 1483 "ease-slide-actor.vala"
++ _tmp2_ = TRUE;
++#line 1483 "ease-slide-actor.vala"
++ while (TRUE) {
++#line 3340 "ease-slide-actor.c"
++ ClutterClone* _tmp3_;
++ gboolean anim_x;
++ const char* _tmp4_;
++#line 1483 "ease-slide-actor.vala"
++ if (!_tmp2_) {
++#line 1483 "ease-slide-actor.vala"
++ hpos++;
++#line 3348 "ease-slide-actor.c"
++ }
++#line 1483 "ease-slide-actor.vala"
++ _tmp2_ = FALSE;
++#line 1483 "ease-slide-actor.vala"
++ if (!(hpos < EASE_SLIDE_ACTOR_ASSEMBLE_TILES)) {
++#line 1483 "ease-slide-actor.vala"
++ break;
++#line 3356 "ease-slide-actor.c"
++ }
++#line 1486 "ease-slide-actor.vala"
++ i = (vpos * EASE_SLIDE_ACTOR_ASSEMBLE_TILES) + hpos;
++#line 1487 "ease-slide-actor.vala"
++ _data18_->particles[i] = (_tmp3_ = g_object_ref_sink ((ClutterClone*) clutter_clone_new ((ClutterActor*) _data18_->new_slide)), _g_object_unref0 (_data18_->particles[i]), _tmp3_);
++#line 1490 "ease-slide-actor.vala"
++ clutter_actor_set_clip ((ClutterActor*) _data18_->particles[i], hpos * size, vpos * size, size + 1, size + 1);
++#line 1494 "ease-slide-actor.vala"
++ anim_x = FALSE;
++#line 1495 "ease-slide-actor.vala"
++ switch (g_random_int_range ((gint32) 0, (gint32) 4)) {
++#line 3368 "ease-slide-actor.c"
++ case 0:
++ {
++#line 1498 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) _data18_->particles[i], ((-(hpos + 1)) * size) - ease_slide_actor_assemble_extra (self));
++#line 1499 "ease-slide-actor.vala"
++ anim_x = TRUE;
++#line 1500 "ease-slide-actor.vala"
++ break;
++#line 3377 "ease-slide-actor.c"
++ }
++ case 1:
++ {
++#line 1502 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) _data18_->particles[i], ((-(vpos + 1)) * size) - ease_slide_actor_assemble_extra (self));
++#line 1503 "ease-slide-actor.vala"
++ break;
++#line 3385 "ease-slide-actor.c"
++ }
++ case 2:
++ {
++#line 1505 "ease-slide-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) _data18_->particles[i], (((EASE_SLIDE_ACTOR_ASSEMBLE_TILES - hpos) + 1) * size) + ease_slide_actor_assemble_extra (self));
++#line 1507 "ease-slide-actor.vala"
++ anim_x = TRUE;
++#line 1508 "ease-slide-actor.vala"
++ break;
++#line 3395 "ease-slide-actor.c"
++ }
++ case 3:
++ {
++#line 1510 "ease-slide-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) _data18_->particles[i], (((v_count - vpos) + 1) * size) + ease_slide_actor_assemble_extra (self));
++#line 1512 "ease-slide-actor.vala"
++ break;
++#line 3403 "ease-slide-actor.c"
++ }
++ }
++ _tmp4_ = NULL;
++#line 1516 "ease-slide-actor.vala"
++ if (anim_x) {
++#line 1516 "ease-slide-actor.vala"
++ _tmp4_ = "x";
++#line 3411 "ease-slide-actor.c"
++ } else {
++#line 1516 "ease-slide-actor.vala"
++ _tmp4_ = "y";
++#line 3415 "ease-slide-actor.c"
++ }
++#line 1515 "ease-slide-actor.vala"
++ clutter_actor_animate ((ClutterActor*) _data18_->particles[i], (gulong) CLUTTER_EASE_IN_OUT_SINE, length, _tmp4_, 0, NULL);
++#line 1517 "ease-slide-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) _data18_->container, (ClutterActor*) _data18_->particles[i]);
++#line 1518 "ease-slide-actor.vala"
++ clutter_actor_show ((ClutterActor*) _data18_->particles[i]);
++#line 3423 "ease-slide-actor.c"
++ }
++ }
++ }
++ }
++ }
++ }
++#line 1523 "ease-slide-actor.vala"
++ g_signal_connect_data (self->priv->_animation_time, "completed", (GCallback) __lambda51__clutter_timeline_completed, block18_data_ref (_data18_), (GClosureNotify) block18_data_unref, 0);
++#line 3432 "ease-slide-actor.c"
++ block18_data_unref (_data18_);
++}
++
++
++#line 1535 "ease-slide-actor.vala"
++static float ease_slide_actor_assemble_extra (EaseSlideActor* self) {
++#line 3439 "ease-slide-actor.c"
++ float result = 0.0F;
++#line 1535 "ease-slide-actor.vala"
++ g_return_val_if_fail (self != NULL, 0.0F);
++#line 3443 "ease-slide-actor.c"
++ result = (float) g_random_int_range ((gint32) 0, (gint32) 1000);
++#line 1537 "ease-slide-actor.vala"
++ return result;
++#line 3447 "ease-slide-actor.c"
++}
++
++
++#line 1540 "ease-slide-actor.vala"
++static float ease_slide_actor_explode_dist (EaseSlideActor* self) {
++#line 3453 "ease-slide-actor.c"
++ float result = 0.0F;
++#line 1540 "ease-slide-actor.vala"
++ g_return_val_if_fail (self != NULL, 0.0F);
++#line 3457 "ease-slide-actor.c"
++ result = (float) g_random_int_range ((gint32) 10, (gint32) 200);
++#line 1542 "ease-slide-actor.vala"
++ return result;
++#line 3461 "ease-slide-actor.c"
++}
++
++
++#line 1545 "ease-slide-actor.vala"
++static float ease_slide_actor_explode_depth (EaseSlideActor* self) {
++#line 3467 "ease-slide-actor.c"
++ float result = 0.0F;
++#line 1545 "ease-slide-actor.vala"
++ g_return_val_if_fail (self != NULL, 0.0F);
++#line 3471 "ease-slide-actor.c"
++ result = (float) g_random_int_range ((gint32) (-5), (gint32) 50);
++#line 1547 "ease-slide-actor.vala"
++ return result;
++#line 3475 "ease-slide-actor.c"
++}
++
++
++#line 1550 "ease-slide-actor.vala"
++static guint ease_slide_actor_explode_time (EaseSlideActor* self, guint time) {
++#line 3481 "ease-slide-actor.c"
++ guint result = 0U;
++#line 1550 "ease-slide-actor.vala"
++ g_return_val_if_fail (self != NULL, 0U);
++#line 3485 "ease-slide-actor.c"
++ result = (guint) ((0.25 * time) + ((g_random_double () * 0.75) * time));
++#line 1552 "ease-slide-actor.vala"
++ return result;
++#line 3489 "ease-slide-actor.c"
++}
++
++
++#line 1558 "ease-slide-actor.vala"
++static guint8 ease_slide_actor_clamp_opacity (double o) {
++#line 3495 "ease-slide-actor.c"
++ guint8 result = 0U;
++ result = (guint8) ease_dmax ((double) 0, ease_dmin ((double) 255, o));
++#line 1560 "ease-slide-actor.vala"
++ return result;
++#line 3500 "ease-slide-actor.c"
++}
++
++
++#line 25 "ease-slide-actor.vala"
++EaseSlideActor* ease_slide_actor_construct (GType object_type) {
++#line 3506 "ease-slide-actor.c"
++ EaseSlideActor * self;
++ self = g_object_newv (object_type, 0, NULL);
++ return self;
++}
++
++
++#line 25 "ease-slide-actor.vala"
++EaseSlideActor* ease_slide_actor_new (void) {
++#line 25 "ease-slide-actor.vala"
++ return ease_slide_actor_construct (EASE_TYPE_SLIDE_ACTOR);
++#line 3517 "ease-slide-actor.c"
++}
++
++
++EaseSlide* ease_slide_actor_get_slide (EaseSlideActor* self) {
++ EaseSlide* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_slide;
++#line 30 "ease-slide-actor.vala"
++ return result;
++#line 3527 "ease-slide-actor.c"
++}
++
++
++void ease_slide_actor_set_slide (EaseSlideActor* self, EaseSlide* value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_slide = value;
++ g_object_notify ((GObject *) self, "slide");
++}
++
++
++ClutterTimeline* ease_slide_actor_get_animation_time (EaseSlideActor* self) {
++ ClutterTimeline* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_animation_time;
++#line 62 "ease-slide-actor.vala"
++ return result;
++#line 3544 "ease-slide-actor.c"
++}
++
++
++void ease_slide_actor_set_animation_time (EaseSlideActor* self, ClutterTimeline* value) {
++ ClutterTimeline* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_animation_time = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_animation_time), _tmp0_);
++ g_object_notify ((GObject *) self, "animation-time");
++}
++
++
++static ClutterAlpha* ease_slide_actor_get_animation_alpha (EaseSlideActor* self) {
++ ClutterAlpha* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_animation_alpha;
++#line 63 "ease-slide-actor.vala"
++ return result;
++#line 3562 "ease-slide-actor.c"
++}
++
++
++static void ease_slide_actor_set_animation_alpha (EaseSlideActor* self, ClutterAlpha* value) {
++ ClutterAlpha* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_animation_alpha = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_animation_alpha), _tmp0_);
++}
++
++
++static void ease_slide_actor_class_init (EaseSlideActorClass * klass) {
++ ease_slide_actor_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseSlideActorPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_slide_actor_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_slide_actor_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_slide_actor_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_ACTOR_SLIDE, g_param_spec_object ("slide", "slide", "slide", EASE_TYPE_SLIDE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_ACTOR_ANIMATION_TIME, g_param_spec_object ("animation-time", "animation-time", "animation-time", CLUTTER_TYPE_TIMELINE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_signal_new ("ease_actor_removed", EASE_TYPE_SLIDE_ACTOR, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_ACTOR);
++ g_signal_new ("ease_actor_added", EASE_TYPE_SLIDE_ACTOR, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_ACTOR);
++}
++
++
++static void ease_slide_actor_instance_init (EaseSlideActor * self) {
++ self->priv = EASE_SLIDE_ACTOR_GET_PRIVATE (self);
++}
++
++
++static void ease_slide_actor_finalize (GObject* obj) {
++ EaseSlideActor * self;
++ self = EASE_SLIDE_ACTOR (obj);
++ _g_object_unref0 (self->background);
++ _g_object_unref0 (self->contents);
++ _g_object_unref0 (self->priv->_animation_time);
++ _g_object_unref0 (self->priv->_animation_alpha);
++ _g_object_unref0 (self->priv->time1);
++ _g_object_unref0 (self->priv->time2);
++ _g_object_unref0 (self->priv->alpha1);
++ _g_object_unref0 (self->priv->alpha2);
++ G_OBJECT_CLASS (ease_slide_actor_parent_class)->finalize (obj);
++}
++
++
++GType ease_slide_actor_get_type (void) {
++ static volatile gsize ease_slide_actor_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_slide_actor_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseSlideActorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_slide_actor_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseSlideActor), 0, (GInstanceInitFunc) ease_slide_actor_instance_init, NULL };
++ GType ease_slide_actor_type_id;
++ ease_slide_actor_type_id = g_type_register_static (CLUTTER_TYPE_GROUP, "EaseSlideActor", &g_define_type_info, 0);
++ g_once_init_leave (&ease_slide_actor_type_id__volatile, ease_slide_actor_type_id);
++ }
++ return ease_slide_actor_type_id__volatile;
++}
++
++
++static void ease_slide_actor_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseSlideActor * self;
++ self = EASE_SLIDE_ACTOR (object);
++ switch (property_id) {
++ case EASE_SLIDE_ACTOR_SLIDE:
++ g_value_set_object (value, ease_slide_actor_get_slide (self));
++ break;
++ case EASE_SLIDE_ACTOR_ANIMATION_TIME:
++ g_value_set_object (value, ease_slide_actor_get_animation_time (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_slide_actor_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseSlideActor * self;
++ self = EASE_SLIDE_ACTOR (object);
++ switch (property_id) {
++ case EASE_SLIDE_ACTOR_SLIDE:
++ ease_slide_actor_set_slide (self, g_value_get_object (value));
++ break;
++ case EASE_SLIDE_ACTOR_ANIMATION_TIME:
++ ease_slide_actor_set_animation_time (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, gint array_length, GDestroyNotify destroy_func) {
++ if ((array != NULL) && (destroy_func != NULL)) {
++ int 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, gint array_length, GDestroyNotify destroy_func) {
++ _vala_array_destroy (array, array_length, destroy_func);
++ g_free (array);
++}
++
++
++
++
diff --cc ease-core/ease-slide-button-panel.c
index 0000000,0000000..a65343d
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-slide-button-panel.c
@@@ -1,0 -1,0 +1,754 @@@
++/* ease-slide-button-panel.c generated by valac, the Vala compiler
++ * generated from ease-slide-button-panel.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++#include <gdk-pixbuf/gdk-pixdata.h>
++#include <float.h>
++#include <math.h>
++#include <cairo.h>
++#include <glib/gi18n-lib.h>
++#include <glib/gstdio.h>
++
++
++#define EASE_TYPE_SLIDE_BUTTON_PANEL (ease_slide_button_panel_get_type ())
++#define EASE_SLIDE_BUTTON_PANEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_BUTTON_PANEL, EaseSlideButtonPanel))
++#define EASE_SLIDE_BUTTON_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_BUTTON_PANEL, EaseSlideButtonPanelClass))
++#define EASE_IS_SLIDE_BUTTON_PANEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_BUTTON_PANEL))
++#define EASE_IS_SLIDE_BUTTON_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_BUTTON_PANEL))
++#define EASE_SLIDE_BUTTON_PANEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_BUTTON_PANEL, EaseSlideButtonPanelClass))
++
++typedef struct _EaseSlideButtonPanel EaseSlideButtonPanel;
++typedef struct _EaseSlideButtonPanelClass EaseSlideButtonPanelClass;
++typedef struct _EaseSlideButtonPanelPrivate EaseSlideButtonPanelPrivate;
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++
++#define EASE_TYPE_EDITOR_WINDOW (ease_editor_window_get_type ())
++#define EASE_EDITOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindow))
++#define EASE_EDITOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindowClass))
++#define EASE_IS_EDITOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_WINDOW))
++#define EASE_IS_EDITOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_WINDOW))
++#define EASE_EDITOR_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindowClass))
++
++typedef struct _EaseEditorWindow EaseEditorWindow;
++typedef struct _EaseEditorWindowClass EaseEditorWindowClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++typedef struct _EaseDocumentPrivate EaseDocumentPrivate;
++
++#define EASE_ITERABLE_TYPE_LIST_STORE (ease_iterable_list_store_get_type ())
++#define EASE_ITERABLE_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStore))
++#define EASE_ITERABLE_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStoreClass))
++#define EASE_ITERABLE_IS_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_ITERABLE_TYPE_LIST_STORE))
++#define EASE_ITERABLE_IS_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_ITERABLE_TYPE_LIST_STORE))
++#define EASE_ITERABLE_LIST_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStoreClass))
++
++typedef struct _EaseIterableListStore EaseIterableListStore;
++typedef struct _EaseIterableListStoreClass EaseIterableListStoreClass;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++
++#define EASE_ITERABLE_TYPE_TREE_MODEL (ease_iterable_tree_model_get_type ())
++#define EASE_ITERABLE_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_ITERABLE_TYPE_TREE_MODEL, EaseIterableTreeModel))
++#define EASE_ITERABLE_IS_TREE_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_ITERABLE_TYPE_TREE_MODEL))
++#define EASE_ITERABLE_TREE_MODEL_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_ITERABLE_TYPE_TREE_MODEL, EaseIterableTreeModelIface))
++
++typedef struct _EaseIterableTreeModel EaseIterableTreeModel;
++typedef struct _EaseIterableTreeModelIface EaseIterableTreeModelIface;
++
++#define EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR (ease_iterable_tree_model_iterator_get_type ())
++#define EASE_ITERABLE_TREE_MODEL_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR, EaseIterableTreeModelIterator))
++#define EASE_ITERABLE_TREE_MODEL_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR, EaseIterableTreeModelIteratorClass))
++#define EASE_ITERABLE_TREE_MODEL_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR))
++#define EASE_ITERABLE_TREE_MODEL_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR))
++#define EASE_ITERABLE_TREE_MODEL_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_ITERABLE_TREE_MODEL_TYPE_ITERATOR, EaseIterableTreeModelIteratorClass))
++
++typedef struct _EaseIterableTreeModelIterator EaseIterableTreeModelIterator;
++typedef struct _EaseIterableTreeModelIteratorClass EaseIterableTreeModelIteratorClass;
++#define _ease_iterable_tree_model_iterator_unref0(var) ((var == NULL) ? NULL : (var = (ease_iterable_tree_model_iterator_unref (var), NULL)))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL)))
++#define _cairo_surface_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_surface_destroy (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++
++struct _EaseSlideButtonPanel {
++ GtkScrolledWindow parent_instance;
++ EaseSlideButtonPanelPrivate * priv;
++};
++
++struct _EaseSlideButtonPanelClass {
++ GtkScrolledWindowClass parent_class;
++};
++
++struct _EaseSlideButtonPanelPrivate {
++ EaseDocument* document;
++ EaseEditorWindow* owner;
++ GtkTreeView* slides;
++ GtkCellRendererPixbuf* renderer;
++};
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseDocument {
++ GObject parent_instance;
++ EaseDocumentPrivate * priv;
++ EaseIterableListStore* slides;
++};
++
++struct _EaseDocumentClass {
++ GObjectClass parent_class;
++};
++
++struct _EaseIterableTreeModelIface {
++ GTypeInterface parent_iface;
++};
++
++
++static char* ease_slide_button_panel_m_temp_dir;
++static char* ease_slide_button_panel_m_temp_dir = NULL;
++static gint ease_slide_button_panel_temp_count;
++static gint ease_slide_button_panel_temp_count = 0;
++static gpointer ease_slide_button_panel_parent_class = NULL;
++
++GType ease_slide_button_panel_get_type (void) G_GNUC_CONST;
++GType ease_document_get_type (void) G_GNUC_CONST;
++GType ease_editor_window_get_type (void) G_GNUC_CONST;
++#define EASE_SLIDE_BUTTON_PANEL_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_SLIDE_BUTTON_PANEL, EaseSlideButtonPanelPrivate))
++enum {
++ EASE_SLIDE_BUTTON_PANEL_DUMMY_PROPERTY
++};
++#define EASE_SLIDE_BUTTON_PANEL_WIDTH_REQUEST 100
++#define EASE_SLIDE_BUTTON_PANEL_PREV_WIDTH 76
++#define EASE_SLIDE_BUTTON_PANEL_PADDING 4
++#define EASE_DOCUMENT_COL_PIXBUF 1
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_iterable_list_store_get_type (void) G_GNUC_CONST;
++GType ease_slide_get_type (void) G_GNUC_CONST;
++GType ease_iterable_tree_model_get_type (void) G_GNUC_CONST;
++gpointer ease_iterable_tree_model_iterator_ref (gpointer instance);
++void ease_iterable_tree_model_iterator_unref (gpointer instance);
++GParamSpec* ease_iterable_tree_model_param_spec_iterator (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
++void ease_iterable_tree_model_value_set_iterator (GValue* value, gpointer v_object);
++void ease_iterable_tree_model_value_take_iterator (GValue* value, gpointer v_object);
++gpointer ease_iterable_tree_model_value_get_iterator (const GValue* value);
++GType ease_iterable_tree_model_iterator_get_type (void) G_GNUC_CONST;
++EaseIterableTreeModelIterator* ease_iterable_tree_model_iterator (EaseIterableTreeModel* self);
++gboolean ease_iterable_tree_model_iterator_next (EaseIterableTreeModelIterator* self);
++void ease_iterable_tree_model_iterator_get (EaseIterableTreeModelIterator* self, GtkTreeIter* result);
++static void ease_slide_button_panel_slide_redraw (EaseSlideButtonPanel* self, GtkTreeIter* itr);
++#define EASE_DOCUMENT_COL_SLIDE 0
++static void ease_slide_button_panel_on_slide_changed (EaseSlideButtonPanel* self, EaseSlide* slide);
++static void _ease_slide_button_panel_on_slide_changed_ease_slide_changed (EaseSlide* _sender, EaseSlide* _self_, gpointer self);
++void ease_editor_window_set_slide (EaseEditorWindow* self, gint index);
++gint ease_document_index_of (EaseDocument* self, EaseSlide* slide);
++static void _lambda26_ (GtkTreeModel* m, GtkTreePath* p, GtkTreeIter* itr, EaseSlideButtonPanel* self);
++static void __lambda26__gtk_tree_selection_foreach_func (GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, gpointer self);
++static void _lambda25_ (GtkTreeSelection* sender, EaseSlideButtonPanel* self);
++static void __lambda25__gtk_tree_selection_changed (GtkTreeSelection* _sender, gpointer self);
++static void _lambda67_ (EaseSlide* slide, gint index, EaseSlideButtonPanel* self);
++static void __lambda67__ease_document_slide_added (EaseDocument* _sender, EaseSlide* slide, gint index, gpointer self);
++static void _lambda68_ (EaseSlide* slide, gint index, EaseSlideButtonPanel* self);
++static void __lambda68__ease_document_slide_deleted (EaseDocument* _sender, EaseSlide* slide, gint index, gpointer self);
++EaseSlideButtonPanel* ease_slide_button_panel_new (EaseDocument* d, EaseEditorWindow* win);
++EaseSlideButtonPanel* ease_slide_button_panel_construct (GType object_type, EaseDocument* d, EaseEditorWindow* win);
++EaseSlide* ease_slide_new (void);
++EaseSlide* ease_slide_construct (GType object_type);
++void ease_slide_button_panel_select_slide (EaseSlideButtonPanel* self, EaseSlide* slide);
++static GdkPixbuf* ease_slide_button_panel_pixbuf (EaseSlide* slide, gint width);
++EaseDocument* ease_slide_get_parent (EaseSlide* self);
++gint ease_document_get_height (EaseDocument* self);
++gint ease_document_get_width (EaseDocument* self);
++void ease_slide_cairo_render (EaseSlide* self, cairo_t* context, GError** error);
++static const char* ease_slide_button_panel_get_temp_dir (void);
++char* ease_temp_request_str (const char* str, GError** error);
++static void ease_slide_button_panel_finalize (GObject* obj);
++static void ease_slide_button_panel_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 219 "ease-slide-button-panel.vala"
++static void _ease_slide_button_panel_on_slide_changed_ease_slide_changed (EaseSlide* _sender, EaseSlide* _self_, gpointer self) {
++#line 223 "ease-slide-button-panel.c"
++ ease_slide_button_panel_on_slide_changed (self, _self_);
++}
++
++
++#line 102 "ease-slide-button-panel.vala"
++static void _lambda26_ (GtkTreeModel* m, GtkTreePath* p, GtkTreeIter* itr, EaseSlideButtonPanel* self) {
++#line 230 "ease-slide-button-panel.c"
++ EaseSlide* sl;
++#line 102 "ease-slide-button-panel.vala"
++ g_return_if_fail (m != NULL);
++#line 102 "ease-slide-button-panel.vala"
++ g_return_if_fail (p != NULL);
++#line 236 "ease-slide-button-panel.c"
++ sl = NULL;
++#line 104 "ease-slide-button-panel.vala"
++ gtk_tree_model_get (m, itr, EASE_DOCUMENT_COL_SLIDE, &sl, -1);
++#line 105 "ease-slide-button-panel.vala"
++ ease_editor_window_set_slide (self->priv->owner, ease_document_index_of (self->priv->document, sl));
++#line 242 "ease-slide-button-panel.c"
++ _g_object_unref0 (sl);
++}
++
++
++#line 102 "ease-slide-button-panel.vala"
++static void __lambda26__gtk_tree_selection_foreach_func (GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, gpointer self) {
++#line 249 "ease-slide-button-panel.c"
++ _lambda26_ (model, path, iter, self);
++}
++
++
++#line 101 "ease-slide-button-panel.vala"
++static void _lambda25_ (GtkTreeSelection* sender, EaseSlideButtonPanel* self) {
++#line 101 "ease-slide-button-panel.vala"
++ g_return_if_fail (sender != NULL);
++#line 102 "ease-slide-button-panel.vala"
++ gtk_tree_selection_selected_foreach (gtk_tree_view_get_selection (self->priv->slides), __lambda26__gtk_tree_selection_foreach_func, self);
++#line 260 "ease-slide-button-panel.c"
++}
++
++
++#line 101 "ease-slide-button-panel.vala"
++static void __lambda25__gtk_tree_selection_changed (GtkTreeSelection* _sender, gpointer self) {
++#line 266 "ease-slide-button-panel.c"
++ _lambda25_ (_sender, self);
++}
++
++
++#line 109 "ease-slide-button-panel.vala"
++static void _lambda67_ (EaseSlide* slide, gint index, EaseSlideButtonPanel* self) {
++#line 109 "ease-slide-button-panel.vala"
++ g_return_if_fail (slide != NULL);
++#line 110 "ease-slide-button-panel.vala"
++ ease_slide_button_panel_on_slide_changed (self, slide);
++#line 111 "ease-slide-button-panel.vala"
++ g_signal_connect_object (slide, "changed", (GCallback) _ease_slide_button_panel_on_slide_changed_ease_slide_changed, self, 0);
++#line 279 "ease-slide-button-panel.c"
++}
++
++
++#line 109 "ease-slide-button-panel.vala"
++static void __lambda67__ease_document_slide_added (EaseDocument* _sender, EaseSlide* slide, gint index, gpointer self) {
++#line 285 "ease-slide-button-panel.c"
++ _lambda67_ (slide, index, self);
++}
++
++
++#line 114 "ease-slide-button-panel.vala"
++static void _lambda68_ (EaseSlide* slide, gint index, EaseSlideButtonPanel* self) {
++#line 292 "ease-slide-button-panel.c"
++ guint _tmp0_;
++#line 114 "ease-slide-button-panel.vala"
++ g_return_if_fail (slide != NULL);
++#line 115 "ease-slide-button-panel.vala"
++ g_signal_parse_name ("changed", EASE_TYPE_SLIDE, &_tmp0_, NULL, FALSE);
++#line 115 "ease-slide-button-panel.vala"
++ g_signal_handlers_disconnect_matched (slide, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _ease_slide_button_panel_on_slide_changed_ease_slide_changed, self);
++#line 300 "ease-slide-button-panel.c"
++}
++
++
++#line 114 "ease-slide-button-panel.vala"
++static void __lambda68__ease_document_slide_deleted (EaseDocument* _sender, EaseSlide* slide, gint index, gpointer self) {
++#line 306 "ease-slide-button-panel.c"
++ _lambda68_ (slide, index, self);
++}
++
++
++#line 63 "ease-slide-button-panel.vala"
++EaseSlideButtonPanel* ease_slide_button_panel_construct (GType object_type, EaseDocument* d, EaseEditorWindow* win) {
++#line 313 "ease-slide-button-panel.c"
++ EaseSlideButtonPanel * self;
++ EaseDocument* _tmp0_;
++ EaseEditorWindow* _tmp1_;
++ GtkTreeView* _tmp2_;
++ GtkCellRendererPixbuf* _tmp3_;
++ GtkViewport* viewport;
++ EaseSlide* s;
++#line 63 "ease-slide-button-panel.vala"
++ g_return_val_if_fail (d != NULL, NULL);
++#line 63 "ease-slide-button-panel.vala"
++ g_return_val_if_fail (win != NULL, NULL);
++#line 325 "ease-slide-button-panel.c"
++ self = g_object_newv (object_type, 0, NULL);
++#line 65 "ease-slide-button-panel.vala"
++ self->priv->document = (_tmp0_ = _g_object_ref0 (d), _g_object_unref0 (self->priv->document), _tmp0_);
++#line 66 "ease-slide-button-panel.vala"
++ self->priv->owner = (_tmp1_ = _g_object_ref0 (win), _g_object_unref0 (self->priv->owner), _tmp1_);
++#line 67 "ease-slide-button-panel.vala"
++ g_object_set ((GtkWidget*) self, "width-request", EASE_SLIDE_BUTTON_PANEL_WIDTH_REQUEST, NULL);
++#line 70 "ease-slide-button-panel.vala"
++ g_object_set ((GtkScrolledWindow*) self, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL);
++#line 71 "ease-slide-button-panel.vala"
++ g_object_set ((GtkScrolledWindow*) self, "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
++#line 72 "ease-slide-button-panel.vala"
++ gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow*) self, GTK_SHADOW_IN);
++#line 75 "ease-slide-button-panel.vala"
++ self->priv->slides = (_tmp2_ = g_object_ref_sink ((GtkTreeView*) gtk_tree_view_new ()), _g_object_unref0 (self->priv->slides), _tmp2_);
++#line 76 "ease-slide-button-panel.vala"
++ gtk_tree_view_set_reorderable (self->priv->slides, TRUE);
++#line 77 "ease-slide-button-panel.vala"
++ gtk_tree_view_set_headers_visible (self->priv->slides, FALSE);
++#line 78 "ease-slide-button-panel.vala"
++ self->priv->renderer = (_tmp3_ = g_object_ref_sink ((GtkCellRendererPixbuf*) gtk_cell_renderer_pixbuf_new ()), _g_object_unref0 (self->priv->renderer), _tmp3_);
++#line 79 "ease-slide-button-panel.vala"
++ gtk_cell_renderer_set_padding ((GtkCellRenderer*) self->priv->renderer, EASE_SLIDE_BUTTON_PANEL_PADDING, EASE_SLIDE_BUTTON_PANEL_PADDING);
++#line 80 "ease-slide-button-panel.vala"
++ gtk_tree_view_insert_column_with_attributes (self->priv->slides, -1, "Slides", (GtkCellRenderer*) self->priv->renderer, "pixbuf", EASE_DOCUMENT_COL_PIXBUF, NULL);
++#line 82 "ease-slide-button-panel.vala"
++ gtk_tree_view_set_model (self->priv->slides, (GtkTreeModel*) self->priv->document->slides);
++#line 86 "ease-slide-button-panel.vala"
++ viewport = g_object_ref_sink ((GtkViewport*) gtk_viewport_new (NULL, NULL));
++#line 87 "ease-slide-button-panel.vala"
++ gtk_viewport_set_shadow_type (viewport, GTK_SHADOW_NONE);
++#line 88 "ease-slide-button-panel.vala"
++ gtk_container_add ((GtkContainer*) viewport, (GtkWidget*) self->priv->slides);
++#line 89 "ease-slide-button-panel.vala"
++ gtk_container_add ((GtkContainer*) self, (GtkWidget*) viewport);
++#line 361 "ease-slide-button-panel.c"
++ s = NULL;
++ {
++ EaseIterableTreeModelIterator* _itr_it;
++#line 93 "ease-slide-button-panel.vala"
++ _itr_it = ease_iterable_tree_model_iterator ((EaseIterableTreeModel*) self->priv->document->slides);
++#line 93 "ease-slide-button-panel.vala"
++ while (TRUE) {
++#line 369 "ease-slide-button-panel.c"
++ GtkTreeIter _tmp4_ = {0};
++ GtkTreeIter itr;
++#line 93 "ease-slide-button-panel.vala"
++ if (!ease_iterable_tree_model_iterator_next (_itr_it)) {
++#line 93 "ease-slide-button-panel.vala"
++ break;
++#line 376 "ease-slide-button-panel.c"
++ }
++#line 93 "ease-slide-button-panel.vala"
++ itr = (ease_iterable_tree_model_iterator_get (_itr_it, &_tmp4_), _tmp4_);
++#line 95 "ease-slide-button-panel.vala"
++ ease_slide_button_panel_slide_redraw (self, &itr);
++#line 96 "ease-slide-button-panel.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->priv->document->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &s, -1);
++#line 97 "ease-slide-button-panel.vala"
++ g_signal_connect_object (s, "changed", (GCallback) _ease_slide_button_panel_on_slide_changed_ease_slide_changed, self, 0);
++#line 386 "ease-slide-button-panel.c"
++ }
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++ }
++#line 101 "ease-slide-button-panel.vala"
++ g_signal_connect_object (gtk_tree_view_get_selection (self->priv->slides), "changed", (GCallback) __lambda25__gtk_tree_selection_changed, self, 0);
++#line 109 "ease-slide-button-panel.vala"
++ g_signal_connect_object (self->priv->document, "slide-added", (GCallback) __lambda67__ease_document_slide_added, self, 0);
++#line 114 "ease-slide-button-panel.vala"
++ g_signal_connect_object (self->priv->document, "slide-deleted", (GCallback) __lambda68__ease_document_slide_deleted, self, 0);
++#line 396 "ease-slide-button-panel.c"
++ _g_object_unref0 (viewport);
++ _g_object_unref0 (s);
++ return self;
++}
++
++
++#line 63 "ease-slide-button-panel.vala"
++EaseSlideButtonPanel* ease_slide_button_panel_new (EaseDocument* d, EaseEditorWindow* win) {
++#line 63 "ease-slide-button-panel.vala"
++ return ease_slide_button_panel_construct (EASE_TYPE_SLIDE_BUTTON_PANEL, d, win);
++#line 407 "ease-slide-button-panel.c"
++}
++
++
++#line 138 "ease-slide-button-panel.vala"
++void ease_slide_button_panel_select_slide (EaseSlideButtonPanel* self, EaseSlide* slide) {
++#line 413 "ease-slide-button-panel.c"
++ GtkTreeIter itr = {0};
++ EaseSlide* s;
++#line 138 "ease-slide-button-panel.vala"
++ g_return_if_fail (self != NULL);
++#line 138 "ease-slide-button-panel.vala"
++ g_return_if_fail (slide != NULL);
++#line 141 "ease-slide-button-panel.vala"
++ s = ease_slide_new ();
++#line 142 "ease-slide-button-panel.vala"
++ if (!gtk_tree_model_get_iter_first ((GtkTreeModel*) self->priv->document->slides, &itr)) {
++#line 424 "ease-slide-button-panel.c"
++ _g_object_unref0 (s);
++#line 142 "ease-slide-button-panel.vala"
++ return;
++#line 428 "ease-slide-button-panel.c"
++ }
++ {
++ gboolean _tmp0_;
++#line 143 "ease-slide-button-panel.vala"
++ _tmp0_ = TRUE;
++#line 143 "ease-slide-button-panel.vala"
++ while (TRUE) {
++#line 143 "ease-slide-button-panel.vala"
++ if (!_tmp0_) {
++#line 151 "ease-slide-button-panel.vala"
++ if (!gtk_tree_model_iter_next ((GtkTreeModel*) self->priv->document->slides, &itr)) {
++#line 151 "ease-slide-button-panel.vala"
++ break;
++#line 442 "ease-slide-button-panel.c"
++ }
++ }
++#line 143 "ease-slide-button-panel.vala"
++ _tmp0_ = FALSE;
++#line 145 "ease-slide-button-panel.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->priv->document->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &s, -1);
++#line 146 "ease-slide-button-panel.vala"
++ if (s == slide) {
++#line 148 "ease-slide-button-panel.vala"
++ gtk_tree_selection_select_iter (gtk_tree_view_get_selection (self->priv->slides), &itr);
++#line 149 "ease-slide-button-panel.vala"
++ break;
++#line 455 "ease-slide-button-panel.c"
++ }
++ }
++ }
++ _g_object_unref0 (s);
++}
++
++
++#line 159 "ease-slide-button-panel.vala"
++static void ease_slide_button_panel_slide_redraw (EaseSlideButtonPanel* self, GtkTreeIter* itr) {
++#line 465 "ease-slide-button-panel.c"
++ EaseSlide* slide;
++ GdkPixbuf* pb;
++#line 159 "ease-slide-button-panel.vala"
++ g_return_if_fail (self != NULL);
++#line 470 "ease-slide-button-panel.c"
++ slide = NULL;
++#line 163 "ease-slide-button-panel.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->priv->document->slides, itr, EASE_DOCUMENT_COL_SLIDE, &slide, -1);
++#line 166 "ease-slide-button-panel.vala"
++ pb = ease_slide_button_panel_pixbuf (slide, EASE_SLIDE_BUTTON_PANEL_PREV_WIDTH);
++#line 167 "ease-slide-button-panel.vala"
++ gtk_list_store_set ((GtkListStore*) self->priv->document->slides, itr, EASE_DOCUMENT_COL_PIXBUF, pb, -1);
++#line 478 "ease-slide-button-panel.c"
++ _g_object_unref0 (pb);
++ _g_object_unref0 (slide);
++}
++
++
++#line 175 "ease-slide-button-panel.vala"
++static GdkPixbuf* ease_slide_button_panel_pixbuf (EaseSlide* slide, gint width) {
++#line 486 "ease-slide-button-panel.c"
++ GdkPixbuf* result = NULL;
++ GError * _inner_error_;
++ gint height;
++ cairo_surface_t* surface;
++ cairo_t* context;
++ char* _tmp1_;
++ char* _tmp0_;
++ char* _tmp2_;
++ char* path;
++#line 175 "ease-slide-button-panel.vala"
++ g_return_val_if_fail (slide != NULL, NULL);
++#line 498 "ease-slide-button-panel.c"
++ _inner_error_ = NULL;
++#line 177 "ease-slide-button-panel.vala"
++ height = (gint) ((((float) width) * ease_document_get_height (ease_slide_get_parent (slide))) / ease_document_get_width (ease_slide_get_parent (slide)));
++#line 179 "ease-slide-button-panel.vala"
++ surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, height);
++#line 181 "ease-slide-button-panel.vala"
++ context = cairo_create (surface);
++#line 182 "ease-slide-button-panel.vala"
++ cairo_save (context);
++#line 183 "ease-slide-button-panel.vala"
++ cairo_scale (context, (double) (((float) width) / ease_document_get_width (ease_slide_get_parent (slide))), (double) (((float) height) / ease_document_get_height (ease_slide_get_parent (slide))));
++#line 510 "ease-slide-button-panel.c"
++ {
++#line 188 "ease-slide-button-panel.vala"
++ ease_slide_cairo_render (slide, context, &_inner_error_);
++#line 514 "ease-slide-button-panel.c"
++ if (_inner_error_ != NULL) {
++ goto __catch17_g_error;
++ }
++ }
++ goto __finally17;
++ __catch17_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 192 "ease-slide-button-panel.vala"
++ g_critical (_ ("Error drawing slide preview: %s"), e->message);
++#line 528 "ease-slide-button-panel.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally17:
++ if (_inner_error_ != NULL) {
++ _cairo_destroy0 (context);
++ _cairo_surface_destroy0 (surface);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++#line 196 "ease-slide-button-panel.vala"
++ cairo_restore (context);
++#line 198 "ease-slide-button-panel.vala"
++ cairo_rectangle (context, (double) 0, (double) 0, (double) width, (double) height);
++#line 199 "ease-slide-button-panel.vala"
++ cairo_set_source_rgb (context, (double) 0, (double) 0, (double) 0);
++#line 200 "ease-slide-button-panel.vala"
++ cairo_stroke (context);
++#line 203 "ease-slide-button-panel.vala"
++ path = (_tmp2_ = g_build_filename (ease_slide_button_panel_get_temp_dir (), _tmp1_ = g_strconcat (_tmp0_ = g_strdup_printf ("%i", ease_slide_button_panel_temp_count++), ".png", NULL), NULL), _g_free0 (_tmp1_), _g_free0 (_tmp0_), _tmp2_);
++#line 205 "ease-slide-button-panel.vala"
++ cairo_surface_write_to_png (surface, path);
++#line 552 "ease-slide-button-panel.c"
++ {
++ GdkPixbuf* pb;
++#line 209 "ease-slide-button-panel.vala"
++ pb = gdk_pixbuf_new_from_file (path, &_inner_error_);
++#line 557 "ease-slide-button-panel.c"
++ if (_inner_error_ != NULL) {
++ goto __catch18_g_error;
++ }
++#line 210 "ease-slide-button-panel.vala"
++ g_remove (path);
++#line 563 "ease-slide-button-panel.c"
++ result = pb;
++ _g_free0 (path);
++ _cairo_destroy0 (context);
++ _cairo_surface_destroy0 (surface);
++#line 211 "ease-slide-button-panel.vala"
++ return result;
++#line 570 "ease-slide-button-panel.c"
++ }
++ goto __finally18;
++ __catch18_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 213 "ease-slide-button-panel.vala"
++ g_error ("ease-slide-button-panel.vala:213: %s", e->message);
++#line 581 "ease-slide-button-panel.c"
++ result = NULL;
++ _g_error_free0 (e);
++ _g_free0 (path);
++ _cairo_destroy0 (context);
++ _cairo_surface_destroy0 (surface);
++#line 213 "ease-slide-button-panel.vala"
++ return result;
++#line 589 "ease-slide-button-panel.c"
++ }
++ }
++ __finally18:
++ {
++ _g_free0 (path);
++ _cairo_destroy0 (context);
++ _cairo_surface_destroy0 (surface);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++ _g_free0 (path);
++ _cairo_destroy0 (context);
++ _cairo_surface_destroy0 (surface);
++}
++
++
++#line 219 "ease-slide-button-panel.vala"
++static void ease_slide_button_panel_on_slide_changed (EaseSlideButtonPanel* self, EaseSlide* slide) {
++#line 609 "ease-slide-button-panel.c"
++ EaseSlide* s;
++#line 219 "ease-slide-button-panel.vala"
++ g_return_if_fail (self != NULL);
++#line 219 "ease-slide-button-panel.vala"
++ g_return_if_fail (slide != NULL);
++#line 615 "ease-slide-button-panel.c"
++ s = NULL;
++ {
++ EaseIterableTreeModelIterator* _itr_it;
++#line 222 "ease-slide-button-panel.vala"
++ _itr_it = ease_iterable_tree_model_iterator ((EaseIterableTreeModel*) self->priv->document->slides);
++#line 222 "ease-slide-button-panel.vala"
++ while (TRUE) {
++#line 623 "ease-slide-button-panel.c"
++ GtkTreeIter _tmp0_ = {0};
++ GtkTreeIter itr;
++#line 222 "ease-slide-button-panel.vala"
++ if (!ease_iterable_tree_model_iterator_next (_itr_it)) {
++#line 222 "ease-slide-button-panel.vala"
++ break;
++#line 630 "ease-slide-button-panel.c"
++ }
++#line 222 "ease-slide-button-panel.vala"
++ itr = (ease_iterable_tree_model_iterator_get (_itr_it, &_tmp0_), _tmp0_);
++#line 224 "ease-slide-button-panel.vala"
++ gtk_tree_model_get ((GtkTreeModel*) self->priv->document->slides, &itr, EASE_DOCUMENT_COL_SLIDE, &s, -1);
++#line 225 "ease-slide-button-panel.vala"
++ if (s == slide) {
++#line 227 "ease-slide-button-panel.vala"
++ ease_slide_button_panel_slide_redraw (self, &itr);
++#line 640 "ease-slide-button-panel.c"
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++ _g_object_unref0 (s);
++#line 228 "ease-slide-button-panel.vala"
++ return;
++#line 645 "ease-slide-button-panel.c"
++ }
++ }
++ _ease_iterable_tree_model_iterator_unref0 (_itr_it);
++ }
++ _g_object_unref0 (s);
++}
++
++
++static const char* ease_slide_button_panel_get_temp_dir (void) {
++ GError * _inner_error_;
++ const char* result;
++ _inner_error_ = NULL;
++#line 39 "ease-slide-button-panel.vala"
++ if (ease_slide_button_panel_m_temp_dir != NULL) {
++#line 660 "ease-slide-button-panel.c"
++ result = ease_slide_button_panel_m_temp_dir;
++#line 39 "ease-slide-button-panel.vala"
++ return result;
++#line 664 "ease-slide-button-panel.c"
++ }
++ {
++ char* _tmp0_;
++ char* _tmp1_;
++#line 40 "ease-slide-button-panel.vala"
++ _tmp0_ = ease_temp_request_str ("thumbnails", &_inner_error_);
++#line 671 "ease-slide-button-panel.c"
++ if (_inner_error_ != NULL) {
++ goto __catch19_g_error;
++ }
++ result = ease_slide_button_panel_m_temp_dir = (_tmp1_ = _tmp0_, _g_free0 (ease_slide_button_panel_m_temp_dir), _tmp1_);
++#line 40 "ease-slide-button-panel.vala"
++ return result;
++#line 678 "ease-slide-button-panel.c"
++ }
++ goto __finally19;
++ __catch19_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 43 "ease-slide-button-panel.vala"
++ g_critical ("ease-slide-button-panel.vala:43: Could not create temporary directory " \
++"for thumbnails");
++#line 689 "ease-slide-button-panel.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally19:
++ if (_inner_error_ != NULL) {
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++ result = NULL;
++#line 45 "ease-slide-button-panel.vala"
++ return result;
++#line 702 "ease-slide-button-panel.c"
++}
++
++
++static void ease_slide_button_panel_class_init (EaseSlideButtonPanelClass * klass) {
++ ease_slide_button_panel_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseSlideButtonPanelPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_slide_button_panel_get_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_slide_button_panel_finalize;
++}
++
++
++static void ease_slide_button_panel_instance_init (EaseSlideButtonPanel * self) {
++ self->priv = EASE_SLIDE_BUTTON_PANEL_GET_PRIVATE (self);
++}
++
++
++static void ease_slide_button_panel_finalize (GObject* obj) {
++ EaseSlideButtonPanel * self;
++ self = EASE_SLIDE_BUTTON_PANEL (obj);
++ _g_object_unref0 (self->priv->document);
++ _g_object_unref0 (self->priv->owner);
++ _g_object_unref0 (self->priv->slides);
++ _g_object_unref0 (self->priv->renderer);
++ G_OBJECT_CLASS (ease_slide_button_panel_parent_class)->finalize (obj);
++}
++
++
++GType ease_slide_button_panel_get_type (void) {
++ static volatile gsize ease_slide_button_panel_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_slide_button_panel_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseSlideButtonPanelClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_slide_button_panel_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseSlideButtonPanel), 0, (GInstanceInitFunc) ease_slide_button_panel_instance_init, NULL };
++ GType ease_slide_button_panel_type_id;
++ ease_slide_button_panel_type_id = g_type_register_static (GTK_TYPE_SCROLLED_WINDOW, "EaseSlideButtonPanel", &g_define_type_info, 0);
++ g_once_init_leave (&ease_slide_button_panel_type_id__volatile, ease_slide_button_panel_type_id);
++ }
++ return ease_slide_button_panel_type_id__volatile;
++}
++
++
++static void ease_slide_button_panel_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseSlideButtonPanel * self;
++ self = EASE_SLIDE_BUTTON_PANEL (object);
++ switch (property_id) {
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
diff --cc ease-core/ease-slide.c
index 0000000,0000000..0623530
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-slide.c
@@@ -1,0 -1,0 +1,1978 @@@
++/* ease-slide.c generated by valac, the Vala compiler
++ * generated from ease-slide.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gee.h>
++#include <float.h>
++#include <math.h>
++#include <stdlib.h>
++#include <string.h>
++#include <json-glib/json-glib.h>
++#include <cairo.h>
++#include <gdk-pixbuf/gdk-pixdata.h>
++#include <gdk/gdk.h>
++#include <clutter/clutter.h>
++#include <gtk/gtk.h>
++#include <glib/gi18n-lib.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++typedef struct _EaseSlidePrivate EaseSlidePrivate;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++
++#define EASE_TYPE_TRANSITION (ease_transition_get_type ())
++
++#define EASE_TYPE_TRANSITION_VARIANT (ease_transition_variant_get_type ())
++
++#define EASE_TYPE_BACKGROUND_TYPE (ease_background_type_get_type ())
++
++#define EASE_TYPE_COLOR (ease_color_get_type ())
++#define EASE_COLOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_COLOR, EaseColor))
++#define EASE_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_COLOR, EaseColorClass))
++#define EASE_IS_COLOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_COLOR))
++#define EASE_IS_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_COLOR))
++#define EASE_COLOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_COLOR, EaseColorClass))
++
++typedef struct _EaseColor EaseColor;
++typedef struct _EaseColorClass EaseColorClass;
++
++#define EASE_TYPE_GRADIENT (ease_gradient_get_type ())
++#define EASE_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_GRADIENT, EaseGradient))
++#define EASE_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_GRADIENT, EaseGradientClass))
++#define EASE_IS_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_GRADIENT))
++#define EASE_IS_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_GRADIENT))
++#define EASE_GRADIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_GRADIENT, EaseGradientClass))
++
++typedef struct _EaseGradient EaseGradient;
++typedef struct _EaseGradientClass EaseGradientClass;
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++
++#define EASE_TYPE_THEME (ease_theme_get_type ())
++#define EASE_THEME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_THEME, EaseTheme))
++#define EASE_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_THEME, EaseThemeClass))
++#define EASE_IS_THEME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_THEME))
++#define EASE_IS_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_THEME))
++#define EASE_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_THEME, EaseThemeClass))
++
++typedef struct _EaseTheme EaseTheme;
++typedef struct _EaseThemeClass EaseThemeClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++
++#define EASE_TYPE_MEDIA_ELEMENT (ease_media_element_get_type ())
++#define EASE_MEDIA_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElement))
++#define EASE_MEDIA_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElementClass))
++#define EASE_IS_MEDIA_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_MEDIA_ELEMENT))
++#define EASE_IS_MEDIA_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_MEDIA_ELEMENT))
++#define EASE_MEDIA_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_MEDIA_ELEMENT, EaseMediaElementClass))
++
++typedef struct _EaseMediaElement EaseMediaElement;
++typedef struct _EaseMediaElementClass EaseMediaElementClass;
++
++#define EASE_TYPE_IMAGE_ELEMENT (ease_image_element_get_type ())
++#define EASE_IMAGE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_IMAGE_ELEMENT, EaseImageElement))
++#define EASE_IMAGE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_IMAGE_ELEMENT, EaseImageElementClass))
++#define EASE_IS_IMAGE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_IMAGE_ELEMENT))
++#define EASE_IS_IMAGE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_IMAGE_ELEMENT))
++#define EASE_IMAGE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_IMAGE_ELEMENT, EaseImageElementClass))
++
++typedef struct _EaseImageElement EaseImageElement;
++typedef struct _EaseImageElementClass EaseImageElementClass;
++
++#define EASE_TYPE_TEXT_ELEMENT (ease_text_element_get_type ())
++#define EASE_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElement))
++#define EASE_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++#define EASE_IS_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_IS_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_TEXT_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++
++typedef struct _EaseTextElement EaseTextElement;
++typedef struct _EaseTextElementClass EaseTextElementClass;
++#define _json_object_unref0(var) ((var == NULL) ? NULL : (var = (json_object_unref (var), NULL)))
++#define _json_array_unref0(var) ((var == NULL) ? NULL : (var = (json_array_unref (var), NULL)))
++#define _json_node_free0(var) ((var == NULL) ? NULL : (var = (json_node_free (var), NULL)))
++
++#define EASE_TYPE_HTML_EXPORTER (ease_html_exporter_get_type ())
++#define EASE_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporter))
++#define EASE_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++#define EASE_IS_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_HTML_EXPORTER))
++#define EASE_IS_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_HTML_EXPORTER))
++#define EASE_HTML_EXPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++
++typedef struct _EaseHTMLExporter EaseHTMLExporter;
++typedef struct _EaseHTMLExporterClass EaseHTMLExporterClass;
++typedef struct _EaseDocumentPrivate EaseDocumentPrivate;
++
++#define EASE_ITERABLE_TYPE_LIST_STORE (ease_iterable_list_store_get_type ())
++#define EASE_ITERABLE_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStore))
++#define EASE_ITERABLE_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStoreClass))
++#define EASE_ITERABLE_IS_LIST_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_ITERABLE_TYPE_LIST_STORE))
++#define EASE_ITERABLE_IS_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_ITERABLE_TYPE_LIST_STORE))
++#define EASE_ITERABLE_LIST_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_ITERABLE_TYPE_LIST_STORE, EaseIterableListStoreClass))
++
++typedef struct _EaseIterableListStore EaseIterableListStore;
++typedef struct _EaseIterableListStoreClass EaseIterableListStoreClass;
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseSlide {
++ GObject parent_instance;
++ EaseSlidePrivate * priv;
++ GeeArrayList* elements;
++};
++
++struct _EaseSlideClass {
++ GObjectClass parent_class;
++};
++
++typedef enum {
++ EASE_TRANSITION_NONE,
++ EASE_TRANSITION_FADE,
++ EASE_TRANSITION_SLIDE,
++ EASE_TRANSITION_DROP,
++ EASE_TRANSITION_PIVOT,
++ EASE_TRANSITION_FLIP,
++ EASE_TRANSITION_REVOLVING_DOOR,
++ EASE_TRANSITION_REVEAL,
++ EASE_TRANSITION_FALL,
++ EASE_TRANSITION_SLATS,
++ EASE_TRANSITION_OPEN_DOOR,
++ EASE_TRANSITION_EXPLODE,
++ EASE_TRANSITION_ASSEMBLE,
++ EASE_TRANSITION_ZOOM,
++ EASE_TRANSITION_PANEL,
++ EASE_TRANSITION_SPIN_CONTENTS,
++ EASE_TRANSITION_SPRING_CONTENTS,
++ EASE_TRANSITION_SWING_CONTENTS,
++ EASE_TRANSITION_SLIDE_CONTENTS,
++ EASE_TRANSITION_ZOOM_CONTENTS
++} EaseTransition;
++
++typedef enum {
++ EASE_TRANSITION_VARIANT_LEFT,
++ EASE_TRANSITION_VARIANT_RIGHT,
++ EASE_TRANSITION_VARIANT_UP,
++ EASE_TRANSITION_VARIANT_DOWN,
++ EASE_TRANSITION_VARIANT_BOTTOM,
++ EASE_TRANSITION_VARIANT_TOP,
++ EASE_TRANSITION_VARIANT_CENTER,
++ EASE_TRANSITION_VARIANT_TOP_LEFT,
++ EASE_TRANSITION_VARIANT_TOP_RIGHT,
++ EASE_TRANSITION_VARIANT_BOTTOM_LEFT,
++ EASE_TRANSITION_VARIANT_BOTTOM_RIGHT,
++ EASE_TRANSITION_VARIANT_TOP_TO_BOTTOM,
++ EASE_TRANSITION_VARIANT_BOTTOM_TO_TOP,
++ EASE_TRANSITION_VARIANT_LEFT_TO_RIGHT,
++ EASE_TRANSITION_VARIANT_RIGHT_TO_LEFT,
++ EASE_TRANSITION_VARIANT_IN,
++ EASE_TRANSITION_VARIANT_OUT
++} EaseTransitionVariant;
++
++typedef enum {
++ EASE_BACKGROUND_TYPE_COLOR,
++ EASE_BACKGROUND_TYPE_GRADIENT,
++ EASE_BACKGROUND_TYPE_IMAGE
++} EaseBackgroundType;
++
++struct _EaseSlidePrivate {
++ EaseTransition _transition;
++ EaseTransitionVariant _variant;
++ double _transition_time;
++ gboolean _automatically_advance;
++ double _advance_delay;
++ EaseBackgroundType _background_type;
++ EaseColor* background_color_priv;
++ EaseGradient* background_gradient_priv;
++ char* _background_image;
++ char* _background_image_source;
++ char* _title;
++ EaseDocument* _parent;
++ EaseTheme* _theme;
++};
++
++struct _EaseDocument {
++ GObject parent_instance;
++ EaseDocumentPrivate * priv;
++ EaseIterableListStore* slides;
++};
++
++struct _EaseDocumentClass {
++ GObjectClass parent_class;
++};
++
++
++static gpointer ease_slide_parent_class = NULL;
++static EaseUndoSourceIface* ease_slide_ease_undo_source_parent_iface = NULL;
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_slide_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++GType ease_transition_get_type (void) G_GNUC_CONST;
++GType ease_transition_variant_get_type (void) G_GNUC_CONST;
++GType ease_background_type_get_type (void) G_GNUC_CONST;
++GType ease_color_get_type (void) G_GNUC_CONST;
++GType ease_gradient_get_type (void) G_GNUC_CONST;
++GType ease_document_get_type (void) G_GNUC_CONST;
++GType ease_theme_get_type (void) G_GNUC_CONST;
++#define EASE_SLIDE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_SLIDE, EaseSlidePrivate))
++enum {
++ EASE_SLIDE_DUMMY_PROPERTY,
++ EASE_SLIDE_TRANSITION,
++ EASE_SLIDE_VARIANT,
++ EASE_SLIDE_TRANSITION_TIME,
++ EASE_SLIDE_TRANSITION_MSECS,
++ EASE_SLIDE_AUTOMATICALLY_ADVANCE,
++ EASE_SLIDE_ADVANCE_DELAY,
++ EASE_SLIDE_BACKGROUND_TYPE,
++ EASE_SLIDE_BACKGROUND_COLOR,
++ EASE_SLIDE_BACKGROUND_GRADIENT,
++ EASE_SLIDE_BACKGROUND_IMAGE,
++ EASE_SLIDE_BACKGROUND_IMAGE_SOURCE,
++ EASE_SLIDE_BACKGROUND_ABS,
++ EASE_SLIDE_TITLE,
++ EASE_SLIDE_PARENT,
++ EASE_SLIDE_THEME,
++ EASE_SLIDE_COUNT,
++ EASE_SLIDE_NEXT,
++ EASE_SLIDE_PREVIOUS
++};
++#define EASE_SLIDE_IMAGE_TYPE "EaseImageElement"
++static void _lambda104_ (GObject* a, GParamSpec* b, EaseSlide* self);
++static void __lambda104__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static void _lambda105_ (GObject* a, GParamSpec* b, EaseSlide* self);
++static void __lambda105__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++EaseSlide* ease_slide_new (void);
++EaseSlide* ease_slide_construct (GType object_type);
++void ease_slide_set_parent (EaseSlide* self, EaseDocument* value);
++EaseSlide* ease_slide_new_with_owner (EaseDocument* owner);
++EaseSlide* ease_slide_construct_with_owner (GType object_type, EaseDocument* owner);
++EaseTransition ease_transition_from_string (const char* str);
++void ease_slide_set_transition (EaseSlide* self, EaseTransition value);
++EaseTransitionVariant ease_transition_variant_from_string (const char* str);
++void ease_slide_set_variant (EaseSlide* self, EaseTransitionVariant value);
++void ease_slide_set_transition_time (EaseSlide* self, double value);
++void ease_slide_set_automatically_advance (EaseSlide* self, gboolean value);
++void ease_slide_set_advance_delay (EaseSlide* self, double value);
++void ease_slide_set_title (EaseSlide* self, const char* value);
++#define EASE_THEME_BACKGROUND_IMAGE "background-image"
++void ease_slide_set_background_image (EaseSlide* self, const char* value);
++void ease_slide_set_background_image_source (EaseSlide* self, const char* value);
++#define EASE_THEME_BACKGROUND_COLOR "background-color"
++EaseColor* ease_color_new_from_string (const char* str);
++EaseColor* ease_color_construct_from_string (GType object_type, const char* str);
++void ease_slide_set_background_color (EaseSlide* self, EaseColor* value);
++#define EASE_THEME_BACKGROUND_GRADIENT "background-gradient"
++EaseGradient* ease_gradient_new_from_string (const char* str);
++EaseGradient* ease_gradient_construct_from_string (GType object_type, const char* str);
++void ease_slide_set_background_gradient (EaseSlide* self, EaseGradient* value);
++EaseBackgroundType ease_background_type_from_string (const char* str);
++#define EASE_THEME_BACKGROUND_TYPE "background-type"
++void ease_slide_set_background_type (EaseSlide* self, EaseBackgroundType value);
++#define EASE_THEME_ELEMENT_TYPE "element-type"
++EaseImageElement* ease_image_element_new_from_json (JsonObject* obj);
++EaseImageElement* ease_image_element_construct_from_json (GType object_type, JsonObject* obj);
++GType ease_media_element_get_type (void) G_GNUC_CONST;
++GType ease_image_element_get_type (void) G_GNUC_CONST;
++EaseTextElement* ease_text_element_new_from_json (JsonObject* obj);
++EaseTextElement* ease_text_element_construct_from_json (GType object_type, JsonObject* obj);
++GType ease_text_element_get_type (void) G_GNUC_CONST;
++void ease_element_set_element_type (EaseElement* self, const char* value);
++void ease_slide_add_element (EaseSlide* self, gint index, EaseElement* e);
++gint ease_slide_get_count (EaseSlide* self);
++EaseSlide* ease_slide_new_from_json (JsonObject* obj);
++EaseSlide* ease_slide_construct_from_json (GType object_type, JsonObject* obj);
++EaseTransition ease_slide_get_transition (EaseSlide* self);
++EaseTransitionVariant ease_slide_get_variant (EaseSlide* self);
++double ease_slide_get_transition_time (EaseSlide* self);
++gboolean ease_slide_get_automatically_advance (EaseSlide* self);
++double ease_slide_get_advance_delay (EaseSlide* self);
++const char* ease_slide_get_title (EaseSlide* self);
++const char* ease_slide_get_background_image (EaseSlide* self);
++const char* ease_slide_get_background_image_source (EaseSlide* self);
++EaseColor* ease_slide_get_background_color (EaseSlide* self);
++char* ease_color_to_string (EaseColor* self);
++EaseGradient* ease_slide_get_background_gradient (EaseSlide* self);
++char* ease_gradient_to_string (EaseGradient* self);
++EaseBackgroundType ease_slide_get_background_type (EaseSlide* self);
++char* ease_background_type_to_string (EaseBackgroundType self);
++JsonObject* ease_element_to_json (EaseElement* self);
++JsonNode* ease_slide_to_json (EaseSlide* self);
++void ease_element_set_parent (EaseElement* self, EaseSlide* value);
++void ease_undo_source_listen (EaseUndoSource* self, EaseUndoSource* source);
++void ease_slide_add (EaseSlide* self, EaseElement* e);
++gint ease_slide_index_of (EaseSlide* self, EaseElement* e);
++void ease_undo_source_silence (EaseUndoSource* self, EaseUndoSource* source);
++void ease_slide_remove_element (EaseSlide* self, EaseElement* e);
++void ease_slide_remove_at (EaseSlide* self, gint index);
++EaseElement* ease_slide_element_at (EaseSlide* self, gint i);
++EaseDocument* ease_slide_get_parent (EaseSlide* self);
++void ease_slide_cairo_render_sized (EaseSlide* self, cairo_t* context, gint w, gint h, GError** error);
++gint ease_document_get_width (EaseDocument* self);
++gint ease_document_get_height (EaseDocument* self);
++void ease_slide_cairo_render (EaseSlide* self, cairo_t* context, GError** error);
++void ease_slide_cairo_render_background (EaseSlide* self, cairo_t* cr, gint w, gint h, GError** error);
++void ease_element_cairo_render (EaseElement* self, cairo_t* context, GError** error);
++void ease_color_set_cairo (EaseColor* self, cairo_t* cr);
++void ease_gradient_cairo_render_rect (EaseGradient* self, cairo_t* cr, gint width, gint height);
++char* ease_slide_get_background_abs (EaseSlide* self);
++void ease_color_get_clutter (EaseColor* self, ClutterColor* result);
++GType ease_html_exporter_get_type (void) G_GNUC_CONST;
++char* ease_html_exporter_get_basename (EaseHTMLExporter* self);
++void ease_html_exporter_copy_file (EaseHTMLExporter* self, const char* end_path, const char* base_path);
++const char* ease_document_get_path (EaseDocument* self);
++void ease_element_to_html (EaseElement* self, char** html, EaseHTMLExporter* exporter, double amount);
++void ease_slide_to_html (EaseSlide* self, char** html, EaseHTMLExporter* exporter, double amount, gint index);
++static void ease_slide_bg_changed (EaseSlide* self, GObject* sender);
++guint ease_slide_get_transition_msecs (EaseSlide* self);
++void ease_slide_set_transition_msecs (EaseSlide* self, guint value);
++static void _ease_slide_bg_changed_ease_color_changed (EaseColor* _sender, EaseColor* _self_, gpointer self);
++static void _ease_slide_bg_changed_ease_gradient_changed (EaseGradient* _sender, EaseGradient* _self_, gpointer self);
++EaseTheme* ease_slide_get_theme (EaseSlide* self);
++const char* ease_theme_get_path (EaseTheme* self);
++void ease_slide_set_theme (EaseSlide* self, EaseTheme* value);
++GType ease_iterable_list_store_get_type (void) G_GNUC_CONST;
++gint ease_iterable_list_store_get_size (EaseIterableListStore* self);
++EaseSlide* ease_document_get_slide (EaseDocument* self, gint index);
++EaseSlide* ease_slide_get_next (EaseSlide* self);
++EaseSlide* ease_slide_get_previous (EaseSlide* self);
++static void ease_slide_finalize (GObject* obj);
++static void ease_slide_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_slide_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++#define EASE_THEME_BACKGROUND_TYPE_COLOR "background-type-color"
++#define EASE_THEME_BACKGROUND_TYPE_GRADIENT "background-type-gradient"
++#define EASE_THEME_BACKGROUND_TYPE_IMAGE "background-type-image"
++char* ease_background_type_description (EaseBackgroundType self);
++static int _vala_strcmp0 (const char * str1, const char * str2);
++
++const EaseBackgroundType EASE_BACKGROUND_TYPE_TYPES[3] = {EASE_BACKGROUND_TYPE_COLOR, EASE_BACKGROUND_TYPE_GRADIENT, EASE_BACKGROUND_TYPE_IMAGE};
++
++static void g_cclosure_user_marshal_VOID__OBJECT_OBJECT_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
++
++#line 225 "ease-slide.vala"
++static void _lambda104_ (GObject* a, GParamSpec* b, EaseSlide* self) {
++#line 225 "ease-slide.vala"
++ g_return_if_fail (a != NULL);
++#line 225 "ease-slide.vala"
++ g_return_if_fail (b != NULL);
++#line 225 "ease-slide.vala"
++ g_signal_emit_by_name (self, "background-changed", self);
++#line 414 "ease-slide.c"
++}
++
++
++#line 225 "ease-slide.vala"
++static void __lambda104__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 420 "ease-slide.c"
++ _lambda104_ (_sender, pspec, self);
++}
++
++
++#line 226 "ease-slide.vala"
++static void _lambda105_ (GObject* a, GParamSpec* b, EaseSlide* self) {
++#line 226 "ease-slide.vala"
++ g_return_if_fail (a != NULL);
++#line 226 "ease-slide.vala"
++ g_return_if_fail (b != NULL);
++#line 226 "ease-slide.vala"
++ g_signal_emit_by_name (self, "background-changed", self);
++#line 433 "ease-slide.c"
++}
++
++
++#line 226 "ease-slide.vala"
++static void __lambda105__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 439 "ease-slide.c"
++ _lambda105_ (_sender, pspec, self);
++}
++
++
++#line 223 "ease-slide.vala"
++EaseSlide* ease_slide_construct (GType object_type) {
++#line 446 "ease-slide.c"
++ EaseSlide * self;
++#line 223 "ease-slide.vala"
++ self = (EaseSlide*) g_object_new (object_type, NULL);
++#line 225 "ease-slide.vala"
++ g_signal_connect_object ((GObject*) self, "notify::background-type", (GCallback) __lambda104__g_object_notify, self, 0);
++#line 226 "ease-slide.vala"
++ g_signal_connect_object ((GObject*) self, "notify::background-image", (GCallback) __lambda105__g_object_notify, self, 0);
++#line 454 "ease-slide.c"
++ return self;
++}
++
++
++#line 223 "ease-slide.vala"
++EaseSlide* ease_slide_new (void) {
++#line 223 "ease-slide.vala"
++ return ease_slide_construct (EASE_TYPE_SLIDE);
++#line 463 "ease-slide.c"
++}
++
++
++#line 236 "ease-slide.vala"
++EaseSlide* ease_slide_construct_with_owner (GType object_type, EaseDocument* owner) {
++#line 469 "ease-slide.c"
++ EaseSlide * self;
++#line 236 "ease-slide.vala"
++ g_return_val_if_fail (owner != NULL, NULL);
++#line 238 "ease-slide.vala"
++ self = (EaseSlide*) ease_slide_construct (object_type);
++#line 239 "ease-slide.vala"
++ ease_slide_set_parent (self, owner);
++#line 477 "ease-slide.c"
++ return self;
++}
++
++
++#line 236 "ease-slide.vala"
++EaseSlide* ease_slide_new_with_owner (EaseDocument* owner) {
++#line 236 "ease-slide.vala"
++ return ease_slide_construct_with_owner (EASE_TYPE_SLIDE, owner);
++#line 486 "ease-slide.c"
++}
++
++
++#line 1056 "glib-2.0.vapi"
++static gboolean string_to_bool (const char* self) {
++#line 492 "ease-slide.c"
++ gboolean result = FALSE;
++#line 1056 "glib-2.0.vapi"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 1057 "glib-2.0.vapi"
++ if (_vala_strcmp0 (self, "true") == 0) {
++#line 498 "ease-slide.c"
++ result = TRUE;
++#line 1058 "glib-2.0.vapi"
++ return result;
++#line 502 "ease-slide.c"
++ } else {
++ result = FALSE;
++#line 1060 "glib-2.0.vapi"
++ return result;
++#line 507 "ease-slide.c"
++ }
++}
++
++
++static gpointer _json_array_ref0 (gpointer self) {
++ return self ? json_array_ref (self) : NULL;
++}
++
++
++static gpointer _json_object_ref0 (gpointer self) {
++ return self ? json_object_ref (self) : NULL;
++}
++
++
++#line 245 "ease-slide.vala"
++EaseSlide* ease_slide_construct_from_json (GType object_type, JsonObject* obj) {
++#line 524 "ease-slide.c"
++ EaseSlide * self;
++ EaseSlide* slide;
++ JsonArray* elements;
++#line 245 "ease-slide.vala"
++ g_return_val_if_fail (obj != NULL, NULL);
++#line 247 "ease-slide.vala"
++ self = (EaseSlide*) ease_slide_construct (object_type);
++#line 249 "ease-slide.vala"
++ slide = ease_slide_new ();
++#line 252 "ease-slide.vala"
++ ease_slide_set_transition (self, ease_transition_from_string (json_object_get_string_member (obj, "transition")));
++#line 255 "ease-slide.vala"
++ ease_slide_set_variant (self, ease_transition_variant_from_string (json_object_get_string_member (obj, "variant")));
++#line 258 "ease-slide.vala"
++ ease_slide_set_transition_time (self, g_ascii_strtod (json_object_get_string_member (obj, "transition_time"), NULL));
++#line 260 "ease-slide.vala"
++ ease_slide_set_automatically_advance (self, string_to_bool (json_object_get_string_member (obj, "automatically_advance")));
++#line 263 "ease-slide.vala"
++ ease_slide_set_advance_delay (self, g_ascii_strtod (json_object_get_string_member (obj, "advance_delay"), NULL));
++#line 266 "ease-slide.vala"
++ ease_slide_set_title (self, json_object_get_string_member (obj, "title"));
++#line 269 "ease-slide.vala"
++ if (json_object_has_member (obj, EASE_THEME_BACKGROUND_IMAGE)) {
++#line 271 "ease-slide.vala"
++ ease_slide_set_background_image (self, json_object_get_string_member (obj, EASE_THEME_BACKGROUND_IMAGE));
++#line 272 "ease-slide.vala"
++ ease_slide_set_background_image_source (self, json_object_get_string_member (obj, "background-image-source"));
++#line 552 "ease-slide.c"
++ }
++#line 275 "ease-slide.vala"
++ if (json_object_has_member (obj, EASE_THEME_BACKGROUND_COLOR)) {
++#line 556 "ease-slide.c"
++ EaseColor* _tmp0_;
++#line 277 "ease-slide.vala"
++ ease_slide_set_background_color (self, _tmp0_ = ease_color_new_from_string (json_object_get_string_member (obj, EASE_THEME_BACKGROUND_COLOR)));
++#line 560 "ease-slide.c"
++ _g_object_unref0 (_tmp0_);
++ }
++#line 281 "ease-slide.vala"
++ if (json_object_has_member (obj, EASE_THEME_BACKGROUND_GRADIENT)) {
++#line 565 "ease-slide.c"
++ EaseGradient* _tmp1_;
++#line 283 "ease-slide.vala"
++ ease_slide_set_background_gradient (self, _tmp1_ = ease_gradient_new_from_string (json_object_get_string_member (obj, EASE_THEME_BACKGROUND_GRADIENT)));
++#line 569 "ease-slide.c"
++ _g_object_unref0 (_tmp1_);
++ }
++#line 287 "ease-slide.vala"
++ ease_slide_set_background_type (self, ease_background_type_from_string (json_object_get_string_member (obj, EASE_THEME_BACKGROUND_TYPE)));
++#line 291 "ease-slide.vala"
++ elements = _json_array_ref0 (json_object_get_array_member (obj, "elements"));
++#line 576 "ease-slide.c"
++ {
++ gint i;
++#line 293 "ease-slide.vala"
++ i = 0;
++#line 581 "ease-slide.c"
++ {
++ gboolean _tmp2_;
++#line 293 "ease-slide.vala"
++ _tmp2_ = TRUE;
++#line 293 "ease-slide.vala"
++ while (TRUE) {
++#line 588 "ease-slide.c"
++ JsonObject* node;
++ char* type;
++ EaseElement* e;
++#line 293 "ease-slide.vala"
++ if (!_tmp2_) {
++#line 293 "ease-slide.vala"
++ i++;
++#line 596 "ease-slide.c"
++ }
++#line 293 "ease-slide.vala"
++ _tmp2_ = FALSE;
++#line 293 "ease-slide.vala"
++ if (!(i < json_array_get_length (elements))) {
++#line 293 "ease-slide.vala"
++ break;
++#line 604 "ease-slide.c"
++ }
++#line 295 "ease-slide.vala"
++ node = _json_object_ref0 (json_array_get_object_element (elements, (guint) i));
++#line 298 "ease-slide.vala"
++ type = g_strdup (json_object_get_string_member (node, EASE_THEME_ELEMENT_TYPE));
++#line 610 "ease-slide.c"
++ e = NULL;
++#line 301 "ease-slide.vala"
++ if (_vala_strcmp0 (type, EASE_SLIDE_IMAGE_TYPE) == 0) {
++#line 614 "ease-slide.c"
++ EaseElement* _tmp3_;
++#line 303 "ease-slide.vala"
++ e = (_tmp3_ = (EaseElement*) ease_image_element_new_from_json (node), _g_object_unref0 (e), _tmp3_);
++#line 618 "ease-slide.c"
++ } else {
++ EaseElement* _tmp4_;
++#line 307 "ease-slide.vala"
++ e = (_tmp4_ = (EaseElement*) ease_text_element_new_from_json (node), _g_object_unref0 (e), _tmp4_);
++#line 623 "ease-slide.c"
++ }
++#line 309 "ease-slide.vala"
++ ease_element_set_element_type (e, type);
++#line 310 "ease-slide.vala"
++ ease_slide_add_element (self, ease_slide_get_count (slide), e);
++#line 629 "ease-slide.c"
++ _g_object_unref0 (e);
++ _g_free0 (type);
++ _json_object_unref0 (node);
++ }
++ }
++ }
++ _json_array_unref0 (elements);
++ _g_object_unref0 (slide);
++ return self;
++}
++
++
++#line 245 "ease-slide.vala"
++EaseSlide* ease_slide_new_from_json (JsonObject* obj) {
++#line 245 "ease-slide.vala"
++ return ease_slide_construct_from_json (EASE_TYPE_SLIDE, obj);
++#line 646 "ease-slide.c"
++}
++
++
++#line 687 "glib-2.0.vapi"
++static char* double_to_string (double self) {
++#line 652 "ease-slide.c"
++ char* result = NULL;
++ gint _tmp0__length1;
++ gchar* _tmp0_;
++ char* _tmp1_;
++ result = (_tmp1_ = g_strdup (g_ascii_dtostr ((_tmp0_ = g_new0 (gchar, G_ASCII_DTOSTR_BUF_SIZE), _tmp0__length1 = G_ASCII_DTOSTR_BUF_SIZE, _tmp0_), G_ASCII_DTOSTR_BUF_SIZE, self)), _tmp0_ = (g_free (_tmp0_), NULL), _tmp1_);
++#line 688 "glib-2.0.vapi"
++ return result;
++#line 660 "ease-slide.c"
++}
++
++
++#line 35 "glib-2.0.vapi"
++static char* bool_to_string (gboolean self) {
++#line 666 "ease-slide.c"
++ char* result = NULL;
++#line 36 "glib-2.0.vapi"
++ if (self) {
++#line 670 "ease-slide.c"
++ result = g_strdup ("true");
++#line 37 "glib-2.0.vapi"
++ return result;
++#line 674 "ease-slide.c"
++ } else {
++ result = g_strdup ("false");
++#line 39 "glib-2.0.vapi"
++ return result;
++#line 679 "ease-slide.c"
++ }
++}
++
++
++#line 314 "ease-slide.vala"
++JsonNode* ease_slide_to_json (EaseSlide* self) {
++#line 686 "ease-slide.c"
++ JsonNode* result = NULL;
++ JsonNode* node;
++ JsonObject* obj;
++ GEnumValue* _tmp0_;
++ GEnumValue* _tmp1_;
++ char* _tmp2_;
++ char* _tmp3_;
++ char* _tmp4_;
++ char* _tmp7_;
++ JsonArray* json_elements;
++#line 314 "ease-slide.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 316 "ease-slide.vala"
++ node = json_node_new (JSON_NODE_OBJECT);
++#line 317 "ease-slide.vala"
++ obj = json_object_new ();
++#line 320 "ease-slide.vala"
++ json_object_set_string_member (obj, "transition", (_tmp0_ = g_enum_get_value (g_type_class_ref (EASE_TYPE_TRANSITION), (int) self->priv->_transition), (_tmp0_ != NULL) ? _tmp0_->value_name : NULL));
++#line 321 "ease-slide.vala"
++ json_object_set_string_member (obj, "variant", (_tmp1_ = g_enum_get_value (g_type_class_ref (EASE_TYPE_TRANSITION_VARIANT), (int) self->priv->_variant), (_tmp1_ != NULL) ? _tmp1_->value_name : NULL));
++#line 322 "ease-slide.vala"
++ json_object_set_string_member (obj, "transition_time", _tmp2_ = double_to_string (self->priv->_transition_time));
++#line 709 "ease-slide.c"
++ _g_free0 (_tmp2_);
++#line 323 "ease-slide.vala"
++ json_object_set_string_member (obj, "automatically_advance", _tmp3_ = bool_to_string (self->priv->_automatically_advance));
++#line 713 "ease-slide.c"
++ _g_free0 (_tmp3_);
++#line 325 "ease-slide.vala"
++ json_object_set_string_member (obj, "advance_delay", _tmp4_ = double_to_string (self->priv->_advance_delay));
++#line 717 "ease-slide.c"
++ _g_free0 (_tmp4_);
++#line 326 "ease-slide.vala"
++ json_object_set_string_member (obj, "title", self->priv->_title);
++#line 329 "ease-slide.vala"
++ if (self->priv->_background_image != NULL) {
++#line 331 "ease-slide.vala"
++ json_object_set_string_member (obj, EASE_THEME_BACKGROUND_IMAGE, self->priv->_background_image);
++#line 332 "ease-slide.vala"
++ json_object_set_string_member (obj, "background-image-source", self->priv->_background_image_source);
++#line 727 "ease-slide.c"
++ }
++#line 335 "ease-slide.vala"
++ if (ease_slide_get_background_color (self) != NULL) {
++#line 731 "ease-slide.c"
++ char* _tmp5_;
++#line 337 "ease-slide.vala"
++ json_object_set_string_member (obj, EASE_THEME_BACKGROUND_COLOR, _tmp5_ = ease_color_to_string (ease_slide_get_background_color (self)));
++#line 735 "ease-slide.c"
++ _g_free0 (_tmp5_);
++ }
++#line 340 "ease-slide.vala"
++ if (ease_slide_get_background_gradient (self) != NULL) {
++#line 740 "ease-slide.c"
++ char* _tmp6_;
++#line 342 "ease-slide.vala"
++ json_object_set_string_member (obj, EASE_THEME_BACKGROUND_GRADIENT, _tmp6_ = ease_gradient_to_string (ease_slide_get_background_gradient (self)));
++#line 744 "ease-slide.c"
++ _g_free0 (_tmp6_);
++ }
++#line 345 "ease-slide.vala"
++ json_object_set_string_member (obj, EASE_THEME_BACKGROUND_TYPE, _tmp7_ = ease_background_type_to_string (self->priv->_background_type));
++#line 749 "ease-slide.c"
++ _g_free0 (_tmp7_);
++#line 349 "ease-slide.vala"
++ json_elements = json_array_new ();
++#line 753 "ease-slide.c"
++ {
++ GeeIterator* _e_it;
++#line 350 "ease-slide.vala"
++ _e_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) self->elements);
++#line 350 "ease-slide.vala"
++ while (TRUE) {
++#line 760 "ease-slide.c"
++ EaseElement* e;
++ JsonNode* e_node;
++ JsonObject* _tmp8_;
++#line 350 "ease-slide.vala"
++ if (!gee_iterator_next (_e_it)) {
++#line 350 "ease-slide.vala"
++ break;
++#line 768 "ease-slide.c"
++ }
++#line 350 "ease-slide.vala"
++ e = (EaseElement*) gee_iterator_get (_e_it);
++#line 352 "ease-slide.vala"
++ e_node = json_node_new (JSON_NODE_OBJECT);
++#line 353 "ease-slide.vala"
++ json_node_set_object (e_node, _tmp8_ = ease_element_to_json (e));
++#line 776 "ease-slide.c"
++ _json_object_unref0 (_tmp8_);
++#line 354 "ease-slide.vala"
++ json_array_add_element (json_elements, json_node_copy (e_node));
++#line 780 "ease-slide.c"
++ _json_node_free0 (e_node);
++ _g_object_unref0 (e);
++ }
++ _g_object_unref0 (_e_it);
++ }
++#line 357 "ease-slide.vala"
++ json_object_set_array_member (obj, "elements", _json_array_ref0 (json_elements));
++#line 359 "ease-slide.vala"
++ json_node_set_object (node, obj);
++#line 790 "ease-slide.c"
++ result = node;
++ _json_array_unref0 (json_elements);
++ _json_object_unref0 (obj);
++#line 360 "ease-slide.vala"
++ return result;
++#line 796 "ease-slide.c"
++}
++
++
++#line 369 "ease-slide.vala"
++void ease_slide_add_element (EaseSlide* self, gint index, EaseElement* e) {
++#line 369 "ease-slide.vala"
++ g_return_if_fail (self != NULL);
++#line 369 "ease-slide.vala"
++ g_return_if_fail (e != NULL);
++#line 371 "ease-slide.vala"
++ ease_element_set_parent (e, self);
++#line 372 "ease-slide.vala"
++ gee_abstract_list_insert ((GeeAbstractList*) self->elements, index, e);
++#line 373 "ease-slide.vala"
++ g_signal_emit_by_name (self, "element-added", self, e, index);
++#line 374 "ease-slide.vala"
++ ease_undo_source_listen ((EaseUndoSource*) self, (EaseUndoSource*) e);
++#line 814 "ease-slide.c"
++}
++
++
++#line 382 "ease-slide.vala"
++void ease_slide_add (EaseSlide* self, EaseElement* e) {
++#line 382 "ease-slide.vala"
++ g_return_if_fail (self != NULL);
++#line 382 "ease-slide.vala"
++ g_return_if_fail (e != NULL);
++#line 384 "ease-slide.vala"
++ ease_slide_add_element (self, ease_slide_get_count (self), e);
++#line 826 "ease-slide.c"
++}
++
++
++#line 390 "ease-slide.vala"
++void ease_slide_remove_element (EaseSlide* self, EaseElement* e) {
++#line 832 "ease-slide.c"
++ gint index;
++#line 390 "ease-slide.vala"
++ g_return_if_fail (self != NULL);
++#line 390 "ease-slide.vala"
++ g_return_if_fail (e != NULL);
++#line 392 "ease-slide.vala"
++ index = ease_slide_index_of (self, e);
++#line 393 "ease-slide.vala"
++ gee_abstract_collection_remove ((GeeAbstractCollection*) self->elements, e);
++#line 394 "ease-slide.vala"
++ g_signal_emit_by_name (self, "element-removed", self, e, index);
++#line 395 "ease-slide.vala"
++ ease_undo_source_silence ((EaseUndoSource*) self, (EaseUndoSource*) e);
++#line 846 "ease-slide.c"
++}
++
++
++#line 401 "ease-slide.vala"
++void ease_slide_remove_at (EaseSlide* self, gint index) {
++#line 852 "ease-slide.c"
++ EaseElement* e;
++ EaseElement* _tmp0_;
++#line 401 "ease-slide.vala"
++ g_return_if_fail (self != NULL);
++#line 403 "ease-slide.vala"
++ e = (EaseElement*) gee_abstract_list_get ((GeeAbstractList*) self->elements, index);
++#line 404 "ease-slide.vala"
++ _tmp0_ = (EaseElement*) gee_abstract_list_remove_at ((GeeAbstractList*) self->elements, index);
++#line 861 "ease-slide.c"
++ _g_object_unref0 (_tmp0_);
++#line 405 "ease-slide.vala"
++ g_signal_emit_by_name (self, "element-removed", self, e, index);
++#line 406 "ease-slide.vala"
++ ease_undo_source_silence ((EaseUndoSource*) self, (EaseUndoSource*) e);
++#line 867 "ease-slide.c"
++ _g_object_unref0 (e);
++}
++
++
++#line 412 "ease-slide.vala"
++gint ease_slide_index_of (EaseSlide* self, EaseElement* e) {
++#line 874 "ease-slide.c"
++ gint result = 0;
++#line 412 "ease-slide.vala"
++ g_return_val_if_fail (self != NULL, 0);
++#line 412 "ease-slide.vala"
++ g_return_val_if_fail (e != NULL, 0);
++#line 880 "ease-slide.c"
++ result = gee_abstract_list_index_of ((GeeAbstractList*) self->elements, e);
++#line 414 "ease-slide.vala"
++ return result;
++#line 884 "ease-slide.c"
++}
++
++
++#line 420 "ease-slide.vala"
++EaseElement* ease_slide_element_at (EaseSlide* self, gint i) {
++#line 890 "ease-slide.c"
++ EaseElement* result = NULL;
++#line 420 "ease-slide.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 894 "ease-slide.c"
++ result = (EaseElement*) gee_abstract_list_get ((GeeAbstractList*) self->elements, i);
++#line 422 "ease-slide.vala"
++ return result;
++#line 898 "ease-slide.c"
++}
++
++
++#line 430 "ease-slide.vala"
++void ease_slide_cairo_render (EaseSlide* self, cairo_t* context, GError** error) {
++#line 904 "ease-slide.c"
++ GError * _inner_error_;
++#line 430 "ease-slide.vala"
++ g_return_if_fail (self != NULL);
++#line 430 "ease-slide.vala"
++ g_return_if_fail (context != NULL);
++#line 910 "ease-slide.c"
++ _inner_error_ = NULL;
++#line 432 "ease-slide.vala"
++ if (self->priv->_parent == NULL) {
++#line 914 "ease-slide.c"
++ _inner_error_ = g_error_new ((GQuark) 0, 0, "Slide must have a parent document", NULL);
++ {
++ g_propagate_error (error, _inner_error_);
++ return;
++ }
++ }
++#line 435 "ease-slide.vala"
++ ease_slide_cairo_render_sized (self, context, ease_document_get_width (self->priv->_parent), ease_document_get_height (self->priv->_parent), &_inner_error_);
++#line 923 "ease-slide.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ return;
++ }
++}
++
++
++#line 445 "ease-slide.vala"
++void ease_slide_cairo_render_sized (EaseSlide* self, cairo_t* context, gint w, gint h, GError** error) {
++#line 933 "ease-slide.c"
++ GError * _inner_error_;
++#line 445 "ease-slide.vala"
++ g_return_if_fail (self != NULL);
++#line 445 "ease-slide.vala"
++ g_return_if_fail (context != NULL);
++#line 939 "ease-slide.c"
++ _inner_error_ = NULL;
++#line 448 "ease-slide.vala"
++ ease_slide_cairo_render_background (self, context, w, h, &_inner_error_);
++#line 943 "ease-slide.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ return;
++ }
++ {
++ GeeIterator* _e_it;
++#line 450 "ease-slide.vala"
++ _e_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) self->elements);
++#line 450 "ease-slide.vala"
++ while (TRUE) {
++#line 954 "ease-slide.c"
++ EaseElement* e;
++#line 450 "ease-slide.vala"
++ if (!gee_iterator_next (_e_it)) {
++#line 450 "ease-slide.vala"
++ break;
++#line 960 "ease-slide.c"
++ }
++#line 450 "ease-slide.vala"
++ e = (EaseElement*) gee_iterator_get (_e_it);
++#line 452 "ease-slide.vala"
++ ease_element_cairo_render (e, context, &_inner_error_);
++#line 966 "ease-slide.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (e);
++ _g_object_unref0 (_e_it);
++ return;
++ }
++ _g_object_unref0 (e);
++ }
++ _g_object_unref0 (_e_it);
++ }
++}
++
++
++#line 463 "ease-slide.vala"
++void ease_slide_cairo_render_background (EaseSlide* self, cairo_t* cr, gint w, gint h, GError** error) {
++#line 982 "ease-slide.c"
++ GError * _inner_error_;
++#line 463 "ease-slide.vala"
++ g_return_if_fail (self != NULL);
++#line 463 "ease-slide.vala"
++ g_return_if_fail (cr != NULL);
++#line 988 "ease-slide.c"
++ _inner_error_ = NULL;
++#line 466 "ease-slide.vala"
++ switch (self->priv->_background_type) {
++#line 992 "ease-slide.c"
++ case EASE_BACKGROUND_TYPE_COLOR:
++ {
++#line 469 "ease-slide.vala"
++ cairo_rectangle (cr, (double) 0, (double) 0, (double) w, (double) h);
++#line 470 "ease-slide.vala"
++ ease_color_set_cairo (ease_slide_get_background_color (self), cr);
++#line 471 "ease-slide.vala"
++ cairo_fill (cr);
++#line 472 "ease-slide.vala"
++ break;
++#line 1003 "ease-slide.c"
++ }
++ case EASE_BACKGROUND_TYPE_GRADIENT:
++ {
++#line 474 "ease-slide.vala"
++ ease_gradient_cairo_render_rect (ease_slide_get_background_gradient (self), cr, w, h);
++#line 475 "ease-slide.vala"
++ break;
++#line 1011 "ease-slide.c"
++ }
++ case EASE_BACKGROUND_TYPE_IMAGE:
++ {
++ char* _tmp0_;
++ GdkPixbuf* _tmp1_;
++ GdkPixbuf* pixbuf;
++#line 477 "ease-slide.vala"
++ pixbuf = (_tmp1_ = gdk_pixbuf_new_from_file_at_scale (_tmp0_ = ease_slide_get_background_abs (self), w, h, FALSE, &_inner_error_), _g_free0 (_tmp0_), _tmp1_);
++#line 1020 "ease-slide.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ return;
++ }
++#line 480 "ease-slide.vala"
++ gdk_cairo_set_source_pixbuf (cr, pixbuf, (double) 0, (double) 0);
++#line 481 "ease-slide.vala"
++ cairo_rectangle (cr, (double) 0, (double) 0, (double) w, (double) h);
++#line 482 "ease-slide.vala"
++ cairo_fill (cr);
++#line 1031 "ease-slide.c"
++ _g_object_unref0 (pixbuf);
++#line 483 "ease-slide.vala"
++ break;
++#line 1035 "ease-slide.c"
++ }
++ }
++}
++
++
++#line 1085 "glib-2.0.vapi"
++static char* string_substring (const char* self, glong offset, glong len) {
++#line 1043 "ease-slide.c"
++ char* result = NULL;
++ glong string_length;
++ const char* start;
++#line 1085 "glib-2.0.vapi"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 1086 "glib-2.0.vapi"
++ string_length = g_utf8_strlen (self, -1);
++#line 1087 "glib-2.0.vapi"
++ if (offset < 0) {
++#line 1088 "glib-2.0.vapi"
++ offset = string_length + offset;
++#line 1089 "glib-2.0.vapi"
++ g_return_val_if_fail (offset >= 0, NULL);
++#line 1057 "ease-slide.c"
++ } else {
++#line 1091 "glib-2.0.vapi"
++ g_return_val_if_fail (offset <= string_length, NULL);
++#line 1061 "ease-slide.c"
++ }
++#line 1093 "glib-2.0.vapi"
++ if (len < 0) {
++#line 1094 "glib-2.0.vapi"
++ len = string_length - offset;
++#line 1067 "ease-slide.c"
++ }
++#line 1096 "glib-2.0.vapi"
++ g_return_val_if_fail ((offset + len) <= string_length, NULL);
++#line 1097 "glib-2.0.vapi"
++ start = g_utf8_offset_to_pointer (self, offset);
++#line 1073 "ease-slide.c"
++ result = g_strndup (start, ((gchar*) g_utf8_offset_to_pointer (start, len)) - ((gchar*) start));
++#line 1098 "glib-2.0.vapi"
++ return result;
++#line 1077 "ease-slide.c"
++}
++
++
++#line 497 "ease-slide.vala"
++void ease_slide_to_html (EaseSlide* self, char** html, EaseHTMLExporter* exporter, double amount, gint index) {
++#line 1083 "ease-slide.c"
++ char* _tmp3_;
++ char* _tmp2_;
++ char* _tmp1_;
++ char* _tmp0_;
++ char* _tmp24_;
++#line 497 "ease-slide.vala"
++ g_return_if_fail (self != NULL);
++#line 497 "ease-slide.vala"
++ g_return_if_fail (html != NULL);
++#line 497 "ease-slide.vala"
++ g_return_if_fail (exporter != NULL);
++#line 503 "ease-slide.vala"
++ *html = (_tmp3_ = g_strconcat (*html, _tmp2_ = g_strconcat (_tmp1_ = g_strconcat ("<div class=\"slide\" id=\"slide", _tmp0_ = g_strdup_printf ("%i", index), NULL), "\" ", NULL), NULL), _g_free0 (*html), _tmp3_);
++#line 1097 "ease-slide.c"
++ _g_free0 (_tmp2_);
++ _g_free0 (_tmp1_);
++ _g_free0 (_tmp0_);
++#line 506 "ease-slide.vala"
++ if (self->priv->_background_image == NULL) {
++#line 1103 "ease-slide.c"
++ char* _tmp10_;
++ char* _tmp9_;
++ char* _tmp8_;
++ char* _tmp7_;
++ char* _tmp6_;
++ ClutterColor _tmp5_;
++ ClutterColor _tmp4_ = {0};
++#line 509 "ease-slide.vala"
++ *html = (_tmp10_ = g_strconcat (*html, _tmp9_ = g_strconcat (_tmp8_ = g_strconcat ("style=\"background-color: ", _tmp7_ = string_substring (_tmp6_ = clutter_color_to_string ((_tmp5_ = (ease_color_get_clutter (ease_slide_get_background_color (self), &_tmp4_), _tmp4_), &_tmp5_)), (glong) 0, (glong) 7), NULL), "\">", NULL), NULL), _g_free0 (*html), _tmp10_);
++#line 1113 "ease-slide.c"
++ _g_free0 (_tmp9_);
++ _g_free0 (_tmp8_);
++ _g_free0 (_tmp7_);
++ _g_free0 (_tmp6_);
++ } else {
++ char* _tmp11_;
++ char* _tmp23_;
++ char* _tmp22_;
++ char* _tmp21_;
++ char* _tmp20_;
++ char* _tmp19_;
++ char* _tmp18_;
++ char* _tmp17_;
++ char* _tmp16_;
++ char* _tmp15_;
++ char* _tmp14_;
++ char* _tmp13_;
++ char* _tmp12_;
++#line 516 "ease-slide.vala"
++ *html = (_tmp11_ = g_strconcat (*html, ">", NULL), _g_free0 (*html), _tmp11_);
++#line 519 "ease-slide.vala"
++ *html = (_tmp23_ = g_strconcat (*html, _tmp22_ = g_strconcat (_tmp21_ = g_strconcat (_tmp19_ = g_strconcat (_tmp18_ = g_strconcat (_tmp16_ = g_strconcat (_tmp15_ = g_strconcat (_tmp14_ = g_strconcat (_tmp13_ = g_strconcat ("<img src=\"", _tmp12_ = ease_html_exporter_get_basename (exporter), NULL), " ", NULL), self->priv->_background_image, NULL), "\" alt=\"Background\" width=\"", NULL), _tmp17_ = g_strdup_printf ("%i", ease_document_get_width (self->priv->_parent)), NULL), "\" height=\"", NULL), _tmp20_ = g_strdup_printf ("%i", ease_document_get_height (self->priv->_parent)), NULL), "\"/>", NULL), NULL), _g_free0 (*html), _tmp23_);
++#line 1136 "ease-slide.c"
++ _g_free0 (_tmp22_);
++ _g_free0 (_tmp21_);
++ _g_free0 (_tmp20_);
++ _g_free0 (_tmp19_);
++ _g_free0 (_tmp18_);
++ _g_free0 (_tmp17_);
++ _g_free0 (_tmp16_);
++ _g_free0 (_tmp15_);
++ _g_free0 (_tmp14_);
++ _g_free0 (_tmp13_);
++ _g_free0 (_tmp12_);
++#line 525 "ease-slide.vala"
++ ease_html_exporter_copy_file (exporter, self->priv->_background_image, ease_document_get_path (self->priv->_parent));
++#line 1150 "ease-slide.c"
++ }
++ {
++ GeeIterator* _e_it;
++#line 529 "ease-slide.vala"
++ _e_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) self->elements);
++#line 529 "ease-slide.vala"
++ while (TRUE) {
++#line 1158 "ease-slide.c"
++ EaseElement* e;
++#line 529 "ease-slide.vala"
++ if (!gee_iterator_next (_e_it)) {
++#line 529 "ease-slide.vala"
++ break;
++#line 1164 "ease-slide.c"
++ }
++#line 529 "ease-slide.vala"
++ e = (EaseElement*) gee_iterator_get (_e_it);
++#line 531 "ease-slide.vala"
++ ease_element_to_html (e, html, exporter, amount / gee_collection_get_size ((GeeCollection*) self->elements));
++#line 1170 "ease-slide.c"
++ _g_object_unref0 (e);
++ }
++ _g_object_unref0 (_e_it);
++ }
++#line 534 "ease-slide.vala"
++ *html = (_tmp24_ = g_strconcat (*html, "</div>\n", NULL), _g_free0 (*html), _tmp24_);
++#line 1177 "ease-slide.c"
++}
++
++
++#line 537 "ease-slide.vala"
++static void ease_slide_bg_changed (EaseSlide* self, GObject* sender) {
++#line 537 "ease-slide.vala"
++ g_return_if_fail (self != NULL);
++#line 537 "ease-slide.vala"
++ g_return_if_fail (sender != NULL);
++#line 539 "ease-slide.vala"
++ g_signal_emit_by_name (self, "background-changed", self);
++#line 1189 "ease-slide.c"
++}
++
++
++EaseTransition ease_slide_get_transition (EaseSlide* self) {
++ EaseTransition result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->_transition;
++#line 37 "ease-slide.vala"
++ return result;
++#line 1199 "ease-slide.c"
++}
++
++
++void ease_slide_set_transition (EaseSlide* self, EaseTransition value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_transition = value;
++ g_object_notify ((GObject *) self, "transition");
++}
++
++
++EaseTransitionVariant ease_slide_get_variant (EaseSlide* self) {
++ EaseTransitionVariant result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->_variant;
++#line 42 "ease-slide.vala"
++ return result;
++#line 1216 "ease-slide.c"
++}
++
++
++void ease_slide_set_variant (EaseSlide* self, EaseTransitionVariant value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_variant = value;
++ g_object_notify ((GObject *) self, "variant");
++}
++
++
++double ease_slide_get_transition_time (EaseSlide* self) {
++ double result;
++ g_return_val_if_fail (self != NULL, 0.0);
++ result = self->priv->_transition_time;
++#line 47 "ease-slide.vala"
++ return result;
++#line 1233 "ease-slide.c"
++}
++
++
++void ease_slide_set_transition_time (EaseSlide* self, double value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_transition_time = value;
++ g_object_notify ((GObject *) self, "transition-time");
++}
++
++
++guint ease_slide_get_transition_msecs (EaseSlide* self) {
++ guint result;
++ g_return_val_if_fail (self != NULL, 0U);
++ result = (guint) (self->priv->_transition_time * 1000);
++#line 54 "ease-slide.vala"
++ return result;
++#line 1250 "ease-slide.c"
++}
++
++
++void ease_slide_set_transition_msecs (EaseSlide* self, guint value) {
++ g_return_if_fail (self != NULL);
++#line 55 "ease-slide.vala"
++ ease_slide_set_transition_time (self, (double) (value / 1000.f));
++#line 1258 "ease-slide.c"
++ g_object_notify ((GObject *) self, "transition-msecs");
++}
++
++
++gboolean ease_slide_get_automatically_advance (EaseSlide* self) {
++ gboolean result;
++ g_return_val_if_fail (self != NULL, FALSE);
++ result = self->priv->_automatically_advance;
++#line 61 "ease-slide.vala"
++ return result;
++#line 1269 "ease-slide.c"
++}
++
++
++void ease_slide_set_automatically_advance (EaseSlide* self, gboolean value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_automatically_advance = value;
++ g_object_notify ((GObject *) self, "automatically-advance");
++}
++
++
++double ease_slide_get_advance_delay (EaseSlide* self) {
++ double result;
++ g_return_val_if_fail (self != NULL, 0.0);
++ result = self->priv->_advance_delay;
++#line 66 "ease-slide.vala"
++ return result;
++#line 1286 "ease-slide.c"
++}
++
++
++void ease_slide_set_advance_delay (EaseSlide* self, double value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_advance_delay = value;
++ g_object_notify ((GObject *) self, "advance-delay");
++}
++
++
++EaseBackgroundType ease_slide_get_background_type (EaseSlide* self) {
++ EaseBackgroundType result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->_background_type;
++#line 71 "ease-slide.vala"
++ return result;
++#line 1303 "ease-slide.c"
++}
++
++
++void ease_slide_set_background_type (EaseSlide* self, EaseBackgroundType value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_background_type = value;
++ g_object_notify ((GObject *) self, "background-type");
++}
++
++
++EaseColor* ease_slide_get_background_color (EaseSlide* self) {
++ EaseColor* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->background_color_priv;
++#line 81 "ease-slide.vala"
++ return result;
++#line 1320 "ease-slide.c"
++}
++
++
++#line 537 "ease-slide.vala"
++static void _ease_slide_bg_changed_ease_color_changed (EaseColor* _sender, EaseColor* _self_, gpointer self) {
++#line 1326 "ease-slide.c"
++ ease_slide_bg_changed (self, _self_);
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++void ease_slide_set_background_color (EaseSlide* self, EaseColor* value) {
++ EaseColor* _tmp1_;
++ g_return_if_fail (self != NULL);
++#line 84 "ease-slide.vala"
++ if (self->priv->background_color_priv != NULL) {
++#line 1341 "ease-slide.c"
++ guint _tmp0_;
++#line 86 "ease-slide.vala"
++ g_signal_parse_name ("changed", EASE_TYPE_COLOR, &_tmp0_, NULL, FALSE);
++#line 86 "ease-slide.vala"
++ g_signal_handlers_disconnect_matched (self->priv->background_color_priv, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _ease_slide_bg_changed_ease_color_changed, self);
++#line 1347 "ease-slide.c"
++ }
++#line 89 "ease-slide.vala"
++ self->priv->background_color_priv = (_tmp1_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->background_color_priv), _tmp1_);
++#line 90 "ease-slide.vala"
++ g_signal_connect_object (self->priv->background_color_priv, "changed", (GCallback) _ease_slide_bg_changed_ease_color_changed, self, 0);
++#line 91 "ease-slide.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 1355 "ease-slide.c"
++ g_object_notify ((GObject *) self, "background-color");
++}
++
++
++EaseGradient* ease_slide_get_background_gradient (EaseSlide* self) {
++ EaseGradient* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->background_gradient_priv;
++#line 104 "ease-slide.vala"
++ return result;
++#line 1366 "ease-slide.c"
++}
++
++
++#line 537 "ease-slide.vala"
++static void _ease_slide_bg_changed_ease_gradient_changed (EaseGradient* _sender, EaseGradient* _self_, gpointer self) {
++#line 1372 "ease-slide.c"
++ ease_slide_bg_changed (self, _self_);
++}
++
++
++void ease_slide_set_background_gradient (EaseSlide* self, EaseGradient* value) {
++ EaseGradient* _tmp1_;
++ g_return_if_fail (self != NULL);
++#line 107 "ease-slide.vala"
++ if (self->priv->background_gradient_priv != NULL) {
++#line 1382 "ease-slide.c"
++ guint _tmp0_;
++#line 109 "ease-slide.vala"
++ g_signal_parse_name ("changed", EASE_TYPE_GRADIENT, &_tmp0_, NULL, FALSE);
++#line 109 "ease-slide.vala"
++ g_signal_handlers_disconnect_matched (self->priv->background_gradient_priv, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _ease_slide_bg_changed_ease_gradient_changed, self);
++#line 1388 "ease-slide.c"
++ }
++#line 112 "ease-slide.vala"
++ self->priv->background_gradient_priv = (_tmp1_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->background_gradient_priv), _tmp1_);
++#line 113 "ease-slide.vala"
++ g_signal_connect_object (self->priv->background_gradient_priv, "changed", (GCallback) _ease_slide_bg_changed_ease_gradient_changed, self, 0);
++#line 114 "ease-slide.vala"
++ g_signal_emit_by_name (self, "changed", self);
++#line 1396 "ease-slide.c"
++ g_object_notify ((GObject *) self, "background-gradient");
++}
++
++
++const char* ease_slide_get_background_image (EaseSlide* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_background_image;
++#line 125 "ease-slide.vala"
++ return result;
++#line 1407 "ease-slide.c"
++}
++
++
++void ease_slide_set_background_image (EaseSlide* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_background_image = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_background_image), _tmp0_);
++ g_object_notify ((GObject *) self, "background-image");
++}
++
++
++const char* ease_slide_get_background_image_source (EaseSlide* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_background_image_source;
++#line 130 "ease-slide.vala"
++ return result;
++#line 1425 "ease-slide.c"
++}
++
++
++void ease_slide_set_background_image_source (EaseSlide* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_background_image_source = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_background_image_source), _tmp0_);
++ g_object_notify ((GObject *) self, "background-image-source");
++}
++
++
++char* ease_slide_get_background_abs (EaseSlide* self) {
++ char* result;
++ const char* _tmp0_;
++ char* p;
++ g_return_val_if_fail (self != NULL, NULL);
++ _tmp0_ = NULL;
++#line 139 "ease-slide.vala"
++ if (self->priv->_parent == NULL) {
++#line 139 "ease-slide.vala"
++ _tmp0_ = ease_theme_get_path (self->priv->_theme);
++#line 1447 "ease-slide.c"
++ } else {
++#line 139 "ease-slide.vala"
++ _tmp0_ = ease_document_get_path (self->priv->_parent);
++#line 1451 "ease-slide.c"
++ }
++#line 139 "ease-slide.vala"
++ p = g_strdup (_tmp0_);
++#line 1455 "ease-slide.c"
++ result = g_build_filename (p, self->priv->_background_image, NULL);
++ _g_free0 (p);
++#line 140 "ease-slide.vala"
++ return result;
++#line 1460 "ease-slide.c"
++}
++
++
++const char* ease_slide_get_title (EaseSlide* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_title;
++#line 147 "ease-slide.vala"
++ return result;
++#line 1470 "ease-slide.c"
++}
++
++
++void ease_slide_set_title (EaseSlide* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_title = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_title), _tmp0_);
++ g_object_notify ((GObject *) self, "title");
++}
++
++
++EaseDocument* ease_slide_get_parent (EaseSlide* self) {
++ EaseDocument* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_parent;
++#line 152 "ease-slide.vala"
++ return result;
++#line 1488 "ease-slide.c"
++}
++
++
++void ease_slide_set_parent (EaseSlide* self, EaseDocument* value) {
++ EaseDocument* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_parent = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_parent), _tmp0_);
++ g_object_notify ((GObject *) self, "parent");
++}
++
++
++EaseTheme* ease_slide_get_theme (EaseSlide* self) {
++ EaseTheme* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_theme;
++#line 157 "ease-slide.vala"
++ return result;
++#line 1506 "ease-slide.c"
++}
++
++
++void ease_slide_set_theme (EaseSlide* self, EaseTheme* value) {
++ EaseTheme* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_theme = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_theme), _tmp0_);
++ g_object_notify ((GObject *) self, "theme");
++}
++
++
++gint ease_slide_get_count (EaseSlide* self) {
++ gint result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = gee_collection_get_size ((GeeCollection*) self->elements);
++#line 162 "ease-slide.vala"
++ return result;
++#line 1524 "ease-slide.c"
++}
++
++
++EaseSlide* ease_slide_get_next (EaseSlide* self) {
++ EaseSlide* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ {
++ gint i;
++#line 171 "ease-slide.vala"
++ i = 0;
++#line 1535 "ease-slide.c"
++ {
++ gboolean _tmp0_;
++#line 171 "ease-slide.vala"
++ _tmp0_ = TRUE;
++#line 171 "ease-slide.vala"
++ while (TRUE) {
++#line 1542 "ease-slide.c"
++ EaseSlide* _tmp1_;
++ gboolean _tmp2_;
++#line 171 "ease-slide.vala"
++ if (!_tmp0_) {
++#line 171 "ease-slide.vala"
++ i++;
++#line 1549 "ease-slide.c"
++ }
++#line 171 "ease-slide.vala"
++ _tmp0_ = FALSE;
++#line 171 "ease-slide.vala"
++ if (!(i < (ease_iterable_list_store_get_size (self->priv->_parent->slides) - 1))) {
++#line 171 "ease-slide.vala"
++ break;
++#line 1557 "ease-slide.c"
++ }
++#line 173 "ease-slide.vala"
++ if ((_tmp2_ = (_tmp1_ = ease_document_get_slide (self->priv->_parent, i)) == self, _g_object_unref0 (_tmp1_), _tmp2_)) {
++#line 1561 "ease-slide.c"
++ result = ease_document_get_slide (self->priv->_parent, i + 1);
++#line 175 "ease-slide.vala"
++ return result;
++#line 1565 "ease-slide.c"
++ }
++ }
++ }
++ }
++ result = NULL;
++#line 178 "ease-slide.vala"
++ return result;
++#line 1573 "ease-slide.c"
++}
++
++
++EaseSlide* ease_slide_get_previous (EaseSlide* self) {
++ EaseSlide* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ {
++ gint i;
++#line 189 "ease-slide.vala"
++ i = 1;
++#line 1584 "ease-slide.c"
++ {
++ gboolean _tmp0_;
++#line 189 "ease-slide.vala"
++ _tmp0_ = TRUE;
++#line 189 "ease-slide.vala"
++ while (TRUE) {
++#line 1591 "ease-slide.c"
++ EaseSlide* _tmp1_;
++ gboolean _tmp2_;
++#line 189 "ease-slide.vala"
++ if (!_tmp0_) {
++#line 189 "ease-slide.vala"
++ i++;
++#line 1598 "ease-slide.c"
++ }
++#line 189 "ease-slide.vala"
++ _tmp0_ = FALSE;
++#line 189 "ease-slide.vala"
++ if (!(i < ease_iterable_list_store_get_size (self->priv->_parent->slides))) {
++#line 189 "ease-slide.vala"
++ break;
++#line 1606 "ease-slide.c"
++ }
++#line 191 "ease-slide.vala"
++ if ((_tmp2_ = (_tmp1_ = ease_document_get_slide (self->priv->_parent, i)) == self, _g_object_unref0 (_tmp1_), _tmp2_)) {
++#line 1610 "ease-slide.c"
++ result = ease_document_get_slide (self->priv->_parent, i - 1);
++#line 193 "ease-slide.vala"
++ return result;
++#line 1614 "ease-slide.c"
++ }
++ }
++ }
++ }
++ result = NULL;
++#line 196 "ease-slide.vala"
++ return result;
++#line 1622 "ease-slide.c"
++}
++
++
++static void ease_slide_class_init (EaseSlideClass * klass) {
++ ease_slide_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseSlidePrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_slide_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_slide_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_slide_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_TRANSITION, g_param_spec_enum ("transition", "transition", "transition", EASE_TYPE_TRANSITION, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_VARIANT, g_param_spec_enum ("variant", "variant", "variant", EASE_TYPE_TRANSITION_VARIANT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_TRANSITION_TIME, g_param_spec_double ("transition-time", "transition-time", "transition-time", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_TRANSITION_MSECS, g_param_spec_uint ("transition-msecs", "transition-msecs", "transition-msecs", 0, G_MAXUINT, 0U, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_AUTOMATICALLY_ADVANCE, g_param_spec_boolean ("automatically-advance", "automatically-advance", "automatically-advance", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_ADVANCE_DELAY, g_param_spec_double ("advance-delay", "advance-delay", "advance-delay", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_BACKGROUND_TYPE, g_param_spec_enum ("background-type", "background-type", "background-type", EASE_TYPE_BACKGROUND_TYPE, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_BACKGROUND_COLOR, g_param_spec_object ("background-color", "background-color", "background-color", EASE_TYPE_COLOR, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_BACKGROUND_GRADIENT, g_param_spec_object ("background-gradient", "background-gradient", "background-gradient", EASE_TYPE_GRADIENT, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_BACKGROUND_IMAGE, g_param_spec_string ("background-image", "background-image", "background-image", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_BACKGROUND_IMAGE_SOURCE, g_param_spec_string ("background-image-source", "background-image-source", "background-image-source", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_BACKGROUND_ABS, g_param_spec_string ("background-abs", "background-abs", "background-abs", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_TITLE, g_param_spec_string ("title", "title", "title", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_PARENT, g_param_spec_object ("parent", "parent", "parent", EASE_TYPE_DOCUMENT, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_THEME, g_param_spec_object ("theme", "theme", "theme", EASE_TYPE_THEME, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_COUNT, g_param_spec_int ("count", "count", "count", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_NEXT, g_param_spec_object ("next", "next", "next", EASE_TYPE_SLIDE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_SLIDE_PREVIOUS, g_param_spec_object ("previous", "previous", "previous", EASE_TYPE_SLIDE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
++ g_signal_new ("changed", EASE_TYPE_SLIDE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_SLIDE);
++ g_signal_new ("background_changed", EASE_TYPE_SLIDE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_SLIDE);
++ g_signal_new ("element_added", EASE_TYPE_SLIDE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_OBJECT_INT, G_TYPE_NONE, 3, EASE_TYPE_SLIDE, EASE_TYPE_ELEMENT, G_TYPE_INT);
++ g_signal_new ("element_removed", EASE_TYPE_SLIDE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_OBJECT_INT, G_TYPE_NONE, 3, EASE_TYPE_SLIDE, EASE_TYPE_ELEMENT, G_TYPE_INT);
++}
++
++
++static void ease_slide_ease_undo_source_interface_init (EaseUndoSourceIface * iface) {
++ ease_slide_ease_undo_source_parent_iface = g_type_interface_peek_parent (iface);
++}
++
++
++static void ease_slide_instance_init (EaseSlide * self) {
++ self->priv = EASE_SLIDE_GET_PRIVATE (self);
++ self->elements = gee_array_list_new (EASE_TYPE_ELEMENT, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
++}
++
++
++static void ease_slide_finalize (GObject* obj) {
++ EaseSlide * self;
++ self = EASE_SLIDE (obj);
++ _g_object_unref0 (self->elements);
++ _g_object_unref0 (self->priv->background_color_priv);
++ _g_object_unref0 (self->priv->background_gradient_priv);
++ _g_free0 (self->priv->_background_image);
++ _g_free0 (self->priv->_background_image_source);
++ _g_free0 (self->priv->_title);
++ _g_object_unref0 (self->priv->_parent);
++ _g_object_unref0 (self->priv->_theme);
++ G_OBJECT_CLASS (ease_slide_parent_class)->finalize (obj);
++}
++
++
++GType ease_slide_get_type (void) {
++ static volatile gsize ease_slide_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_slide_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseSlideClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_slide_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseSlide), 0, (GInstanceInitFunc) ease_slide_instance_init, NULL };
++ static const GInterfaceInfo ease_undo_source_info = { (GInterfaceInitFunc) ease_slide_ease_undo_source_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
++ GType ease_slide_type_id;
++ ease_slide_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseSlide", &g_define_type_info, 0);
++ g_type_add_interface_static (ease_slide_type_id, EASE_TYPE_UNDO_SOURCE, &ease_undo_source_info);
++ g_once_init_leave (&ease_slide_type_id__volatile, ease_slide_type_id);
++ }
++ return ease_slide_type_id__volatile;
++}
++
++
++static void ease_slide_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseSlide * self;
++ self = EASE_SLIDE (object);
++ switch (property_id) {
++ case EASE_SLIDE_TRANSITION:
++ g_value_set_enum (value, ease_slide_get_transition (self));
++ break;
++ case EASE_SLIDE_VARIANT:
++ g_value_set_enum (value, ease_slide_get_variant (self));
++ break;
++ case EASE_SLIDE_TRANSITION_TIME:
++ g_value_set_double (value, ease_slide_get_transition_time (self));
++ break;
++ case EASE_SLIDE_TRANSITION_MSECS:
++ g_value_set_uint (value, ease_slide_get_transition_msecs (self));
++ break;
++ case EASE_SLIDE_AUTOMATICALLY_ADVANCE:
++ g_value_set_boolean (value, ease_slide_get_automatically_advance (self));
++ break;
++ case EASE_SLIDE_ADVANCE_DELAY:
++ g_value_set_double (value, ease_slide_get_advance_delay (self));
++ break;
++ case EASE_SLIDE_BACKGROUND_TYPE:
++ g_value_set_enum (value, ease_slide_get_background_type (self));
++ break;
++ case EASE_SLIDE_BACKGROUND_COLOR:
++ g_value_set_object (value, ease_slide_get_background_color (self));
++ break;
++ case EASE_SLIDE_BACKGROUND_GRADIENT:
++ g_value_set_object (value, ease_slide_get_background_gradient (self));
++ break;
++ case EASE_SLIDE_BACKGROUND_IMAGE:
++ g_value_set_string (value, ease_slide_get_background_image (self));
++ break;
++ case EASE_SLIDE_BACKGROUND_IMAGE_SOURCE:
++ g_value_set_string (value, ease_slide_get_background_image_source (self));
++ break;
++ case EASE_SLIDE_BACKGROUND_ABS:
++ g_value_take_string (value, ease_slide_get_background_abs (self));
++ break;
++ case EASE_SLIDE_TITLE:
++ g_value_set_string (value, ease_slide_get_title (self));
++ break;
++ case EASE_SLIDE_PARENT:
++ g_value_set_object (value, ease_slide_get_parent (self));
++ break;
++ case EASE_SLIDE_THEME:
++ g_value_set_object (value, ease_slide_get_theme (self));
++ break;
++ case EASE_SLIDE_COUNT:
++ g_value_set_int (value, ease_slide_get_count (self));
++ break;
++ case EASE_SLIDE_NEXT:
++ g_value_take_object (value, ease_slide_get_next (self));
++ break;
++ case EASE_SLIDE_PREVIOUS:
++ g_value_take_object (value, ease_slide_get_previous (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_slide_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseSlide * self;
++ self = EASE_SLIDE (object);
++ switch (property_id) {
++ case EASE_SLIDE_TRANSITION:
++ ease_slide_set_transition (self, g_value_get_enum (value));
++ break;
++ case EASE_SLIDE_VARIANT:
++ ease_slide_set_variant (self, g_value_get_enum (value));
++ break;
++ case EASE_SLIDE_TRANSITION_TIME:
++ ease_slide_set_transition_time (self, g_value_get_double (value));
++ break;
++ case EASE_SLIDE_TRANSITION_MSECS:
++ ease_slide_set_transition_msecs (self, g_value_get_uint (value));
++ break;
++ case EASE_SLIDE_AUTOMATICALLY_ADVANCE:
++ ease_slide_set_automatically_advance (self, g_value_get_boolean (value));
++ break;
++ case EASE_SLIDE_ADVANCE_DELAY:
++ ease_slide_set_advance_delay (self, g_value_get_double (value));
++ break;
++ case EASE_SLIDE_BACKGROUND_TYPE:
++ ease_slide_set_background_type (self, g_value_get_enum (value));
++ break;
++ case EASE_SLIDE_BACKGROUND_COLOR:
++ ease_slide_set_background_color (self, g_value_get_object (value));
++ break;
++ case EASE_SLIDE_BACKGROUND_GRADIENT:
++ ease_slide_set_background_gradient (self, g_value_get_object (value));
++ break;
++ case EASE_SLIDE_BACKGROUND_IMAGE:
++ ease_slide_set_background_image (self, g_value_get_string (value));
++ break;
++ case EASE_SLIDE_BACKGROUND_IMAGE_SOURCE:
++ ease_slide_set_background_image_source (self, g_value_get_string (value));
++ break;
++ case EASE_SLIDE_TITLE:
++ ease_slide_set_title (self, g_value_get_string (value));
++ break;
++ case EASE_SLIDE_PARENT:
++ ease_slide_set_parent (self, g_value_get_object (value));
++ break;
++ case EASE_SLIDE_THEME:
++ ease_slide_set_theme (self, g_value_get_object (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++#line 554 "ease-slide.vala"
++char* ease_background_type_to_string (EaseBackgroundType self) {
++#line 1817 "ease-slide.c"
++ char* result = NULL;
++#line 556 "ease-slide.vala"
++ switch (self) {
++#line 1821 "ease-slide.c"
++ case EASE_BACKGROUND_TYPE_COLOR:
++ {
++ result = g_strdup (EASE_THEME_BACKGROUND_TYPE_COLOR);
++#line 558 "ease-slide.vala"
++ return result;
++#line 1827 "ease-slide.c"
++ }
++ case EASE_BACKGROUND_TYPE_GRADIENT:
++ {
++ result = g_strdup (EASE_THEME_BACKGROUND_TYPE_GRADIENT);
++#line 559 "ease-slide.vala"
++ return result;
++#line 1834 "ease-slide.c"
++ }
++ case EASE_BACKGROUND_TYPE_IMAGE:
++ {
++ result = g_strdup (EASE_THEME_BACKGROUND_TYPE_IMAGE);
++#line 560 "ease-slide.vala"
++ return result;
++#line 1841 "ease-slide.c"
++ }
++ }
++ result = g_strdup ("undefined");
++#line 562 "ease-slide.vala"
++ return result;
++#line 1847 "ease-slide.c"
++}
++
++
++#line 568 "ease-slide.vala"
++EaseBackgroundType ease_background_type_from_string (const char* str) {
++#line 1853 "ease-slide.c"
++ EaseBackgroundType result = 0;
++ GQuark _tmp1_;
++ const char* _tmp0_;
++#line 568 "ease-slide.vala"
++ g_return_val_if_fail (str != NULL, 0);
++#line 1859 "ease-slide.c"
++ _tmp0_ = str;
++ _tmp1_ = (NULL == _tmp0_) ? 0 : g_quark_from_string (_tmp0_);
++ if (_tmp1_ == g_quark_from_string (EASE_THEME_BACKGROUND_TYPE_COLOR))
++ switch (0) {
++ default:
++ {
++ result = EASE_BACKGROUND_TYPE_COLOR;
++#line 572 "ease-slide.vala"
++ return result;
++#line 1869 "ease-slide.c"
++ }
++ } else if (_tmp1_ == g_quark_from_string (EASE_THEME_BACKGROUND_TYPE_GRADIENT))
++ switch (0) {
++ default:
++ {
++ result = EASE_BACKGROUND_TYPE_GRADIENT;
++#line 573 "ease-slide.vala"
++ return result;
++#line 1878 "ease-slide.c"
++ }
++ } else if (_tmp1_ == g_quark_from_string (EASE_THEME_BACKGROUND_TYPE_IMAGE))
++ switch (0) {
++ default:
++ {
++ result = EASE_BACKGROUND_TYPE_IMAGE;
++#line 574 "ease-slide.vala"
++ return result;
++#line 1887 "ease-slide.c"
++ }
++ }
++#line 577 "ease-slide.vala"
++ g_warning ("ease-slide.vala:577: %s is not a gradient type", str);
++#line 1892 "ease-slide.c"
++ result = EASE_BACKGROUND_TYPE_COLOR;
++#line 578 "ease-slide.vala"
++ return result;
++#line 1896 "ease-slide.c"
++}
++
++
++#line 584 "ease-slide.vala"
++char* ease_background_type_description (EaseBackgroundType self) {
++#line 1902 "ease-slide.c"
++ char* result = NULL;
++#line 586 "ease-slide.vala"
++ switch (self) {
++#line 1906 "ease-slide.c"
++ case EASE_BACKGROUND_TYPE_COLOR:
++ {
++ result = g_strdup (_ ("Solid Color"));
++#line 588 "ease-slide.vala"
++ return result;
++#line 1912 "ease-slide.c"
++ }
++ case EASE_BACKGROUND_TYPE_GRADIENT:
++ {
++ result = g_strdup (_ ("Gradient"));
++#line 589 "ease-slide.vala"
++ return result;
++#line 1919 "ease-slide.c"
++ }
++ case EASE_BACKGROUND_TYPE_IMAGE:
++ {
++ result = g_strdup (_ ("Image"));
++#line 590 "ease-slide.vala"
++ return result;
++#line 1926 "ease-slide.c"
++ }
++ }
++ result = g_strdup ("undefined");
++#line 592 "ease-slide.vala"
++ return result;
++#line 1932 "ease-slide.c"
++}
++
++
++GType ease_background_type_get_type (void) {
++ static volatile gsize ease_background_type_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_background_type_type_id__volatile)) {
++ static const GEnumValue values[] = {{EASE_BACKGROUND_TYPE_COLOR, "EASE_BACKGROUND_TYPE_COLOR", "color"}, {EASE_BACKGROUND_TYPE_GRADIENT, "EASE_BACKGROUND_TYPE_GRADIENT", "gradient"}, {EASE_BACKGROUND_TYPE_IMAGE, "EASE_BACKGROUND_TYPE_IMAGE", "image"}, {0, NULL, NULL}};
++ GType ease_background_type_type_id;
++ ease_background_type_type_id = g_enum_register_static ("EaseBackgroundType", values);
++ g_once_init_leave (&ease_background_type_type_id__volatile, ease_background_type_type_id);
++ }
++ return ease_background_type_type_id__volatile;
++}
++
++
++static int _vala_strcmp0 (const char * str1, const char * str2) {
++ if (str1 == NULL) {
++ return -(str1 != str2);
++ }
++ if (str2 == NULL) {
++ return str1 != str2;
++ }
++ return strcmp (str1, str2);
++}
++
++
++
++static void g_cclosure_user_marshal_VOID__OBJECT_OBJECT_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
++ typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_INT) (gpointer data1, gpointer arg_1, gpointer arg_2, gint arg_3, gpointer data2);
++ register GMarshalFunc_VOID__OBJECT_OBJECT_INT callback;
++ register GCClosure * cc;
++ register gpointer data1, data2;
++ cc = (GCClosure *) closure;
++ g_return_if_fail (n_param_values == 4);
++ 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__OBJECT_OBJECT_INT) (marshal_data ? marshal_data : cc->callback);
++ callback (data1, g_value_get_object (param_values + 1), g_value_get_object (param_values + 2), g_value_get_int (param_values + 3), data2);
++}
++
++
++
diff --cc ease-core/ease-temp.c
index 0000000,0000000..25aca92
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-temp.c
@@@ -1,0 -1,0 +1,683 @@@
++/* ease-temp.c generated by valac, the Vala compiler
++ * generated from ease-temp.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <stdlib.h>
++#include <string.h>
++#include <gee.h>
++#include <gio/gio.h>
++#include <archive.h>
++#include <archive_entry.h>
++#include <sys/stat.h>
++#include <fcntl.h>
++#include <sys/types.h>
++#include <unistd.h>
++#include <glib/gi18n-lib.h>
++
++
++#define EASE_TYPE_TEMP (ease_temp_get_type ())
++#define EASE_TEMP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_TEMP, EaseTemp))
++#define EASE_TEMP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_TEMP, EaseTempClass))
++#define EASE_IS_TEMP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_TEMP))
++#define EASE_IS_TEMP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_TEMP))
++#define EASE_TEMP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_TEMP, EaseTempClass))
++
++typedef struct _EaseTemp EaseTemp;
++typedef struct _EaseTempClass EaseTempClass;
++typedef struct _EaseTempPrivate EaseTempPrivate;
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _archive_read_finish0(var) ((var == NULL) ? NULL : (var = (archive_read_finish (var), NULL)))
++#define _g_dir_close0(var) ((var == NULL) ? NULL : (var = (g_dir_close (var), NULL)))
++#define _archive_entry_free0(var) ((var == NULL) ? NULL : (var = (archive_entry_free (var), NULL)))
++#define _archive_write_finish0(var) ((var == NULL) ? NULL : (var = (archive_write_finish (var), NULL)))
++typedef struct _Block19Data Block19Data;
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++
++struct _EaseTemp {
++ GObject parent_instance;
++ EaseTempPrivate * priv;
++};
++
++struct _EaseTempClass {
++ GObjectClass parent_class;
++};
++
++typedef void (*EaseRecursiveDirAction) (const char* path, const char* full_path, void* user_data, GError** error);
++struct _Block19Data {
++ int _ref_count_;
++ struct archive* archive;
++ gchar* buffer;
++ gint buffer_length1;
++ gint _buffer_size_;
++};
++
++
++static gint ease_temp_index;
++static gint ease_temp_index = 0;
++static char* ease_temp_m_temp;
++static char* ease_temp_m_temp = NULL;
++static GeeLinkedList* ease_temp_m_dirs;
++static GeeLinkedList* ease_temp_m_dirs = NULL;
++static gpointer ease_temp_parent_class = NULL;
++
++GType ease_temp_get_type (void) G_GNUC_CONST;
++enum {
++ EASE_TEMP_DUMMY_PROPERTY
++};
++#define EASE_TEMP_ARCHIVE_BUFFER 4096
++#define EASE_TEMP_TEMP_DIR "ease"
++#define EASE_TEMP_THEME_DIR "themes"
++#define EASE_TEMP_IMG_DIR "svg"
++#define EASE_TEMP_UI_DIR "ui"
++gboolean ease_temp_exists (gint dir, const char* tmp);
++static const char* ease_temp_get_temp (void);
++static GeeLinkedList* ease_temp_get_dirs (void);
++char* ease_temp_request (GError** error);
++char* ease_temp_request_str (const char* str, GError** error);
++char* ease_temp_extract (const char* filename, GError** error);
++void ease_recursive_directory (const char* directory, EaseRecursiveDirAction directory_action, void* directory_action_target, EaseRecursiveDirAction file_action, void* file_action_target, GError** error);
++static void ease_temp_arc_fail (int _result_, struct archive* archive);
++static void _lambda19_ (const char* path, const char* full_path, Block19Data* _data19_, GError** error);
++static void __lambda19__ease_recursive_dir_action (const char* path, const char* full_path, gpointer self, GError** error);
++static Block19Data* block19_data_ref (Block19Data* _data19_);
++static void block19_data_unref (Block19Data* _data19_);
++void ease_temp_archive (const char* temp_path, const char* filename, GError** error);
++void ease_recursive_delete (const char* path, GError** error);
++void ease_temp_clean (void);
++EaseTemp* ease_temp_new (void);
++EaseTemp* ease_temp_construct (GType object_type);
++static void ease_temp_finalize (GObject* obj);
++static void ease_temp_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++
++
++
++#line 70 "ease-temp.vala"
++char* ease_temp_request (GError** error) {
++#line 116 "ease-temp.c"
++ char* result = NULL;
++ GError * _inner_error_;
++ char* _tmp0_;
++ char* _tmp1_;
++ char* tmp;
++ GFile* file;
++ _inner_error_ = NULL;
++#line 73 "ease-temp.vala"
++ while (TRUE) {
++#line 73 "ease-temp.vala"
++ if (!ease_temp_exists (ease_temp_index, ease_temp_get_temp ())) {
++#line 73 "ease-temp.vala"
++ break;
++#line 130 "ease-temp.c"
++ }
++#line 75 "ease-temp.vala"
++ ease_temp_index++;
++#line 134 "ease-temp.c"
++ }
++#line 79 "ease-temp.vala"
++ tmp = (_tmp1_ = g_build_filename (ease_temp_get_temp (), _tmp0_ = g_strdup_printf ("%i", ease_temp_index), NULL), _g_free0 (_tmp0_), _tmp1_);
++#line 82 "ease-temp.vala"
++ gee_deque_offer_head ((GeeDeque*) ease_temp_get_dirs (), tmp);
++#line 85 "ease-temp.vala"
++ file = g_file_new_for_path (tmp);
++#line 86 "ease-temp.vala"
++ g_file_make_directory_with_parents (file, NULL, &_inner_error_);
++#line 144 "ease-temp.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (file);
++ _g_free0 (tmp);
++ return NULL;
++ }
++ result = tmp;
++ _g_object_unref0 (file);
++#line 88 "ease-temp.vala"
++ return result;
++#line 155 "ease-temp.c"
++}
++
++
++#line 102 "ease-temp.vala"
++char* ease_temp_request_str (const char* str, GError** error) {
++#line 161 "ease-temp.c"
++ char* result = NULL;
++ GError * _inner_error_;
++ char* tmp;
++ GFile* file;
++#line 102 "ease-temp.vala"
++ g_return_val_if_fail (str != NULL, NULL);
++#line 168 "ease-temp.c"
++ _inner_error_ = NULL;
++#line 105 "ease-temp.vala"
++ tmp = g_build_filename (ease_temp_get_temp (), str, NULL);
++#line 108 "ease-temp.vala"
++ gee_deque_offer_head ((GeeDeque*) ease_temp_get_dirs (), tmp);
++#line 111 "ease-temp.vala"
++ file = g_file_new_for_path (tmp);
++#line 112 "ease-temp.vala"
++ g_file_make_directory_with_parents (file, NULL, &_inner_error_);
++#line 178 "ease-temp.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (file);
++ _g_free0 (tmp);
++ return NULL;
++ }
++ result = tmp;
++ _g_object_unref0 (file);
++#line 114 "ease-temp.vala"
++ return result;
++#line 189 "ease-temp.c"
++}
++
++
++#line 126 "ease-temp.vala"
++char* ease_temp_extract (const char* filename, GError** error) {
++#line 195 "ease-temp.c"
++ char* result = NULL;
++ GError * _inner_error_;
++ struct archive* archive;
++ char* path;
++ struct archive_entry* entry;
++#line 126 "ease-temp.vala"
++ g_return_val_if_fail (filename != NULL, NULL);
++#line 203 "ease-temp.c"
++ _inner_error_ = NULL;
++#line 129 "ease-temp.vala"
++ archive = archive_read_new ();
++#line 132 "ease-temp.vala"
++ archive_read_support_compression_all (archive);
++#line 133 "ease-temp.vala"
++ archive_read_support_format_all (archive);
++#line 136 "ease-temp.vala"
++ archive_read_open_filename (archive, filename, (gsize) EASE_TEMP_ARCHIVE_BUFFER);
++#line 139 "ease-temp.vala"
++ path = ease_temp_request (&_inner_error_);
++#line 215 "ease-temp.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _archive_read_finish0 (archive);
++ return NULL;
++ }
++ entry = NULL;
++#line 143 "ease-temp.vala"
++ while (TRUE) {
++#line 224 "ease-temp.c"
++ char* fpath;
++ GFile* file;
++#line 143 "ease-temp.vala"
++ if (!(archive_read_next_header (archive, &entry) == ARCHIVE_OK)) {
++#line 143 "ease-temp.vala"
++ break;
++#line 231 "ease-temp.c"
++ }
++#line 145 "ease-temp.vala"
++ fpath = g_build_filename (path, archive_entry_pathname (entry), NULL);
++#line 146 "ease-temp.vala"
++ file = g_file_new_for_path (fpath);
++#line 148 "ease-temp.vala"
++ if (S_ISDIR (archive_entry_mode (entry))) {
++#line 150 "ease-temp.vala"
++ g_file_make_directory_with_parents (file, NULL, &_inner_error_);
++#line 241 "ease-temp.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (file);
++ _g_free0 (fpath);
++ _g_free0 (path);
++ _archive_read_finish0 (archive);
++ return NULL;
++ }
++ } else {
++ GFile* parent;
++ GFileOutputStream* _tmp0_;
++ gint fd;
++#line 154 "ease-temp.vala"
++ parent = g_file_get_parent (file);
++#line 155 "ease-temp.vala"
++ if (!g_file_query_exists (parent, NULL)) {
++#line 157 "ease-temp.vala"
++ g_file_make_directory_with_parents (parent, NULL, &_inner_error_);
++#line 260 "ease-temp.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (parent);
++ _g_object_unref0 (file);
++ _g_free0 (fpath);
++ _g_free0 (path);
++ _archive_read_finish0 (archive);
++ return NULL;
++ }
++ }
++#line 160 "ease-temp.vala"
++ _tmp0_ = g_file_create (file, G_FILE_CREATE_REPLACE_DESTINATION, NULL, &_inner_error_);
++#line 273 "ease-temp.c"
++ _g_object_unref0 (_tmp0_);
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (parent);
++ _g_object_unref0 (file);
++ _g_free0 (fpath);
++ _g_free0 (path);
++ _archive_read_finish0 (archive);
++ return NULL;
++ }
++#line 161 "ease-temp.vala"
++ fd = open (fpath, O_WRONLY, (mode_t) 0644);
++#line 162 "ease-temp.vala"
++ archive_read_data_into_fd (archive, fd);
++#line 163 "ease-temp.vala"
++ close (fd);
++#line 290 "ease-temp.c"
++ _g_object_unref0 (parent);
++ }
++ _g_object_unref0 (file);
++ _g_free0 (fpath);
++ }
++ result = path;
++ _archive_read_finish0 (archive);
++#line 167 "ease-temp.vala"
++ return result;
++#line 300 "ease-temp.c"
++}
++
++
++#line 205 "ease-temp.vala"
++static void _lambda19_ (const char* path, const char* full_path, Block19Data* _data19_, GError** error) {
++#line 306 "ease-temp.c"
++ struct archive_entry* entry;
++ struct stat st = {0};
++ gint fd;
++ gssize len;
++#line 205 "ease-temp.vala"
++ g_return_if_fail (path != NULL);
++#line 205 "ease-temp.vala"
++ g_return_if_fail (full_path != NULL);
++#line 207 "ease-temp.vala"
++ entry = archive_entry_new ();
++#line 208 "ease-temp.vala"
++ archive_entry_set_pathname (entry, path);
++#line 209 "ease-temp.vala"
++ archive_entry_set_perm (entry, (mode_t) 0644);
++#line 211 "ease-temp.vala"
++ stat (full_path, &st);
++#line 212 "ease-temp.vala"
++ archive_entry_copy_stat (entry, &st);
++#line 213 "ease-temp.vala"
++ ease_temp_arc_fail (archive_write_header (_data19_->archive, entry), _data19_->archive);
++#line 216 "ease-temp.vala"
++ fd = open (full_path, O_RDONLY, 0);
++#line 217 "ease-temp.vala"
++ len = read (fd, _data19_->buffer, (gsize) (sizeof (gchar) * EASE_TEMP_ARCHIVE_BUFFER));
++#line 218 "ease-temp.vala"
++ while (TRUE) {
++#line 218 "ease-temp.vala"
++ if (!(len > 0)) {
++#line 218 "ease-temp.vala"
++ break;
++#line 337 "ease-temp.c"
++ }
++#line 220 "ease-temp.vala"
++ archive_write_data (_data19_->archive, _data19_->buffer, (gsize) len);
++#line 221 "ease-temp.vala"
++ len = read (fd, _data19_->buffer, (gsize) (sizeof (gchar) * EASE_TEMP_ARCHIVE_BUFFER));
++#line 343 "ease-temp.c"
++ }
++#line 223 "ease-temp.vala"
++ close (fd);
++#line 224 "ease-temp.vala"
++ ease_temp_arc_fail (archive_write_finish_entry (_data19_->archive), _data19_->archive);
++#line 349 "ease-temp.c"
++ _archive_entry_free0 (entry);
++}
++
++
++#line 205 "ease-temp.vala"
++static void __lambda19__ease_recursive_dir_action (const char* path, const char* full_path, gpointer self, GError** error) {
++#line 356 "ease-temp.c"
++ _lambda19_ (path, full_path, self, error);
++}
++
++
++static Block19Data* block19_data_ref (Block19Data* _data19_) {
++ g_atomic_int_inc (&_data19_->_ref_count_);
++ return _data19_;
++}
++
++
++static void block19_data_unref (Block19Data* _data19_) {
++ if (g_atomic_int_dec_and_test (&_data19_->_ref_count_)) {
++ _data19_->buffer = (g_free (_data19_->buffer), NULL);
++ _archive_write_finish0 (_data19_->archive);
++ g_slice_free (Block19Data, _data19_);
++ }
++}
++
++
++#line 178 "ease-temp.vala"
++void ease_temp_archive (const char* temp_path, const char* filename, GError** error) {
++#line 378 "ease-temp.c"
++ GError * _inner_error_;
++ Block19Data* _data19_;
++ gchar* _tmp0_;
++ GDir* dir;
++#line 178 "ease-temp.vala"
++ g_return_if_fail (temp_path != NULL);
++#line 178 "ease-temp.vala"
++ g_return_if_fail (filename != NULL);
++#line 387 "ease-temp.c"
++ _inner_error_ = NULL;
++ _data19_ = g_slice_new0 (Block19Data);
++ _data19_->_ref_count_ = 1;
++ _data19_->archive = archive_write_new ();
++ _data19_->buffer = (_tmp0_ = g_new0 (gchar, EASE_TEMP_ARCHIVE_BUFFER), _data19_->buffer_length1 = EASE_TEMP_ARCHIVE_BUFFER, _tmp0_);
++#line 185 "ease-temp.vala"
++ archive_write_set_format_pax_restricted (_data19_->archive);
++#line 186 "ease-temp.vala"
++ archive_write_set_compression_none (_data19_->archive);
++#line 189 "ease-temp.vala"
++ if (archive_write_open_filename (_data19_->archive, filename) == ARCHIVE_FAILED) {
++#line 399 "ease-temp.c"
++ _inner_error_ = g_error_new ((GQuark) 0, 0, "Error opening %s", filename, NULL);
++ {
++ g_propagate_error (error, _inner_error_);
++ block19_data_unref (_data19_);
++ return;
++ }
++ }
++#line 195 "ease-temp.vala"
++ dir = g_dir_open (temp_path, (guint) 0, &_inner_error_);
++#line 409 "ease-temp.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ block19_data_unref (_data19_);
++ return;
++ }
++#line 198 "ease-temp.vala"
++ if (dir == NULL) {
++#line 417 "ease-temp.c"
++ _inner_error_ = g_error_new (G_FILE_ERROR, G_FILE_ERROR_NOENT, _ ("Temporary directory doesn't exist: %s"), temp_path);
++ {
++ g_propagate_error (error, _inner_error_);
++ _g_dir_close0 (dir);
++ block19_data_unref (_data19_);
++ return;
++ }
++ }
++#line 205 "ease-temp.vala"
++ ease_recursive_directory (temp_path, NULL, NULL, __lambda19__ease_recursive_dir_action, _data19_, &_inner_error_);
++#line 428 "ease-temp.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_dir_close0 (dir);
++ block19_data_unref (_data19_);
++ return;
++ }
++#line 228 "ease-temp.vala"
++ ease_temp_arc_fail (archive_write_close (_data19_->archive), _data19_->archive);
++#line 437 "ease-temp.c"
++ _g_dir_close0 (dir);
++ block19_data_unref (_data19_);
++}
++
++
++#line 234 "ease-temp.vala"
++static void ease_temp_arc_fail (int _result_, struct archive* archive) {
++#line 234 "ease-temp.vala"
++ g_return_if_fail (archive != NULL);
++#line 236 "ease-temp.vala"
++ if (_result_ != ARCHIVE_OK) {
++#line 236 "ease-temp.vala"
++ g_error ("ease-temp.vala:236: %s", archive_error_string (archive));
++#line 451 "ease-temp.c"
++ }
++}
++
++
++#line 243 "ease-temp.vala"
++void ease_temp_clean (void) {
++#line 458 "ease-temp.c"
++ GError * _inner_error_;
++ char* dir;
++ char* tmp;
++ _inner_error_ = NULL;
++#line 245 "ease-temp.vala"
++ if (ease_temp_get_dirs () == NULL) {
++#line 245 "ease-temp.vala"
++ return;
++#line 467 "ease-temp.c"
++ }
++ dir = NULL;
++#line 248 "ease-temp.vala"
++ while (TRUE) {
++#line 472 "ease-temp.c"
++ char* _tmp0_;
++#line 248 "ease-temp.vala"
++ if (!((dir = (_tmp0_ = (char*) gee_deque_poll_head ((GeeDeque*) ease_temp_get_dirs ()), _g_free0 (dir), _tmp0_)) != NULL)) {
++#line 248 "ease-temp.vala"
++ break;
++#line 478 "ease-temp.c"
++ }
++ {
++#line 250 "ease-temp.vala"
++ ease_recursive_delete (dir, &_inner_error_);
++#line 483 "ease-temp.c"
++ if (_inner_error_ != NULL) {
++ goto __catch20_g_error;
++ }
++ }
++ goto __finally20;
++ __catch20_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 253 "ease-temp.vala"
++ g_debug ("ease-temp.vala:253: %s", e->message);
++#line 497 "ease-temp.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally20:
++ if (_inner_error_ != NULL) {
++ _g_free0 (dir);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++ }
++#line 261 "ease-temp.vala"
++ tmp = g_build_filename (g_get_tmp_dir (), EASE_TEMP_TEMP_DIR, NULL);
++#line 511 "ease-temp.c"
++ {
++ GFile* file;
++ GFile* _tmp1_;
++#line 265 "ease-temp.vala"
++ file = g_file_new_for_path (ease_temp_get_temp ());
++#line 266 "ease-temp.vala"
++ g_file_delete (file, NULL, &_inner_error_);
++#line 519 "ease-temp.c"
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (file);
++ goto __catch21_g_error;
++ }
++#line 269 "ease-temp.vala"
++ file = (_tmp1_ = g_file_new_for_path (tmp), _g_object_unref0 (file), _tmp1_);
++#line 270 "ease-temp.vala"
++ g_file_delete (file, NULL, &_inner_error_);
++#line 528 "ease-temp.c"
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (file);
++ goto __catch21_g_error;
++ }
++ _g_object_unref0 (file);
++ }
++ goto __finally21;
++ __catch21_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++ _g_error_free0 (e);
++ }
++ }
++ __finally21:
++ if (_inner_error_ != NULL) {
++ _g_free0 (tmp);
++ _g_free0 (dir);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++ _g_free0 (tmp);
++ _g_free0 (dir);
++}
++
++
++#line 281 "ease-temp.vala"
++gboolean ease_temp_exists (gint dir, const char* tmp) {
++#line 560 "ease-temp.c"
++ gboolean result = FALSE;
++ char* _tmp0_;
++ char* _tmp1_;
++ char* dir_tmp;
++ GFile* file;
++#line 281 "ease-temp.vala"
++ g_return_val_if_fail (tmp != NULL, FALSE);
++#line 283 "ease-temp.vala"
++ dir_tmp = (_tmp1_ = g_build_filename (tmp, _tmp0_ = g_strdup_printf ("%i", dir), NULL), _g_free0 (_tmp0_), _tmp1_);
++#line 284 "ease-temp.vala"
++ file = g_file_new_for_path (dir_tmp);
++#line 572 "ease-temp.c"
++ result = g_file_query_exists (file, NULL);
++ _g_object_unref0 (file);
++ _g_free0 (dir_tmp);
++#line 286 "ease-temp.vala"
++ return result;
++#line 578 "ease-temp.c"
++}
++
++
++#line 31 "ease-temp.vala"
++EaseTemp* ease_temp_construct (GType object_type) {
++#line 584 "ease-temp.c"
++ EaseTemp * self;
++#line 31 "ease-temp.vala"
++ self = (EaseTemp*) g_object_new (object_type, NULL);
++#line 588 "ease-temp.c"
++ return self;
++}
++
++
++#line 31 "ease-temp.vala"
++EaseTemp* ease_temp_new (void) {
++#line 31 "ease-temp.vala"
++ return ease_temp_construct (EASE_TYPE_TEMP);
++#line 597 "ease-temp.c"
++}
++
++
++static const char* ease_temp_get_temp (void) {
++ const char* result;
++ char* _tmp1_;
++ char* _tmp0_;
++#line 40 "ease-temp.vala"
++ if (ease_temp_m_temp != NULL) {
++#line 607 "ease-temp.c"
++ result = ease_temp_m_temp;
++#line 40 "ease-temp.vala"
++ return result;
++#line 611 "ease-temp.c"
++ }
++#line 41 "ease-temp.vala"
++ ease_temp_m_temp = (_tmp1_ = g_build_filename (g_get_tmp_dir (), EASE_TEMP_TEMP_DIR, _tmp0_ = g_strdup_printf ("%i", (gint) getpid ()), NULL), _g_free0 (ease_temp_m_temp), _tmp1_);
++#line 615 "ease-temp.c"
++ _g_free0 (_tmp0_);
++ result = ease_temp_m_temp;
++#line 43 "ease-temp.vala"
++ return result;
++#line 620 "ease-temp.c"
++}
++
++
++static GeeLinkedList* ease_temp_get_dirs (void) {
++ GeeLinkedList* result;
++ GeeLinkedList* _tmp0_;
++#line 52 "ease-temp.vala"
++ if (ease_temp_m_dirs != NULL) {
++#line 629 "ease-temp.c"
++ result = ease_temp_m_dirs;
++#line 52 "ease-temp.vala"
++ return result;
++#line 633 "ease-temp.c"
++ }
++ result = ease_temp_m_dirs = (_tmp0_ = gee_linked_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL), _g_object_unref0 (ease_temp_m_dirs), _tmp0_);
++#line 53 "ease-temp.vala"
++ return result;
++#line 638 "ease-temp.c"
++}
++
++
++static void ease_temp_class_init (EaseTempClass * klass) {
++ ease_temp_parent_class = g_type_class_peek_parent (klass);
++ G_OBJECT_CLASS (klass)->get_property = ease_temp_get_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_temp_finalize;
++}
++
++
++static void ease_temp_instance_init (EaseTemp * self) {
++}
++
++
++static void ease_temp_finalize (GObject* obj) {
++ EaseTemp * self;
++ self = EASE_TEMP (obj);
++ G_OBJECT_CLASS (ease_temp_parent_class)->finalize (obj);
++}
++
++
++GType ease_temp_get_type (void) {
++ static volatile gsize ease_temp_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_temp_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseTempClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_temp_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseTemp), 0, (GInstanceInitFunc) ease_temp_instance_init, NULL };
++ GType ease_temp_type_id;
++ ease_temp_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseTemp", &g_define_type_info, 0);
++ g_once_init_leave (&ease_temp_type_id__volatile, ease_temp_type_id);
++ }
++ return ease_temp_type_id__volatile;
++}
++
++
++static void ease_temp_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseTemp * self;
++ self = EASE_TEMP (object);
++ switch (property_id) {
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
diff --cc ease-core/ease-text-actor.c
index 0000000,0000000..450ec69
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-text-actor.c
@@@ -1,0 -1,0 +1,758 @@@
++/* ease-text-actor.c generated by valac, the Vala compiler
++ * generated from ease-text-actor.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <clutter/clutter.h>
++#include <gtk/gtk.h>
++#include <stdlib.h>
++#include <string.h>
++#include <glib/gi18n-lib.h>
++#include <pango/pango.h>
++#include <float.h>
++#include <math.h>
++
++
++#define EASE_TYPE_ACTOR (ease_actor_get_type ())
++#define EASE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ACTOR, EaseActor))
++#define EASE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ACTOR, EaseActorClass))
++#define EASE_IS_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ACTOR))
++#define EASE_IS_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ACTOR))
++#define EASE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ACTOR, EaseActorClass))
++
++typedef struct _EaseActor EaseActor;
++typedef struct _EaseActorClass EaseActorClass;
++typedef struct _EaseActorPrivate EaseActorPrivate;
++
++#define EASE_TYPE_SCROLLABLE_EMBED (ease_scrollable_embed_get_type ())
++#define EASE_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbed))
++#define EASE_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++#define EASE_IS_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_IS_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_SCROLLABLE_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++
++typedef struct _EaseScrollableEmbed EaseScrollableEmbed;
++typedef struct _EaseScrollableEmbedClass EaseScrollableEmbedClass;
++
++#define EASE_TYPE_EDITOR_EMBED (ease_editor_embed_get_type ())
++#define EASE_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbed))
++#define EASE_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++#define EASE_IS_EDITOR_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_EMBED))
++#define EASE_IS_EDITOR_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_EMBED))
++#define EASE_EDITOR_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_EMBED, EaseEditorEmbedClass))
++
++typedef struct _EaseEditorEmbed EaseEditorEmbed;
++typedef struct _EaseEditorEmbedClass EaseEditorEmbedClass;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++#define EASE_TYPE_TEXT_ACTOR (ease_text_actor_get_type ())
++#define EASE_TEXT_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_TEXT_ACTOR, EaseTextActor))
++#define EASE_TEXT_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_TEXT_ACTOR, EaseTextActorClass))
++#define EASE_IS_TEXT_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_TEXT_ACTOR))
++#define EASE_IS_TEXT_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_TEXT_ACTOR))
++#define EASE_TEXT_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_TEXT_ACTOR, EaseTextActorClass))
++
++typedef struct _EaseTextActor EaseTextActor;
++typedef struct _EaseTextActorClass EaseTextActorClass;
++typedef struct _EaseTextActorPrivate EaseTextActorPrivate;
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++
++#define EASE_TYPE_UNDO_ACTION (ease_undo_action_get_type ())
++#define EASE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoAction))
++#define EASE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++#define EASE_IS_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ACTION))
++#define EASE_IS_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ACTION))
++#define EASE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++
++typedef struct _EaseUndoAction EaseUndoAction;
++typedef struct _EaseUndoActionClass EaseUndoActionClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++
++#define EASE_TYPE_COLOR (ease_color_get_type ())
++#define EASE_COLOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_COLOR, EaseColor))
++#define EASE_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_COLOR, EaseColorClass))
++#define EASE_IS_COLOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_COLOR))
++#define EASE_IS_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_COLOR))
++#define EASE_COLOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_COLOR, EaseColorClass))
++
++typedef struct _EaseColor EaseColor;
++typedef struct _EaseColorClass EaseColorClass;
++
++#define EASE_TYPE_TEXT_ELEMENT (ease_text_element_get_type ())
++#define EASE_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElement))
++#define EASE_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++#define EASE_IS_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_IS_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_TEXT_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++
++typedef struct _EaseTextElement EaseTextElement;
++typedef struct _EaseTextElementClass EaseTextElementClass;
++#define _pango_font_description_free0(var) ((var == NULL) ? NULL : (var = (pango_font_description_free (var), NULL)))
++typedef struct _Block20Data Block20Data;
++typedef struct _Block21Data Block21Data;
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++struct _EaseActor {
++ ClutterGroup parent_instance;
++ EaseActorPrivate * priv;
++ ClutterActor* contents;
++ EaseElement* element;
++ EaseActorContext context;
++ gboolean is_background;
++};
++
++struct _EaseActorClass {
++ ClutterGroupClass parent_class;
++ void (*edit) (EaseActor* self, EaseEditorEmbed* sender);
++ void (*end_edit) (EaseActor* self, EaseEditorEmbed* sender);
++};
++
++struct _EaseTextActor {
++ EaseActor parent_instance;
++ EaseTextActorPrivate * priv;
++};
++
++struct _EaseTextActorClass {
++ EaseActorClass parent_class;
++};
++
++struct _EaseTextActorPrivate {
++ EaseUndoAction* undo_action;
++ char* original_text;
++};
++
++struct _Block20Data {
++ int _ref_count_;
++ EaseTextActor * self;
++ ClutterText* text;
++ EaseTextElement* e;
++};
++
++struct _Block21Data {
++ int _ref_count_;
++ EaseTextActor * self;
++ ClutterText* text;
++ EaseEditorEmbed* sender;
++};
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++
++static gpointer ease_text_actor_parent_class = NULL;
++
++GType ease_actor_get_type (void) G_GNUC_CONST;
++GType ease_scrollable_embed_get_type (void) G_GNUC_CONST;
++GType ease_editor_embed_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++GType ease_text_actor_get_type (void) G_GNUC_CONST;
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++GType ease_undo_action_get_type (void) G_GNUC_CONST;
++#define EASE_TEXT_ACTOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_TEXT_ACTOR, EaseTextActorPrivate))
++enum {
++ EASE_TEXT_ACTOR_DUMMY_PROPERTY
++};
++#define EASE_TEXT_ACTOR_DEFAULT_TEXT _ ("Double Click to Edit")
++#define EASE_TEXT_ACTOR_SELECTION_ALPHA ((guchar) 200)
++EaseActor* ease_actor_construct (GType object_type, EaseElement* e, EaseActorContext c);
++GType ease_color_get_type (void) G_GNUC_CONST;
++GType ease_text_element_get_type (void) G_GNUC_CONST;
++EaseColor* ease_text_element_get_color (EaseTextElement* self);
++void ease_color_get_clutter (EaseColor* self, ClutterColor* result);
++PangoAlignment ease_text_element_get_text_align (EaseTextElement* self);
++PangoFontDescription* ease_text_element_get_font_description (EaseTextElement* self);
++gboolean ease_element_get_has_been_edited (EaseElement* self);
++const char* ease_text_element_get_text (EaseTextElement* self);
++float ease_element_get_width (EaseElement* self);
++float ease_element_get_height (EaseElement* self);
++float ease_element_get_x (EaseElement* self);
++float ease_element_get_y (EaseElement* self);
++static void _lambda10_ (GObject* sender, GParamSpec* spec, Block20Data* _data20_);
++static void __lambda10__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static void _lambda11_ (GObject* sender, GParamSpec* spec, Block20Data* _data20_);
++static void __lambda11__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static void _lambda12_ (GObject* sender, GParamSpec* spec, Block20Data* _data20_);
++static void __lambda12__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static void _lambda13_ (GObject* sender, GParamSpec* spec, Block20Data* _data20_);
++static void __lambda13__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static void _lambda14_ (GObject* sender, GParamSpec* spec, Block20Data* _data20_);
++static void __lambda14__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static Block20Data* block20_data_ref (Block20Data* _data20_);
++static void block20_data_unref (Block20Data* _data20_);
++EaseTextActor* ease_text_actor_new (EaseTextElement* e, EaseActorContext c);
++EaseTextActor* ease_text_actor_construct (GType object_type, EaseTextElement* e, EaseActorContext c);
++static void ease_text_actor_text_changed (EaseTextActor* self, ClutterText* sender);
++static void _ease_text_actor_text_changed_clutter_text_text_changed (ClutterText* _sender, gpointer self);
++static void ease_text_actor_text_activate (EaseTextActor* self, ClutterText* sender);
++static void _ease_text_actor_text_activate_clutter_text_activate (ClutterText* _sender, gpointer self);
++void ease_scrollable_embed_key_focus (EaseScrollableEmbed* self);
++EaseUndoAction* ease_undo_action_new (GObject* obj, const char* prop);
++EaseUndoAction* ease_undo_action_construct (GType object_type, GObject* obj, const char* prop);
++void ease_undo_action_add (EaseUndoAction* self, GObject* obj, const char* prop);
++void ease_actor_end_edit (EaseActor* self, EaseEditorEmbed* sender);
++static void _lambda97_ (EaseUndoAction* action, Block21Data* _data21_);
++static void __lambda97__ease_undo_item_pre_apply (EaseUndoItem* _sender, EaseUndoAction* sender, gpointer self);
++static Block21Data* block21_data_ref (Block21Data* _data21_);
++static void block21_data_unref (Block21Data* _data21_);
++static void ease_text_actor_real_edit (EaseActor* base, EaseEditorEmbed* sender);
++void ease_element_set_has_been_edited (EaseElement* self, gboolean value);
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++static void ease_text_actor_real_end_edit (EaseActor* base, EaseEditorEmbed* sender);
++void ease_text_element_set_text (EaseTextElement* self, const char* value);
++GType ease_slide_get_type (void) G_GNUC_CONST;
++EaseSlide* ease_element_get_parent (EaseElement* self);
++static void ease_text_actor_finalize (GObject* obj);
++static int _vala_strcmp0 (const char * str1, const char * str2);
++
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 76 "ease-text-actor.vala"
++static void _lambda10_ (GObject* sender, GParamSpec* spec, Block20Data* _data20_) {
++#line 280 "ease-text-actor.c"
++ EaseTextActor * self;
++ GObject* _tmp0_;
++ ClutterColor _tmp1_ = {0};
++ ClutterColor _tmp2_;
++ self = _data20_->self;
++#line 76 "ease-text-actor.vala"
++ g_return_if_fail (sender != NULL);
++#line 76 "ease-text-actor.vala"
++ g_return_if_fail (spec != NULL);
++#line 77 "ease-text-actor.vala"
++ clutter_text_set_color (_data20_->text, (_tmp2_ = (ease_color_get_clutter (ease_text_element_get_color ((_tmp0_ = sender, EASE_IS_TEXT_ELEMENT (_tmp0_) ? ((EaseTextElement*) _tmp0_) : NULL)), &_tmp1_), _tmp1_), &_tmp2_));
++#line 292 "ease-text-actor.c"
++}
++
++
++#line 76 "ease-text-actor.vala"
++static void __lambda10__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 298 "ease-text-actor.c"
++ _lambda10_ (_sender, pspec, self);
++}
++
++
++#line 80 "ease-text-actor.vala"
++static void _lambda11_ (GObject* sender, GParamSpec* spec, Block20Data* _data20_) {
++#line 305 "ease-text-actor.c"
++ EaseTextActor * self;
++ PangoFontDescription* _tmp0_;
++ self = _data20_->self;
++#line 80 "ease-text-actor.vala"
++ g_return_if_fail (sender != NULL);
++#line 80 "ease-text-actor.vala"
++ g_return_if_fail (spec != NULL);
++#line 81 "ease-text-actor.vala"
++ clutter_text_set_font_name (_data20_->text, pango_font_description_to_string (_tmp0_ = ease_text_element_get_font_description (_data20_->e)));
++#line 315 "ease-text-actor.c"
++ _pango_font_description_free0 (_tmp0_);
++}
++
++
++#line 80 "ease-text-actor.vala"
++static void __lambda11__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 322 "ease-text-actor.c"
++ _lambda11_ (_sender, pspec, self);
++}
++
++
++#line 84 "ease-text-actor.vala"
++static void _lambda12_ (GObject* sender, GParamSpec* spec, Block20Data* _data20_) {
++#line 329 "ease-text-actor.c"
++ EaseTextActor * self;
++ self = _data20_->self;
++#line 84 "ease-text-actor.vala"
++ g_return_if_fail (sender != NULL);
++#line 84 "ease-text-actor.vala"
++ g_return_if_fail (spec != NULL);
++#line 85 "ease-text-actor.vala"
++ clutter_text_set_line_alignment (_data20_->text, ease_text_element_get_text_align (_data20_->e));
++#line 338 "ease-text-actor.c"
++}
++
++
++#line 84 "ease-text-actor.vala"
++static void __lambda12__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 344 "ease-text-actor.c"
++ _lambda12_ (_sender, pspec, self);
++}
++
++
++#line 88 "ease-text-actor.vala"
++static void _lambda13_ (GObject* sender, GParamSpec* spec, Block20Data* _data20_) {
++#line 351 "ease-text-actor.c"
++ EaseTextActor * self;
++ ClutterColor _tmp0_ = {0};
++ ClutterColor _tmp1_;
++ self = _data20_->self;
++#line 88 "ease-text-actor.vala"
++ g_return_if_fail (sender != NULL);
++#line 88 "ease-text-actor.vala"
++ g_return_if_fail (spec != NULL);
++#line 89 "ease-text-actor.vala"
++ clutter_text_set_color (_data20_->text, (_tmp1_ = (ease_color_get_clutter (ease_text_element_get_color (_data20_->e), &_tmp0_), _tmp0_), &_tmp1_));
++#line 362 "ease-text-actor.c"
++}
++
++
++#line 88 "ease-text-actor.vala"
++static void __lambda13__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 368 "ease-text-actor.c"
++ _lambda13_ (_sender, pspec, self);
++}
++
++
++#line 92 "ease-text-actor.vala"
++static void _lambda14_ (GObject* sender, GParamSpec* spec, Block20Data* _data20_) {
++#line 375 "ease-text-actor.c"
++ EaseTextActor * self;
++ self = _data20_->self;
++#line 92 "ease-text-actor.vala"
++ g_return_if_fail (sender != NULL);
++#line 92 "ease-text-actor.vala"
++ g_return_if_fail (spec != NULL);
++#line 93 "ease-text-actor.vala"
++ if (!clutter_text_get_editable (_data20_->text)) {
++#line 384 "ease-text-actor.c"
++ const char* _tmp0_;
++ _tmp0_ = NULL;
++#line 95 "ease-text-actor.vala"
++ if (ease_element_get_has_been_edited ((EaseElement*) _data20_->e)) {
++#line 95 "ease-text-actor.vala"
++ _tmp0_ = ease_text_element_get_text (_data20_->e);
++#line 391 "ease-text-actor.c"
++ } else {
++#line 95 "ease-text-actor.vala"
++ _tmp0_ = EASE_TEXT_ACTOR_DEFAULT_TEXT;
++#line 395 "ease-text-actor.c"
++ }
++#line 95 "ease-text-actor.vala"
++ clutter_text_set_markup (_data20_->text, _tmp0_);
++#line 399 "ease-text-actor.c"
++ }
++}
++
++
++#line 92 "ease-text-actor.vala"
++static void __lambda14__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 406 "ease-text-actor.c"
++ _lambda14_ (_sender, pspec, self);
++}
++
++
++static Block20Data* block20_data_ref (Block20Data* _data20_) {
++ g_atomic_int_inc (&_data20_->_ref_count_);
++ return _data20_;
++}
++
++
++static void block20_data_unref (Block20Data* _data20_) {
++ if (g_atomic_int_dec_and_test (&_data20_->_ref_count_)) {
++ _g_object_unref0 (_data20_->self);
++ _g_object_unref0 (_data20_->text);
++ _g_object_unref0 (_data20_->e);
++ g_slice_free (Block20Data, _data20_);
++ }
++}
++
++
++#line 53 "ease-text-actor.vala"
++EaseTextActor* ease_text_actor_construct (GType object_type, EaseTextElement* e, EaseActorContext c) {
++#line 429 "ease-text-actor.c"
++ EaseTextActor * self;
++ Block20Data* _data20_;
++ ClutterActor* _tmp0_;
++ ClutterColor _tmp1_ = {0};
++ ClutterColor _tmp2_;
++ PangoFontDescription* _tmp3_;
++ const char* _tmp4_;
++#line 53 "ease-text-actor.vala"
++ g_return_val_if_fail (e != NULL, NULL);
++#line 439 "ease-text-actor.c"
++ _data20_ = g_slice_new0 (Block20Data);
++ _data20_->_ref_count_ = 1;
++ _data20_->e = _g_object_ref0 (e);
++#line 55 "ease-text-actor.vala"
++ _data20_->self = g_object_ref (self = (EaseTextActor*) ease_actor_construct (object_type, (EaseElement*) _data20_->e, c));
++#line 445 "ease-text-actor.c"
++ _data20_->text = g_object_ref_sink ((ClutterText*) clutter_text_new ());
++#line 58 "ease-text-actor.vala"
++ ((EaseActor*) self)->contents = (_tmp0_ = _g_object_ref0 ((ClutterActor*) _data20_->text), _g_object_unref0 (((EaseActor*) self)->contents), _tmp0_);
++#line 61 "ease-text-actor.vala"
++ clutter_text_set_use_markup (_data20_->text, TRUE);
++#line 62 "ease-text-actor.vala"
++ clutter_text_set_line_wrap (_data20_->text, TRUE);
++#line 63 "ease-text-actor.vala"
++ clutter_text_set_line_wrap_mode (_data20_->text, PANGO_WRAP_WORD_CHAR);
++#line 64 "ease-text-actor.vala"
++ clutter_text_set_color (_data20_->text, (_tmp2_ = (ease_color_get_clutter (ease_text_element_get_color (_data20_->e), &_tmp1_), _tmp1_), &_tmp2_));
++#line 65 "ease-text-actor.vala"
++ clutter_text_set_line_alignment (_data20_->text, ease_text_element_get_text_align (_data20_->e));
++#line 66 "ease-text-actor.vala"
++ clutter_text_set_font_name (_data20_->text, pango_font_description_to_string (_tmp3_ = ease_text_element_get_font_description (_data20_->e)));
++#line 461 "ease-text-actor.c"
++ _pango_font_description_free0 (_tmp3_);
++ _tmp4_ = NULL;
++#line 67 "ease-text-actor.vala"
++ if (ease_element_get_has_been_edited ((EaseElement*) _data20_->e)) {
++#line 67 "ease-text-actor.vala"
++ _tmp4_ = ease_text_element_get_text (_data20_->e);
++#line 468 "ease-text-actor.c"
++ } else {
++#line 67 "ease-text-actor.vala"
++ _tmp4_ = EASE_TEXT_ACTOR_DEFAULT_TEXT;
++#line 472 "ease-text-actor.c"
++ }
++#line 67 "ease-text-actor.vala"
++ clutter_text_set_markup (_data20_->text, _tmp4_);
++#line 69 "ease-text-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) self, ((EaseActor*) self)->contents);
++#line 70 "ease-text-actor.vala"
++ clutter_actor_set_width (((EaseActor*) self)->contents, ease_element_get_width ((EaseElement*) _data20_->e));
++#line 71 "ease-text-actor.vala"
++ clutter_actor_set_height (((EaseActor*) self)->contents, ease_element_get_height ((EaseElement*) _data20_->e));
++#line 72 "ease-text-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) self, ease_element_get_x ((EaseElement*) _data20_->e));
++#line 73 "ease-text-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) self, ease_element_get_y ((EaseElement*) _data20_->e));
++#line 76 "ease-text-actor.vala"
++ g_signal_connect_data ((GObject*) _data20_->e, "notify::color", (GCallback) __lambda10__g_object_notify, block20_data_ref (_data20_), (GClosureNotify) block20_data_unref, 0);
++#line 80 "ease-text-actor.vala"
++ g_signal_connect_data ((GObject*) _data20_->e, "notify::font-description", (GCallback) __lambda11__g_object_notify, block20_data_ref (_data20_), (GClosureNotify) block20_data_unref, 0);
++#line 84 "ease-text-actor.vala"
++ g_signal_connect_data ((GObject*) _data20_->e, "notify::text-align", (GCallback) __lambda12__g_object_notify, block20_data_ref (_data20_), (GClosureNotify) block20_data_unref, 0);
++#line 88 "ease-text-actor.vala"
++ g_signal_connect_data ((GObject*) _data20_->e, "notify::color", (GCallback) __lambda13__g_object_notify, block20_data_ref (_data20_), (GClosureNotify) block20_data_unref, 0);
++#line 92 "ease-text-actor.vala"
++ g_signal_connect_data ((GObject*) _data20_->e, "notify::text", (GCallback) __lambda14__g_object_notify, block20_data_ref (_data20_), (GClosureNotify) block20_data_unref, 0);
++#line 496 "ease-text-actor.c"
++ block20_data_unref (_data20_);
++ return self;
++}
++
++
++#line 53 "ease-text-actor.vala"
++EaseTextActor* ease_text_actor_new (EaseTextElement* e, EaseActorContext c) {
++#line 53 "ease-text-actor.vala"
++ return ease_text_actor_construct (EASE_TYPE_TEXT_ACTOR, e, c);
++#line 506 "ease-text-actor.c"
++}
++
++
++#line 179 "ease-text-actor.vala"
++static void _ease_text_actor_text_changed_clutter_text_text_changed (ClutterText* _sender, gpointer self) {
++#line 512 "ease-text-actor.c"
++ ease_text_actor_text_changed (self, _sender);
++}
++
++
++#line 188 "ease-text-actor.vala"
++static void _ease_text_actor_text_activate_clutter_text_activate (ClutterText* _sender, gpointer self) {
++#line 519 "ease-text-actor.c"
++ ease_text_actor_text_activate (self, _sender);
++}
++
++
++#line 137 "ease-text-actor.vala"
++static void _lambda97_ (EaseUndoAction* action, Block21Data* _data21_) {
++#line 526 "ease-text-actor.c"
++ EaseTextActor * self;
++ self = _data21_->self;
++#line 137 "ease-text-actor.vala"
++ g_return_if_fail (action != NULL);
++#line 138 "ease-text-actor.vala"
++ if (clutter_text_get_editable (_data21_->text)) {
++#line 138 "ease-text-actor.vala"
++ ease_actor_end_edit ((EaseActor*) self, _data21_->sender);
++#line 535 "ease-text-actor.c"
++ }
++}
++
++
++#line 137 "ease-text-actor.vala"
++static void __lambda97__ease_undo_item_pre_apply (EaseUndoItem* _sender, EaseUndoAction* sender, gpointer self) {
++#line 542 "ease-text-actor.c"
++ _lambda97_ (sender, self);
++}
++
++
++static Block21Data* block21_data_ref (Block21Data* _data21_) {
++ g_atomic_int_inc (&_data21_->_ref_count_);
++ return _data21_;
++}
++
++
++static void block21_data_unref (Block21Data* _data21_) {
++ if (g_atomic_int_dec_and_test (&_data21_->_ref_count_)) {
++ _g_object_unref0 (_data21_->self);
++ _g_object_unref0 (_data21_->text);
++ _g_object_unref0 (_data21_->sender);
++ g_slice_free (Block21Data, _data21_);
++ }
++}
++
++
++#line 103 "ease-text-actor.vala"
++static void ease_text_actor_real_edit (EaseActor* base, EaseEditorEmbed* sender) {
++#line 565 "ease-text-actor.c"
++ EaseTextActor * self;
++ Block21Data* _data21_;
++ ClutterActor* _tmp0_;
++ ClutterColor _tmp1_ = {0};
++ ClutterColor _tmp2_ = {0};
++ ClutterColor _tmp3_ = {0};
++ ClutterColor _tmp4_ = {0};
++ ClutterColor _tmp5_;
++ EaseUndoAction* _tmp6_;
++ char* _tmp8_;
++ EaseElement* _tmp7_;
++ self = (EaseTextActor*) base;
++#line 103 "ease-text-actor.vala"
++ g_return_if_fail (sender != NULL);
++#line 580 "ease-text-actor.c"
++ _data21_ = g_slice_new0 (Block21Data);
++ _data21_->_ref_count_ = 1;
++ _data21_->self = g_object_ref (self);
++ _data21_->sender = _g_object_ref0 (sender);
++ _data21_->text = _g_object_ref0 ((_tmp0_ = ((EaseActor*) self)->contents, CLUTTER_IS_TEXT (_tmp0_) ? ((ClutterText*) _tmp0_) : NULL));
++#line 107 "ease-text-actor.vala"
++ clutter_text_set_editable (_data21_->text, TRUE);
++#line 108 "ease-text-actor.vala"
++ clutter_actor_set_reactive ((ClutterActor*) _data21_->text, TRUE);
++#line 109 "ease-text-actor.vala"
++ clutter_text_set_activatable (_data21_->text, TRUE);
++#line 110 "ease-text-actor.vala"
++ g_signal_connect_object (_data21_->text, "text-changed", (GCallback) _ease_text_actor_text_changed_clutter_text_text_changed, self, 0);
++#line 111 "ease-text-actor.vala"
++ g_signal_connect_object (_data21_->text, "activate", (GCallback) _ease_text_actor_text_activate_clutter_text_activate, self, 0);
++#line 114 "ease-text-actor.vala"
++ ease_scrollable_embed_key_focus ((EaseScrollableEmbed*) _data21_->sender);
++#line 115 "ease-text-actor.vala"
++ clutter_stage_set_key_focus (CLUTTER_STAGE (clutter_actor_get_stage ((ClutterActor*) self)), (ClutterActor*) _data21_->text);
++#line 118 "ease-text-actor.vala"
++ clutter_text_set_selection_color (_data21_->text, (_tmp5_ = (_tmp4_.red = (guchar) (255 - (clutter_text_get_color (_data21_->text, &_tmp1_), _tmp1_.red)), _tmp4_.green = (guchar) (255 - (clutter_text_get_color (_data21_->text, &_tmp2_), _tmp2_.green)), _tmp4_.blue = (guchar) (255 - (clutter_text_get_color (_data21_->text, &_tmp3_), _tmp3_.blue)), _tmp4_.alpha = EASE_TEXT_ACTOR_SELECTION_ALPHA, _tmp4_), &_tmp5_));
++#line 124 "ease-text-actor.vala"
++ if (!ease_element_get_has_been_edited (((EaseActor*) self)->element)) {
++#line 126 "ease-text-actor.vala"
++ clutter_text_set_text (_data21_->text, "");
++#line 606 "ease-text-actor.c"
++ }
++#line 130 "ease-text-actor.vala"
++ self->priv->undo_action = (_tmp6_ = ease_undo_action_new ((GObject*) ((EaseActor*) self)->element, "has-been-edited"), _g_object_unref0 (self->priv->undo_action), _tmp6_);
++#line 133 "ease-text-actor.vala"
++ ease_undo_action_add (self->priv->undo_action, (GObject*) ((EaseActor*) self)->element, "text");
++#line 134 "ease-text-actor.vala"
++ self->priv->original_text = (_tmp8_ = g_strdup (ease_text_element_get_text ((_tmp7_ = ((EaseActor*) self)->element, EASE_IS_TEXT_ELEMENT (_tmp7_) ? ((EaseTextElement*) _tmp7_) : NULL))), _g_free0 (self->priv->original_text), _tmp8_);
++#line 137 "ease-text-actor.vala"
++ g_signal_connect_data ((EaseUndoItem*) self->priv->undo_action, "pre-apply", (GCallback) __lambda97__ease_undo_item_pre_apply, block21_data_ref (_data21_), (GClosureNotify) block21_data_unref, 0);
++#line 616 "ease-text-actor.c"
++ block21_data_unref (_data21_);
++}
++
++
++#line 145 "ease-text-actor.vala"
++static void ease_text_actor_real_end_edit (EaseActor* base, EaseEditorEmbed* sender) {
++#line 623 "ease-text-actor.c"
++ EaseTextActor * self;
++ ClutterActor* _tmp0_;
++ ClutterText* text;
++ guint _tmp1_;
++ guint _tmp2_;
++ gboolean _tmp3_ = FALSE;
++ EaseElement* _tmp4_;
++ self = (EaseTextActor*) base;
++#line 145 "ease-text-actor.vala"
++ g_return_if_fail (sender != NULL);
++#line 148 "ease-text-actor.vala"
++ clutter_stage_set_key_focus (CLUTTER_STAGE (clutter_actor_get_stage ((ClutterActor*) self)), NULL);
++#line 151 "ease-text-actor.vala"
++ text = _g_object_ref0 ((_tmp0_ = ((EaseActor*) self)->contents, CLUTTER_IS_TEXT (_tmp0_) ? ((ClutterText*) _tmp0_) : NULL));
++#line 152 "ease-text-actor.vala"
++ clutter_text_set_editable (text, FALSE);
++#line 153 "ease-text-actor.vala"
++ clutter_actor_set_reactive ((ClutterActor*) text, FALSE);
++#line 154 "ease-text-actor.vala"
++ clutter_text_set_activatable (text, FALSE);
++#line 155 "ease-text-actor.vala"
++ g_signal_parse_name ("text-changed", CLUTTER_TYPE_TEXT, &_tmp1_, NULL, FALSE);
++#line 155 "ease-text-actor.vala"
++ g_signal_handlers_disconnect_matched (text, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp1_, 0, NULL, (GCallback) _ease_text_actor_text_changed_clutter_text_text_changed, self);
++#line 156 "ease-text-actor.vala"
++ g_signal_parse_name ("activate", CLUTTER_TYPE_TEXT, &_tmp2_, NULL, FALSE);
++#line 156 "ease-text-actor.vala"
++ g_signal_handlers_disconnect_matched (text, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp2_, 0, NULL, (GCallback) _ease_text_actor_text_activate_clutter_text_activate, self);
++#line 159 "ease-text-actor.vala"
++ if (_vala_strcmp0 (clutter_text_get_text (text), "") == 0) {
++#line 159 "ease-text-actor.vala"
++ _tmp3_ = !ease_element_get_has_been_edited (((EaseActor*) self)->element);
++#line 656 "ease-text-actor.c"
++ } else {
++#line 159 "ease-text-actor.vala"
++ _tmp3_ = FALSE;
++#line 660 "ease-text-actor.c"
++ }
++#line 159 "ease-text-actor.vala"
++ if (_tmp3_) {
++#line 161 "ease-text-actor.vala"
++ clutter_text_set_text (text, EASE_TEXT_ACTOR_DEFAULT_TEXT);
++#line 666 "ease-text-actor.c"
++ } else {
++#line 165 "ease-text-actor.vala"
++ ease_element_set_has_been_edited (((EaseActor*) self)->element, TRUE);
++#line 670 "ease-text-actor.c"
++ }
++#line 169 "ease-text-actor.vala"
++ if (_vala_strcmp0 (self->priv->original_text, ease_text_element_get_text ((_tmp4_ = ((EaseActor*) self)->element, EASE_IS_TEXT_ELEMENT (_tmp4_) ? ((EaseTextElement*) _tmp4_) : NULL))) != 0) {
++#line 171 "ease-text-actor.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) ((EaseActor*) self)->element, "undo", (EaseUndoItem*) self->priv->undo_action);
++#line 676 "ease-text-actor.c"
++ }
++ _g_object_unref0 (text);
++}
++
++
++#line 179 "ease-text-actor.vala"
++static void ease_text_actor_text_changed (EaseTextActor* self, ClutterText* sender) {
++#line 684 "ease-text-actor.c"
++ EaseElement* _tmp0_;
++#line 179 "ease-text-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 179 "ease-text-actor.vala"
++ g_return_if_fail (sender != NULL);
++#line 181 "ease-text-actor.vala"
++ ease_text_element_set_text ((_tmp0_ = ((EaseActor*) self)->element, EASE_IS_TEXT_ELEMENT (_tmp0_) ? ((EaseTextElement*) _tmp0_) : NULL), clutter_text_get_text (sender));
++#line 182 "ease-text-actor.vala"
++ g_signal_emit_by_name (ease_element_get_parent (((EaseActor*) self)->element), "changed", ease_element_get_parent (((EaseActor*) self)->element));
++#line 694 "ease-text-actor.c"
++}
++
++
++#line 188 "ease-text-actor.vala"
++static void ease_text_actor_text_activate (EaseTextActor* self, ClutterText* sender) {
++#line 700 "ease-text-actor.c"
++ ClutterActor* _tmp0_;
++#line 188 "ease-text-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 188 "ease-text-actor.vala"
++ g_return_if_fail (sender != NULL);
++#line 190 "ease-text-actor.vala"
++ clutter_text_insert_unichar ((_tmp0_ = ((EaseActor*) self)->contents, CLUTTER_IS_TEXT (_tmp0_) ? ((ClutterText*) _tmp0_) : NULL), (gunichar) '\n');
++#line 708 "ease-text-actor.c"
++}
++
++
++static void ease_text_actor_class_init (EaseTextActorClass * klass) {
++ ease_text_actor_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseTextActorPrivate));
++ EASE_ACTOR_CLASS (klass)->edit = ease_text_actor_real_edit;
++ EASE_ACTOR_CLASS (klass)->end_edit = ease_text_actor_real_end_edit;
++ G_OBJECT_CLASS (klass)->finalize = ease_text_actor_finalize;
++}
++
++
++static void ease_text_actor_instance_init (EaseTextActor * self) {
++ self->priv = EASE_TEXT_ACTOR_GET_PRIVATE (self);
++}
++
++
++static void ease_text_actor_finalize (GObject* obj) {
++ EaseTextActor * self;
++ self = EASE_TEXT_ACTOR (obj);
++ _g_object_unref0 (self->priv->undo_action);
++ _g_free0 (self->priv->original_text);
++ G_OBJECT_CLASS (ease_text_actor_parent_class)->finalize (obj);
++}
++
++
++GType ease_text_actor_get_type (void) {
++ static volatile gsize ease_text_actor_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_text_actor_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseTextActorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_text_actor_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseTextActor), 0, (GInstanceInitFunc) ease_text_actor_instance_init, NULL };
++ GType ease_text_actor_type_id;
++ ease_text_actor_type_id = g_type_register_static (EASE_TYPE_ACTOR, "EaseTextActor", &g_define_type_info, 0);
++ g_once_init_leave (&ease_text_actor_type_id__volatile, ease_text_actor_type_id);
++ }
++ return ease_text_actor_type_id__volatile;
++}
++
++
++static int _vala_strcmp0 (const char * str1, const char * str2) {
++ if (str1 == NULL) {
++ return -(str1 != str2);
++ }
++ if (str2 == NULL) {
++ return str1 != str2;
++ }
++ return strcmp (str1, str2);
++}
++
++
++
++
diff --cc ease-core/ease-text-element.c
index 0000000,0000000..86ecc61
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-text-element.c
@@@ -1,0 -1,0 +1,1787 @@@
++/* ease-text-element.c generated by valac, the Vala compiler
++ * generated from ease-text-element.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <json-glib/json-glib.h>
++#include <stdlib.h>
++#include <string.h>
++#include <float.h>
++#include <math.h>
++#include <cairo.h>
++#include <clutter/clutter.h>
++#include <gtk/gtk.h>
++#include <pango/pango.h>
++#include <gdk/gdk.h>
++#include <pango/pangocairo.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++typedef struct _EaseElementPrivate EaseElementPrivate;
++
++#define EASE_TYPE_HTML_EXPORTER (ease_html_exporter_get_type ())
++#define EASE_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporter))
++#define EASE_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++#define EASE_IS_HTML_EXPORTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_HTML_EXPORTER))
++#define EASE_IS_HTML_EXPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_HTML_EXPORTER))
++#define EASE_HTML_EXPORTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_HTML_EXPORTER, EaseHTMLExporterClass))
++
++typedef struct _EaseHTMLExporter EaseHTMLExporter;
++typedef struct _EaseHTMLExporterClass EaseHTMLExporterClass;
++
++#define EASE_TYPE_ACTOR_CONTEXT (ease_actor_context_get_type ())
++
++#define EASE_TYPE_ACTOR (ease_actor_get_type ())
++#define EASE_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ACTOR, EaseActor))
++#define EASE_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ACTOR, EaseActorClass))
++#define EASE_IS_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ACTOR))
++#define EASE_IS_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ACTOR))
++#define EASE_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ACTOR, EaseActorClass))
++
++typedef struct _EaseActor EaseActor;
++typedef struct _EaseActorClass EaseActorClass;
++
++#define EASE_TYPE_TEXT_ELEMENT (ease_text_element_get_type ())
++#define EASE_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElement))
++#define EASE_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++#define EASE_IS_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_IS_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_TEXT_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++
++typedef struct _EaseTextElement EaseTextElement;
++typedef struct _EaseTextElementClass EaseTextElementClass;
++typedef struct _EaseTextElementPrivate EaseTextElementPrivate;
++
++#define EASE_TYPE_COLOR (ease_color_get_type ())
++#define EASE_COLOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_COLOR, EaseColor))
++#define EASE_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_COLOR, EaseColorClass))
++#define EASE_IS_COLOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_COLOR))
++#define EASE_IS_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_COLOR))
++#define EASE_COLOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_COLOR, EaseColorClass))
++
++typedef struct _EaseColor EaseColor;
++typedef struct _EaseColorClass EaseColorClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _json_object_unref0(var) ((var == NULL) ? NULL : (var = (json_object_unref (var), NULL)))
++
++#define EASE_TYPE_TEXT_ACTOR (ease_text_actor_get_type ())
++#define EASE_TEXT_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_TEXT_ACTOR, EaseTextActor))
++#define EASE_TEXT_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_TEXT_ACTOR, EaseTextActorClass))
++#define EASE_IS_TEXT_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_TEXT_ACTOR))
++#define EASE_IS_TEXT_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_TEXT_ACTOR))
++#define EASE_TEXT_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_TEXT_ACTOR, EaseTextActorClass))
++
++typedef struct _EaseTextActor EaseTextActor;
++typedef struct _EaseTextActorClass EaseTextActorClass;
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++#define _pango_font_description_free0(var) ((var == NULL) ? NULL : (var = (pango_font_description_free (var), NULL)))
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++
++#define EASE_TYPE_UNDO_ACTION (ease_undo_action_get_type ())
++#define EASE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoAction))
++#define EASE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++#define EASE_IS_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ACTION))
++#define EASE_IS_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ACTION))
++#define EASE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++
++typedef struct _EaseUndoAction EaseUndoAction;
++typedef struct _EaseUndoActionClass EaseUndoActionClass;
++typedef struct _Block22Data Block22Data;
++#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++typedef enum {
++ EASE_ACTOR_CONTEXT_PRESENTATION,
++ EASE_ACTOR_CONTEXT_EDITOR,
++ EASE_ACTOR_CONTEXT_INSPECTOR
++} EaseActorContext;
++
++struct _EaseElement {
++ GObject parent_instance;
++ EaseElementPrivate * priv;
++};
++
++struct _EaseElementClass {
++ GObjectClass parent_class;
++ JsonObject* (*to_json) (EaseElement* self);
++ void (*to_html) (EaseElement* self, char** html, EaseHTMLExporter* exporter, double amount);
++ void (*write_html) (EaseElement* self, char** html, EaseHTMLExporter* exporter);
++ void (*cairo_render) (EaseElement* self, cairo_t* context, GError** error);
++ EaseActor* (*actor) (EaseElement* self, EaseActorContext c);
++ GtkWidget* (*inspector_widget) (EaseElement* self);
++ GList* (*tool_items) (EaseElement* self);
++ gboolean (*set_color) (EaseElement* self, ClutterColor* c);
++ ClutterColor* (*get_color) (EaseElement* self);
++};
++
++struct _EaseTextElement {
++ EaseElement parent_instance;
++ EaseTextElementPrivate * priv;
++};
++
++struct _EaseTextElementClass {
++ EaseElementClass parent_class;
++};
++
++struct _EaseTextElementPrivate {
++ gboolean freeze;
++ GtkWidget* inspector_pane;
++ char* _text;
++ EaseColor* _color;
++ char* text_font_priv;
++ PangoStyle text_style_priv;
++ PangoVariant text_variant_priv;
++ gint text_weight_priv;
++ PangoAlignment _text_align;
++ gint text_size_priv;
++};
++
++struct _Block22Data {
++ int _ref_count_;
++ EaseTextElement * self;
++ GtkButton* left;
++ GtkButton* center;
++ GtkButton* right;
++ GtkFontButton* font;
++ GtkColorButton* color_b;
++};
++
++
++static gpointer ease_text_element_parent_class = NULL;
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++GType ease_html_exporter_get_type (void) G_GNUC_CONST;
++GType ease_actor_context_get_type (void) G_GNUC_CONST;
++GType ease_actor_get_type (void) G_GNUC_CONST;
++GType ease_text_element_get_type (void) G_GNUC_CONST;
++GType ease_color_get_type (void) G_GNUC_CONST;
++#define EASE_TEXT_ELEMENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_TEXT_ELEMENT, EaseTextElementPrivate))
++enum {
++ EASE_TEXT_ELEMENT_DUMMY_PROPERTY,
++ EASE_TEXT_ELEMENT_TEXT,
++ EASE_TEXT_ELEMENT_COLOR,
++ EASE_TEXT_ELEMENT_TEXT_FONT,
++ EASE_TEXT_ELEMENT_TEXT_STYLE,
++ EASE_TEXT_ELEMENT_TEXT_VARIANT,
++ EASE_TEXT_ELEMENT_TEXT_WEIGHT,
++ EASE_TEXT_ELEMENT_FONT_DESCRIPTION,
++ EASE_TEXT_ELEMENT_TEXT_ALIGN,
++ EASE_TEXT_ELEMENT_TEXT_SIZE
++};
++#define EASE_TEXT_ELEMENT_UI_FILE_PATH "inspector-element-text.ui"
++EaseElement* ease_element_construct (GType object_type);
++EaseTextElement* ease_text_element_new (void);
++EaseTextElement* ease_text_element_construct (GType object_type);
++EaseElement* ease_element_construct_from_json (GType object_type, JsonObject* obj);
++#define EASE_THEME_TEXT_TEXT "text"
++void ease_text_element_set_text (EaseTextElement* self, const char* value);
++EaseColor* ease_color_new_from_string (const char* str);
++EaseColor* ease_color_construct_from_string (GType object_type, const char* str);
++#define EASE_THEME_TEXT_COLOR "text-color"
++void ease_text_element_set_color (EaseTextElement* self, EaseColor* value);
++#define EASE_THEME_TEXT_FONT "text-font"
++void ease_text_element_set_text_font (EaseTextElement* self, const char* value);
++void ease_text_element_text_style_from_string (EaseTextElement* self, const char* str);
++#define EASE_THEME_TEXT_STYLE "text-style"
++void ease_text_element_text_variant_from_string (EaseTextElement* self, const char* str);
++#define EASE_THEME_TEXT_VARIANT "text-variant"
++void ease_text_element_text_weight_from_string (EaseTextElement* self, const char* str);
++#define EASE_THEME_TEXT_WEIGHT "text-weight"
++void ease_text_element_text_align_from_string (EaseTextElement* self, const char* str);
++#define EASE_THEME_TEXT_ALIGN "text-align"
++void ease_text_element_text_size_from_string (EaseTextElement* self, const char* str);
++#define EASE_THEME_TEXT_SIZE "text-size"
++EaseTextElement* ease_text_element_new_from_json (JsonObject* obj);
++EaseTextElement* ease_text_element_construct_from_json (GType object_type, JsonObject* obj);
++JsonObject* ease_element_to_json (EaseElement* self);
++EaseColor* ease_text_element_get_color (EaseTextElement* self);
++char* ease_color_to_string (EaseColor* self);
++const char* ease_text_element_get_text (EaseTextElement* self);
++const char* ease_text_element_get_text_font (EaseTextElement* self);
++char* ease_text_element_text_style_to_string (EaseTextElement* self);
++char* ease_text_element_text_variant_to_string (EaseTextElement* self);
++char* ease_text_element_text_weight_to_string (EaseTextElement* self);
++char* ease_text_element_text_align_to_string (EaseTextElement* self);
++char* ease_text_element_text_size_to_string (EaseTextElement* self);
++static JsonObject* ease_text_element_real_to_json (EaseElement* base);
++EaseTextActor* ease_text_actor_new (EaseTextElement* e, EaseActorContext c);
++EaseTextActor* ease_text_actor_construct (GType object_type, EaseTextElement* e, EaseActorContext c);
++GType ease_text_actor_get_type (void) G_GNUC_CONST;
++static EaseActor* ease_text_element_real_actor (EaseElement* base, EaseActorContext c);
++EaseColor* ease_color_new_from_clutter (ClutterColor* color);
++EaseColor* ease_color_construct_from_clutter (GType object_type, ClutterColor* color);
++static gboolean ease_text_element_real_set_color (EaseElement* base, ClutterColor* c);
++void ease_color_get_clutter (EaseColor* self, ClutterColor* result);
++static ClutterColor* _clutter_color_dup (ClutterColor* self);
++static ClutterColor* ease_text_element_real_get_color (EaseElement* base);
++char* ease_data_path (const char* path);
++#define EASE_TEMP_UI_DIR "ui"
++PangoAlignment ease_text_element_get_text_align (EaseTextElement* self);
++static void _lambda98_ (GObject* obj, GParamSpec* spec, Block22Data* _data22_);
++static void __lambda98__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++PangoFontDescription* ease_text_element_get_font_description (EaseTextElement* self);
++EaseUndoAction* ease_undo_action_new (GObject* obj, const char* prop);
++EaseUndoAction* ease_undo_action_construct (GType object_type, GObject* obj, const char* prop);
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++GType ease_undo_action_get_type (void) G_GNUC_CONST;
++void ease_text_element_set_font_description (EaseTextElement* self, const PangoFontDescription* value);
++static void _lambda99_ (GtkFontButton* button, Block22Data* _data22_);
++static void __lambda99__gtk_font_button_font_set (GtkFontButton* _sender, gpointer self);
++static void _lambda100_ (GObject* obj, GParamSpec* spec, Block22Data* _data22_);
++static void __lambda100__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++void ease_color_get_gdk (EaseColor* self, GdkColor* result);
++EaseColor* ease_color_new_from_gdk (GdkColor* color);
++EaseColor* ease_color_construct_from_gdk (GType object_type, GdkColor* color);
++static void _lambda101_ (GtkColorButton* button, Block22Data* _data22_);
++static void __lambda101__gtk_color_button_color_set (GtkColorButton* _sender, gpointer self);
++static void _lambda102_ (GObject* obj, GParamSpec* spec, Block22Data* _data22_);
++static void __lambda102__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
++static Block22Data* block22_data_ref (Block22Data* _data22_);
++static void block22_data_unref (Block22Data* _data22_);
++static GtkWidget* ease_text_element_real_inspector_widget (EaseElement* base);
++static void _lambda103_ (GtkWidget* widget, EaseTextElement* self);
++static void __lambda103__gtk_callback (GtkWidget* widget, gpointer self);
++void ease_text_element_on_inspector_alignment (GtkWidget* sender, EaseTextElement* self);
++float ease_element_get_x (EaseElement* self);
++float ease_element_get_y (EaseElement* self);
++float ease_element_get_width (EaseElement* self);
++double ease_color_get_red (EaseColor* self);
++double ease_color_get_green (EaseColor* self);
++double ease_color_get_blue (EaseColor* self);
++static void ease_text_element_real_write_html (EaseElement* base, char** html, EaseHTMLExporter* exporter);
++float ease_element_get_height (EaseElement* self);
++void ease_color_set_cairo (EaseColor* self, cairo_t* cr);
++static void ease_text_element_real_cairo_render (EaseElement* base, cairo_t* context, GError** error);
++PangoStyle ease_text_element_get_text_style (EaseTextElement* self);
++void ease_text_element_set_text_style (EaseTextElement* self, PangoStyle value);
++void ease_text_element_set_text_variant (EaseTextElement* self, PangoVariant value);
++PangoVariant ease_text_element_get_text_variant (EaseTextElement* self);
++void ease_text_element_set_text_weight (EaseTextElement* self, gint value);
++gint ease_text_element_get_text_weight (EaseTextElement* self);
++void ease_text_element_set_text_align (EaseTextElement* self, PangoAlignment value);
++void ease_text_element_set_text_size (EaseTextElement* self, gint value);
++gint ease_text_element_get_text_size (EaseTextElement* self);
++static void ease_text_element_finalize (GObject* obj);
++static void ease_text_element_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_text_element_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++static int _vala_strcmp0 (const char * str1, const char * str2);
++
++
++
++#line 30 "ease-text-element.vala"
++EaseTextElement* ease_text_element_construct (GType object_type) {
++#line 321 "ease-text-element.c"
++ EaseTextElement * self;
++#line 30 "ease-text-element.vala"
++ self = (EaseTextElement*) ease_element_construct (object_type);
++#line 325 "ease-text-element.c"
++ return self;
++}
++
++
++#line 30 "ease-text-element.vala"
++EaseTextElement* ease_text_element_new (void) {
++#line 30 "ease-text-element.vala"
++ return ease_text_element_construct (EASE_TYPE_TEXT_ELEMENT);
++#line 334 "ease-text-element.c"
++}
++
++
++#line 35 "ease-text-element.vala"
++EaseTextElement* ease_text_element_construct_from_json (GType object_type, JsonObject* obj) {
++#line 340 "ease-text-element.c"
++ EaseTextElement * self;
++ EaseColor* _tmp0_;
++#line 35 "ease-text-element.vala"
++ g_return_val_if_fail (obj != NULL, NULL);
++#line 37 "ease-text-element.vala"
++ self = (EaseTextElement*) ease_element_construct_from_json (object_type, obj);
++#line 39 "ease-text-element.vala"
++ ease_text_element_set_text (self, json_object_get_string_member (obj, EASE_THEME_TEXT_TEXT));
++#line 40 "ease-text-element.vala"
++ ease_text_element_set_color (self, _tmp0_ = ease_color_new_from_string (json_object_get_string_member (obj, EASE_THEME_TEXT_COLOR)));
++#line 351 "ease-text-element.c"
++ _g_object_unref0 (_tmp0_);
++#line 41 "ease-text-element.vala"
++ ease_text_element_set_text_font (self, json_object_get_string_member (obj, EASE_THEME_TEXT_FONT));
++#line 42 "ease-text-element.vala"
++ ease_text_element_text_style_from_string (self, json_object_get_string_member (obj, EASE_THEME_TEXT_STYLE));
++#line 43 "ease-text-element.vala"
++ ease_text_element_text_variant_from_string (self, json_object_get_string_member (obj, EASE_THEME_TEXT_VARIANT));
++#line 44 "ease-text-element.vala"
++ ease_text_element_text_weight_from_string (self, json_object_get_string_member (obj, EASE_THEME_TEXT_WEIGHT));
++#line 45 "ease-text-element.vala"
++ ease_text_element_text_align_from_string (self, json_object_get_string_member (obj, EASE_THEME_TEXT_ALIGN));
++#line 46 "ease-text-element.vala"
++ ease_text_element_text_size_from_string (self, json_object_get_string_member (obj, EASE_THEME_TEXT_SIZE));
++#line 365 "ease-text-element.c"
++ return self;
++}
++
++
++#line 35 "ease-text-element.vala"
++EaseTextElement* ease_text_element_new_from_json (JsonObject* obj) {
++#line 35 "ease-text-element.vala"
++ return ease_text_element_construct_from_json (EASE_TYPE_TEXT_ELEMENT, obj);
++#line 374 "ease-text-element.c"
++}
++
++
++#line 49 "ease-text-element.vala"
++static JsonObject* ease_text_element_real_to_json (EaseElement* base) {
++#line 380 "ease-text-element.c"
++ EaseTextElement * self;
++ JsonObject* result = NULL;
++ JsonObject* obj;
++ char* _tmp0_;
++ char* _tmp1_;
++ char* _tmp2_;
++ char* _tmp3_;
++ char* _tmp4_;
++ char* _tmp5_;
++ self = (EaseTextElement*) base;
++#line 51 "ease-text-element.vala"
++ obj = EASE_ELEMENT_CLASS (ease_text_element_parent_class)->to_json (EASE_ELEMENT (self));
++#line 53 "ease-text-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_TEXT_COLOR, _tmp0_ = ease_color_to_string (self->priv->_color));
++#line 395 "ease-text-element.c"
++ _g_free0 (_tmp0_);
++#line 54 "ease-text-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_TEXT_TEXT, self->priv->_text);
++#line 55 "ease-text-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_TEXT_FONT, ease_text_element_get_text_font (self));
++#line 56 "ease-text-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_TEXT_STYLE, _tmp1_ = ease_text_element_text_style_to_string (self));
++#line 403 "ease-text-element.c"
++ _g_free0 (_tmp1_);
++#line 57 "ease-text-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_TEXT_VARIANT, _tmp2_ = ease_text_element_text_variant_to_string (self));
++#line 407 "ease-text-element.c"
++ _g_free0 (_tmp2_);
++#line 58 "ease-text-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_TEXT_WEIGHT, _tmp3_ = ease_text_element_text_weight_to_string (self));
++#line 411 "ease-text-element.c"
++ _g_free0 (_tmp3_);
++#line 59 "ease-text-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_TEXT_ALIGN, _tmp4_ = ease_text_element_text_align_to_string (self));
++#line 415 "ease-text-element.c"
++ _g_free0 (_tmp4_);
++#line 60 "ease-text-element.vala"
++ json_object_set_string_member (obj, EASE_THEME_TEXT_SIZE, _tmp5_ = ease_text_element_text_size_to_string (self));
++#line 419 "ease-text-element.c"
++ _g_free0 (_tmp5_);
++ result = obj;
++#line 62 "ease-text-element.vala"
++ return result;
++#line 424 "ease-text-element.c"
++}
++
++
++#line 65 "ease-text-element.vala"
++static EaseActor* ease_text_element_real_actor (EaseElement* base, EaseActorContext c) {
++#line 430 "ease-text-element.c"
++ EaseTextElement * self;
++ EaseActor* result = NULL;
++ self = (EaseTextElement*) base;
++ result = (EaseActor*) g_object_ref_sink (ease_text_actor_new (self, c));
++#line 67 "ease-text-element.vala"
++ return result;
++#line 437 "ease-text-element.c"
++}
++
++
++#line 75 "ease-text-element.vala"
++static gboolean ease_text_element_real_set_color (EaseElement* base, ClutterColor* c) {
++#line 443 "ease-text-element.c"
++ EaseTextElement * self;
++ gboolean result = FALSE;
++ EaseColor* _tmp0_;
++ self = (EaseTextElement*) base;
++#line 77 "ease-text-element.vala"
++ ease_text_element_set_color (self, _tmp0_ = ease_color_new_from_clutter (c));
++#line 450 "ease-text-element.c"
++ _g_object_unref0 (_tmp0_);
++ result = TRUE;
++#line 78 "ease-text-element.vala"
++ return result;
++#line 455 "ease-text-element.c"
++}
++
++
++static ClutterColor* _clutter_color_dup (ClutterColor* self) {
++ ClutterColor* dup;
++ dup = g_new0 (ClutterColor, 1);
++ memcpy (dup, self, sizeof (ClutterColor));
++ return dup;
++}
++
++
++static gpointer __clutter_color_dup0 (gpointer self) {
++ return self ? _clutter_color_dup (self) : NULL;
++}
++
++
++#line 84 "ease-text-element.vala"
++static ClutterColor* ease_text_element_real_get_color (EaseElement* base) {
++#line 474 "ease-text-element.c"
++ EaseTextElement * self;
++ ClutterColor* result = NULL;
++ ClutterColor _tmp1_;
++ ClutterColor _tmp0_ = {0};
++ self = (EaseTextElement*) base;
++ result = __clutter_color_dup0 ((_tmp1_ = (ease_color_get_clutter (self->priv->_color, &_tmp0_), _tmp0_), &_tmp1_));
++#line 86 "ease-text-element.vala"
++ return result;
++#line 483 "ease-text-element.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 124 "ease-text-element.vala"
++static void _lambda98_ (GObject* obj, GParamSpec* spec, Block22Data* _data22_) {
++#line 494 "ease-text-element.c"
++ EaseTextElement * self;
++ self = _data22_->self;
++#line 124 "ease-text-element.vala"
++ g_return_if_fail (obj != NULL);
++#line 124 "ease-text-element.vala"
++ g_return_if_fail (spec != NULL);
++#line 125 "ease-text-element.vala"
++ switch (self->priv->_text_align) {
++#line 503 "ease-text-element.c"
++ case PANGO_ALIGN_LEFT:
++ {
++#line 128 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->left, GTK_RELIEF_NORMAL);
++#line 129 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->center, GTK_RELIEF_NONE);
++#line 130 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->right, GTK_RELIEF_NONE);
++#line 131 "ease-text-element.vala"
++ break;
++#line 514 "ease-text-element.c"
++ }
++ case PANGO_ALIGN_CENTER:
++ {
++#line 133 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->left, GTK_RELIEF_NONE);
++#line 134 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->center, GTK_RELIEF_NORMAL);
++#line 135 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->right, GTK_RELIEF_NONE);
++#line 136 "ease-text-element.vala"
++ break;
++#line 526 "ease-text-element.c"
++ }
++ case PANGO_ALIGN_RIGHT:
++ {
++#line 138 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->left, GTK_RELIEF_NONE);
++#line 139 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->center, GTK_RELIEF_NONE);
++#line 140 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->right, GTK_RELIEF_NORMAL);
++#line 141 "ease-text-element.vala"
++ break;
++#line 538 "ease-text-element.c"
++ }
++ }
++}
++
++
++#line 124 "ease-text-element.vala"
++static void __lambda98__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 546 "ease-text-element.c"
++ _lambda98_ (_sender, pspec, self);
++}
++
++
++#line 149 "ease-text-element.vala"
++static void _lambda99_ (GtkFontButton* button, Block22Data* _data22_) {
++#line 553 "ease-text-element.c"
++ EaseTextElement * self;
++ EaseUndoAction* action;
++ PangoFontDescription* _tmp0_;
++ self = _data22_->self;
++#line 149 "ease-text-element.vala"
++ g_return_if_fail (button != NULL);
++#line 150 "ease-text-element.vala"
++ action = ease_undo_action_new ((GObject*) self, "font-description");
++#line 151 "ease-text-element.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) action);
++#line 152 "ease-text-element.vala"
++ ease_text_element_set_font_description (self, _tmp0_ = pango_font_description_from_string (gtk_font_button_get_font_name (_data22_->font)));
++#line 566 "ease-text-element.c"
++ _pango_font_description_free0 (_tmp0_);
++ _g_object_unref0 (action);
++}
++
++
++#line 149 "ease-text-element.vala"
++static void __lambda99__gtk_font_button_font_set (GtkFontButton* _sender, gpointer self) {
++#line 574 "ease-text-element.c"
++ _lambda99_ (_sender, self);
++}
++
++
++#line 156 "ease-text-element.vala"
++static void _lambda100_ (GObject* obj, GParamSpec* spec, Block22Data* _data22_) {
++#line 581 "ease-text-element.c"
++ EaseTextElement * self;
++ PangoFontDescription* _tmp0_;
++ self = _data22_->self;
++#line 156 "ease-text-element.vala"
++ g_return_if_fail (obj != NULL);
++#line 156 "ease-text-element.vala"
++ g_return_if_fail (spec != NULL);
++#line 157 "ease-text-element.vala"
++ gtk_font_button_set_font_name (_data22_->font, pango_font_description_to_string (_tmp0_ = ease_text_element_get_font_description (self)));
++#line 591 "ease-text-element.c"
++ _pango_font_description_free0 (_tmp0_);
++}
++
++
++#line 156 "ease-text-element.vala"
++static void __lambda100__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 598 "ease-text-element.c"
++ _lambda100_ (_sender, pspec, self);
++}
++
++
++#line 164 "ease-text-element.vala"
++static void _lambda101_ (GtkColorButton* button, Block22Data* _data22_) {
++#line 605 "ease-text-element.c"
++ EaseTextElement * self;
++ EaseUndoAction* action;
++ EaseColor* _tmp2_;
++ GdkColor _tmp1_;
++ GdkColor _tmp0_ = {0};
++ self = _data22_->self;
++#line 164 "ease-text-element.vala"
++ g_return_if_fail (button != NULL);
++#line 165 "ease-text-element.vala"
++ action = ease_undo_action_new ((GObject*) self, "color");
++#line 166 "ease-text-element.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) action);
++#line 167 "ease-text-element.vala"
++ ease_text_element_set_color (self, _tmp2_ = ease_color_new_from_gdk ((_tmp1_ = (gtk_color_button_get_color (_data22_->color_b, &_tmp0_), _tmp0_), &_tmp1_)));
++#line 620 "ease-text-element.c"
++ _g_object_unref0 (_tmp2_);
++ _g_object_unref0 (action);
++}
++
++
++#line 164 "ease-text-element.vala"
++static void __lambda101__gtk_color_button_color_set (GtkColorButton* _sender, gpointer self) {
++#line 628 "ease-text-element.c"
++ _lambda101_ (_sender, self);
++}
++
++
++#line 170 "ease-text-element.vala"
++static void _lambda102_ (GObject* obj, GParamSpec* spec, Block22Data* _data22_) {
++#line 635 "ease-text-element.c"
++ EaseTextElement * self;
++ GdkColor _tmp0_ = {0};
++ GdkColor _tmp1_;
++ self = _data22_->self;
++#line 170 "ease-text-element.vala"
++ g_return_if_fail (obj != NULL);
++#line 170 "ease-text-element.vala"
++ g_return_if_fail (spec != NULL);
++#line 171 "ease-text-element.vala"
++ gtk_color_button_set_color (_data22_->color_b, (_tmp1_ = (ease_color_get_gdk (self->priv->_color, &_tmp0_), _tmp0_), &_tmp1_));
++#line 646 "ease-text-element.c"
++}
++
++
++#line 170 "ease-text-element.vala"
++static void __lambda102__g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
++#line 652 "ease-text-element.c"
++ _lambda102_ (_sender, pspec, self);
++}
++
++
++static Block22Data* block22_data_ref (Block22Data* _data22_) {
++ g_atomic_int_inc (&_data22_->_ref_count_);
++ return _data22_;
++}
++
++
++static void block22_data_unref (Block22Data* _data22_) {
++ if (g_atomic_int_dec_and_test (&_data22_->_ref_count_)) {
++ _g_object_unref0 (_data22_->self);
++ _g_object_unref0 (_data22_->color_b);
++ _g_object_unref0 (_data22_->font);
++ _g_object_unref0 (_data22_->right);
++ _g_object_unref0 (_data22_->center);
++ _g_object_unref0 (_data22_->left);
++ g_slice_free (Block22Data, _data22_);
++ }
++}
++
++
++#line 89 "ease-text-element.vala"
++static GtkWidget* ease_text_element_real_inspector_widget (EaseElement* base) {
++#line 678 "ease-text-element.c"
++ EaseTextElement * self;
++ GtkWidget* result = NULL;
++ GError * _inner_error_;
++ Block22Data* _data22_;
++ GtkBuilder* builder;
++ GObject* _tmp2_;
++ GObject* _tmp3_;
++ GObject* _tmp4_;
++ GObject* _tmp5_;
++ PangoFontDescription* _tmp6_;
++ GObject* _tmp7_;
++ GdkColor _tmp9_;
++ GdkColor _tmp8_ = {0};
++ GtkWidget* _tmp11_;
++ GObject* _tmp10_;
++ self = (EaseTextElement*) base;
++ _inner_error_ = NULL;
++ _data22_ = g_slice_new0 (Block22Data);
++ _data22_->_ref_count_ = 1;
++ _data22_->self = g_object_ref (self);
++#line 91 "ease-text-element.vala"
++ if (self->priv->inspector_pane != NULL) {
++#line 701 "ease-text-element.c"
++ result = _g_object_ref0 (self->priv->inspector_pane);
++ block22_data_unref (_data22_);
++#line 91 "ease-text-element.vala"
++ return result;
++#line 706 "ease-text-element.c"
++ }
++#line 93 "ease-text-element.vala"
++ builder = gtk_builder_new ();
++#line 710 "ease-text-element.c"
++ {
++ char* _tmp1_;
++ char* _tmp0_;
++#line 96 "ease-text-element.vala"
++ gtk_builder_add_from_file (builder, _tmp1_ = ease_data_path (_tmp0_ = g_build_filename (EASE_TEMP_UI_DIR, EASE_TEXT_ELEMENT_UI_FILE_PATH, NULL)), &_inner_error_);
++#line 716 "ease-text-element.c"
++ _g_free0 (_tmp1_);
++ _g_free0 (_tmp0_);
++ if (_inner_error_ != NULL) {
++ goto __catch22_g_error;
++ }
++ }
++ goto __finally22;
++ __catch22_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 99 "ease-text-element.vala"
++ g_error ("ease-text-element.vala:99: Error loading UI: %s", e->message);
++#line 732 "ease-text-element.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally22:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (builder);
++ block22_data_unref (_data22_);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++#line 102 "ease-text-element.vala"
++ gtk_builder_connect_signals (builder, self);
++#line 746 "ease-text-element.c"
++ _data22_->left = _g_object_ref0 ((_tmp2_ = gtk_builder_get_object (builder, "left-button"), GTK_IS_BUTTON (_tmp2_) ? ((GtkButton*) _tmp2_) : NULL));
++ _data22_->center = _g_object_ref0 ((_tmp3_ = gtk_builder_get_object (builder, "center-button"), GTK_IS_BUTTON (_tmp3_) ? ((GtkButton*) _tmp3_) : NULL));
++ _data22_->right = _g_object_ref0 ((_tmp4_ = gtk_builder_get_object (builder, "right-button"), GTK_IS_BUTTON (_tmp4_) ? ((GtkButton*) _tmp4_) : NULL));
++#line 110 "ease-text-element.vala"
++ switch (self->priv->_text_align) {
++#line 752 "ease-text-element.c"
++ case PANGO_ALIGN_LEFT:
++ {
++#line 113 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->left, GTK_RELIEF_NORMAL);
++#line 114 "ease-text-element.vala"
++ break;
++#line 759 "ease-text-element.c"
++ }
++ case PANGO_ALIGN_CENTER:
++ {
++#line 116 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->center, GTK_RELIEF_NORMAL);
++#line 117 "ease-text-element.vala"
++ break;
++#line 767 "ease-text-element.c"
++ }
++ case PANGO_ALIGN_RIGHT:
++ {
++#line 119 "ease-text-element.vala"
++ gtk_button_set_relief (_data22_->right, GTK_RELIEF_NORMAL);
++#line 120 "ease-text-element.vala"
++ break;
++#line 775 "ease-text-element.c"
++ }
++ }
++#line 124 "ease-text-element.vala"
++ g_signal_connect_data ((GObject*) self, "notify::text-align", (GCallback) __lambda98__g_object_notify, block22_data_ref (_data22_), (GClosureNotify) block22_data_unref, 0);
++#line 780 "ease-text-element.c"
++ _data22_->font = _g_object_ref0 ((_tmp5_ = gtk_builder_get_object (builder, "font-button"), GTK_IS_FONT_BUTTON (_tmp5_) ? ((GtkFontButton*) _tmp5_) : NULL));
++#line 147 "ease-text-element.vala"
++ gtk_font_button_set_font_name (_data22_->font, pango_font_description_to_string (_tmp6_ = ease_text_element_get_font_description (self)));
++#line 784 "ease-text-element.c"
++ _pango_font_description_free0 (_tmp6_);
++#line 149 "ease-text-element.vala"
++ g_signal_connect_data (_data22_->font, "font-set", (GCallback) __lambda99__gtk_font_button_font_set, block22_data_ref (_data22_), (GClosureNotify) block22_data_unref, 0);
++#line 156 "ease-text-element.vala"
++ g_signal_connect_data ((GObject*) self, "notify::font-description", (GCallback) __lambda100__g_object_notify, block22_data_ref (_data22_), (GClosureNotify) block22_data_unref, 0);
++#line 790 "ease-text-element.c"
++ _data22_->color_b = _g_object_ref0 ((_tmp7_ = gtk_builder_get_object (builder, "color-button"), GTK_IS_COLOR_BUTTON (_tmp7_) ? ((GtkColorButton*) _tmp7_) : NULL));
++#line 162 "ease-text-element.vala"
++ gtk_color_button_set_color (_data22_->color_b, (_tmp9_ = (ease_color_get_gdk (self->priv->_color, &_tmp8_), _tmp8_), &_tmp9_));
++#line 164 "ease-text-element.vala"
++ g_signal_connect_data (_data22_->color_b, "color-set", (GCallback) __lambda101__gtk_color_button_color_set, block22_data_ref (_data22_), (GClosureNotify) block22_data_unref, 0);
++#line 170 "ease-text-element.vala"
++ g_signal_connect_data ((GObject*) self, "notify::color", (GCallback) __lambda102__g_object_notify, block22_data_ref (_data22_), (GClosureNotify) block22_data_unref, 0);
++#line 798 "ease-text-element.c"
++ result = _g_object_ref0 (self->priv->inspector_pane = (_tmp11_ = _g_object_ref0 ((_tmp10_ = gtk_builder_get_object (builder, "root"), GTK_IS_WIDGET (_tmp10_) ? ((GtkWidget*) _tmp10_) : NULL)), _g_object_unref0 (self->priv->inspector_pane), _tmp11_));
++ _g_object_unref0 (builder);
++ block22_data_unref (_data22_);
++#line 175 "ease-text-element.vala"
++ return result;
++#line 804 "ease-text-element.c"
++ _g_object_unref0 (builder);
++ block22_data_unref (_data22_);
++}
++
++
++#line 181 "ease-text-element.vala"
++static void _lambda103_ (GtkWidget* widget, EaseTextElement* self) {
++#line 812 "ease-text-element.c"
++ GtkWidget* _tmp0_;
++#line 181 "ease-text-element.vala"
++ g_return_if_fail (widget != NULL);
++#line 182 "ease-text-element.vala"
++ gtk_button_set_relief ((_tmp0_ = widget, GTK_IS_BUTTON (_tmp0_) ? ((GtkButton*) _tmp0_) : NULL), GTK_RELIEF_NONE);
++#line 818 "ease-text-element.c"
++}
++
++
++#line 181 "ease-text-element.vala"
++static void __lambda103__gtk_callback (GtkWidget* widget, gpointer self) {
++#line 824 "ease-text-element.c"
++ _lambda103_ (widget, self);
++}
++
++
++#line 179 "ease-text-element.vala"
++void ease_text_element_on_inspector_alignment (GtkWidget* sender, EaseTextElement* self) {
++#line 831 "ease-text-element.c"
++ GtkWidget* _tmp0_;
++ GtkWidget* _tmp1_;
++ EaseUndoAction* action;
++ PangoAlignment old;
++ char* _tmp5_;
++ GtkWidget* _tmp2_;
++ GtkWidget* _tmp3_;
++ char* _tmp4_ = NULL;
++#line 179 "ease-text-element.vala"
++ g_return_if_fail (self != NULL);
++#line 179 "ease-text-element.vala"
++ g_return_if_fail (sender != NULL);
++#line 181 "ease-text-element.vala"
++ gtk_container_foreach ((_tmp0_ = gtk_widget_get_parent (sender), GTK_IS_CONTAINER (_tmp0_) ? ((GtkContainer*) _tmp0_) : NULL), __lambda103__gtk_callback, self);
++#line 185 "ease-text-element.vala"
++ gtk_button_set_relief ((_tmp1_ = sender, GTK_IS_BUTTON (_tmp1_) ? ((GtkButton*) _tmp1_) : NULL), GTK_RELIEF_NORMAL);
++#line 187 "ease-text-element.vala"
++ action = ease_undo_action_new ((GObject*) self, "text-align");
++#line 188 "ease-text-element.vala"
++ old = self->priv->_text_align;
++#line 190 "ease-text-element.vala"
++ ease_text_element_text_align_from_string (self, _tmp5_ = (g_object_get ((_tmp3_ = gtk_bin_get_child ((_tmp2_ = sender, GTK_IS_BIN (_tmp2_) ? ((GtkBin*) _tmp2_) : NULL)), GTK_IS_IMAGE (_tmp3_) ? ((GtkImage*) _tmp3_) : NULL), "stock", &_tmp4_, NULL), _tmp4_));
++#line 854 "ease-text-element.c"
++ _g_free0 (_tmp5_);
++#line 193 "ease-text-element.vala"
++ if (self->priv->_text_align != old) {
++#line 195 "ease-text-element.vala"
++ g_signal_emit_by_name ((EaseUndoSource*) self, "undo", (EaseUndoItem*) action);
++#line 860 "ease-text-element.c"
++ }
++ _g_object_unref0 (action);
++}
++
++
++#line 687 "glib-2.0.vapi"
++static char* double_to_string (double self) {
++#line 868 "ease-text-element.c"
++ char* result = NULL;
++ gint _tmp0__length1;
++ gchar* _tmp0_;
++ char* _tmp1_;
++ result = (_tmp1_ = g_strdup (g_ascii_dtostr ((_tmp0_ = g_new0 (gchar, G_ASCII_DTOSTR_BUF_SIZE), _tmp0__length1 = G_ASCII_DTOSTR_BUF_SIZE, _tmp0_), G_ASCII_DTOSTR_BUF_SIZE, self)), _tmp0_ = (g_free (_tmp0_), NULL), _tmp1_);
++#line 688 "glib-2.0.vapi"
++ return result;
++#line 876 "ease-text-element.c"
++}
++
++
++#line 1156 "glib-2.0.vapi"
++static char* string_replace (const char* self, const char* old, const char* replacement) {
++#line 882 "ease-text-element.c"
++ char* result = NULL;
++ GError * _inner_error_;
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (old != NULL, NULL);
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (replacement != NULL, NULL);
++#line 891 "ease-text-element.c"
++ _inner_error_ = NULL;
++ {
++ char* _tmp0_;
++ GRegex* _tmp1_;
++ GRegex* regex;
++ char* _tmp2_;
++#line 1158 "glib-2.0.vapi"
++ regex = (_tmp1_ = g_regex_new (_tmp0_ = g_regex_escape_string (old, -1), 0, 0, &_inner_error_), _g_free0 (_tmp0_), _tmp1_);
++#line 900 "ease-text-element.c"
++ if (_inner_error_ != NULL) {
++ if (_inner_error_->domain == G_REGEX_ERROR) {
++ goto __catch23_g_regex_error;
++ }
++ g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++#line 1159 "glib-2.0.vapi"
++ _tmp2_ = g_regex_replace_literal (regex, self, (gssize) (-1), 0, replacement, 0, &_inner_error_);
++#line 911 "ease-text-element.c"
++ if (_inner_error_ != NULL) {
++ _g_regex_unref0 (regex);
++ if (_inner_error_->domain == G_REGEX_ERROR) {
++ goto __catch23_g_regex_error;
++ }
++ _g_regex_unref0 (regex);
++ g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++ result = _tmp2_;
++ _g_regex_unref0 (regex);
++#line 1159 "glib-2.0.vapi"
++ return result;
++#line 926 "ease-text-element.c"
++ }
++ goto __finally23;
++ __catch23_g_regex_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 1161 "glib-2.0.vapi"
++ g_assert_not_reached ();
++#line 937 "ease-text-element.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally23:
++ if (_inner_error_ != NULL) {
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++}
++
++
++#line 199 "ease-text-element.vala"
++static void ease_text_element_real_write_html (EaseElement* base, char** html, EaseHTMLExporter* exporter) {
++#line 952 "ease-text-element.c"
++ EaseTextElement * self;
++ char* _tmp0_;
++ char* _tmp1_;
++ char* _tmp5_;
++ char* _tmp4_;
++ char* _tmp3_;
++ char* _tmp2_;
++ char* _tmp9_;
++ char* _tmp8_;
++ char* _tmp7_;
++ char* _tmp6_;
++ char* _tmp13_;
++ char* _tmp12_;
++ char* _tmp11_;
++ char* _tmp10_;
++ char* _tmp17_;
++ char* _tmp16_;
++ char* _tmp15_;
++ char* _tmp14_;
++ char* _tmp18_;
++ char* _tmp24_;
++ char* _tmp23_;
++ char* _tmp22_;
++ char* _tmp21_;
++ char* _tmp20_;
++ char* _tmp19_;
++ char* _tmp27_;
++ char* _tmp26_;
++ char* _tmp25_;
++ char* _tmp31_;
++ char* _tmp30_;
++ char* _tmp29_;
++ char* _tmp28_;
++ char* _tmp35_;
++ char* _tmp34_;
++ char* _tmp33_;
++ char* _tmp32_;
++ char* _tmp40_;
++ char* _tmp39_;
++ char* _tmp38_;
++ char* _tmp37_;
++ char* _tmp36_;
++ char* _tmp44_;
++ char* _tmp43_;
++ char* _tmp42_;
++ char* _tmp41_;
++ char* _tmp48_;
++ char* _tmp47_;
++ char* _tmp46_;
++ char* _tmp45_;
++ self = (EaseTextElement*) base;
++#line 199 "ease-text-element.vala"
++ g_return_if_fail (html != NULL);
++#line 199 "ease-text-element.vala"
++ g_return_if_fail (exporter != NULL);
++#line 202 "ease-text-element.vala"
++ *html = (_tmp0_ = g_strconcat (*html, "<div class=\"text element\" ", NULL), _g_free0 (*html), _tmp0_);
++#line 205 "ease-text-element.vala"
++ *html = (_tmp1_ = g_strconcat (*html, "style=\"", NULL), _g_free0 (*html), _tmp1_);
++#line 206 "ease-text-element.vala"
++ *html = (_tmp5_ = g_strconcat (*html, _tmp4_ = g_strconcat (_tmp3_ = g_strconcat ("left:", _tmp2_ = g_strdup_printf ("%g", ease_element_get_x ((EaseElement*) self)), NULL), "px;", NULL), NULL), _g_free0 (*html), _tmp5_);
++#line 1014 "ease-text-element.c"
++ _g_free0 (_tmp4_);
++ _g_free0 (_tmp3_);
++ _g_free0 (_tmp2_);
++#line 207 "ease-text-element.vala"
++ *html = (_tmp9_ = g_strconcat (*html, _tmp8_ = g_strconcat (_tmp7_ = g_strconcat (" top:", _tmp6_ = g_strdup_printf ("%g", ease_element_get_y ((EaseElement*) self)), NULL), "px;", NULL), NULL), _g_free0 (*html), _tmp9_);
++#line 1020 "ease-text-element.c"
++ _g_free0 (_tmp8_);
++ _g_free0 (_tmp7_);
++ _g_free0 (_tmp6_);
++#line 208 "ease-text-element.vala"
++ *html = (_tmp13_ = g_strconcat (*html, _tmp12_ = g_strconcat (_tmp11_ = g_strconcat (" width:", _tmp10_ = g_strdup_printf ("%g", ease_element_get_width ((EaseElement*) self)), NULL), "px;", NULL), NULL), _g_free0 (*html), _tmp13_);
++#line 1026 "ease-text-element.c"
++ _g_free0 (_tmp12_);
++ _g_free0 (_tmp11_);
++ _g_free0 (_tmp10_);
++#line 209 "ease-text-element.vala"
++ *html = (_tmp17_ = g_strconcat (*html, _tmp16_ = g_strconcat (_tmp15_ = g_strconcat (" height:", _tmp14_ = g_strdup_printf ("%g", ease_element_get_width ((EaseElement*) self)), NULL), "px;", NULL), NULL), _g_free0 (*html), _tmp17_);
++#line 1032 "ease-text-element.c"
++ _g_free0 (_tmp16_);
++ _g_free0 (_tmp15_);
++ _g_free0 (_tmp14_);
++#line 210 "ease-text-element.vala"
++ *html = (_tmp18_ = g_strconcat (*html, " position: absolute;", NULL), _g_free0 (*html), _tmp18_);
++#line 213 "ease-text-element.vala"
++ *html = (_tmp24_ = g_strconcat (*html, _tmp23_ = g_strconcat (" color:", _tmp22_ = g_strconcat ("rgb(", _tmp19_ = double_to_string (ease_color_get_red (self->priv->_color)), ",", _tmp20_ = double_to_string (ease_color_get_green (self->priv->_color)), ",", _tmp21_ = double_to_string (ease_color_get_blue (self->priv->_color)), ");", NULL), NULL), NULL), _g_free0 (*html), _tmp24_);
++#line 1040 "ease-text-element.c"
++ _g_free0 (_tmp23_);
++ _g_free0 (_tmp22_);
++ _g_free0 (_tmp21_);
++ _g_free0 (_tmp20_);
++ _g_free0 (_tmp19_);
++#line 216 "ease-text-element.vala"
++ *html = (_tmp27_ = g_strconcat (*html, _tmp26_ = g_strconcat (_tmp25_ = g_strconcat (" font-family:'", ease_text_element_get_text_font (self), NULL), "', sans-serif;", NULL), NULL), _g_free0 (*html), _tmp27_);
++#line 1048 "ease-text-element.c"
++ _g_free0 (_tmp26_);
++ _g_free0 (_tmp25_);
++#line 218 "ease-text-element.vala"
++ *html = (_tmp31_ = g_strconcat (*html, _tmp30_ = g_strconcat (_tmp29_ = g_strconcat (" font-size:", _tmp28_ = ease_text_element_text_size_to_string (self), NULL), "pt;", NULL), NULL), _g_free0 (*html), _tmp31_);
++#line 1053 "ease-text-element.c"
++ _g_free0 (_tmp30_);
++ _g_free0 (_tmp29_);
++ _g_free0 (_tmp28_);
++#line 220 "ease-text-element.vala"
++ *html = (_tmp35_ = g_strconcat (*html, _tmp34_ = g_strconcat (_tmp33_ = g_strconcat (" font-weight:", _tmp32_ = ease_text_element_text_weight_to_string (self), NULL), ";", NULL), NULL), _g_free0 (*html), _tmp35_);
++#line 1059 "ease-text-element.c"
++ _g_free0 (_tmp34_);
++ _g_free0 (_tmp33_);
++ _g_free0 (_tmp32_);
++#line 221 "ease-text-element.vala"
++ *html = (_tmp40_ = g_strconcat (*html, _tmp39_ = g_strconcat (_tmp38_ = g_strconcat (" font-style:", _tmp37_ = g_utf8_strdown (_tmp36_ = ease_text_element_text_style_to_string (self), -1), NULL), ";", NULL), NULL), _g_free0 (*html), _tmp40_);
++#line 1065 "ease-text-element.c"
++ _g_free0 (_tmp39_);
++ _g_free0 (_tmp38_);
++ _g_free0 (_tmp37_);
++ _g_free0 (_tmp36_);
++#line 224 "ease-text-element.vala"
++ *html = (_tmp44_ = g_strconcat (*html, _tmp43_ = g_strconcat (_tmp42_ = g_strconcat (" text-align:", _tmp41_ = ease_text_element_text_align_to_string (self), NULL), ";\"", NULL), NULL), _g_free0 (*html), _tmp44_);
++#line 1072 "ease-text-element.c"
++ _g_free0 (_tmp43_);
++ _g_free0 (_tmp42_);
++ _g_free0 (_tmp41_);
++#line 227 "ease-text-element.vala"
++ *html = (_tmp48_ = g_strconcat (*html, _tmp47_ = g_strconcat (_tmp46_ = g_strconcat (">", _tmp45_ = string_replace (self->priv->_text, "\n", "<br />"), NULL), "</div>", NULL), NULL), _g_free0 (*html), _tmp48_);
++#line 1078 "ease-text-element.c"
++ _g_free0 (_tmp47_);
++ _g_free0 (_tmp46_);
++ _g_free0 (_tmp45_);
++}
++
++
++static glong string_get_length (const char* self) {
++ glong result;
++ g_return_val_if_fail (self != NULL, 0L);
++ result = g_utf8_strlen (self, -1);
++#line 1166 "glib-2.0.vapi"
++ return result;
++#line 1091 "ease-text-element.c"
++}
++
++
++#line 234 "ease-text-element.vala"
++static void ease_text_element_real_cairo_render (EaseElement* base, cairo_t* context, GError** error) {
++#line 1097 "ease-text-element.c"
++ EaseTextElement * self;
++ PangoLayout* layout;
++ PangoFontDescription* _tmp0_;
++ self = (EaseTextElement*) base;
++#line 234 "ease-text-element.vala"
++ g_return_if_fail (context != NULL);
++#line 237 "ease-text-element.vala"
++ layout = pango_cairo_create_layout (context);
++#line 238 "ease-text-element.vala"
++ pango_layout_set_text (layout, self->priv->_text, (gint) string_get_length (self->priv->_text));
++#line 239 "ease-text-element.vala"
++ pango_layout_set_width (layout, (gint) (ease_element_get_width ((EaseElement*) self) * PANGO_SCALE));
++#line 240 "ease-text-element.vala"
++ pango_layout_set_height (layout, (gint) (ease_element_get_height ((EaseElement*) self) * PANGO_SCALE));
++#line 241 "ease-text-element.vala"
++ pango_layout_set_font_description (layout, _tmp0_ = ease_text_element_get_font_description (self));
++#line 1114 "ease-text-element.c"
++ _pango_font_description_free0 (_tmp0_);
++#line 242 "ease-text-element.vala"
++ pango_layout_set_alignment (layout, self->priv->_text_align);
++#line 245 "ease-text-element.vala"
++ cairo_save (context);
++#line 247 "ease-text-element.vala"
++ ease_color_set_cairo (self->priv->_color, context);
++#line 249 "ease-text-element.vala"
++ pango_cairo_update_layout (context, layout);
++#line 250 "ease-text-element.vala"
++ cairo_move_to (context, (double) ((gint) ease_element_get_x ((EaseElement*) self)), (double) ((gint) ease_element_get_y ((EaseElement*) self)));
++#line 252 "ease-text-element.vala"
++ pango_cairo_show_layout (context, layout);
++#line 253 "ease-text-element.vala"
++ cairo_restore (context);
++#line 1130 "ease-text-element.c"
++ _g_object_unref0 (layout);
++}
++
++
++#line 294 "ease-text-element.vala"
++char* ease_text_element_text_style_to_string (EaseTextElement* self) {
++#line 1137 "ease-text-element.c"
++ char* result = NULL;
++#line 294 "ease-text-element.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 296 "ease-text-element.vala"
++ switch (ease_text_element_get_text_style (self)) {
++#line 1143 "ease-text-element.c"
++ case PANGO_STYLE_OBLIQUE:
++ {
++ result = g_strdup ("oblique");
++#line 299 "ease-text-element.vala"
++ return result;
++#line 1149 "ease-text-element.c"
++ }
++ case PANGO_STYLE_ITALIC:
++ {
++ result = g_strdup ("italic");
++#line 301 "ease-text-element.vala"
++ return result;
++#line 1156 "ease-text-element.c"
++ }
++ case PANGO_STYLE_NORMAL:
++ {
++ result = g_strdup ("normal");
++#line 303 "ease-text-element.vala"
++ return result;
++#line 1163 "ease-text-element.c"
++ }
++ default:
++ {
++#line 305 "ease-text-element.vala"
++ g_critical ("ease-text-element.vala:305: Invalid text style");
++#line 1169 "ease-text-element.c"
++ result = g_strdup ("normal");
++#line 306 "ease-text-element.vala"
++ return result;
++#line 1173 "ease-text-element.c"
++ }
++ }
++}
++
++
++#line 310 "ease-text-element.vala"
++void ease_text_element_text_style_from_string (EaseTextElement* self, const char* str) {
++#line 1181 "ease-text-element.c"
++ GQuark _tmp1_;
++ const char* _tmp0_;
++ static GQuark _tmp1__label0 = 0;
++ static GQuark _tmp1__label1 = 0;
++#line 310 "ease-text-element.vala"
++ g_return_if_fail (self != NULL);
++#line 310 "ease-text-element.vala"
++ g_return_if_fail (str != NULL);
++#line 1190 "ease-text-element.c"
++ _tmp0_ = str;
++ _tmp1_ = (NULL == _tmp0_) ? 0 : g_quark_from_string (_tmp0_);
++ if (_tmp1_ == ((0 != _tmp1__label0) ? _tmp1__label0 : (_tmp1__label0 = g_quark_from_static_string ("oblique"))))
++ switch (0) {
++ default:
++ {
++#line 315 "ease-text-element.vala"
++ ease_text_element_set_text_style (self, PANGO_STYLE_OBLIQUE);
++#line 316 "ease-text-element.vala"
++ break;
++#line 1201 "ease-text-element.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label1) ? _tmp1__label1 : (_tmp1__label1 = g_quark_from_static_string ("italic"))))
++ switch (0) {
++ default:
++ {
++#line 318 "ease-text-element.vala"
++ ease_text_element_set_text_style (self, PANGO_STYLE_ITALIC);
++#line 319 "ease-text-element.vala"
++ break;
++#line 1211 "ease-text-element.c"
++ }
++ } else
++ switch (0) {
++ default:
++ {
++#line 321 "ease-text-element.vala"
++ ease_text_element_set_text_style (self, PANGO_STYLE_NORMAL);
++#line 322 "ease-text-element.vala"
++ break;
++#line 1221 "ease-text-element.c"
++ }
++ }
++}
++
++
++#line 340 "ease-text-element.vala"
++void ease_text_element_text_variant_from_string (EaseTextElement* self, const char* str) {
++#line 1229 "ease-text-element.c"
++ PangoVariant _tmp0_ = 0;
++#line 340 "ease-text-element.vala"
++ g_return_if_fail (self != NULL);
++#line 340 "ease-text-element.vala"
++ g_return_if_fail (str != NULL);
++#line 342 "ease-text-element.vala"
++ if (_vala_strcmp0 (str, "normal") == 0) {
++#line 343 "ease-text-element.vala"
++ _tmp0_ = PANGO_VARIANT_NORMAL;
++#line 1239 "ease-text-element.c"
++ } else {
++#line 343 "ease-text-element.vala"
++ _tmp0_ = PANGO_VARIANT_SMALL_CAPS;
++#line 1243 "ease-text-element.c"
++ }
++#line 342 "ease-text-element.vala"
++ ease_text_element_set_text_variant (self, _tmp0_);
++#line 1247 "ease-text-element.c"
++}
++
++
++#line 346 "ease-text-element.vala"
++char* ease_text_element_text_variant_to_string (EaseTextElement* self) {
++#line 1253 "ease-text-element.c"
++ char* result = NULL;
++ const char* _tmp0_;
++#line 346 "ease-text-element.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 1258 "ease-text-element.c"
++ _tmp0_ = NULL;
++#line 348 "ease-text-element.vala"
++ if (ease_text_element_get_text_variant (self) == PANGO_VARIANT_NORMAL) {
++#line 348 "ease-text-element.vala"
++ _tmp0_ = "Normal";
++#line 1264 "ease-text-element.c"
++ } else {
++#line 348 "ease-text-element.vala"
++ _tmp0_ = "Small Caps";
++#line 1268 "ease-text-element.c"
++ }
++ result = g_strdup (_tmp0_);
++#line 348 "ease-text-element.vala"
++ return result;
++#line 1273 "ease-text-element.c"
++}
++
++
++#line 366 "ease-text-element.vala"
++void ease_text_element_text_weight_from_string (EaseTextElement* self, const char* str) {
++#line 366 "ease-text-element.vala"
++ g_return_if_fail (self != NULL);
++#line 366 "ease-text-element.vala"
++ g_return_if_fail (str != NULL);
++#line 368 "ease-text-element.vala"
++ ease_text_element_set_text_weight (self, (gint) ((PangoWeight) atoi (str)));
++#line 1285 "ease-text-element.c"
++}
++
++
++#line 371 "ease-text-element.vala"
++char* ease_text_element_text_weight_to_string (EaseTextElement* self) {
++#line 1291 "ease-text-element.c"
++ char* result = NULL;
++#line 371 "ease-text-element.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 1295 "ease-text-element.c"
++ result = g_strdup_printf ("%i", (gint) ease_text_element_get_text_weight (self));
++#line 373 "ease-text-element.vala"
++ return result;
++#line 1299 "ease-text-element.c"
++}
++
++
++#line 412 "ease-text-element.vala"
++void ease_text_element_text_align_from_string (EaseTextElement* self, const char* str) {
++#line 1305 "ease-text-element.c"
++ GQuark _tmp1_;
++ const char* _tmp0_;
++ static GQuark _tmp1__label0 = 0;
++ static GQuark _tmp1__label1 = 0;
++ static GQuark _tmp1__label2 = 0;
++ static GQuark _tmp1__label3 = 0;
++ static GQuark _tmp1__label4 = 0;
++ static GQuark _tmp1__label5 = 0;
++#line 412 "ease-text-element.vala"
++ g_return_if_fail (self != NULL);
++#line 412 "ease-text-element.vala"
++ g_return_if_fail (str != NULL);
++#line 1318 "ease-text-element.c"
++ _tmp0_ = str;
++ _tmp1_ = (NULL == _tmp0_) ? 0 : g_quark_from_string (_tmp0_);
++ if ((_tmp1_ == ((0 != _tmp1__label0) ? _tmp1__label0 : (_tmp1__label0 = g_quark_from_static_string ("right")))) || (_tmp1_ == ((0 != _tmp1__label1) ? _tmp1__label1 : (_tmp1__label1 = g_quark_from_static_string ("gtk-justify-right")))))
++ switch (0) {
++ default:
++ {
++#line 418 "ease-text-element.vala"
++ ease_text_element_set_text_align (self, PANGO_ALIGN_RIGHT);
++#line 419 "ease-text-element.vala"
++ break;
++#line 1329 "ease-text-element.c"
++ }
++ } else if ((_tmp1_ == ((0 != _tmp1__label2) ? _tmp1__label2 : (_tmp1__label2 = g_quark_from_static_string ("center")))) || (_tmp1_ == ((0 != _tmp1__label3) ? _tmp1__label3 : (_tmp1__label3 = g_quark_from_static_string ("gtk-justify-center")))))
++ switch (0) {
++ default:
++ {
++#line 422 "ease-text-element.vala"
++ ease_text_element_set_text_align (self, PANGO_ALIGN_CENTER);
++#line 423 "ease-text-element.vala"
++ break;
++#line 1339 "ease-text-element.c"
++ }
++ } else if ((_tmp1_ == ((0 != _tmp1__label4) ? _tmp1__label4 : (_tmp1__label4 = g_quark_from_static_string ("left")))) || (_tmp1_ == ((0 != _tmp1__label5) ? _tmp1__label5 : (_tmp1__label5 = g_quark_from_static_string ("gtk-justify-left")))))
++ switch (0) {
++ default:
++ {
++#line 426 "ease-text-element.vala"
++ ease_text_element_set_text_align (self, PANGO_ALIGN_LEFT);
++#line 427 "ease-text-element.vala"
++ break;
++#line 1349 "ease-text-element.c"
++ }
++ } else
++ switch (0) {
++ default:
++ {
++#line 429 "ease-text-element.vala"
++ g_critical ("ease-text-element.vala:429: Illegal alignment: %s", str);
++#line 430 "ease-text-element.vala"
++ ease_text_element_set_text_align (self, PANGO_ALIGN_LEFT);
++#line 431 "ease-text-element.vala"
++ break;
++#line 1361 "ease-text-element.c"
++ }
++ }
++}
++
++
++#line 435 "ease-text-element.vala"
++char* ease_text_element_text_align_to_string (EaseTextElement* self) {
++#line 1369 "ease-text-element.c"
++ char* result = NULL;
++#line 435 "ease-text-element.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 437 "ease-text-element.vala"
++ switch (self->priv->_text_align) {
++#line 1375 "ease-text-element.c"
++ case PANGO_ALIGN_RIGHT:
++ {
++ result = g_strdup ("right");
++#line 440 "ease-text-element.vala"
++ return result;
++#line 1381 "ease-text-element.c"
++ }
++ case PANGO_ALIGN_CENTER:
++ {
++ result = g_strdup ("center");
++#line 442 "ease-text-element.vala"
++ return result;
++#line 1388 "ease-text-element.c"
++ }
++ default:
++ {
++ result = g_strdup ("left");
++#line 444 "ease-text-element.vala"
++ return result;
++#line 1395 "ease-text-element.c"
++ }
++ }
++}
++
++
++#line 465 "ease-text-element.vala"
++void ease_text_element_text_size_from_string (EaseTextElement* self, const char* str) {
++#line 465 "ease-text-element.vala"
++ g_return_if_fail (self != NULL);
++#line 465 "ease-text-element.vala"
++ g_return_if_fail (str != NULL);
++#line 467 "ease-text-element.vala"
++ ease_text_element_set_text_size (self, atoi (str));
++#line 1409 "ease-text-element.c"
++}
++
++
++#line 470 "ease-text-element.vala"
++char* ease_text_element_text_size_to_string (EaseTextElement* self) {
++#line 1415 "ease-text-element.c"
++ char* result = NULL;
++#line 470 "ease-text-element.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 1419 "ease-text-element.c"
++ result = g_strdup_printf ("%i", ease_text_element_get_text_size (self));
++#line 472 "ease-text-element.vala"
++ return result;
++#line 1423 "ease-text-element.c"
++}
++
++
++const char* ease_text_element_get_text (EaseTextElement* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_text;
++#line 259 "ease-text-element.vala"
++ return result;
++#line 1433 "ease-text-element.c"
++}
++
++
++void ease_text_element_set_text (EaseTextElement* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_text = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_text), _tmp0_);
++ g_object_notify ((GObject *) self, "text");
++}
++
++
++EaseColor* ease_text_element_get_color (EaseTextElement* self) {
++ EaseColor* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_color;
++#line 264 "ease-text-element.vala"
++ return result;
++#line 1451 "ease-text-element.c"
++}
++
++
++void ease_text_element_set_color (EaseTextElement* self, EaseColor* value) {
++ EaseColor* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_color = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_color), _tmp0_);
++ g_object_notify ((GObject *) self, "color");
++}
++
++
++const char* ease_text_element_get_text_font (EaseTextElement* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->text_font_priv;
++#line 271 "ease-text-element.vala"
++ return result;
++#line 1469 "ease-text-element.c"
++}
++
++
++void ease_text_element_set_text_font (EaseTextElement* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++#line 274 "ease-text-element.vala"
++ self->priv->text_font_priv = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->text_font_priv), _tmp0_);
++#line 275 "ease-text-element.vala"
++ if (!self->priv->freeze) {
++#line 275 "ease-text-element.vala"
++ g_object_notify ((GObject*) self, "font-description");
++#line 1482 "ease-text-element.c"
++ }
++ g_object_notify ((GObject *) self, "text-font");
++}
++
++
++PangoStyle ease_text_element_get_text_style (EaseTextElement* self) {
++ PangoStyle result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->text_style_priv;
++#line 285 "ease-text-element.vala"
++ return result;
++#line 1494 "ease-text-element.c"
++}
++
++
++void ease_text_element_set_text_style (EaseTextElement* self, PangoStyle value) {
++ g_return_if_fail (self != NULL);
++#line 288 "ease-text-element.vala"
++ self->priv->text_style_priv = value;
++#line 289 "ease-text-element.vala"
++ if (!self->priv->freeze) {
++#line 289 "ease-text-element.vala"
++ g_object_notify ((GObject*) self, "font-description");
++#line 1506 "ease-text-element.c"
++ }
++ g_object_notify ((GObject *) self, "text-style");
++}
++
++
++PangoVariant ease_text_element_get_text_variant (EaseTextElement* self) {
++ PangoVariant result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->text_variant_priv;
++#line 331 "ease-text-element.vala"
++ return result;
++#line 1518 "ease-text-element.c"
++}
++
++
++void ease_text_element_set_text_variant (EaseTextElement* self, PangoVariant value) {
++ g_return_if_fail (self != NULL);
++#line 334 "ease-text-element.vala"
++ self->priv->text_variant_priv = value;
++#line 335 "ease-text-element.vala"
++ if (!self->priv->freeze) {
++#line 335 "ease-text-element.vala"
++ g_object_notify ((GObject*) self, "font-description");
++#line 1530 "ease-text-element.c"
++ }
++ g_object_notify ((GObject *) self, "text-variant");
++}
++
++
++gint ease_text_element_get_text_weight (EaseTextElement* self) {
++ gint result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->text_weight_priv;
++#line 356 "ease-text-element.vala"
++ return result;
++#line 1542 "ease-text-element.c"
++}
++
++
++void ease_text_element_set_text_weight (EaseTextElement* self, gint value) {
++ g_return_if_fail (self != NULL);
++#line 359 "ease-text-element.vala"
++ self->priv->text_weight_priv = value;
++#line 360 "ease-text-element.vala"
++ if (!self->priv->freeze) {
++#line 360 "ease-text-element.vala"
++ g_object_notify ((GObject*) self, "font-description");
++#line 1554 "ease-text-element.c"
++ }
++ g_object_notify ((GObject *) self, "text-weight");
++}
++
++
++PangoFontDescription* ease_text_element_get_font_description (EaseTextElement* self) {
++ PangoFontDescription* result;
++ PangoFontDescription* desc;
++ g_return_val_if_fail (self != NULL, NULL);
++#line 386 "ease-text-element.vala"
++ desc = pango_font_description_new ();
++#line 387 "ease-text-element.vala"
++ pango_font_description_set_family (desc, ease_text_element_get_text_font (self));
++#line 388 "ease-text-element.vala"
++ pango_font_description_set_style (desc, ease_text_element_get_text_style (self));
++#line 389 "ease-text-element.vala"
++ pango_font_description_set_weight (desc, (PangoWeight) ease_text_element_get_text_weight (self));
++#line 390 "ease-text-element.vala"
++ pango_font_description_set_variant (desc, ease_text_element_get_text_variant (self));
++#line 391 "ease-text-element.vala"
++ pango_font_description_set_size (desc, ease_text_element_get_text_size (self) * PANGO_SCALE);
++#line 1576 "ease-text-element.c"
++ result = desc;
++#line 393 "ease-text-element.vala"
++ return result;
++#line 1580 "ease-text-element.c"
++}
++
++
++void ease_text_element_set_font_description (EaseTextElement* self, const PangoFontDescription* value) {
++ g_return_if_fail (self != NULL);
++#line 397 "ease-text-element.vala"
++ self->priv->freeze = TRUE;
++#line 398 "ease-text-element.vala"
++ ease_text_element_set_text_font (self, pango_font_description_get_family (value));
++#line 399 "ease-text-element.vala"
++ ease_text_element_set_text_style (self, pango_font_description_get_style (value));
++#line 400 "ease-text-element.vala"
++ ease_text_element_set_text_weight (self, (gint) pango_font_description_get_weight (value));
++#line 401 "ease-text-element.vala"
++ ease_text_element_set_text_variant (self, pango_font_description_get_variant (value));
++#line 402 "ease-text-element.vala"
++ ease_text_element_set_text_size (self, pango_font_description_get_size (value) / PANGO_SCALE);
++#line 403 "ease-text-element.vala"
++ self->priv->freeze = FALSE;
++#line 1600 "ease-text-element.c"
++ g_object_notify ((GObject *) self, "font-description");
++}
++
++
++PangoAlignment ease_text_element_get_text_align (EaseTextElement* self) {
++ PangoAlignment result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->_text_align;
++#line 410 "ease-text-element.vala"
++ return result;
++#line 1611 "ease-text-element.c"
++}
++
++
++void ease_text_element_set_text_align (EaseTextElement* self, PangoAlignment value) {
++ g_return_if_fail (self != NULL);
++ self->priv->_text_align = value;
++ g_object_notify ((GObject *) self, "text-align");
++}
++
++
++gint ease_text_element_get_text_size (EaseTextElement* self) {
++ gint result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = self->priv->text_size_priv;
++#line 456 "ease-text-element.vala"
++ return result;
++#line 1628 "ease-text-element.c"
++}
++
++
++void ease_text_element_set_text_size (EaseTextElement* self, gint value) {
++ g_return_if_fail (self != NULL);
++#line 459 "ease-text-element.vala"
++ self->priv->text_size_priv = value;
++#line 460 "ease-text-element.vala"
++ if (!self->priv->freeze) {
++#line 460 "ease-text-element.vala"
++ g_object_notify ((GObject*) self, "font-description");
++#line 1640 "ease-text-element.c"
++ }
++ g_object_notify ((GObject *) self, "text-size");
++}
++
++
++static void ease_text_element_class_init (EaseTextElementClass * klass) {
++ ease_text_element_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseTextElementPrivate));
++ EASE_ELEMENT_CLASS (klass)->to_json = ease_text_element_real_to_json;
++ EASE_ELEMENT_CLASS (klass)->actor = ease_text_element_real_actor;
++ EASE_ELEMENT_CLASS (klass)->set_color = ease_text_element_real_set_color;
++ EASE_ELEMENT_CLASS (klass)->get_color = ease_text_element_real_get_color;
++ EASE_ELEMENT_CLASS (klass)->inspector_widget = ease_text_element_real_inspector_widget;
++ EASE_ELEMENT_CLASS (klass)->write_html = ease_text_element_real_write_html;
++ EASE_ELEMENT_CLASS (klass)->cairo_render = ease_text_element_real_cairo_render;
++ G_OBJECT_CLASS (klass)->get_property = ease_text_element_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_text_element_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_text_element_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_TEXT_ELEMENT_TEXT, g_param_spec_string ("text", "text", "text", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_TEXT_ELEMENT_COLOR, g_param_spec_object ("color", "color", "color", EASE_TYPE_COLOR, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_TEXT_ELEMENT_TEXT_FONT, g_param_spec_string ("text-font", "text-font", "text-font", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_TEXT_ELEMENT_TEXT_STYLE, g_param_spec_enum ("text-style", "text-style", "text-style", PANGO_TYPE_STYLE, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_TEXT_ELEMENT_TEXT_VARIANT, g_param_spec_enum ("text-variant", "text-variant", "text-variant", PANGO_TYPE_VARIANT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_TEXT_ELEMENT_TEXT_WEIGHT, g_param_spec_int ("text-weight", "text-weight", "text-weight", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_TEXT_ELEMENT_FONT_DESCRIPTION, g_param_spec_boxed ("font-description", "font-description", "font-description", PANGO_TYPE_FONT_DESCRIPTION, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_TEXT_ELEMENT_TEXT_ALIGN, g_param_spec_enum ("text-align", "text-align", "text-align", PANGO_TYPE_ALIGNMENT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_TEXT_ELEMENT_TEXT_SIZE, g_param_spec_int ("text-size", "text-size", "text-size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++}
++
++
++static void ease_text_element_instance_init (EaseTextElement * self) {
++ self->priv = EASE_TEXT_ELEMENT_GET_PRIVATE (self);
++ self->priv->freeze = FALSE;
++}
++
++
++static void ease_text_element_finalize (GObject* obj) {
++ EaseTextElement * self;
++ self = EASE_TEXT_ELEMENT (obj);
++ _g_object_unref0 (self->priv->inspector_pane);
++ _g_free0 (self->priv->_text);
++ _g_object_unref0 (self->priv->_color);
++ _g_free0 (self->priv->text_font_priv);
++ G_OBJECT_CLASS (ease_text_element_parent_class)->finalize (obj);
++}
++
++
++GType ease_text_element_get_type (void) {
++ static volatile gsize ease_text_element_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_text_element_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseTextElementClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_text_element_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseTextElement), 0, (GInstanceInitFunc) ease_text_element_instance_init, NULL };
++ GType ease_text_element_type_id;
++ ease_text_element_type_id = g_type_register_static (EASE_TYPE_ELEMENT, "EaseTextElement", &g_define_type_info, 0);
++ g_once_init_leave (&ease_text_element_type_id__volatile, ease_text_element_type_id);
++ }
++ return ease_text_element_type_id__volatile;
++}
++
++
++static void ease_text_element_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseTextElement * self;
++ self = EASE_TEXT_ELEMENT (object);
++ switch (property_id) {
++ case EASE_TEXT_ELEMENT_TEXT:
++ g_value_set_string (value, ease_text_element_get_text (self));
++ break;
++ case EASE_TEXT_ELEMENT_COLOR:
++ g_value_set_object (value, ease_text_element_get_color (self));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_FONT:
++ g_value_set_string (value, ease_text_element_get_text_font (self));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_STYLE:
++ g_value_set_enum (value, ease_text_element_get_text_style (self));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_VARIANT:
++ g_value_set_enum (value, ease_text_element_get_text_variant (self));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_WEIGHT:
++ g_value_set_int (value, ease_text_element_get_text_weight (self));
++ break;
++ case EASE_TEXT_ELEMENT_FONT_DESCRIPTION:
++ g_value_take_boxed (value, ease_text_element_get_font_description (self));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_ALIGN:
++ g_value_set_enum (value, ease_text_element_get_text_align (self));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_SIZE:
++ g_value_set_int (value, ease_text_element_get_text_size (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_text_element_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseTextElement * self;
++ self = EASE_TEXT_ELEMENT (object);
++ switch (property_id) {
++ case EASE_TEXT_ELEMENT_TEXT:
++ ease_text_element_set_text (self, g_value_get_string (value));
++ break;
++ case EASE_TEXT_ELEMENT_COLOR:
++ ease_text_element_set_color (self, g_value_get_object (value));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_FONT:
++ ease_text_element_set_text_font (self, g_value_get_string (value));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_STYLE:
++ ease_text_element_set_text_style (self, g_value_get_enum (value));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_VARIANT:
++ ease_text_element_set_text_variant (self, g_value_get_enum (value));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_WEIGHT:
++ ease_text_element_set_text_weight (self, g_value_get_int (value));
++ break;
++ case EASE_TEXT_ELEMENT_FONT_DESCRIPTION:
++ ease_text_element_set_font_description (self, g_value_get_boxed (value));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_ALIGN:
++ ease_text_element_set_text_align (self, g_value_get_enum (value));
++ break;
++ case EASE_TEXT_ELEMENT_TEXT_SIZE:
++ ease_text_element_set_text_size (self, g_value_get_int (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static int _vala_strcmp0 (const char * str1, const char * str2) {
++ if (str1 == NULL) {
++ return -(str1 != str2);
++ }
++ if (str2 == NULL) {
++ return str1 != str2;
++ }
++ return strcmp (str1, str2);
++}
++
++
++
++
diff --cc ease-core/ease-theme.c
index 0000000,0000000..5b3d9a0
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-theme.c
@@@ -1,0 -1,0 +1,1456 @@@
++/* ease-theme.c generated by valac, the Vala compiler
++ * generated from ease-theme.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <stdlib.h>
++#include <string.h>
++#include <gee.h>
++#include <json-glib/json-glib.h>
++#include <glib/gi18n-lib.h>
++#include <gio/gio.h>
++#include <float.h>
++#include <math.h>
++
++
++#define EASE_TYPE_THEME (ease_theme_get_type ())
++#define EASE_THEME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_THEME, EaseTheme))
++#define EASE_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_THEME, EaseThemeClass))
++#define EASE_IS_THEME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_THEME))
++#define EASE_IS_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_THEME))
++#define EASE_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_THEME, EaseThemeClass))
++
++typedef struct _EaseTheme EaseTheme;
++typedef struct _EaseThemeClass EaseThemeClass;
++typedef struct _EaseThemePrivate EaseThemePrivate;
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++#define _json_object_unref0(var) ((var == NULL) ? NULL : (var = (json_object_unref (var), NULL)))
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++
++#define EASE_TYPE_COLOR (ease_color_get_type ())
++#define EASE_COLOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_COLOR, EaseColor))
++#define EASE_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_COLOR, EaseColorClass))
++#define EASE_IS_COLOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_COLOR))
++#define EASE_IS_COLOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_COLOR))
++#define EASE_COLOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_COLOR, EaseColorClass))
++
++typedef struct _EaseColor EaseColor;
++typedef struct _EaseColorClass EaseColorClass;
++
++#define EASE_TYPE_BACKGROUND_TYPE (ease_background_type_get_type ())
++
++#define EASE_TYPE_GRADIENT (ease_gradient_get_type ())
++#define EASE_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_GRADIENT, EaseGradient))
++#define EASE_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_GRADIENT, EaseGradientClass))
++#define EASE_IS_GRADIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_GRADIENT))
++#define EASE_IS_GRADIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_GRADIENT))
++#define EASE_GRADIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_GRADIENT, EaseGradientClass))
++
++typedef struct _EaseGradient EaseGradient;
++typedef struct _EaseGradientClass EaseGradientClass;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++
++#define EASE_TYPE_TEXT_ELEMENT (ease_text_element_get_type ())
++#define EASE_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElement))
++#define EASE_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++#define EASE_IS_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_IS_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_TEXT_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++
++typedef struct _EaseTextElement EaseTextElement;
++typedef struct _EaseTextElementClass EaseTextElementClass;
++#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
++
++struct _EaseTheme {
++ GObject parent_instance;
++ EaseThemePrivate * priv;
++ char* title;
++};
++
++struct _EaseThemeClass {
++ GObjectClass parent_class;
++};
++
++struct _EaseThemePrivate {
++ char* _path;
++ GeeMap* masters;
++ GeeMap* elements;
++ GeeMap* master_defaults;
++ GeeMap* element_defaults;
++};
++
++typedef enum {
++ EASE_BACKGROUND_TYPE_COLOR,
++ EASE_BACKGROUND_TYPE_GRADIENT,
++ EASE_BACKGROUND_TYPE_IMAGE
++} EaseBackgroundType;
++
++
++static EaseTheme* ease_theme_defaults_store;
++static EaseTheme* ease_theme_defaults_store = NULL;
++static gpointer ease_theme_parent_class = NULL;
++
++GType ease_theme_get_type (void) G_GNUC_CONST;
++#define EASE_THEME_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_THEME, EaseThemePrivate))
++enum {
++ EASE_THEME_DUMMY_PROPERTY,
++ EASE_THEME_PATH
++};
++#define EASE_THEME_DEFAULTS_PATH "theme-defaults.json"
++#define EASE_THEME_JSON_PATH "Theme.json"
++#define EASE_THEME_MEDIA_PATH "Media"
++#define EASE_THEME_MASTERS "masters"
++#define EASE_THEME_ELEMENTS "elements"
++#define EASE_THEME_MASTER_DEF "master-defaults"
++#define EASE_THEME_ELEMENT_DEF "element-defaults"
++#define EASE_THEME_THEME_TITLE "title"
++#define EASE_THEME_THEME_AUTHOR "author"
++#define EASE_THEME_TITLE "title"
++#define EASE_THEME_CONTENT "content"
++#define EASE_THEME_CONTENT_HEADER "content-header"
++#define EASE_THEME_CONTENT_DUAL "content-dual"
++#define EASE_THEME_CONTENT_DUAL_HEADER "content-dual-header"
++#define EASE_THEME_MEDIA "media"
++#define EASE_THEME_MEDIA_HEADER "media-header"
++#define EASE_THEME_BACKGROUND_COLOR "background-color"
++#define EASE_THEME_BACKGROUND_GRADIENT "background-gradient"
++#define EASE_THEME_BACKGROUND_IMAGE "background-image"
++#define EASE_THEME_S_IDENTIFIER "slide-identifier"
++#define EASE_THEME_BACKGROUND_TYPE "background-type"
++#define EASE_THEME_BACKGROUND_TYPE_COLOR "background-type-color"
++#define EASE_THEME_BACKGROUND_TYPE_GRADIENT "background-type-gradient"
++#define EASE_THEME_BACKGROUND_TYPE_IMAGE "background-type-image"
++#define EASE_THEME_TITLE_TEXT "title-text"
++#define EASE_THEME_AUTHOR_TEXT "author-text"
++#define EASE_THEME_CONTENT_TEXT "content-text"
++#define EASE_THEME_HEADER_TEXT "header-text"
++#define EASE_THEME_CUSTOM_TEXT "custom-text"
++#define EASE_THEME_TEXT_FONT "text-font"
++#define EASE_THEME_TEXT_SIZE "text-size"
++#define EASE_THEME_TEXT_STYLE "text-style"
++#define EASE_THEME_TEXT_VARIANT "text-variant"
++#define EASE_THEME_TEXT_WEIGHT "text-weight"
++#define EASE_THEME_TEXT_ALIGN "text-align"
++#define EASE_THEME_TEXT_COLOR "text-color"
++#define EASE_THEME_TEXT_TEXT "text"
++#define EASE_THEME_CONTENT_MEDIA "content-media"
++#define EASE_THEME_CUSTOM_MEDIA "custom-media"
++#define EASE_THEME_MEDIA_FILENAME "media-filename"
++#define EASE_THEME_MEDIA_SOURCE_FILENAME "media-source-filename"
++#define EASE_THEME_GRAD_LINEAR "linear"
++#define EASE_THEME_GRAD_LINEAR_MIRRORED "linear-mirrored"
++#define EASE_THEME_GRAD_RADIAL "radial"
++#define EASE_THEME_E_IDENTIFIER "element-identifier"
++#define EASE_THEME_ELEMENT_TYPE "element-type"
++#define EASE_THEME_PAD_LEFT "padding-left"
++#define EASE_THEME_PAD_RIGHT "padding-right"
++#define EASE_THEME_PAD_TOP "padding-top"
++#define EASE_THEME_PAD_BOTTOM "padding-bottom"
++#define EASE_THEME_WIDTH "width"
++#define EASE_THEME_HEIGHT "height"
++#define EASE_THEME_X "x"
++#define EASE_THEME_Y "y"
++#define EASE_THEME_HAS_BEEN_EDITED "has-been-edited"
++void ease_theme_set_path (EaseTheme* self, const char* value);
++static void ease_theme_load_from_json (EaseTheme* self, const char* json_path);
++const char* ease_theme_get_path (EaseTheme* self);
++EaseTheme* ease_theme_new (const char* dir_path);
++EaseTheme* ease_theme_construct (GType object_type, const char* dir_path);
++EaseTheme* ease_theme_new_json (const char* json_path);
++EaseTheme* ease_theme_construct_json (GType object_type, const char* json_path);
++static EaseTheme* ease_theme_new_copy (EaseTheme* copy_from);
++static EaseTheme* ease_theme_construct_copy (GType object_type, EaseTheme* copy_from);
++void ease_recursive_copy (const char* from_dir, const char* to_dir, GError** error);
++EaseTheme* ease_theme_copy_to_path (EaseTheme* self, const char* copy_to, GError** error);
++static void ease_theme_fill_map (EaseTheme* self, JsonObject* obj, const char* name, GeeMap* map);
++static void ease_theme_fill_single_map (EaseTheme* self, JsonObject* obj, GeeMap* map);
++void ease_theme_copy_media (EaseTheme* self, const char* target, GError** error);
++EaseSlide* ease_slide_new (void);
++EaseSlide* ease_slide_construct (GType object_type);
++GType ease_slide_get_type (void) G_GNUC_CONST;
++static char* ease_theme_master_get (EaseTheme* self, const char* master, const char* prop);
++EaseColor* ease_color_new_from_string (const char* str);
++EaseColor* ease_color_construct_from_string (GType object_type, const char* str);
++GType ease_color_get_type (void) G_GNUC_CONST;
++void ease_slide_set_background_color (EaseSlide* self, EaseColor* value);
++GType ease_background_type_get_type (void) G_GNUC_CONST;
++void ease_slide_set_background_type (EaseSlide* self, EaseBackgroundType value);
++EaseGradient* ease_gradient_new_from_string (const char* str);
++EaseGradient* ease_gradient_construct_from_string (GType object_type, const char* str);
++GType ease_gradient_get_type (void) G_GNUC_CONST;
++void ease_slide_set_background_gradient (EaseSlide* self, EaseGradient* value);
++void ease_slide_set_background_image (EaseSlide* self, const char* value);
++static char* ease_theme_element_get (EaseTheme* self, const char* element, const char* prop);
++GType ease_element_get_type (void) G_GNUC_CONST;
++void ease_slide_add (EaseSlide* self, EaseElement* e);
++GType ease_text_element_get_type (void) G_GNUC_CONST;
++static EaseTextElement* ease_theme_create_text (EaseTheme* self, const char* type, gint x, gint y, gint w, gint h);
++EaseSlide* ease_theme_create_slide (EaseTheme* self, const char* master, gint width, gint height);
++EaseTextElement* ease_theme_create_custom_text (EaseTheme* self);
++EaseTextElement* ease_text_element_new (void);
++EaseTextElement* ease_text_element_construct (GType object_type);
++void ease_text_element_set_text_font (EaseTextElement* self, const char* value);
++void ease_text_element_text_size_from_string (EaseTextElement* self, const char* str);
++void ease_text_element_text_style_from_string (EaseTextElement* self, const char* str);
++void ease_text_element_text_variant_from_string (EaseTextElement* self, const char* str);
++void ease_text_element_text_weight_from_string (EaseTextElement* self, const char* str);
++void ease_text_element_text_align_from_string (EaseTextElement* self, const char* str);
++void ease_text_element_set_color (EaseTextElement* self, EaseColor* value);
++void ease_element_set_x (EaseElement* self, float value);
++void ease_element_set_y (EaseElement* self, float value);
++void ease_element_set_width (EaseElement* self, float value);
++void ease_element_set_height (EaseElement* self, float value);
++void ease_element_set_identifier (EaseElement* self, const char* value);
++void ease_element_set_has_been_edited (EaseElement* self, gboolean value);
++void ease_text_element_set_text (EaseTextElement* self, const char* value);
++static EaseTheme* ease_theme_get_defaults (void);
++char* ease_theme_master_mnemonic_description (const char* master);
++char* ease_theme_master_description (const char* master);
++char* ease_theme_master_from_description (const char* desc);
++char* ease_data_path (const char* path);
++static void ease_theme_finalize (GObject* obj);
++static void ease_theme_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_theme_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++static int _vala_strcmp0 (const char * str1, const char * str2);
++
++const char* EASE_THEME_MASTER_SLIDES[7] = {EASE_THEME_TITLE, EASE_THEME_CONTENT_HEADER, EASE_THEME_CONTENT, EASE_THEME_CONTENT_DUAL_HEADER, EASE_THEME_CONTENT_DUAL, EASE_THEME_MEDIA_HEADER, EASE_THEME_MEDIA};
++static const char* EASE_THEME_TEXT_PROPS[6] = {EASE_THEME_TEXT_FONT, EASE_THEME_TEXT_SIZE, EASE_THEME_TEXT_STYLE, EASE_THEME_TEXT_VARIANT, EASE_THEME_TEXT_WEIGHT, EASE_THEME_TEXT_ALIGN};
++
++
++#line 187 "ease-theme.vala"
++EaseTheme* ease_theme_construct (GType object_type, const char* dir_path) {
++#line 260 "ease-theme.c"
++ EaseTheme * self;
++ char* _tmp0_;
++#line 187 "ease-theme.vala"
++ g_return_val_if_fail (dir_path != NULL, NULL);
++#line 187 "ease-theme.vala"
++ self = (EaseTheme*) g_object_new (object_type, NULL);
++#line 189 "ease-theme.vala"
++ ease_theme_set_path (self, dir_path);
++#line 190 "ease-theme.vala"
++ ease_theme_load_from_json (self, _tmp0_ = g_build_filename (self->priv->_path, EASE_THEME_JSON_PATH, NULL));
++#line 271 "ease-theme.c"
++ _g_free0 (_tmp0_);
++ return self;
++}
++
++
++#line 187 "ease-theme.vala"
++EaseTheme* ease_theme_new (const char* dir_path) {
++#line 187 "ease-theme.vala"
++ return ease_theme_construct (EASE_TYPE_THEME, dir_path);
++#line 281 "ease-theme.c"
++}
++
++
++#line 201 "ease-theme.vala"
++EaseTheme* ease_theme_construct_json (GType object_type, const char* json_path) {
++#line 287 "ease-theme.c"
++ EaseTheme * self;
++#line 201 "ease-theme.vala"
++ g_return_val_if_fail (json_path != NULL, NULL);
++#line 201 "ease-theme.vala"
++ self = (EaseTheme*) g_object_new (object_type, NULL);
++#line 203 "ease-theme.vala"
++ ease_theme_load_from_json (self, json_path);
++#line 295 "ease-theme.c"
++ return self;
++}
++
++
++#line 201 "ease-theme.vala"
++EaseTheme* ease_theme_new_json (const char* json_path) {
++#line 201 "ease-theme.vala"
++ return ease_theme_construct_json (EASE_TYPE_THEME, json_path);
++#line 304 "ease-theme.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 214 "ease-theme.vala"
++static EaseTheme* ease_theme_construct_copy (GType object_type, EaseTheme* copy_from) {
++#line 315 "ease-theme.c"
++ EaseTheme * self;
++ GeeMap* _tmp0_;
++ GeeMap* _tmp1_;
++ GeeMap* _tmp2_;
++ GeeMap* _tmp3_;
++ char* _tmp4_;
++#line 214 "ease-theme.vala"
++ g_return_val_if_fail (copy_from != NULL, NULL);
++#line 214 "ease-theme.vala"
++ self = (EaseTheme*) g_object_new (object_type, NULL);
++#line 217 "ease-theme.vala"
++ self->priv->masters = (_tmp0_ = _g_object_ref0 (copy_from->priv->masters), _g_object_unref0 (self->priv->masters), _tmp0_);
++#line 218 "ease-theme.vala"
++ self->priv->elements = (_tmp1_ = _g_object_ref0 (copy_from->priv->elements), _g_object_unref0 (self->priv->elements), _tmp1_);
++#line 219 "ease-theme.vala"
++ self->priv->master_defaults = (_tmp2_ = _g_object_ref0 (copy_from->priv->master_defaults), _g_object_unref0 (self->priv->master_defaults), _tmp2_);
++#line 220 "ease-theme.vala"
++ self->priv->element_defaults = (_tmp3_ = _g_object_ref0 (copy_from->priv->element_defaults), _g_object_unref0 (self->priv->element_defaults), _tmp3_);
++#line 221 "ease-theme.vala"
++ self->title = (_tmp4_ = g_strdup (copy_from->title), _g_free0 (self->title), _tmp4_);
++#line 222 "ease-theme.vala"
++ ease_theme_set_path (self, copy_from->priv->_path);
++#line 338 "ease-theme.c"
++ return self;
++}
++
++
++#line 214 "ease-theme.vala"
++static EaseTheme* ease_theme_new_copy (EaseTheme* copy_from) {
++#line 214 "ease-theme.vala"
++ return ease_theme_construct_copy (EASE_TYPE_THEME, copy_from);
++#line 347 "ease-theme.c"
++}
++
++
++#line 236 "ease-theme.vala"
++EaseTheme* ease_theme_copy_to_path (EaseTheme* self, const char* copy_to, GError** error) {
++#line 353 "ease-theme.c"
++ EaseTheme* result = NULL;
++ GError * _inner_error_;
++ EaseTheme* theme;
++#line 236 "ease-theme.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 236 "ease-theme.vala"
++ g_return_val_if_fail (copy_to != NULL, NULL);
++#line 361 "ease-theme.c"
++ _inner_error_ = NULL;
++#line 239 "ease-theme.vala"
++ ease_recursive_copy (self->priv->_path, copy_to, &_inner_error_);
++#line 365 "ease-theme.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ return NULL;
++ }
++#line 242 "ease-theme.vala"
++ theme = ease_theme_new_copy (self);
++#line 243 "ease-theme.vala"
++ ease_theme_set_path (theme, copy_to);
++#line 374 "ease-theme.c"
++ result = theme;
++#line 244 "ease-theme.vala"
++ return result;
++#line 378 "ease-theme.c"
++}
++
++
++static gpointer _json_object_ref0 (gpointer self) {
++ return self ? json_object_ref (self) : NULL;
++}
++
++
++#line 255 "ease-theme.vala"
++static void ease_theme_load_from_json (EaseTheme* self, const char* json_path) {
++#line 389 "ease-theme.c"
++ GError * _inner_error_;
++ JsonParser* parser;
++ GeeMap* _tmp0_;
++ GeeMap* _tmp1_;
++ GeeMap* _tmp2_;
++ GeeMap* _tmp3_;
++ JsonNode* node;
++ JsonObject* root;
++#line 255 "ease-theme.vala"
++ g_return_if_fail (self != NULL);
++#line 255 "ease-theme.vala"
++ g_return_if_fail (json_path != NULL);
++#line 402 "ease-theme.c"
++ _inner_error_ = NULL;
++#line 257 "ease-theme.vala"
++ parser = json_parser_new ();
++#line 406 "ease-theme.c"
++ {
++#line 260 "ease-theme.vala"
++ json_parser_load_from_file (parser, json_path, &_inner_error_);
++#line 410 "ease-theme.c"
++ if (_inner_error_ != NULL) {
++ goto __catch24_g_error;
++ }
++ }
++ goto __finally24;
++ __catch24_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 264 "ease-theme.vala"
++ g_error (_ ("Error loading theme: %s"), e->message);
++#line 424 "ease-theme.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally24:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (parser);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++#line 268 "ease-theme.vala"
++ self->priv->masters = (_tmp0_ = (GeeMap*) gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, GEE_TYPE_MAP, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL), _g_object_unref0 (self->priv->masters), _tmp0_);
++#line 269 "ease-theme.vala"
++ self->priv->elements = (_tmp1_ = (GeeMap*) gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, GEE_TYPE_MAP, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL), _g_object_unref0 (self->priv->elements), _tmp1_);
++#line 270 "ease-theme.vala"
++ self->priv->master_defaults = (_tmp2_ = (GeeMap*) gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL), _g_object_unref0 (self->priv->master_defaults), _tmp2_);
++#line 271 "ease-theme.vala"
++ self->priv->element_defaults = (_tmp3_ = (GeeMap*) gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL), _g_object_unref0 (self->priv->element_defaults), _tmp3_);
++#line 274 "ease-theme.vala"
++ node = json_parser_get_root (parser);
++#line 275 "ease-theme.vala"
++ if (node == NULL) {
++#line 447 "ease-theme.c"
++ _g_object_unref0 (parser);
++#line 275 "ease-theme.vala"
++ return;
++#line 451 "ease-theme.c"
++ }
++#line 276 "ease-theme.vala"
++ root = _json_object_ref0 (json_node_get_object (node));
++#line 277 "ease-theme.vala"
++ if (root == NULL) {
++#line 457 "ease-theme.c"
++ _json_object_unref0 (root);
++ _g_object_unref0 (parser);
++#line 277 "ease-theme.vala"
++ return;
++#line 462 "ease-theme.c"
++ }
++#line 280 "ease-theme.vala"
++ if (json_object_has_member (root, EASE_THEME_THEME_TITLE)) {
++#line 466 "ease-theme.c"
++ char* _tmp4_;
++#line 281 "ease-theme.vala"
++ self->title = (_tmp4_ = g_strdup (json_node_get_string (json_object_get_member (root, EASE_THEME_THEME_TITLE))), _g_free0 (self->title), _tmp4_);
++#line 470 "ease-theme.c"
++ }
++#line 284 "ease-theme.vala"
++ ease_theme_fill_map (self, root, EASE_THEME_MASTERS, self->priv->masters);
++#line 285 "ease-theme.vala"
++ ease_theme_fill_map (self, root, EASE_THEME_ELEMENTS, self->priv->elements);
++#line 287 "ease-theme.vala"
++ if (json_object_has_member (root, EASE_THEME_MASTER_DEF)) {
++#line 288 "ease-theme.vala"
++ ease_theme_fill_single_map (self, json_object_get_object_member (root, EASE_THEME_MASTER_DEF), self->priv->master_defaults);
++#line 480 "ease-theme.c"
++ }
++#line 290 "ease-theme.vala"
++ if (json_object_has_member (root, EASE_THEME_ELEMENT_DEF)) {
++#line 291 "ease-theme.vala"
++ ease_theme_fill_single_map (self, json_object_get_object_member (root, EASE_THEME_ELEMENT_DEF), self->priv->element_defaults);
++#line 486 "ease-theme.c"
++ }
++ _json_object_unref0 (root);
++ _g_object_unref0 (parser);
++}
++
++
++#line 300 "ease-theme.vala"
++void ease_theme_copy_media (EaseTheme* self, const char* target, GError** error) {
++#line 495 "ease-theme.c"
++ GError * _inner_error_;
++ char* origin_path;
++ GFile* _tmp0_;
++ gboolean _tmp1_;
++ char* target_path;
++#line 300 "ease-theme.vala"
++ g_return_if_fail (self != NULL);
++#line 300 "ease-theme.vala"
++ g_return_if_fail (target != NULL);
++#line 505 "ease-theme.c"
++ _inner_error_ = NULL;
++#line 302 "ease-theme.vala"
++ origin_path = g_build_filename (self->priv->_path, EASE_THEME_MEDIA_PATH, NULL);
++#line 304 "ease-theme.vala"
++ if ((_tmp1_ = !g_file_query_exists (_tmp0_ = g_file_new_for_path (origin_path), NULL), _g_object_unref0 (_tmp0_), _tmp1_)) {
++#line 511 "ease-theme.c"
++ _g_free0 (origin_path);
++#line 304 "ease-theme.vala"
++ return;
++#line 515 "ease-theme.c"
++ }
++#line 306 "ease-theme.vala"
++ target_path = g_build_filename (target, EASE_THEME_MEDIA_PATH, NULL);
++#line 308 "ease-theme.vala"
++ ease_recursive_copy (origin_path, target_path, &_inner_error_);
++#line 521 "ease-theme.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_free0 (target_path);
++ _g_free0 (origin_path);
++ return;
++ }
++ _g_free0 (target_path);
++ _g_free0 (origin_path);
++}
++
++
++#line 319 "ease-theme.vala"
++EaseSlide* ease_theme_create_slide (EaseTheme* self, const char* master, gint width, gint height) {
++#line 535 "ease-theme.c"
++ EaseSlide* result = NULL;
++ EaseSlide* slide;
++ GQuark _tmp6_;
++ char* _tmp5_;
++ GQuark _tmp41_;
++ const char* _tmp40_;
++#line 319 "ease-theme.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 319 "ease-theme.vala"
++ g_return_val_if_fail (master != NULL, NULL);
++#line 321 "ease-theme.vala"
++ slide = ease_slide_new ();
++#line 548 "ease-theme.c"
++ _tmp5_ = ease_theme_master_get (self, master, EASE_THEME_BACKGROUND_TYPE);
++ _tmp6_ = (NULL == _tmp5_) ? 0 : g_quark_from_string (_tmp5_);
++ g_free (_tmp5_);
++ if (_tmp6_ == g_quark_from_string (EASE_THEME_BACKGROUND_TYPE_COLOR))
++ switch (0) {
++ default:
++ {
++ EaseColor* _tmp1_;
++ char* _tmp0_;
++#line 327 "ease-theme.vala"
++ ease_slide_set_background_color (slide, _tmp1_ = ease_color_new_from_string (_tmp0_ = ease_theme_master_get (self, master, EASE_THEME_BACKGROUND_COLOR)));
++#line 560 "ease-theme.c"
++ _g_object_unref0 (_tmp1_);
++ _g_free0 (_tmp0_);
++#line 329 "ease-theme.vala"
++ ease_slide_set_background_type (slide, EASE_BACKGROUND_TYPE_COLOR);
++#line 330 "ease-theme.vala"
++ break;
++#line 567 "ease-theme.c"
++ }
++ } else if (_tmp6_ == g_quark_from_string (EASE_THEME_BACKGROUND_TYPE_GRADIENT))
++ switch (0) {
++ default:
++ {
++ EaseGradient* _tmp3_;
++ char* _tmp2_;
++#line 332 "ease-theme.vala"
++ ease_slide_set_background_gradient (slide, _tmp3_ = ease_gradient_new_from_string (_tmp2_ = ease_theme_master_get (self, master, EASE_THEME_BACKGROUND_GRADIENT)));
++#line 577 "ease-theme.c"
++ _g_object_unref0 (_tmp3_);
++ _g_free0 (_tmp2_);
++#line 334 "ease-theme.vala"
++ ease_slide_set_background_type (slide, EASE_BACKGROUND_TYPE_GRADIENT);
++#line 335 "ease-theme.vala"
++ break;
++#line 584 "ease-theme.c"
++ }
++ } else if (_tmp6_ == g_quark_from_string (EASE_THEME_BACKGROUND_TYPE_IMAGE))
++ switch (0) {
++ default:
++ {
++ char* _tmp4_;
++#line 337 "ease-theme.vala"
++ ease_slide_set_background_image (slide, _tmp4_ = ease_theme_master_get (self, master, EASE_THEME_BACKGROUND_IMAGE));
++#line 593 "ease-theme.c"
++ _g_free0 (_tmp4_);
++#line 338 "ease-theme.vala"
++ ease_slide_set_background_type (slide, EASE_BACKGROUND_TYPE_IMAGE);
++#line 339 "ease-theme.vala"
++ break;
++#line 599 "ease-theme.c"
++ }
++ }
++ _tmp40_ = master;
++ _tmp41_ = (NULL == _tmp40_) ? 0 : g_quark_from_string (_tmp40_);
++ if (_tmp41_ == g_quark_from_string (EASE_THEME_TITLE))
++ switch (0) {
++ default:
++ {
++ char* _tmp7_;
++ gint _tmp8_;
++ gint left;
++ char* _tmp9_;
++ gint _tmp10_;
++ gint h;
++ EaseTextElement* _tmp13_;
++ char* _tmp12_;
++ char* _tmp11_;
++ char* _tmp14_;
++ EaseTextElement* _tmp18_;
++ char* _tmp17_;
++ char* _tmp16_;
++ char* _tmp15_;
++#line 347 "ease-theme.vala"
++ left = (_tmp8_ = atoi (_tmp7_ = ease_theme_element_get (self, EASE_THEME_TITLE_TEXT, EASE_THEME_PAD_LEFT)), _g_free0 (_tmp7_), _tmp8_);
++#line 348 "ease-theme.vala"
++ h = (_tmp10_ = atoi (_tmp9_ = ease_theme_element_get (self, EASE_THEME_TITLE_TEXT, EASE_THEME_HEIGHT)), _g_free0 (_tmp9_), _tmp10_);
++#line 349 "ease-theme.vala"
++ ease_slide_add (slide, (EaseElement*) (_tmp13_ = ease_theme_create_text (self, EASE_THEME_TITLE_TEXT, left, ((height / 2) - h) - atoi (_tmp11_ = ease_theme_element_get (self, EASE_THEME_TITLE_TEXT, EASE_THEME_PAD_BOTTOM)), (width - left) - atoi (_tmp12_ = ease_theme_element_get (self, EASE_THEME_TITLE_TEXT, EASE_THEME_PAD_RIGHT)), h)));
++#line 628 "ease-theme.c"
++ _g_object_unref0 (_tmp13_);
++ _g_free0 (_tmp12_);
++ _g_free0 (_tmp11_);
++#line 358 "ease-theme.vala"
++ left = atoi (_tmp14_ = ease_theme_element_get (self, EASE_THEME_AUTHOR_TEXT, EASE_THEME_PAD_LEFT));
++#line 634 "ease-theme.c"
++ _g_free0 (_tmp14_);
++#line 359 "ease-theme.vala"
++ ease_slide_add (slide, (EaseElement*) (_tmp18_ = ease_theme_create_text (self, EASE_THEME_AUTHOR_TEXT, left, (height / 2) + atoi (_tmp15_ = ease_theme_element_get (self, EASE_THEME_AUTHOR_TEXT, EASE_THEME_PAD_TOP)), (width - left) - atoi (_tmp16_ = ease_theme_element_get (self, EASE_THEME_AUTHOR_TEXT, EASE_THEME_PAD_RIGHT)), atoi (_tmp17_ = ease_theme_element_get (self, EASE_THEME_AUTHOR_TEXT, EASE_THEME_HEIGHT)))));
++#line 638 "ease-theme.c"
++ _g_object_unref0 (_tmp18_);
++ _g_free0 (_tmp17_);
++ _g_free0 (_tmp16_);
++ _g_free0 (_tmp15_);
++#line 366 "ease-theme.vala"
++ break;
++#line 645 "ease-theme.c"
++ }
++ } else if (_tmp41_ == g_quark_from_string (EASE_THEME_CONTENT))
++ switch (0) {
++ default:
++ {
++ char* _tmp19_;
++ gint _tmp20_;
++ gint left;
++ char* _tmp21_;
++ gint _tmp22_;
++ gint top;
++ EaseTextElement* _tmp25_;
++ char* _tmp24_;
++ char* _tmp23_;
++#line 369 "ease-theme.vala"
++ left = (_tmp20_ = atoi (_tmp19_ = ease_theme_element_get (self, EASE_THEME_CONTENT_TEXT, EASE_THEME_PAD_LEFT)), _g_free0 (_tmp19_), _tmp20_);
++#line 370 "ease-theme.vala"
++ top = (_tmp22_ = atoi (_tmp21_ = ease_theme_element_get (self, EASE_THEME_CONTENT_TEXT, EASE_THEME_PAD_TOP)), _g_free0 (_tmp21_), _tmp22_);
++#line 372 "ease-theme.vala"
++ ease_slide_add (slide, (EaseElement*) (_tmp25_ = ease_theme_create_text (self, EASE_THEME_CONTENT_TEXT, left, top, (width - left) - atoi (_tmp23_ = ease_theme_element_get (self, EASE_THEME_CONTENT_TEXT, EASE_THEME_PAD_RIGHT)), (height - top) - atoi (_tmp24_ = ease_theme_element_get (self, EASE_THEME_HEADER_TEXT, EASE_THEME_PAD_BOTTOM)))));
++#line 666 "ease-theme.c"
++ _g_object_unref0 (_tmp25_);
++ _g_free0 (_tmp24_);
++ _g_free0 (_tmp23_);
++#line 379 "ease-theme.vala"
++ break;
++#line 672 "ease-theme.c"
++ }
++ } else if (_tmp41_ == g_quark_from_string (EASE_THEME_CONTENT_HEADER))
++ switch (0) {
++ default:
++ {
++ char* _tmp26_;
++ gint _tmp27_;
++ gint left;
++ char* _tmp28_;
++ gint _tmp29_;
++ gint top;
++ EaseTextElement* _tmp32_;
++ char* _tmp31_;
++ char* _tmp30_;
++ char* _tmp33_;
++ char* _tmp36_;
++ char* _tmp35_;
++ char* _tmp34_;
++ EaseTextElement* _tmp39_;
++ char* _tmp38_;
++ char* _tmp37_;
++#line 383 "ease-theme.vala"
++ left = (_tmp27_ = atoi (_tmp26_ = ease_theme_element_get (self, EASE_THEME_HEADER_TEXT, EASE_THEME_PAD_LEFT)), _g_free0 (_tmp26_), _tmp27_);
++#line 384 "ease-theme.vala"
++ top = (_tmp29_ = atoi (_tmp28_ = ease_theme_element_get (self, EASE_THEME_HEADER_TEXT, EASE_THEME_PAD_TOP)), _g_free0 (_tmp28_), _tmp29_);
++#line 386 "ease-theme.vala"
++ ease_slide_add (slide, (EaseElement*) (_tmp32_ = ease_theme_create_text (self, EASE_THEME_HEADER_TEXT, left, top, (width - left) - atoi (_tmp30_ = ease_theme_element_get (self, EASE_THEME_HEADER_TEXT, EASE_THEME_PAD_RIGHT)), atoi (_tmp31_ = ease_theme_element_get (self, EASE_THEME_HEADER_TEXT, EASE_THEME_HEIGHT)))));
++#line 700 "ease-theme.c"
++ _g_object_unref0 (_tmp32_);
++ _g_free0 (_tmp31_);
++ _g_free0 (_tmp30_);
++#line 395 "ease-theme.vala"
++ left = atoi (_tmp33_ = ease_theme_element_get (self, EASE_THEME_CONTENT_TEXT, EASE_THEME_PAD_LEFT));
++#line 706 "ease-theme.c"
++ _g_free0 (_tmp33_);
++#line 396 "ease-theme.vala"
++ top = top + ((atoi (_tmp34_ = ease_theme_element_get (self, EASE_THEME_HEADER_TEXT, EASE_THEME_HEIGHT)) + atoi (_tmp35_ = ease_theme_element_get (self, EASE_THEME_HEADER_TEXT, EASE_THEME_PAD_BOTTOM))) + atoi (_tmp36_ = ease_theme_element_get (self, EASE_THEME_CONTENT_TEXT, EASE_THEME_PAD_TOP)));
++#line 710 "ease-theme.c"
++ _g_free0 (_tmp36_);
++ _g_free0 (_tmp35_);
++ _g_free0 (_tmp34_);
++#line 399 "ease-theme.vala"
++ ease_slide_add (slide, (EaseElement*) (_tmp39_ = ease_theme_create_text (self, EASE_THEME_CONTENT_TEXT, left, top, (width - left) - atoi (_tmp37_ = ease_theme_element_get (self, EASE_THEME_CONTENT_TEXT, EASE_THEME_PAD_RIGHT)), (height - top) - atoi (_tmp38_ = ease_theme_element_get (self, EASE_THEME_CONTENT_TEXT, EASE_THEME_PAD_BOTTOM)))));
++#line 716 "ease-theme.c"
++ _g_object_unref0 (_tmp39_);
++ _g_free0 (_tmp38_);
++ _g_free0 (_tmp37_);
++#line 406 "ease-theme.vala"
++ break;
++#line 722 "ease-theme.c"
++ }
++ } else if ((((_tmp41_ == g_quark_from_string (EASE_THEME_CONTENT_DUAL)) || (_tmp41_ == g_quark_from_string (EASE_THEME_CONTENT_DUAL_HEADER))) || (_tmp41_ == g_quark_from_string (EASE_THEME_MEDIA))) || (_tmp41_ == g_quark_from_string (EASE_THEME_MEDIA_HEADER)))
++ switch (0) {
++ default:
++ {
++#line 412 "ease-theme.vala"
++ break;
++#line 730 "ease-theme.c"
++ }
++ } else
++ switch (0) {
++ default:
++ {
++#line 414 "ease-theme.vala"
++ g_error (_ ("Invalid master slide title: %s"), master);
++#line 738 "ease-theme.c"
++ result = NULL;
++ _g_object_unref0 (slide);
++#line 415 "ease-theme.vala"
++ return result;
++#line 743 "ease-theme.c"
++ }
++ }
++ result = slide;
++#line 418 "ease-theme.vala"
++ return result;
++#line 749 "ease-theme.c"
++}
++
++
++#line 424 "ease-theme.vala"
++EaseTextElement* ease_theme_create_custom_text (EaseTheme* self) {
++#line 755 "ease-theme.c"
++ EaseTextElement* result = NULL;
++ char* _tmp1_;
++ char* _tmp0_;
++ EaseTextElement* _tmp2_;
++#line 424 "ease-theme.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 762 "ease-theme.c"
++ result = (_tmp2_ = ease_theme_create_text (self, EASE_THEME_CUSTOM_TEXT, 0, 0, atoi (_tmp0_ = ease_theme_element_get (self, EASE_THEME_CUSTOM_TEXT, EASE_THEME_WIDTH)), atoi (_tmp1_ = ease_theme_element_get (self, EASE_THEME_CUSTOM_TEXT, EASE_THEME_HEIGHT))), _g_free0 (_tmp1_), _g_free0 (_tmp0_), _tmp2_);
++#line 426 "ease-theme.vala"
++ return result;
++#line 766 "ease-theme.c"
++}
++
++
++#line 434 "ease-theme.vala"
++static EaseTextElement* ease_theme_create_text (EaseTheme* self, const char* type, gint x, gint y, gint w, gint h) {
++#line 772 "ease-theme.c"
++ EaseTextElement* result = NULL;
++ gboolean _tmp0_ = FALSE;
++ gboolean _tmp1_ = FALSE;
++ gboolean _tmp2_ = FALSE;
++ gboolean _tmp3_ = FALSE;
++ EaseTextElement* text;
++ char* _tmp4_;
++ char* _tmp5_;
++ char* _tmp6_;
++ char* _tmp7_;
++ char* _tmp8_;
++ char* _tmp9_;
++ EaseColor* _tmp11_;
++ char* _tmp10_;
++#line 434 "ease-theme.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 434 "ease-theme.vala"
++ g_return_val_if_fail (type != NULL, NULL);
++#line 437 "ease-theme.vala"
++ if (_vala_strcmp0 (type, EASE_THEME_TITLE_TEXT) == 0) {
++#line 437 "ease-theme.vala"
++ _tmp3_ = TRUE;
++#line 795 "ease-theme.c"
++ } else {
++#line 437 "ease-theme.vala"
++ _tmp3_ = _vala_strcmp0 (type, EASE_THEME_AUTHOR_TEXT) == 0;
++#line 799 "ease-theme.c"
++ }
++#line 437 "ease-theme.vala"
++ if (_tmp3_) {
++#line 437 "ease-theme.vala"
++ _tmp2_ = TRUE;
++#line 805 "ease-theme.c"
++ } else {
++#line 438 "ease-theme.vala"
++ _tmp2_ = _vala_strcmp0 (type, EASE_THEME_CUSTOM_TEXT) == 0;
++#line 809 "ease-theme.c"
++ }
++#line 437 "ease-theme.vala"
++ if (_tmp2_) {
++#line 437 "ease-theme.vala"
++ _tmp1_ = TRUE;
++#line 815 "ease-theme.c"
++ } else {
++#line 438 "ease-theme.vala"
++ _tmp1_ = _vala_strcmp0 (type, EASE_THEME_CONTENT_TEXT) == 0;
++#line 819 "ease-theme.c"
++ }
++#line 437 "ease-theme.vala"
++ if (_tmp1_) {
++#line 437 "ease-theme.vala"
++ _tmp0_ = TRUE;
++#line 825 "ease-theme.c"
++ } else {
++#line 439 "ease-theme.vala"
++ _tmp0_ = _vala_strcmp0 (type, EASE_THEME_HEADER_TEXT) == 0;
++#line 829 "ease-theme.c"
++ }
++#line 437 "ease-theme.vala"
++ if (!_tmp0_) {
++#line 441 "ease-theme.vala"
++ g_error (_ ("Not a valid text element type: %s"), type);
++#line 835 "ease-theme.c"
++ }
++#line 445 "ease-theme.vala"
++ text = ease_text_element_new ();
++#line 448 "ease-theme.vala"
++ ease_text_element_set_text_font (text, _tmp4_ = ease_theme_element_get (self, type, EASE_THEME_TEXT_FONT));
++#line 841 "ease-theme.c"
++ _g_free0 (_tmp4_);
++#line 449 "ease-theme.vala"
++ ease_text_element_text_size_from_string (text, _tmp5_ = ease_theme_element_get (self, type, EASE_THEME_TEXT_SIZE));
++#line 845 "ease-theme.c"
++ _g_free0 (_tmp5_);
++#line 450 "ease-theme.vala"
++ ease_text_element_text_style_from_string (text, _tmp6_ = ease_theme_element_get (self, type, EASE_THEME_TEXT_STYLE));
++#line 849 "ease-theme.c"
++ _g_free0 (_tmp6_);
++#line 451 "ease-theme.vala"
++ ease_text_element_text_variant_from_string (text, _tmp7_ = ease_theme_element_get (self, type, EASE_THEME_TEXT_VARIANT));
++#line 853 "ease-theme.c"
++ _g_free0 (_tmp7_);
++#line 452 "ease-theme.vala"
++ ease_text_element_text_weight_from_string (text, _tmp8_ = ease_theme_element_get (self, type, EASE_THEME_TEXT_WEIGHT));
++#line 857 "ease-theme.c"
++ _g_free0 (_tmp8_);
++#line 453 "ease-theme.vala"
++ ease_text_element_text_align_from_string (text, _tmp9_ = ease_theme_element_get (self, type, EASE_THEME_TEXT_ALIGN));
++#line 861 "ease-theme.c"
++ _g_free0 (_tmp9_);
++#line 456 "ease-theme.vala"
++ ease_text_element_set_color (text, _tmp11_ = ease_color_new_from_string (_tmp10_ = ease_theme_element_get (self, type, EASE_THEME_TEXT_COLOR)));
++#line 865 "ease-theme.c"
++ _g_object_unref0 (_tmp11_);
++ _g_free0 (_tmp10_);
++#line 459 "ease-theme.vala"
++ ease_element_set_x ((EaseElement*) text, (float) x);
++#line 460 "ease-theme.vala"
++ ease_element_set_y ((EaseElement*) text, (float) y);
++#line 461 "ease-theme.vala"
++ ease_element_set_width ((EaseElement*) text, (float) w);
++#line 462 "ease-theme.vala"
++ ease_element_set_height ((EaseElement*) text, (float) h);
++#line 465 "ease-theme.vala"
++ ease_element_set_identifier ((EaseElement*) text, type);
++#line 466 "ease-theme.vala"
++ ease_element_set_has_been_edited ((EaseElement*) text, FALSE);
++#line 467 "ease-theme.vala"
++ ease_text_element_set_text (text, "");
++#line 882 "ease-theme.c"
++ result = text;
++#line 469 "ease-theme.vala"
++ return result;
++#line 886 "ease-theme.c"
++}
++
++
++#line 478 "ease-theme.vala"
++static char* ease_theme_element_get (EaseTheme* self, const char* element, const char* prop) {
++#line 892 "ease-theme.c"
++ char* result = NULL;
++ GeeMap* map;
++ char* str;
++#line 478 "ease-theme.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 478 "ease-theme.vala"
++ g_return_val_if_fail (element != NULL, NULL);
++#line 478 "ease-theme.vala"
++ g_return_val_if_fail (prop != NULL, NULL);
++#line 481 "ease-theme.vala"
++ map = (GeeMap*) gee_map_get (self->priv->elements, element);
++#line 482 "ease-theme.vala"
++ if (map != NULL) {
++#line 906 "ease-theme.c"
++ char* str;
++#line 484 "ease-theme.vala"
++ str = (char*) gee_map_get (map, prop);
++#line 485 "ease-theme.vala"
++ if (str != NULL) {
++#line 912 "ease-theme.c"
++ result = str;
++ _g_object_unref0 (map);
++#line 485 "ease-theme.vala"
++ return result;
++#line 917 "ease-theme.c"
++ }
++ _g_free0 (str);
++ }
++#line 489 "ease-theme.vala"
++ str = (char*) gee_map_get (self->priv->element_defaults, prop);
++#line 490 "ease-theme.vala"
++ if (str != NULL) {
++#line 925 "ease-theme.c"
++ result = str;
++ _g_object_unref0 (map);
++#line 490 "ease-theme.vala"
++ return result;
++#line 930 "ease-theme.c"
++ }
++#line 493 "ease-theme.vala"
++ if (ease_theme_get_defaults () == self) {
++#line 495 "ease-theme.vala"
++ g_error (_ ("Could not find property %s on element type %s."), prop, element);
++#line 936 "ease-theme.c"
++ }
++ result = ease_theme_element_get (ease_theme_get_defaults (), element, prop);
++ _g_free0 (str);
++ _g_object_unref0 (map);
++#line 499 "ease-theme.vala"
++ return result;
++#line 943 "ease-theme.c"
++}
++
++
++#line 508 "ease-theme.vala"
++static char* ease_theme_master_get (EaseTheme* self, const char* master, const char* prop) {
++#line 949 "ease-theme.c"
++ char* result = NULL;
++ GeeMap* map;
++ char* str;
++#line 508 "ease-theme.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 508 "ease-theme.vala"
++ g_return_val_if_fail (master != NULL, NULL);
++#line 508 "ease-theme.vala"
++ g_return_val_if_fail (prop != NULL, NULL);
++#line 511 "ease-theme.vala"
++ map = (GeeMap*) gee_map_get (self->priv->masters, master);
++#line 512 "ease-theme.vala"
++ if (map != NULL) {
++#line 963 "ease-theme.c"
++ char* str;
++#line 514 "ease-theme.vala"
++ str = (char*) gee_map_get (map, prop);
++#line 515 "ease-theme.vala"
++ if (str != NULL) {
++#line 969 "ease-theme.c"
++ result = str;
++ _g_object_unref0 (map);
++#line 515 "ease-theme.vala"
++ return result;
++#line 974 "ease-theme.c"
++ }
++ _g_free0 (str);
++ }
++#line 519 "ease-theme.vala"
++ str = (char*) gee_map_get (self->priv->master_defaults, prop);
++#line 520 "ease-theme.vala"
++ if (str != NULL) {
++#line 982 "ease-theme.c"
++ result = str;
++ _g_object_unref0 (map);
++#line 520 "ease-theme.vala"
++ return result;
++#line 987 "ease-theme.c"
++ }
++#line 523 "ease-theme.vala"
++ if (ease_theme_get_defaults () == self) {
++#line 525 "ease-theme.vala"
++ g_error (_ ("Could not find property %s on master type %s."), prop, master);
++#line 993 "ease-theme.c"
++ }
++ result = ease_theme_master_get (ease_theme_get_defaults (), master, prop);
++ _g_free0 (str);
++ _g_object_unref0 (map);
++#line 529 "ease-theme.vala"
++ return result;
++#line 1000 "ease-theme.c"
++}
++
++
++#line 1156 "glib-2.0.vapi"
++static char* string_replace (const char* self, const char* old, const char* replacement) {
++#line 1006 "ease-theme.c"
++ char* result = NULL;
++ GError * _inner_error_;
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (old != NULL, NULL);
++#line 1156 "glib-2.0.vapi"
++ g_return_val_if_fail (replacement != NULL, NULL);
++#line 1015 "ease-theme.c"
++ _inner_error_ = NULL;
++ {
++ char* _tmp0_;
++ GRegex* _tmp1_;
++ GRegex* regex;
++ char* _tmp2_;
++#line 1158 "glib-2.0.vapi"
++ regex = (_tmp1_ = g_regex_new (_tmp0_ = g_regex_escape_string (old, -1), 0, 0, &_inner_error_), _g_free0 (_tmp0_), _tmp1_);
++#line 1024 "ease-theme.c"
++ if (_inner_error_ != NULL) {
++ if (_inner_error_->domain == G_REGEX_ERROR) {
++ goto __catch25_g_regex_error;
++ }
++ g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++#line 1159 "glib-2.0.vapi"
++ _tmp2_ = g_regex_replace_literal (regex, self, (gssize) (-1), 0, replacement, 0, &_inner_error_);
++#line 1035 "ease-theme.c"
++ if (_inner_error_ != NULL) {
++ _g_regex_unref0 (regex);
++ if (_inner_error_->domain == G_REGEX_ERROR) {
++ goto __catch25_g_regex_error;
++ }
++ _g_regex_unref0 (regex);
++ g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++ result = _tmp2_;
++ _g_regex_unref0 (regex);
++#line 1159 "glib-2.0.vapi"
++ return result;
++#line 1050 "ease-theme.c"
++ }
++ goto __finally25;
++ __catch25_g_regex_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 1161 "glib-2.0.vapi"
++ g_assert_not_reached ();
++#line 1061 "ease-theme.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally25:
++ if (_inner_error_ != NULL) {
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++}
++
++
++#line 537 "ease-theme.vala"
++char* ease_theme_master_description (const char* master) {
++#line 1076 "ease-theme.c"
++ char* result = NULL;
++ char* _tmp0_;
++ char* _tmp1_;
++#line 537 "ease-theme.vala"
++ g_return_val_if_fail (master != NULL, NULL);
++#line 1082 "ease-theme.c"
++ result = (_tmp1_ = string_replace (_tmp0_ = ease_theme_master_mnemonic_description (master), "_", ""), _g_free0 (_tmp0_), _tmp1_);
++#line 539 "ease-theme.vala"
++ return result;
++#line 1086 "ease-theme.c"
++}
++
++
++#line 548 "ease-theme.vala"
++char* ease_theme_master_mnemonic_description (const char* master) {
++#line 1092 "ease-theme.c"
++ char* result = NULL;
++ GQuark _tmp1_;
++ const char* _tmp0_;
++#line 548 "ease-theme.vala"
++ g_return_val_if_fail (master != NULL, NULL);
++#line 1098 "ease-theme.c"
++ _tmp0_ = master;
++ _tmp1_ = (NULL == _tmp0_) ? 0 : g_quark_from_string (_tmp0_);
++ if (_tmp1_ == g_quark_from_string (EASE_THEME_TITLE))
++ switch (0) {
++ default:
++ {
++ result = g_strdup (_ ("_Title slide"));
++#line 553 "ease-theme.vala"
++ return result;
++#line 1108 "ease-theme.c"
++ }
++ } else if (_tmp1_ == g_quark_from_string (EASE_THEME_CONTENT))
++ switch (0) {
++ default:
++ {
++ result = g_strdup (_ ("Content slide _without header"));
++#line 555 "ease-theme.vala"
++ return result;
++#line 1117 "ease-theme.c"
++ }
++ } else if (_tmp1_ == g_quark_from_string (EASE_THEME_CONTENT_HEADER))
++ switch (0) {
++ default:
++ {
++ result = g_strdup (_ ("_Content slide"));
++#line 557 "ease-theme.vala"
++ return result;
++#line 1126 "ease-theme.c"
++ }
++ } else if (_tmp1_ == g_quark_from_string (EASE_THEME_CONTENT_DUAL))
++ switch (0) {
++ default:
++ {
++ result = g_strdup (_ ("Two column slide without _header"));
++#line 559 "ease-theme.vala"
++ return result;
++#line 1135 "ease-theme.c"
++ }
++ } else if (_tmp1_ == g_quark_from_string (EASE_THEME_CONTENT_DUAL_HEADER))
++ switch (0) {
++ default:
++ {
++ result = g_strdup (_ ("T_wo column slide with header"));
++#line 561 "ease-theme.vala"
++ return result;
++#line 1144 "ease-theme.c"
++ }
++ } else if (_tmp1_ == g_quark_from_string (EASE_THEME_MEDIA))
++ switch (0) {
++ default:
++ {
++ result = g_strdup (_ ("M_edia slide without header"));
++#line 563 "ease-theme.vala"
++ return result;
++#line 1153 "ease-theme.c"
++ }
++ } else if (_tmp1_ == g_quark_from_string (EASE_THEME_MEDIA_HEADER))
++ switch (0) {
++ default:
++ {
++ result = g_strdup (_ ("_Media slide"));
++#line 565 "ease-theme.vala"
++ return result;
++#line 1162 "ease-theme.c"
++ }
++ }
++#line 568 "ease-theme.vala"
++ g_critical (_ ("%s is not a valid identifier"), master);
++#line 1167 "ease-theme.c"
++ result = g_strdup (master);
++#line 569 "ease-theme.vala"
++ return result;
++#line 1171 "ease-theme.c"
++}
++
++
++#line 580 "ease-theme.vala"
++char* ease_theme_master_from_description (const char* desc) {
++#line 1177 "ease-theme.c"
++ char* result = NULL;
++ char* replaced;
++#line 580 "ease-theme.vala"
++ g_return_val_if_fail (desc != NULL, NULL);
++#line 582 "ease-theme.vala"
++ replaced = string_replace (desc, "_", "");
++#line 1184 "ease-theme.c"
++ {
++ const char** master_collection;
++ int master_collection_length1;
++ int master_it;
++#line 584 "ease-theme.vala"
++ master_collection = EASE_THEME_MASTER_SLIDES;
++#line 1191 "ease-theme.c"
++ master_collection_length1 = G_N_ELEMENTS (EASE_THEME_MASTER_SLIDES);
++ for (master_it = 0; master_it < G_N_ELEMENTS (EASE_THEME_MASTER_SLIDES); master_it = master_it + 1) {
++ const char* master;
++ master = master_collection[master_it];
++ {
++ char* _tmp0_;
++ gboolean _tmp1_;
++#line 586 "ease-theme.vala"
++ if ((_tmp1_ = _vala_strcmp0 (_tmp0_ = ease_theme_master_description (master), replaced) == 0, _g_free0 (_tmp0_), _tmp1_)) {
++#line 1201 "ease-theme.c"
++ result = g_strdup (master);
++ _g_free0 (replaced);
++#line 586 "ease-theme.vala"
++ return result;
++#line 1206 "ease-theme.c"
++ }
++ }
++ }
++ }
++#line 589 "ease-theme.vala"
++ g_critical ("ease-theme.vala:589: Not a valid master description: %s", desc);
++#line 1213 "ease-theme.c"
++ result = g_strdup (desc);
++ _g_free0 (replaced);
++#line 590 "ease-theme.vala"
++ return result;
++#line 1218 "ease-theme.c"
++}
++
++
++#line 601 "ease-theme.vala"
++static void ease_theme_fill_map (EaseTheme* self, JsonObject* obj, const char* name, GeeMap* map) {
++#line 1224 "ease-theme.c"
++ JsonObject* sub;
++#line 601 "ease-theme.vala"
++ g_return_if_fail (self != NULL);
++#line 601 "ease-theme.vala"
++ g_return_if_fail (obj != NULL);
++#line 601 "ease-theme.vala"
++ g_return_if_fail (name != NULL);
++#line 601 "ease-theme.vala"
++ g_return_if_fail (map != NULL);
++#line 604 "ease-theme.vala"
++ if (!json_object_has_member (obj, name)) {
++#line 604 "ease-theme.vala"
++ return;
++#line 1238 "ease-theme.c"
++ }
++#line 605 "ease-theme.vala"
++ sub = _json_object_ref0 (json_object_get_object_member (obj, name));
++#line 606 "ease-theme.vala"
++ if (sub == NULL) {
++#line 1244 "ease-theme.c"
++ _json_object_unref0 (sub);
++#line 606 "ease-theme.vala"
++ return;
++#line 1248 "ease-theme.c"
++ }
++ {
++ GList* i;
++#line 608 "ease-theme.vala"
++ i = json_object_get_members (sub);
++#line 1254 "ease-theme.c"
++ {
++ gboolean _tmp0_;
++#line 608 "ease-theme.vala"
++ _tmp0_ = TRUE;
++#line 608 "ease-theme.vala"
++ while (TRUE) {
++#line 1261 "ease-theme.c"
++ JsonObject* curr_obj;
++ GeeHashMap* submap;
++#line 608 "ease-theme.vala"
++ if (!_tmp0_) {
++#line 609 "ease-theme.vala"
++ i = i->next;
++#line 1268 "ease-theme.c"
++ }
++#line 608 "ease-theme.vala"
++ _tmp0_ = FALSE;
++#line 609 "ease-theme.vala"
++ if (!(i != NULL)) {
++#line 609 "ease-theme.vala"
++ break;
++#line 1276 "ease-theme.c"
++ }
++#line 612 "ease-theme.vala"
++ curr_obj = _json_object_ref0 (json_node_get_object (json_object_get_member (sub, (const char*) i->data)));
++#line 615 "ease-theme.vala"
++ submap = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);
++#line 618 "ease-theme.vala"
++ ease_theme_fill_single_map (self, curr_obj, (GeeMap*) submap);
++#line 621 "ease-theme.vala"
++ gee_map_set (map, (const char*) i->data, (GeeMap*) submap);
++#line 1286 "ease-theme.c"
++ _g_object_unref0 (submap);
++ _json_object_unref0 (curr_obj);
++ }
++ }
++ }
++ _json_object_unref0 (sub);
++}
++
++
++#line 631 "ease-theme.vala"
++static void ease_theme_fill_single_map (EaseTheme* self, JsonObject* obj, GeeMap* map) {
++#line 631 "ease-theme.vala"
++ g_return_if_fail (self != NULL);
++#line 631 "ease-theme.vala"
++ g_return_if_fail (obj != NULL);
++#line 631 "ease-theme.vala"
++ g_return_if_fail (map != NULL);
++#line 1304 "ease-theme.c"
++ {
++ GList* j;
++#line 633 "ease-theme.vala"
++ j = json_object_get_members (obj);
++#line 1309 "ease-theme.c"
++ {
++ gboolean _tmp0_;
++#line 633 "ease-theme.vala"
++ _tmp0_ = TRUE;
++#line 633 "ease-theme.vala"
++ while (TRUE) {
++#line 633 "ease-theme.vala"
++ if (!_tmp0_) {
++#line 634 "ease-theme.vala"
++ j = j->next;
++#line 1320 "ease-theme.c"
++ }
++#line 633 "ease-theme.vala"
++ _tmp0_ = FALSE;
++#line 634 "ease-theme.vala"
++ if (!(j != NULL)) {
++#line 634 "ease-theme.vala"
++ break;
++#line 1328 "ease-theme.c"
++ }
++#line 636 "ease-theme.vala"
++ gee_map_set (map, (const char*) j->data, json_node_get_string (json_object_get_member (obj, (const char*) j->data)));
++#line 1332 "ease-theme.c"
++ }
++ }
++ }
++}
++
++
++const char* ease_theme_get_path (EaseTheme* self) {
++ const char* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_path;
++#line 135 "ease-theme.vala"
++ return result;
++#line 1345 "ease-theme.c"
++}
++
++
++void ease_theme_set_path (EaseTheme* self, const char* value) {
++ char* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_path = (_tmp0_ = g_strdup (value), _g_free0 (self->priv->_path), _tmp0_);
++ g_object_notify ((GObject *) self, "path");
++}
++
++
++static EaseTheme* ease_theme_get_defaults (void) {
++ EaseTheme* result;
++ EaseTheme* _tmp1_;
++ char* _tmp0_;
++ EaseTheme* _tmp2_;
++#line 172 "ease-theme.vala"
++ if (ease_theme_defaults_store != NULL) {
++#line 1364 "ease-theme.c"
++ result = ease_theme_defaults_store;
++#line 172 "ease-theme.vala"
++ return result;
++#line 1368 "ease-theme.c"
++ }
++ result = (_tmp2_ = ease_theme_defaults_store = (_tmp1_ = ease_theme_new_json (_tmp0_ = ease_data_path (EASE_THEME_DEFAULTS_PATH)), _g_object_unref0 (ease_theme_defaults_store), _tmp1_), _g_free0 (_tmp0_), _tmp2_);
++#line 173 "ease-theme.vala"
++ return result;
++#line 1373 "ease-theme.c"
++}
++
++
++static void ease_theme_class_init (EaseThemeClass * klass) {
++ ease_theme_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseThemePrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_theme_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_theme_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_theme_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_THEME_PATH, g_param_spec_string ("path", "path", "path", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++}
++
++
++static void ease_theme_instance_init (EaseTheme * self) {
++ self->priv = EASE_THEME_GET_PRIVATE (self);
++}
++
++
++static void ease_theme_finalize (GObject* obj) {
++ EaseTheme * self;
++ self = EASE_THEME (obj);
++ _g_free0 (self->title);
++ _g_free0 (self->priv->_path);
++ _g_object_unref0 (self->priv->masters);
++ _g_object_unref0 (self->priv->elements);
++ _g_object_unref0 (self->priv->master_defaults);
++ _g_object_unref0 (self->priv->element_defaults);
++ G_OBJECT_CLASS (ease_theme_parent_class)->finalize (obj);
++}
++
++
++GType ease_theme_get_type (void) {
++ static volatile gsize ease_theme_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_theme_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseThemeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_theme_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseTheme), 0, (GInstanceInitFunc) ease_theme_instance_init, NULL };
++ GType ease_theme_type_id;
++ ease_theme_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseTheme", &g_define_type_info, 0);
++ g_once_init_leave (&ease_theme_type_id__volatile, ease_theme_type_id);
++ }
++ return ease_theme_type_id__volatile;
++}
++
++
++static void ease_theme_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseTheme * self;
++ self = EASE_THEME (object);
++ switch (property_id) {
++ case EASE_THEME_PATH:
++ g_value_set_string (value, ease_theme_get_path (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_theme_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseTheme * self;
++ self = EASE_THEME (object);
++ switch (property_id) {
++ case EASE_THEME_PATH:
++ ease_theme_set_path (self, g_value_get_string (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static int _vala_strcmp0 (const char * str1, const char * str2) {
++ if (str1 == NULL) {
++ return -(str1 != str2);
++ }
++ if (str2 == NULL) {
++ return str1 != str2;
++ }
++ return strcmp (str1, str2);
++}
++
++
++
++
diff --cc ease-core/ease-transformations.c
index 0000000,0000000..ca0f72a
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-transformations.c
@@@ -1,0 -1,0 +1,62 @@@
++/* ease-transformations.c generated by valac, the Vala compiler
++ * generated from ease-transformations.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <float.h>
++#include <math.h>
++#include <clutter/clutter.h>
++#include <gdk/gdk.h>
++
++
++
++
++#define EASE_TRANSFORMATIONS_TO_GDK_COLOR_FACTOR (65535.0 / 255)
++#define EASE_TRANSFORMATIONS_TO_CLUTTER_COLOR_FACTOR (255.0 / 65535)
++#define EASE_TRANSFORMATIONS_CLUTTER_COLOR_ALPHA ((guint8) 255)
++void ease_transformations_clutter_color_to_gdk_color (ClutterColor* color, GdkColor* result);
++void ease_transformations_gdk_color_to_clutter_color (GdkColor* color, ClutterColor* result);
++
++
++
++#line 32 "ease-transformations.vala"
++void ease_transformations_clutter_color_to_gdk_color (ClutterColor* color, GdkColor* result) {
++#line 42 "ease-transformations.c"
++ GdkColor _tmp0_ = {0};
++ *result = (_tmp0_.pixel = (guint32) 0, _tmp0_.red = (guint16) ((*color).red * EASE_TRANSFORMATIONS_TO_GDK_COLOR_FACTOR), _tmp0_.green = (guint16) ((*color).green * EASE_TRANSFORMATIONS_TO_GDK_COLOR_FACTOR), _tmp0_.blue = (guint16) ((*color).blue * EASE_TRANSFORMATIONS_TO_GDK_COLOR_FACTOR), _tmp0_);
++#line 34 "ease-transformations.vala"
++ return;
++#line 47 "ease-transformations.c"
++}
++
++
++#line 45 "ease-transformations.vala"
++void ease_transformations_gdk_color_to_clutter_color (GdkColor* color, ClutterColor* result) {
++#line 53 "ease-transformations.c"
++ ClutterColor _tmp0_ = {0};
++ *result = (_tmp0_.red = (guchar) ((guint8) ((*color).red * EASE_TRANSFORMATIONS_TO_CLUTTER_COLOR_FACTOR)), _tmp0_.green = (guchar) ((guint8) ((*color).green * EASE_TRANSFORMATIONS_TO_CLUTTER_COLOR_FACTOR)), _tmp0_.blue = (guchar) ((guint8) ((*color).blue * EASE_TRANSFORMATIONS_TO_CLUTTER_COLOR_FACTOR)), _tmp0_.alpha = (guchar) EASE_TRANSFORMATIONS_CLUTTER_COLOR_ALPHA, _tmp0_);
++#line 47 "ease-transformations.vala"
++ return;
++#line 58 "ease-transformations.c"
++}
++
++
++
++
diff --cc ease-core/ease-transitions.c
index 0000000,0000000..34202be
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-transitions.c
@@@ -1,0 -1,0 +1,1044 @@@
++/* ease-transitions.c generated by valac, the Vala compiler
++ * generated from ease-transitions.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <stdlib.h>
++#include <string.h>
++#include <gtk/gtk.h>
++#include <glib/gi18n-lib.h>
++
++
++#define EASE_TYPE_TRANSITION (ease_transition_get_type ())
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++#define EASE_TYPE_TRANSITION_VARIANT (ease_transition_variant_get_type ())
++
++typedef enum {
++ EASE_TRANSITION_NONE,
++ EASE_TRANSITION_FADE,
++ EASE_TRANSITION_SLIDE,
++ EASE_TRANSITION_DROP,
++ EASE_TRANSITION_PIVOT,
++ EASE_TRANSITION_FLIP,
++ EASE_TRANSITION_REVOLVING_DOOR,
++ EASE_TRANSITION_REVEAL,
++ EASE_TRANSITION_FALL,
++ EASE_TRANSITION_SLATS,
++ EASE_TRANSITION_OPEN_DOOR,
++ EASE_TRANSITION_EXPLODE,
++ EASE_TRANSITION_ASSEMBLE,
++ EASE_TRANSITION_ZOOM,
++ EASE_TRANSITION_PANEL,
++ EASE_TRANSITION_SPIN_CONTENTS,
++ EASE_TRANSITION_SPRING_CONTENTS,
++ EASE_TRANSITION_SWING_CONTENTS,
++ EASE_TRANSITION_SLIDE_CONTENTS,
++ EASE_TRANSITION_ZOOM_CONTENTS
++} EaseTransition;
++
++typedef enum {
++ EASE_TRANSITION_VARIANT_LEFT,
++ EASE_TRANSITION_VARIANT_RIGHT,
++ EASE_TRANSITION_VARIANT_UP,
++ EASE_TRANSITION_VARIANT_DOWN,
++ EASE_TRANSITION_VARIANT_BOTTOM,
++ EASE_TRANSITION_VARIANT_TOP,
++ EASE_TRANSITION_VARIANT_CENTER,
++ EASE_TRANSITION_VARIANT_TOP_LEFT,
++ EASE_TRANSITION_VARIANT_TOP_RIGHT,
++ EASE_TRANSITION_VARIANT_BOTTOM_LEFT,
++ EASE_TRANSITION_VARIANT_BOTTOM_RIGHT,
++ EASE_TRANSITION_VARIANT_TOP_TO_BOTTOM,
++ EASE_TRANSITION_VARIANT_BOTTOM_TO_TOP,
++ EASE_TRANSITION_VARIANT_LEFT_TO_RIGHT,
++ EASE_TRANSITION_VARIANT_RIGHT_TO_LEFT,
++ EASE_TRANSITION_VARIANT_IN,
++ EASE_TRANSITION_VARIANT_OUT
++} EaseTransitionVariant;
++
++
++
++GType ease_transition_get_type (void) G_GNUC_CONST;
++char* ease_transition_get_name (EaseTransition self);
++GtkListStore* ease_transition_model (void);
++GType ease_transition_variant_get_type (void) G_GNUC_CONST;
++EaseTransitionVariant* ease_transition_variants (EaseTransition self, int* result_length1);
++char* ease_transition_variant_get_name (EaseTransitionVariant self);
++GtkListStore* ease_transition_variant_model (EaseTransition self);
++EaseTransition ease_transition_from_string (const char* str);
++EaseTransitionVariant ease_transition_variant_from_string (const char* str);
++
++static const EaseTransition EASE_TRANSITION_TRANSITIONS[20] = {EASE_TRANSITION_NONE, EASE_TRANSITION_FADE, EASE_TRANSITION_SLIDE, EASE_TRANSITION_DROP, EASE_TRANSITION_PIVOT, EASE_TRANSITION_FLIP, EASE_TRANSITION_REVOLVING_DOOR, EASE_TRANSITION_REVEAL, EASE_TRANSITION_FALL, EASE_TRANSITION_SLATS, EASE_TRANSITION_OPEN_DOOR, EASE_TRANSITION_EXPLODE, EASE_TRANSITION_ASSEMBLE, EASE_TRANSITION_ZOOM, EASE_TRANSITION_PANEL, EASE_TRANSITION_SPIN_CONTENTS, EASE_TRANSITION_SPRING_CONTENTS, EASE_TRANSITION_SWING_CONTENTS, EASE_TRANSITION_SLIDE_CONTENTS, EASE_TRANSITION_ZOOM_CONTENTS};
++
++
++#line 66 "ease-transitions.vala"
++GtkListStore* ease_transition_model (void) {
++#line 96 "ease-transitions.c"
++ GtkListStore* result = NULL;
++ GtkListStore* store;
++ GtkTreeIter itr = {0};
++#line 68 "ease-transitions.vala"
++ store = gtk_list_store_new (2, G_TYPE_STRING, EASE_TYPE_TRANSITION, NULL);
++#line 102 "ease-transitions.c"
++ {
++ gint i;
++#line 70 "ease-transitions.vala"
++ i = 0;
++#line 107 "ease-transitions.c"
++ {
++ gboolean _tmp0_;
++#line 70 "ease-transitions.vala"
++ _tmp0_ = TRUE;
++#line 70 "ease-transitions.vala"
++ while (TRUE) {
++#line 114 "ease-transitions.c"
++ char* _tmp1_;
++#line 70 "ease-transitions.vala"
++ if (!_tmp0_) {
++#line 70 "ease-transitions.vala"
++ i++;
++#line 120 "ease-transitions.c"
++ }
++#line 70 "ease-transitions.vala"
++ _tmp0_ = FALSE;
++#line 70 "ease-transitions.vala"
++ if (!(i < G_N_ELEMENTS (EASE_TRANSITION_TRANSITIONS))) {
++#line 70 "ease-transitions.vala"
++ break;
++#line 128 "ease-transitions.c"
++ }
++#line 72 "ease-transitions.vala"
++ gtk_list_store_append (store, &itr);
++#line 73 "ease-transitions.vala"
++ gtk_list_store_set (store, &itr, 0, _tmp1_ = ease_transition_get_name (EASE_TRANSITION_TRANSITIONS[i]), 1, EASE_TRANSITION_TRANSITIONS[i], -1);
++#line 134 "ease-transitions.c"
++ _g_free0 (_tmp1_);
++ }
++ }
++ }
++ result = store;
++#line 76 "ease-transitions.vala"
++ return result;
++#line 142 "ease-transitions.c"
++}
++
++
++#line 79 "ease-transitions.vala"
++GtkListStore* ease_transition_variant_model (EaseTransition self) {
++#line 148 "ease-transitions.c"
++ GtkListStore* result = NULL;
++ GtkListStore* store;
++ GtkTreeIter itr = {0};
++#line 81 "ease-transitions.vala"
++ store = gtk_list_store_new (2, G_TYPE_STRING, EASE_TYPE_TRANSITION_VARIANT, NULL);
++#line 154 "ease-transitions.c"
++ {
++ gint _tmp0_;
++ EaseTransitionVariant* variant_collection;
++ int variant_collection_length1;
++ int variant_it;
++#line 84 "ease-transitions.vala"
++ variant_collection = ease_transition_variants (self, &_tmp0_);
++#line 162 "ease-transitions.c"
++ variant_collection_length1 = _tmp0_;
++ for (variant_it = 0; variant_it < _tmp0_; variant_it = variant_it + 1) {
++ EaseTransitionVariant variant;
++ variant = variant_collection[variant_it];
++ {
++ char* _tmp1_;
++#line 86 "ease-transitions.vala"
++ gtk_list_store_append (store, &itr);
++#line 87 "ease-transitions.vala"
++ gtk_list_store_set (store, &itr, 0, _tmp1_ = ease_transition_variant_get_name (variant), 1, variant, -1);
++#line 173 "ease-transitions.c"
++ _g_free0 (_tmp1_);
++ }
++ }
++#line 84 "ease-transitions.vala"
++ variant_collection = (g_free (variant_collection), NULL);
++#line 179 "ease-transitions.c"
++ }
++ result = store;
++#line 90 "ease-transitions.vala"
++ return result;
++#line 184 "ease-transitions.c"
++}
++
++
++#line 93 "ease-transitions.vala"
++EaseTransition ease_transition_from_string (const char* str) {
++#line 190 "ease-transitions.c"
++ EaseTransition result = 0;
++ GQuark _tmp1_;
++ const char* _tmp0_;
++ static GQuark _tmp1__label0 = 0;
++ static GQuark _tmp1__label1 = 0;
++ static GQuark _tmp1__label2 = 0;
++ static GQuark _tmp1__label3 = 0;
++ static GQuark _tmp1__label4 = 0;
++ static GQuark _tmp1__label5 = 0;
++ static GQuark _tmp1__label6 = 0;
++ static GQuark _tmp1__label7 = 0;
++ static GQuark _tmp1__label8 = 0;
++ static GQuark _tmp1__label9 = 0;
++ static GQuark _tmp1__label10 = 0;
++ static GQuark _tmp1__label11 = 0;
++ static GQuark _tmp1__label12 = 0;
++ static GQuark _tmp1__label13 = 0;
++ static GQuark _tmp1__label14 = 0;
++ static GQuark _tmp1__label15 = 0;
++ static GQuark _tmp1__label16 = 0;
++ static GQuark _tmp1__label17 = 0;
++ static GQuark _tmp1__label18 = 0;
++ static GQuark _tmp1__label19 = 0;
++#line 93 "ease-transitions.vala"
++ g_return_val_if_fail (str != NULL, 0);
++#line 216 "ease-transitions.c"
++ _tmp0_ = str;
++ _tmp1_ = (NULL == _tmp0_) ? 0 : g_quark_from_string (_tmp0_);
++ if (_tmp1_ == ((0 != _tmp1__label0) ? _tmp1__label0 : (_tmp1__label0 = g_quark_from_static_string ("EASE_TRANSITION_NONE"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_NONE;
++#line 98 "ease-transitions.vala"
++ return result;
++#line 226 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label1) ? _tmp1__label1 : (_tmp1__label1 = g_quark_from_static_string ("EASE_TRANSITION_FADE"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_FADE;
++#line 100 "ease-transitions.vala"
++ return result;
++#line 235 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label2) ? _tmp1__label2 : (_tmp1__label2 = g_quark_from_static_string ("EASE_TRANSITION_SLIDE"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_SLIDE;
++#line 102 "ease-transitions.vala"
++ return result;
++#line 244 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label3) ? _tmp1__label3 : (_tmp1__label3 = g_quark_from_static_string ("EASE_TRANSITION_DROP"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_DROP;
++#line 104 "ease-transitions.vala"
++ return result;
++#line 253 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label4) ? _tmp1__label4 : (_tmp1__label4 = g_quark_from_static_string ("EASE_TRANSITION_PIVOT"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_PIVOT;
++#line 106 "ease-transitions.vala"
++ return result;
++#line 262 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label5) ? _tmp1__label5 : (_tmp1__label5 = g_quark_from_static_string ("EASE_TRANSITION_FLIP"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_FLIP;
++#line 108 "ease-transitions.vala"
++ return result;
++#line 271 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label6) ? _tmp1__label6 : (_tmp1__label6 = g_quark_from_static_string ("EASE_TRANSITION_REVOLVING_DOOR"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_REVOLVING_DOOR;
++#line 110 "ease-transitions.vala"
++ return result;
++#line 280 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label7) ? _tmp1__label7 : (_tmp1__label7 = g_quark_from_static_string ("EASE_TRANSITION_REVEAL"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_REVEAL;
++#line 112 "ease-transitions.vala"
++ return result;
++#line 289 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label8) ? _tmp1__label8 : (_tmp1__label8 = g_quark_from_static_string ("EASE_TRANSITION_FALL"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_FALL;
++#line 114 "ease-transitions.vala"
++ return result;
++#line 298 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label9) ? _tmp1__label9 : (_tmp1__label9 = g_quark_from_static_string ("EASE_TRANSITION_SLATS"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_SLATS;
++#line 116 "ease-transitions.vala"
++ return result;
++#line 307 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label10) ? _tmp1__label10 : (_tmp1__label10 = g_quark_from_static_string ("EASE_TRANSITION_OPEN_DOOR"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_OPEN_DOOR;
++#line 118 "ease-transitions.vala"
++ return result;
++#line 316 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label11) ? _tmp1__label11 : (_tmp1__label11 = g_quark_from_static_string ("EASE_TRANSITION_EXPLODE"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_EXPLODE;
++#line 120 "ease-transitions.vala"
++ return result;
++#line 325 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label12) ? _tmp1__label12 : (_tmp1__label12 = g_quark_from_static_string ("EASE_TRANSITION_ASSEMBLE"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_ASSEMBLE;
++#line 122 "ease-transitions.vala"
++ return result;
++#line 334 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label13) ? _tmp1__label13 : (_tmp1__label13 = g_quark_from_static_string ("EASE_TRANSITION_ZOOM"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_ZOOM;
++#line 124 "ease-transitions.vala"
++ return result;
++#line 343 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label14) ? _tmp1__label14 : (_tmp1__label14 = g_quark_from_static_string ("EASE_TRANSITION_PANEL"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_PANEL;
++#line 126 "ease-transitions.vala"
++ return result;
++#line 352 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label15) ? _tmp1__label15 : (_tmp1__label15 = g_quark_from_static_string ("EASE_TRANSITION_SPIN_CONTENTS"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_SPIN_CONTENTS;
++#line 128 "ease-transitions.vala"
++ return result;
++#line 361 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label16) ? _tmp1__label16 : (_tmp1__label16 = g_quark_from_static_string ("EASE_TRANSITION_SPRING_CONTENTS"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_SPRING_CONTENTS;
++#line 130 "ease-transitions.vala"
++ return result;
++#line 370 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label17) ? _tmp1__label17 : (_tmp1__label17 = g_quark_from_static_string ("EASE_TRANSITION_SWING_CONTENTS"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_SWING_CONTENTS;
++#line 132 "ease-transitions.vala"
++ return result;
++#line 379 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label18) ? _tmp1__label18 : (_tmp1__label18 = g_quark_from_static_string ("EASE_TRANSITION_SLIDE_CONTENTS"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_SLIDE_CONTENTS;
++#line 134 "ease-transitions.vala"
++ return result;
++#line 388 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label19) ? _tmp1__label19 : (_tmp1__label19 = g_quark_from_static_string ("EASE_TRANSITION_ZOOM_CONTENTS"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_ZOOM_CONTENTS;
++#line 136 "ease-transitions.vala"
++ return result;
++#line 397 "ease-transitions.c"
++ }
++ } else
++ switch (0) {
++ default:
++ {
++#line 138 "ease-transitions.vala"
++ g_critical ("ease-transitions.vala:138: Invalid transition string: %s", str);
++#line 405 "ease-transitions.c"
++ result = EASE_TRANSITION_NONE;
++#line 139 "ease-transitions.vala"
++ return result;
++#line 409 "ease-transitions.c"
++ }
++ }
++}
++
++
++#line 143 "ease-transitions.vala"
++EaseTransitionVariant* ease_transition_variants (EaseTransition self, int* result_length1) {
++#line 417 "ease-transitions.c"
++ EaseTransitionVariant* result = NULL;
++#line 145 "ease-transitions.vala"
++ switch (self) {
++#line 421 "ease-transitions.c"
++ case EASE_TRANSITION_NONE:
++ case EASE_TRANSITION_FADE:
++ case EASE_TRANSITION_DROP:
++ case EASE_TRANSITION_FALL:
++ case EASE_TRANSITION_SLATS:
++ case EASE_TRANSITION_OPEN_DOOR:
++ case EASE_TRANSITION_EXPLODE:
++ case EASE_TRANSITION_ASSEMBLE:
++ case EASE_TRANSITION_SWING_CONTENTS:
++ {
++ EaseTransitionVariant* _tmp0_ = NULL;
++ EaseTransitionVariant* _tmp1_;
++ result = (_tmp1_ = (_tmp0_ = g_new0 (EaseTransitionVariant, 0), _tmp0_), *result_length1 = 0, _tmp1_);
++#line 156 "ease-transitions.vala"
++ return result;
++#line 437 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_REVOLVING_DOOR:
++ case EASE_TRANSITION_REVEAL:
++ case EASE_TRANSITION_SLIDE:
++ case EASE_TRANSITION_PANEL:
++ case EASE_TRANSITION_SLIDE_CONTENTS:
++ {
++ EaseTransitionVariant* _tmp2_ = NULL;
++ EaseTransitionVariant* _tmp3_;
++ result = (_tmp3_ = (_tmp2_ = g_new0 (EaseTransitionVariant, 4), _tmp2_[0] = EASE_TRANSITION_VARIANT_LEFT, _tmp2_[1] = EASE_TRANSITION_VARIANT_RIGHT, _tmp2_[2] = EASE_TRANSITION_VARIANT_UP, _tmp2_[3] = EASE_TRANSITION_VARIANT_DOWN, _tmp2_), *result_length1 = 4, _tmp3_);
++#line 163 "ease-transitions.vala"
++ return result;
++#line 450 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_PIVOT:
++ {
++ EaseTransitionVariant* _tmp4_ = NULL;
++ EaseTransitionVariant* _tmp5_;
++ result = (_tmp5_ = (_tmp4_ = g_new0 (EaseTransitionVariant, 4), _tmp4_[0] = EASE_TRANSITION_VARIANT_TOP_LEFT, _tmp4_[1] = EASE_TRANSITION_VARIANT_TOP_RIGHT, _tmp4_[2] = EASE_TRANSITION_VARIANT_BOTTOM_LEFT, _tmp4_[3] = EASE_TRANSITION_VARIANT_BOTTOM_RIGHT, _tmp4_), *result_length1 = 4, _tmp5_);
++#line 170 "ease-transitions.vala"
++ return result;
++#line 459 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_FLIP:
++ {
++ EaseTransitionVariant* _tmp6_ = NULL;
++ EaseTransitionVariant* _tmp7_;
++ result = (_tmp7_ = (_tmp6_ = g_new0 (EaseTransitionVariant, 4), _tmp6_[0] = EASE_TRANSITION_VARIANT_LEFT_TO_RIGHT, _tmp6_[1] = EASE_TRANSITION_VARIANT_RIGHT_TO_LEFT, _tmp6_[2] = EASE_TRANSITION_VARIANT_TOP_TO_BOTTOM, _tmp6_[3] = EASE_TRANSITION_VARIANT_BOTTOM_TO_TOP, _tmp6_), *result_length1 = 4, _tmp7_);
++#line 176 "ease-transitions.vala"
++ return result;
++#line 468 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_ZOOM:
++ {
++ EaseTransitionVariant* _tmp8_ = NULL;
++ EaseTransitionVariant* _tmp9_;
++ result = (_tmp9_ = (_tmp8_ = g_new0 (EaseTransitionVariant, 5), _tmp8_[0] = EASE_TRANSITION_VARIANT_CENTER, _tmp8_[1] = EASE_TRANSITION_VARIANT_TOP_LEFT, _tmp8_[2] = EASE_TRANSITION_VARIANT_TOP_RIGHT, _tmp8_[3] = EASE_TRANSITION_VARIANT_BOTTOM_LEFT, _tmp8_[4] = EASE_TRANSITION_VARIANT_BOTTOM_RIGHT, _tmp8_), *result_length1 = 5, _tmp9_);
++#line 182 "ease-transitions.vala"
++ return result;
++#line 477 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_SPIN_CONTENTS:
++ {
++ EaseTransitionVariant* _tmp10_ = NULL;
++ EaseTransitionVariant* _tmp11_;
++ result = (_tmp11_ = (_tmp10_ = g_new0 (EaseTransitionVariant, 2), _tmp10_[0] = EASE_TRANSITION_VARIANT_LEFT, _tmp10_[1] = EASE_TRANSITION_VARIANT_RIGHT, _tmp10_), *result_length1 = 2, _tmp11_);
++#line 189 "ease-transitions.vala"
++ return result;
++#line 486 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_SPRING_CONTENTS:
++ {
++ EaseTransitionVariant* _tmp12_ = NULL;
++ EaseTransitionVariant* _tmp13_;
++ result = (_tmp13_ = (_tmp12_ = g_new0 (EaseTransitionVariant, 2), _tmp12_[0] = EASE_TRANSITION_VARIANT_UP, _tmp12_[1] = EASE_TRANSITION_VARIANT_DOWN, _tmp12_), *result_length1 = 2, _tmp13_);
++#line 193 "ease-transitions.vala"
++ return result;
++#line 495 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_ZOOM_CONTENTS:
++ {
++ EaseTransitionVariant* _tmp14_ = NULL;
++ EaseTransitionVariant* _tmp15_;
++ result = (_tmp15_ = (_tmp14_ = g_new0 (EaseTransitionVariant, 2), _tmp14_[0] = EASE_TRANSITION_VARIANT_IN, _tmp14_[1] = EASE_TRANSITION_VARIANT_OUT, _tmp14_), *result_length1 = 2, _tmp15_);
++#line 197 "ease-transitions.vala"
++ return result;
++#line 504 "ease-transitions.c"
++ }
++ default:
++ {
++ EaseTransitionVariant* _tmp16_ = NULL;
++ EaseTransitionVariant* _tmp17_;
++#line 201 "ease-transitions.vala"
++ g_critical ("ease-transitions.vala:201: Undefined transition %i", (gint) self);
++#line 512 "ease-transitions.c"
++ result = (_tmp17_ = (_tmp16_ = g_new0 (EaseTransitionVariant, 0), _tmp16_), *result_length1 = 0, _tmp17_);
++#line 202 "ease-transitions.vala"
++ return result;
++#line 516 "ease-transitions.c"
++ }
++ }
++}
++
++
++#line 206 "ease-transitions.vala"
++char* ease_transition_get_name (EaseTransition self) {
++#line 524 "ease-transitions.c"
++ char* result = NULL;
++#line 208 "ease-transitions.vala"
++ switch (self) {
++#line 528 "ease-transitions.c"
++ case EASE_TRANSITION_NONE:
++ {
++ result = g_strdup (_ ("None"));
++#line 211 "ease-transitions.vala"
++ return result;
++#line 534 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_FADE:
++ {
++ result = g_strdup (_ ("Fade"));
++#line 213 "ease-transitions.vala"
++ return result;
++#line 541 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_SLIDE:
++ {
++ result = g_strdup (_ ("Slide"));
++#line 215 "ease-transitions.vala"
++ return result;
++#line 548 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_DROP:
++ {
++ result = g_strdup (_ ("Drop"));
++#line 217 "ease-transitions.vala"
++ return result;
++#line 555 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_PIVOT:
++ {
++ result = g_strdup (_ ("Pivot"));
++#line 219 "ease-transitions.vala"
++ return result;
++#line 562 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_FLIP:
++ {
++ result = g_strdup (_ ("Flip"));
++#line 221 "ease-transitions.vala"
++ return result;
++#line 569 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_REVOLVING_DOOR:
++ {
++ result = g_strdup (_ ("Revolving Door"));
++#line 223 "ease-transitions.vala"
++ return result;
++#line 576 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_REVEAL:
++ {
++ result = g_strdup (_ ("Reveal"));
++#line 225 "ease-transitions.vala"
++ return result;
++#line 583 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_FALL:
++ {
++ result = g_strdup (_ ("Fall"));
++#line 227 "ease-transitions.vala"
++ return result;
++#line 590 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_SLATS:
++ {
++ result = g_strdup (_ ("Slats"));
++#line 229 "ease-transitions.vala"
++ return result;
++#line 597 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_OPEN_DOOR:
++ {
++ result = g_strdup (_ ("Open Door"));
++#line 231 "ease-transitions.vala"
++ return result;
++#line 604 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_EXPLODE:
++ {
++ result = g_strdup (_ ("Explode"));
++#line 233 "ease-transitions.vala"
++ return result;
++#line 611 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_ASSEMBLE:
++ {
++ result = g_strdup (_ ("Assemble"));
++#line 235 "ease-transitions.vala"
++ return result;
++#line 618 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_ZOOM:
++ {
++ result = g_strdup (_ ("Zoom"));
++#line 237 "ease-transitions.vala"
++ return result;
++#line 625 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_PANEL:
++ {
++ result = g_strdup (_ ("Panel"));
++#line 239 "ease-transitions.vala"
++ return result;
++#line 632 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_SPIN_CONTENTS:
++ {
++ result = g_strdup (_ ("Spin Contents"));
++#line 241 "ease-transitions.vala"
++ return result;
++#line 639 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_SPRING_CONTENTS:
++ {
++ result = g_strdup (_ ("Spring Contents"));
++#line 243 "ease-transitions.vala"
++ return result;
++#line 646 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_SWING_CONTENTS:
++ {
++ result = g_strdup (_ ("Swing Contents"));
++#line 245 "ease-transitions.vala"
++ return result;
++#line 653 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_SLIDE_CONTENTS:
++ {
++ result = g_strdup (_ ("Slide Contents"));
++#line 247 "ease-transitions.vala"
++ return result;
++#line 660 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_ZOOM_CONTENTS:
++ {
++ result = g_strdup (_ ("Zoom Contents"));
++#line 249 "ease-transitions.vala"
++ return result;
++#line 667 "ease-transitions.c"
++ }
++ default:
++ {
++#line 251 "ease-transitions.vala"
++ g_critical ("ease-transitions.vala:251: Undefined transition %i", (gint) self);
++#line 673 "ease-transitions.c"
++ result = g_strdup (_ ("Undefined"));
++#line 252 "ease-transitions.vala"
++ return result;
++#line 677 "ease-transitions.c"
++ }
++ }
++}
++
++
++GType ease_transition_get_type (void) {
++ static volatile gsize ease_transition_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_transition_type_id__volatile)) {
++ static const GEnumValue values[] = {{EASE_TRANSITION_NONE, "EASE_TRANSITION_NONE", "none"}, {EASE_TRANSITION_FADE, "EASE_TRANSITION_FADE", "fade"}, {EASE_TRANSITION_SLIDE, "EASE_TRANSITION_SLIDE", "slide"}, {EASE_TRANSITION_DROP, "EASE_TRANSITION_DROP", "drop"}, {EASE_TRANSITION_PIVOT, "EASE_TRANSITION_PIVOT", "pivot"}, {EASE_TRANSITION_FLIP, "EASE_TRANSITION_FLIP", "flip"}, {EASE_TRANSITION_REVOLVING_DOOR, "EASE_TRANSITION_REVOLVING_DOOR", "revolving-door"}, {EASE_TRANSITION_REVEAL, "EASE_TRANSITION_REVEAL", "reveal"}, {EASE_TRANSITION_FALL, "EASE_TRANSITION_FALL", "fall"}, {EASE_TRANSITION_SLATS, "EASE_TRANSITION_SLATS", "slats"}, {EASE_TRANSITION_OPEN_DOOR, "EASE_TRANSITION_OPEN_DOOR", "open-door"}, {EASE_TRANSITION_EXPLODE, "EASE_TRANSITION_EXPLODE", "explode"}, {EASE_TRANSITION_ASSEMBLE, "EASE_TRANSITION_ASSEMBLE", "assemble"}, {EASE_TRANSITION_ZOOM, "EASE_TRANSITION_ZOOM", "zoom"}, {EASE_TRANSITION_PANEL, "EASE_TRANSITION_PANEL", "panel"}, {EASE_TRANSITION_SPIN_CONT
ENTS, "EASE_TRANSITION_SPIN_CONTENTS", "spin-contents"}, {EASE_TRANSITION_SPRING_CONTENTS, "EASE_TRANSITION_SPRING_CONTENTS", "spring-contents"}, {EASE_TRANSITION_SWING_CONTENTS, "EASE_TRANSITION_SWING_CONTENTS", "swing-contents"}, {EASE_TRANSITION_SLIDE_CONTENTS, "EASE_TRANSITION_SLIDE_CONTENTS", "slide-contents"}, {EASE_TRANSITION_ZOOM_CONTENTS, "EASE_TRANSITION_ZOOM_CONTENTS", "zoom-contents"}, {0, NULL, NULL}};
++ GType ease_transition_type_id;
++ ease_transition_type_id = g_enum_register_static ("EaseTransition", values);
++ g_once_init_leave (&ease_transition_type_id__volatile, ease_transition_type_id);
++ }
++ return ease_transition_type_id__volatile;
++}
++
++
++#line 280 "ease-transitions.vala"
++EaseTransitionVariant ease_transition_variant_from_string (const char* str) {
++#line 697 "ease-transitions.c"
++ EaseTransitionVariant result = 0;
++ GQuark _tmp1_;
++ const char* _tmp0_;
++ static GQuark _tmp1__label0 = 0;
++ static GQuark _tmp1__label1 = 0;
++ static GQuark _tmp1__label2 = 0;
++ static GQuark _tmp1__label3 = 0;
++ static GQuark _tmp1__label4 = 0;
++ static GQuark _tmp1__label5 = 0;
++ static GQuark _tmp1__label6 = 0;
++ static GQuark _tmp1__label7 = 0;
++ static GQuark _tmp1__label8 = 0;
++ static GQuark _tmp1__label9 = 0;
++ static GQuark _tmp1__label10 = 0;
++ static GQuark _tmp1__label11 = 0;
++ static GQuark _tmp1__label12 = 0;
++ static GQuark _tmp1__label13 = 0;
++ static GQuark _tmp1__label14 = 0;
++ static GQuark _tmp1__label15 = 0;
++ static GQuark _tmp1__label16 = 0;
++#line 280 "ease-transitions.vala"
++ g_return_val_if_fail (str != NULL, 0);
++#line 720 "ease-transitions.c"
++ _tmp0_ = str;
++ _tmp1_ = (NULL == _tmp0_) ? 0 : g_quark_from_string (_tmp0_);
++ if (_tmp1_ == ((0 != _tmp1__label0) ? _tmp1__label0 : (_tmp1__label0 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_UP"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_UP;
++#line 285 "ease-transitions.vala"
++ return result;
++#line 730 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label1) ? _tmp1__label1 : (_tmp1__label1 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_DOWN"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_DOWN;
++#line 287 "ease-transitions.vala"
++ return result;
++#line 739 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label2) ? _tmp1__label2 : (_tmp1__label2 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_LEFT"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_LEFT;
++#line 289 "ease-transitions.vala"
++ return result;
++#line 748 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label3) ? _tmp1__label3 : (_tmp1__label3 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_RIGHT"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_RIGHT;
++#line 291 "ease-transitions.vala"
++ return result;
++#line 757 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label4) ? _tmp1__label4 : (_tmp1__label4 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_BOTTOM"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_BOTTOM;
++#line 293 "ease-transitions.vala"
++ return result;
++#line 766 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label5) ? _tmp1__label5 : (_tmp1__label5 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_TOP"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_TOP;
++#line 295 "ease-transitions.vala"
++ return result;
++#line 775 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label6) ? _tmp1__label6 : (_tmp1__label6 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_CENTER"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_CENTER;
++#line 297 "ease-transitions.vala"
++ return result;
++#line 784 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label7) ? _tmp1__label7 : (_tmp1__label7 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_TOP_LEFT"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_TOP_LEFT;
++#line 299 "ease-transitions.vala"
++ return result;
++#line 793 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label8) ? _tmp1__label8 : (_tmp1__label8 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_TOP_RIGHT"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_TOP_RIGHT;
++#line 301 "ease-transitions.vala"
++ return result;
++#line 802 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label9) ? _tmp1__label9 : (_tmp1__label9 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_BOTTOM_LEFT"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_BOTTOM_LEFT;
++#line 303 "ease-transitions.vala"
++ return result;
++#line 811 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label10) ? _tmp1__label10 : (_tmp1__label10 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_BOTTOM_RIGHT"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_BOTTOM_RIGHT;
++#line 305 "ease-transitions.vala"
++ return result;
++#line 820 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label11) ? _tmp1__label11 : (_tmp1__label11 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_TOP_TO_BOTTOM"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_TOP_TO_BOTTOM;
++#line 307 "ease-transitions.vala"
++ return result;
++#line 829 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label12) ? _tmp1__label12 : (_tmp1__label12 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_BOTTOM_TO_TOP"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_BOTTOM_TO_TOP;
++#line 309 "ease-transitions.vala"
++ return result;
++#line 838 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label13) ? _tmp1__label13 : (_tmp1__label13 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_LEFT_TO_RIGHT"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_LEFT_TO_RIGHT;
++#line 311 "ease-transitions.vala"
++ return result;
++#line 847 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label14) ? _tmp1__label14 : (_tmp1__label14 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_RIGHT_TO_LEFT"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_RIGHT_TO_LEFT;
++#line 313 "ease-transitions.vala"
++ return result;
++#line 856 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label15) ? _tmp1__label15 : (_tmp1__label15 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_IN"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_IN;
++#line 315 "ease-transitions.vala"
++ return result;
++#line 865 "ease-transitions.c"
++ }
++ } else if (_tmp1_ == ((0 != _tmp1__label16) ? _tmp1__label16 : (_tmp1__label16 = g_quark_from_static_string ("EASE_TRANSITION_VARIANT_OUT"))))
++ switch (0) {
++ default:
++ {
++ result = EASE_TRANSITION_VARIANT_OUT;
++#line 317 "ease-transitions.vala"
++ return result;
++#line 874 "ease-transitions.c"
++ }
++ } else
++ switch (0) {
++ default:
++ {
++#line 319 "ease-transitions.vala"
++ g_critical ("ease-transitions.vala:319: Invalid transition variant: %s", str);
++#line 882 "ease-transitions.c"
++ result = EASE_TRANSITION_VARIANT_UP;
++#line 320 "ease-transitions.vala"
++ return result;
++#line 886 "ease-transitions.c"
++ }
++ }
++}
++
++
++#line 324 "ease-transitions.vala"
++char* ease_transition_variant_get_name (EaseTransitionVariant self) {
++#line 894 "ease-transitions.c"
++ char* result = NULL;
++#line 326 "ease-transitions.vala"
++ switch (self) {
++#line 898 "ease-transitions.c"
++ case EASE_TRANSITION_VARIANT_UP:
++ {
++ result = g_strdup (_ ("Up"));
++#line 329 "ease-transitions.vala"
++ return result;
++#line 904 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_DOWN:
++ {
++ result = g_strdup (_ ("Down"));
++#line 331 "ease-transitions.vala"
++ return result;
++#line 911 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_LEFT:
++ {
++ result = g_strdup (_ ("Left"));
++#line 333 "ease-transitions.vala"
++ return result;
++#line 918 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_RIGHT:
++ {
++ result = g_strdup (_ ("Right"));
++#line 335 "ease-transitions.vala"
++ return result;
++#line 925 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_BOTTOM:
++ {
++ result = g_strdup (_ ("Bottom"));
++#line 337 "ease-transitions.vala"
++ return result;
++#line 932 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_TOP:
++ {
++ result = g_strdup (_ ("Top"));
++#line 339 "ease-transitions.vala"
++ return result;
++#line 939 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_CENTER:
++ {
++ result = g_strdup (_ ("Center"));
++#line 341 "ease-transitions.vala"
++ return result;
++#line 946 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_TOP_LEFT:
++ {
++ result = g_strdup (_ ("Top Left"));
++#line 343 "ease-transitions.vala"
++ return result;
++#line 953 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_TOP_RIGHT:
++ {
++ result = g_strdup (_ ("Top Right"));
++#line 345 "ease-transitions.vala"
++ return result;
++#line 960 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_BOTTOM_LEFT:
++ {
++ result = g_strdup (_ ("Bottom Left"));
++#line 347 "ease-transitions.vala"
++ return result;
++#line 967 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_BOTTOM_RIGHT:
++ {
++ result = g_strdup (_ ("Bottom Right"));
++#line 349 "ease-transitions.vala"
++ return result;
++#line 974 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_TOP_TO_BOTTOM:
++ {
++ result = g_strdup (_ ("Top to Bottom"));
++#line 351 "ease-transitions.vala"
++ return result;
++#line 981 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_BOTTOM_TO_TOP:
++ {
++ result = g_strdup (_ ("Bottom to Top"));
++#line 353 "ease-transitions.vala"
++ return result;
++#line 988 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_LEFT_TO_RIGHT:
++ {
++ result = g_strdup (_ ("Left to Right"));
++#line 355 "ease-transitions.vala"
++ return result;
++#line 995 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_RIGHT_TO_LEFT:
++ {
++ result = g_strdup (_ ("Right to Left"));
++#line 357 "ease-transitions.vala"
++ return result;
++#line 1002 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_IN:
++ {
++ result = g_strdup (_ ("In"));
++#line 359 "ease-transitions.vala"
++ return result;
++#line 1009 "ease-transitions.c"
++ }
++ case EASE_TRANSITION_VARIANT_OUT:
++ {
++ result = g_strdup (_ ("Out"));
++#line 361 "ease-transitions.vala"
++ return result;
++#line 1016 "ease-transitions.c"
++ }
++ default:
++ {
++#line 363 "ease-transitions.vala"
++ g_critical ("ease-transitions.vala:363: Undefined variant: %i", (gint) self);
++#line 1022 "ease-transitions.c"
++ result = g_strdup (_ ("Undefined"));
++#line 364 "ease-transitions.vala"
++ return result;
++#line 1026 "ease-transitions.c"
++ }
++ }
++}
++
++
++GType ease_transition_variant_get_type (void) {
++ static volatile gsize ease_transition_variant_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_transition_variant_type_id__volatile)) {
++ static const GEnumValue values[] = {{EASE_TRANSITION_VARIANT_LEFT, "EASE_TRANSITION_VARIANT_LEFT", "left"}, {EASE_TRANSITION_VARIANT_RIGHT, "EASE_TRANSITION_VARIANT_RIGHT", "right"}, {EASE_TRANSITION_VARIANT_UP, "EASE_TRANSITION_VARIANT_UP", "up"}, {EASE_TRANSITION_VARIANT_DOWN, "EASE_TRANSITION_VARIANT_DOWN", "down"}, {EASE_TRANSITION_VARIANT_BOTTOM, "EASE_TRANSITION_VARIANT_BOTTOM", "bottom"}, {EASE_TRANSITION_VARIANT_TOP, "EASE_TRANSITION_VARIANT_TOP", "top"}, {EASE_TRANSITION_VARIANT_CENTER, "EASE_TRANSITION_VARIANT_CENTER", "center"}, {EASE_TRANSITION_VARIANT_TOP_LEFT, "EASE_TRANSITION_VARIANT_TOP_LEFT", "top-left"}, {EASE_TRANSITION_VARIANT_TOP_RIGHT, "EASE_TRANSITION_VARIANT_TOP_RIGHT", "top-right"}, {EASE_TRANSITION_VARIANT_BOTTOM_LEFT, "EASE_TRANSITION_VARIANT_BOTTOM_LEFT", "bottom-left"}, {EASE_TRANSITION_VARIANT_BOTTOM_RIGHT, "EASE_TRANSITION_VARIANT_BOTTOM_RIGHT", "bottom-right"}, {EASE_TRANSITION_VARIANT_TOP_TO_BOTTOM, "EASE_TRANSITION_VARIANT_TOP_TO_BOTTOM",
"top-to-bottom"}, {EASE_TRANSITION_VARIANT_BOTTOM_TO_TOP, "EASE_TRANSITION_VARIANT_BOTTOM_TO_TOP", "bottom-to-top"}, {EASE_TRANSITION_VARIANT_LEFT_TO_RIGHT, "EASE_TRANSITION_VARIANT_LEFT_TO_RIGHT", "left-to-right"}, {EASE_TRANSITION_VARIANT_RIGHT_TO_LEFT, "EASE_TRANSITION_VARIANT_RIGHT_TO_LEFT", "right-to-left"}, {EASE_TRANSITION_VARIANT_IN, "EASE_TRANSITION_VARIANT_IN", "in"}, {EASE_TRANSITION_VARIANT_OUT, "EASE_TRANSITION_VARIANT_OUT", "out"}, {0, NULL, NULL}};
++ GType ease_transition_variant_type_id;
++ ease_transition_variant_type_id = g_enum_register_static ("EaseTransitionVariant", values);
++ g_once_init_leave (&ease_transition_variant_type_id__volatile, ease_transition_variant_type_id);
++ }
++ return ease_transition_variant_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-undo-action.c
index 0000000,0000000..2f14a3c
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-undo-action.c
@@@ -1,0 -1,0 +1,527 @@@
++/* ease-undo-action.c generated by valac, the Vala compiler
++ * generated from ease-undo-action.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gee.h>
++#include <stdlib.h>
++#include <string.h>
++#include <gobject/gvaluecollector.h>
++
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++typedef struct _EaseUndoItemPrivate EaseUndoItemPrivate;
++
++#define EASE_TYPE_UNDO_ACTION (ease_undo_action_get_type ())
++#define EASE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoAction))
++#define EASE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++#define EASE_IS_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ACTION))
++#define EASE_IS_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ACTION))
++#define EASE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++
++typedef struct _EaseUndoAction EaseUndoAction;
++typedef struct _EaseUndoActionClass EaseUndoActionClass;
++typedef struct _EaseUndoActionPrivate EaseUndoActionPrivate;
++
++#define EASE_UNDO_ACTION_TYPE_UNDO_PAIR (ease_undo_action_undo_pair_get_type ())
++#define EASE_UNDO_ACTION_UNDO_PAIR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_UNDO_ACTION_TYPE_UNDO_PAIR, EaseUndoActionUndoPair))
++#define EASE_UNDO_ACTION_UNDO_PAIR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_UNDO_ACTION_TYPE_UNDO_PAIR, EaseUndoActionUndoPairClass))
++#define EASE_UNDO_ACTION_IS_UNDO_PAIR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_UNDO_ACTION_TYPE_UNDO_PAIR))
++#define EASE_UNDO_ACTION_IS_UNDO_PAIR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_UNDO_ACTION_TYPE_UNDO_PAIR))
++#define EASE_UNDO_ACTION_UNDO_PAIR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_UNDO_ACTION_TYPE_UNDO_PAIR, EaseUndoActionUndoPairClass))
++
++typedef struct _EaseUndoActionUndoPair EaseUndoActionUndoPair;
++typedef struct _EaseUndoActionUndoPairClass EaseUndoActionUndoPairClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _ease_undo_action_undo_pair_unref0(var) ((var == NULL) ? NULL : (var = (ease_undo_action_undo_pair_unref (var), NULL)))
++typedef struct _EaseUndoActionUndoPairPrivate EaseUndoActionUndoPairPrivate;
++#define _g_free0(var) (var = (g_free (var), NULL))
++typedef struct _EaseUndoActionParamSpecUndoPair EaseUndoActionParamSpecUndoPair;
++
++struct _EaseUndoItem {
++ GObject parent_instance;
++ EaseUndoItemPrivate * priv;
++};
++
++struct _EaseUndoItemClass {
++ GObjectClass parent_class;
++ EaseUndoItem* (*apply) (EaseUndoItem* self);
++};
++
++struct _EaseUndoAction {
++ EaseUndoItem parent_instance;
++ EaseUndoActionPrivate * priv;
++};
++
++struct _EaseUndoActionClass {
++ EaseUndoItemClass parent_class;
++};
++
++struct _EaseUndoActionPrivate {
++ GeeLinkedList* pairs;
++};
++
++struct _EaseUndoActionUndoPair {
++ GTypeInstance parent_instance;
++ volatile int ref_count;
++ EaseUndoActionUndoPairPrivate * priv;
++};
++
++struct _EaseUndoActionUndoPairClass {
++ GTypeClass parent_class;
++ void (*finalize) (EaseUndoActionUndoPair *self);
++};
++
++struct _EaseUndoActionUndoPairPrivate {
++ char* property;
++ GObject* object;
++ GValue val;
++ GType type;
++};
++
++struct _EaseUndoActionParamSpecUndoPair {
++ GParamSpec parent_instance;
++};
++
++
++static gpointer ease_undo_action_undo_pair_parent_class = NULL;
++static gpointer ease_undo_action_parent_class = NULL;
++
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++GType ease_undo_action_get_type (void) G_GNUC_CONST;
++static gpointer ease_undo_action_undo_pair_ref (gpointer instance);
++static void ease_undo_action_undo_pair_unref (gpointer instance);
++static GParamSpec* ease_undo_action_param_spec_undo_pair (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) G_GNUC_UNUSED;
++static void ease_undo_action_value_set_undo_pair (GValue* value, gpointer v_object) G_GNUC_UNUSED;
++static void ease_undo_action_value_take_undo_pair (GValue* value, gpointer v_object) G_GNUC_UNUSED;
++static gpointer ease_undo_action_value_get_undo_pair (const GValue* value) G_GNUC_UNUSED;
++static GType ease_undo_action_undo_pair_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
++#define EASE_UNDO_ACTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_UNDO_ACTION, EaseUndoActionPrivate))
++enum {
++ EASE_UNDO_ACTION_DUMMY_PROPERTY
++};
++EaseUndoItem* ease_undo_item_construct (GType object_type);
++static EaseUndoActionUndoPair* ease_undo_action_undo_pair_new (GObject* obj, const char* prop);
++static EaseUndoActionUndoPair* ease_undo_action_undo_pair_construct (GType object_type, GObject* obj, const char* prop);
++EaseUndoAction* ease_undo_action_new (GObject* obj, const char* prop);
++EaseUndoAction* ease_undo_action_construct (GType object_type, GObject* obj, const char* prop);
++void ease_undo_action_add (EaseUndoAction* self, GObject* obj, const char* prop);
++void ease_undo_action_combine (EaseUndoAction* self, EaseUndoAction* action);
++static void ease_undo_action_undo_pair_apply (EaseUndoActionUndoPair* self);
++static EaseUndoItem* ease_undo_action_real_apply (EaseUndoItem* base);
++#define EASE_UNDO_ACTION_UNDO_PAIR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_UNDO_ACTION_TYPE_UNDO_PAIR, EaseUndoActionUndoPairPrivate))
++enum {
++ EASE_UNDO_ACTION_UNDO_PAIR_DUMMY_PROPERTY
++};
++static void ease_undo_action_undo_pair_finalize (EaseUndoActionUndoPair* obj);
++static void ease_undo_action_finalize (GObject* obj);
++
++
++
++#line 34 "ease-undo-action.vala"
++EaseUndoAction* ease_undo_action_construct (GType object_type, GObject* obj, const char* prop) {
++#line 149 "ease-undo-action.c"
++ EaseUndoAction * self;
++ EaseUndoActionUndoPair* _tmp0_;
++#line 34 "ease-undo-action.vala"
++ g_return_val_if_fail (obj != NULL, NULL);
++#line 34 "ease-undo-action.vala"
++ g_return_val_if_fail (prop != NULL, NULL);
++#line 34 "ease-undo-action.vala"
++ self = (EaseUndoAction*) ease_undo_item_construct (object_type);
++#line 36 "ease-undo-action.vala"
++ gee_abstract_collection_add ((GeeAbstractCollection*) self->priv->pairs, _tmp0_ = ease_undo_action_undo_pair_new (obj, prop));
++#line 160 "ease-undo-action.c"
++ _ease_undo_action_undo_pair_unref0 (_tmp0_);
++ return self;
++}
++
++
++#line 34 "ease-undo-action.vala"
++EaseUndoAction* ease_undo_action_new (GObject* obj, const char* prop) {
++#line 34 "ease-undo-action.vala"
++ return ease_undo_action_construct (EASE_TYPE_UNDO_ACTION, obj, prop);
++#line 170 "ease-undo-action.c"
++}
++
++
++#line 45 "ease-undo-action.vala"
++void ease_undo_action_add (EaseUndoAction* self, GObject* obj, const char* prop) {
++#line 176 "ease-undo-action.c"
++ EaseUndoActionUndoPair* _tmp0_;
++#line 45 "ease-undo-action.vala"
++ g_return_if_fail (self != NULL);
++#line 45 "ease-undo-action.vala"
++ g_return_if_fail (obj != NULL);
++#line 45 "ease-undo-action.vala"
++ g_return_if_fail (prop != NULL);
++#line 47 "ease-undo-action.vala"
++ gee_abstract_collection_add ((GeeAbstractCollection*) self->priv->pairs, _tmp0_ = ease_undo_action_undo_pair_new (obj, prop));
++#line 186 "ease-undo-action.c"
++ _ease_undo_action_undo_pair_unref0 (_tmp0_);
++}
++
++
++#line 55 "ease-undo-action.vala"
++void ease_undo_action_combine (EaseUndoAction* self, EaseUndoAction* action) {
++#line 55 "ease-undo-action.vala"
++ g_return_if_fail (self != NULL);
++#line 55 "ease-undo-action.vala"
++ g_return_if_fail (action != NULL);
++#line 197 "ease-undo-action.c"
++ {
++ GeeIterator* _p_it;
++#line 57 "ease-undo-action.vala"
++ _p_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) action->priv->pairs);
++#line 57 "ease-undo-action.vala"
++ while (TRUE) {
++#line 204 "ease-undo-action.c"
++ EaseUndoActionUndoPair* p;
++#line 57 "ease-undo-action.vala"
++ if (!gee_iterator_next (_p_it)) {
++#line 57 "ease-undo-action.vala"
++ break;
++#line 210 "ease-undo-action.c"
++ }
++#line 57 "ease-undo-action.vala"
++ p = (EaseUndoActionUndoPair*) gee_iterator_get (_p_it);
++#line 57 "ease-undo-action.vala"
++ gee_abstract_collection_add ((GeeAbstractCollection*) self->priv->pairs, p);
++#line 216 "ease-undo-action.c"
++ _ease_undo_action_undo_pair_unref0 (p);
++ }
++ _g_object_unref0 (_p_it);
++ }
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 65 "ease-undo-action.vala"
++static EaseUndoItem* ease_undo_action_real_apply (EaseUndoItem* base) {
++#line 231 "ease-undo-action.c"
++ EaseUndoAction * self;
++ EaseUndoItem* result = NULL;
++ self = (EaseUndoAction*) base;
++#line 67 "ease-undo-action.vala"
++ g_signal_emit_by_name ((EaseUndoItem*) self, "pre-apply", self);
++#line 237 "ease-undo-action.c"
++ {
++ GeeIterator* _pair_it;
++#line 68 "ease-undo-action.vala"
++ _pair_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) self->priv->pairs);
++#line 68 "ease-undo-action.vala"
++ while (TRUE) {
++#line 244 "ease-undo-action.c"
++ EaseUndoActionUndoPair* pair;
++#line 68 "ease-undo-action.vala"
++ if (!gee_iterator_next (_pair_it)) {
++#line 68 "ease-undo-action.vala"
++ break;
++#line 250 "ease-undo-action.c"
++ }
++#line 68 "ease-undo-action.vala"
++ pair = (EaseUndoActionUndoPair*) gee_iterator_get (_pair_it);
++#line 68 "ease-undo-action.vala"
++ ease_undo_action_undo_pair_apply (pair);
++#line 256 "ease-undo-action.c"
++ _ease_undo_action_undo_pair_unref0 (pair);
++ }
++ _g_object_unref0 (_pair_it);
++ }
++#line 69 "ease-undo-action.vala"
++ g_signal_emit_by_name ((EaseUndoItem*) self, "applied", self);
++#line 263 "ease-undo-action.c"
++ result = _g_object_ref0 ((EaseUndoItem*) self);
++#line 70 "ease-undo-action.vala"
++ return result;
++#line 267 "ease-undo-action.c"
++}
++
++
++#line 83 "ease-undo-action.vala"
++static EaseUndoActionUndoPair* ease_undo_action_undo_pair_construct (GType object_type, GObject* obj, const char* prop) {
++#line 273 "ease-undo-action.c"
++ EaseUndoActionUndoPair* self;
++ GObject* _tmp0_;
++ char* _tmp1_;
++ GValue _tmp3_;
++ GValue _tmp2_ = {0};
++#line 83 "ease-undo-action.vala"
++ g_return_val_if_fail (obj != NULL, NULL);
++#line 83 "ease-undo-action.vala"
++ g_return_val_if_fail (prop != NULL, NULL);
++#line 283 "ease-undo-action.c"
++ self = (EaseUndoActionUndoPair*) g_type_create_instance (object_type);
++#line 86 "ease-undo-action.vala"
++ self->priv->object = (_tmp0_ = _g_object_ref0 (obj), _g_object_unref0 (self->priv->object), _tmp0_);
++#line 87 "ease-undo-action.vala"
++ self->priv->property = (_tmp1_ = g_strdup (prop), _g_free0 (self->priv->property), _tmp1_);
++#line 90 "ease-undo-action.vala"
++ self->priv->type = g_object_class_find_property (G_OBJECT_GET_CLASS (obj), prop)->value_type;
++#line 91 "ease-undo-action.vala"
++ self->priv->val = (_tmp3_ = (g_value_init (&_tmp2_, self->priv->type), _tmp2_), G_IS_VALUE (&self->priv->val) ? (g_value_unset (&self->priv->val), NULL) : NULL, _tmp3_);
++#line 94 "ease-undo-action.vala"
++ g_object_get_property (obj, prop, &self->priv->val);
++#line 295 "ease-undo-action.c"
++ return self;
++}
++
++
++#line 83 "ease-undo-action.vala"
++static EaseUndoActionUndoPair* ease_undo_action_undo_pair_new (GObject* obj, const char* prop) {
++#line 83 "ease-undo-action.vala"
++ return ease_undo_action_undo_pair_construct (EASE_UNDO_ACTION_TYPE_UNDO_PAIR, obj, prop);
++#line 304 "ease-undo-action.c"
++}
++
++
++#line 103 "ease-undo-action.vala"
++static void ease_undo_action_undo_pair_apply (EaseUndoActionUndoPair* self) {
++#line 310 "ease-undo-action.c"
++ GValue temp = {0};
++ GValue _tmp1_;
++ GValue _tmp0_ = {0};
++#line 103 "ease-undo-action.vala"
++ g_return_if_fail (self != NULL);
++#line 316 "ease-undo-action.c"
++ g_value_init (&temp, self->priv->type);
++#line 107 "ease-undo-action.vala"
++ g_object_get_property (self->priv->object, self->priv->property, &temp);
++#line 110 "ease-undo-action.vala"
++ g_object_set_property (self->priv->object, self->priv->property, &self->priv->val);
++#line 113 "ease-undo-action.vala"
++ self->priv->val = (_tmp1_ = G_IS_VALUE (&temp) ? (g_value_init (&_tmp0_, G_VALUE_TYPE (&temp)), g_value_copy (&temp, &_tmp0_), _tmp0_) : temp, G_IS_VALUE (&self->priv->val) ? (g_value_unset (&self->priv->val), NULL) : NULL, _tmp1_);
++#line 324 "ease-undo-action.c"
++ G_IS_VALUE (&temp) ? (g_value_unset (&temp), NULL) : NULL;
++}
++
++
++static void ease_undo_action_value_undo_pair_init (GValue* value) {
++ value->data[0].v_pointer = NULL;
++}
++
++
++static void ease_undo_action_value_undo_pair_free_value (GValue* value) {
++ if (value->data[0].v_pointer) {
++ ease_undo_action_undo_pair_unref (value->data[0].v_pointer);
++ }
++}
++
++
++static void ease_undo_action_value_undo_pair_copy_value (const GValue* src_value, GValue* dest_value) {
++ if (src_value->data[0].v_pointer) {
++ dest_value->data[0].v_pointer = ease_undo_action_undo_pair_ref (src_value->data[0].v_pointer);
++ } else {
++ dest_value->data[0].v_pointer = NULL;
++ }
++}
++
++
++static gpointer ease_undo_action_value_undo_pair_peek_pointer (const GValue* value) {
++ return value->data[0].v_pointer;
++}
++
++
++static gchar* ease_undo_action_value_undo_pair_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
++ if (collect_values[0].v_pointer) {
++ EaseUndoActionUndoPair* object;
++ object = collect_values[0].v_pointer;
++ if (object->parent_instance.g_class == NULL) {
++ return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
++ } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
++ return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
++ }
++ value->data[0].v_pointer = ease_undo_action_undo_pair_ref (object);
++ } else {
++ value->data[0].v_pointer = NULL;
++ }
++ return NULL;
++}
++
++
++static gchar* ease_undo_action_value_undo_pair_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
++ EaseUndoActionUndoPair** object_p;
++ object_p = collect_values[0].v_pointer;
++ if (!object_p) {
++ return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
++ }
++ if (!value->data[0].v_pointer) {
++ *object_p = NULL;
++ } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
++ *object_p = value->data[0].v_pointer;
++ } else {
++ *object_p = ease_undo_action_undo_pair_ref (value->data[0].v_pointer);
++ }
++ return NULL;
++}
++
++
++static GParamSpec* ease_undo_action_param_spec_undo_pair (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
++ EaseUndoActionParamSpecUndoPair* spec;
++ g_return_val_if_fail (g_type_is_a (object_type, EASE_UNDO_ACTION_TYPE_UNDO_PAIR), NULL);
++ spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
++ G_PARAM_SPEC (spec)->value_type = object_type;
++ return G_PARAM_SPEC (spec);
++}
++
++
++static gpointer ease_undo_action_value_get_undo_pair (const GValue* value) {
++ g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, EASE_UNDO_ACTION_TYPE_UNDO_PAIR), NULL);
++ return value->data[0].v_pointer;
++}
++
++
++static void ease_undo_action_value_set_undo_pair (GValue* value, gpointer v_object) {
++ EaseUndoActionUndoPair* old;
++ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, EASE_UNDO_ACTION_TYPE_UNDO_PAIR));
++ old = value->data[0].v_pointer;
++ if (v_object) {
++ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, EASE_UNDO_ACTION_TYPE_UNDO_PAIR));
++ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
++ value->data[0].v_pointer = v_object;
++ ease_undo_action_undo_pair_ref (value->data[0].v_pointer);
++ } else {
++ value->data[0].v_pointer = NULL;
++ }
++ if (old) {
++ ease_undo_action_undo_pair_unref (old);
++ }
++}
++
++
++static void ease_undo_action_value_take_undo_pair (GValue* value, gpointer v_object) {
++ EaseUndoActionUndoPair* old;
++ g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, EASE_UNDO_ACTION_TYPE_UNDO_PAIR));
++ old = value->data[0].v_pointer;
++ if (v_object) {
++ g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, EASE_UNDO_ACTION_TYPE_UNDO_PAIR));
++ g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
++ value->data[0].v_pointer = v_object;
++ } else {
++ value->data[0].v_pointer = NULL;
++ }
++ if (old) {
++ ease_undo_action_undo_pair_unref (old);
++ }
++}
++
++
++static void ease_undo_action_undo_pair_class_init (EaseUndoActionUndoPairClass * klass) {
++ ease_undo_action_undo_pair_parent_class = g_type_class_peek_parent (klass);
++ EASE_UNDO_ACTION_UNDO_PAIR_CLASS (klass)->finalize = ease_undo_action_undo_pair_finalize;
++ g_type_class_add_private (klass, sizeof (EaseUndoActionUndoPairPrivate));
++}
++
++
++static void ease_undo_action_undo_pair_instance_init (EaseUndoActionUndoPair * self) {
++ self->priv = EASE_UNDO_ACTION_UNDO_PAIR_GET_PRIVATE (self);
++ self->ref_count = 1;
++}
++
++
++static void ease_undo_action_undo_pair_finalize (EaseUndoActionUndoPair* obj) {
++ EaseUndoActionUndoPair * self;
++ self = EASE_UNDO_ACTION_UNDO_PAIR (obj);
++ _g_free0 (self->priv->property);
++ _g_object_unref0 (self->priv->object);
++ G_IS_VALUE (&self->priv->val) ? (g_value_unset (&self->priv->val), NULL) : NULL;
++}
++
++
++static GType ease_undo_action_undo_pair_get_type (void) {
++ static volatile gsize ease_undo_action_undo_pair_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_undo_action_undo_pair_type_id__volatile)) {
++ static const GTypeValueTable g_define_type_value_table = { ease_undo_action_value_undo_pair_init, ease_undo_action_value_undo_pair_free_value, ease_undo_action_value_undo_pair_copy_value, ease_undo_action_value_undo_pair_peek_pointer, "p", ease_undo_action_value_undo_pair_collect_value, "p", ease_undo_action_value_undo_pair_lcopy_value };
++ static const GTypeInfo g_define_type_info = { sizeof (EaseUndoActionUndoPairClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_undo_action_undo_pair_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseUndoActionUndoPair), 0, (GInstanceInitFunc) ease_undo_action_undo_pair_instance_init, &g_define_type_value_table };
++ static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
++ GType ease_undo_action_undo_pair_type_id;
++ ease_undo_action_undo_pair_type_id = g_type_register_fundamental (g_type_fundamental_next (), "EaseUndoActionUndoPair", &g_define_type_info, &g_define_type_fundamental_info, 0);
++ g_once_init_leave (&ease_undo_action_undo_pair_type_id__volatile, ease_undo_action_undo_pair_type_id);
++ }
++ return ease_undo_action_undo_pair_type_id__volatile;
++}
++
++
++static gpointer ease_undo_action_undo_pair_ref (gpointer instance) {
++ EaseUndoActionUndoPair* self;
++ self = instance;
++ g_atomic_int_inc (&self->ref_count);
++ return instance;
++}
++
++
++static void ease_undo_action_undo_pair_unref (gpointer instance) {
++ EaseUndoActionUndoPair* self;
++ self = instance;
++ if (g_atomic_int_dec_and_test (&self->ref_count)) {
++ EASE_UNDO_ACTION_UNDO_PAIR_GET_CLASS (self)->finalize (self);
++ g_type_free_instance ((GTypeInstance *) self);
++ }
++}
++
++
++static void ease_undo_action_class_init (EaseUndoActionClass * klass) {
++ ease_undo_action_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseUndoActionPrivate));
++ EASE_UNDO_ITEM_CLASS (klass)->apply = ease_undo_action_real_apply;
++ G_OBJECT_CLASS (klass)->finalize = ease_undo_action_finalize;
++}
++
++
++static void ease_undo_action_instance_init (EaseUndoAction * self) {
++ self->priv = EASE_UNDO_ACTION_GET_PRIVATE (self);
++ self->priv->pairs = gee_linked_list_new (EASE_UNDO_ACTION_TYPE_UNDO_PAIR, (GBoxedCopyFunc) ease_undo_action_undo_pair_ref, ease_undo_action_undo_pair_unref, NULL);
++}
++
++
++static void ease_undo_action_finalize (GObject* obj) {
++ EaseUndoAction * self;
++ self = EASE_UNDO_ACTION (obj);
++ _g_object_unref0 (self->priv->pairs);
++ G_OBJECT_CLASS (ease_undo_action_parent_class)->finalize (obj);
++}
++
++
++GType ease_undo_action_get_type (void) {
++ static volatile gsize ease_undo_action_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_undo_action_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseUndoActionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_undo_action_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseUndoAction), 0, (GInstanceInitFunc) ease_undo_action_instance_init, NULL };
++ GType ease_undo_action_type_id;
++ ease_undo_action_type_id = g_type_register_static (EASE_TYPE_UNDO_ITEM, "EaseUndoAction", &g_define_type_info, 0);
++ g_once_init_leave (&ease_undo_action_type_id__volatile, ease_undo_action_type_id);
++ }
++ return ease_undo_action_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-undo-actions-element.c
index 0000000,0000000..5c0663e
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-undo-actions-element.c
@@@ -1,0 -1,0 +1,311 @@@
++/* ease-undo-actions-element.c generated by valac, the Vala compiler
++ * generated from ease-undo-actions-element.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++typedef struct _EaseUndoItemPrivate EaseUndoItemPrivate;
++
++#define EASE_TYPE_ELEMENT_ADD_UNDO_ACTION (ease_element_add_undo_action_get_type ())
++#define EASE_ELEMENT_ADD_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT_ADD_UNDO_ACTION, EaseElementAddUndoAction))
++#define EASE_ELEMENT_ADD_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT_ADD_UNDO_ACTION, EaseElementAddUndoActionClass))
++#define EASE_IS_ELEMENT_ADD_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT_ADD_UNDO_ACTION))
++#define EASE_IS_ELEMENT_ADD_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT_ADD_UNDO_ACTION))
++#define EASE_ELEMENT_ADD_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT_ADD_UNDO_ACTION, EaseElementAddUndoActionClass))
++
++typedef struct _EaseElementAddUndoAction EaseElementAddUndoAction;
++typedef struct _EaseElementAddUndoActionClass EaseElementAddUndoActionClass;
++typedef struct _EaseElementAddUndoActionPrivate EaseElementAddUndoActionPrivate;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++#define EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION (ease_element_remove_undo_action_get_type ())
++#define EASE_ELEMENT_REMOVE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION, EaseElementRemoveUndoAction))
++#define EASE_ELEMENT_REMOVE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION, EaseElementRemoveUndoActionClass))
++#define EASE_IS_ELEMENT_REMOVE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION))
++#define EASE_IS_ELEMENT_REMOVE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION))
++#define EASE_ELEMENT_REMOVE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION, EaseElementRemoveUndoActionClass))
++
++typedef struct _EaseElementRemoveUndoAction EaseElementRemoveUndoAction;
++typedef struct _EaseElementRemoveUndoActionClass EaseElementRemoveUndoActionClass;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++typedef struct _EaseElementRemoveUndoActionPrivate EaseElementRemoveUndoActionPrivate;
++
++struct _EaseUndoItem {
++ GObject parent_instance;
++ EaseUndoItemPrivate * priv;
++};
++
++struct _EaseUndoItemClass {
++ GObjectClass parent_class;
++ EaseUndoItem* (*apply) (EaseUndoItem* self);
++};
++
++struct _EaseElementAddUndoAction {
++ EaseUndoItem parent_instance;
++ EaseElementAddUndoActionPrivate * priv;
++};
++
++struct _EaseElementAddUndoActionClass {
++ EaseUndoItemClass parent_class;
++};
++
++struct _EaseElementAddUndoActionPrivate {
++ EaseElement* element;
++};
++
++struct _EaseElementRemoveUndoAction {
++ EaseUndoItem parent_instance;
++ EaseElementRemoveUndoActionPrivate * priv;
++};
++
++struct _EaseElementRemoveUndoActionClass {
++ EaseUndoItemClass parent_class;
++};
++
++struct _EaseElementRemoveUndoActionPrivate {
++ EaseElement* element;
++ EaseSlide* slide;
++ gint index;
++};
++
++
++static gpointer ease_element_add_undo_action_parent_class = NULL;
++static gpointer ease_element_remove_undo_action_parent_class = NULL;
++
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++GType ease_element_add_undo_action_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++#define EASE_ELEMENT_ADD_UNDO_ACTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_ELEMENT_ADD_UNDO_ACTION, EaseElementAddUndoActionPrivate))
++enum {
++ EASE_ELEMENT_ADD_UNDO_ACTION_DUMMY_PROPERTY
++};
++EaseUndoItem* ease_undo_item_construct (GType object_type);
++EaseElementAddUndoAction* ease_element_add_undo_action_new (EaseElement* e);
++EaseElementAddUndoAction* ease_element_add_undo_action_construct (GType object_type, EaseElement* e);
++EaseElementRemoveUndoAction* ease_element_remove_undo_action_new (EaseElement* e);
++EaseElementRemoveUndoAction* ease_element_remove_undo_action_construct (GType object_type, EaseElement* e);
++GType ease_element_remove_undo_action_get_type (void) G_GNUC_CONST;
++GType ease_slide_get_type (void) G_GNUC_CONST;
++EaseSlide* ease_element_get_parent (EaseElement* self);
++void ease_slide_remove_element (EaseSlide* self, EaseElement* e);
++static EaseUndoItem* ease_element_add_undo_action_real_apply (EaseUndoItem* base);
++static void ease_element_add_undo_action_finalize (GObject* obj);
++#define EASE_ELEMENT_REMOVE_UNDO_ACTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION, EaseElementRemoveUndoActionPrivate))
++enum {
++ EASE_ELEMENT_REMOVE_UNDO_ACTION_DUMMY_PROPERTY
++};
++gint ease_slide_index_of (EaseSlide* self, EaseElement* e);
++void ease_slide_add_element (EaseSlide* self, gint index, EaseElement* e);
++static EaseUndoItem* ease_element_remove_undo_action_real_apply (EaseUndoItem* base);
++static void ease_element_remove_undo_action_finalize (GObject* obj);
++
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 33 "ease-undo-actions-element.vala"
++EaseElementAddUndoAction* ease_element_add_undo_action_construct (GType object_type, EaseElement* e) {
++#line 158 "ease-undo-actions-element.c"
++ EaseElementAddUndoAction * self;
++ EaseElement* _tmp0_;
++#line 33 "ease-undo-actions-element.vala"
++ g_return_val_if_fail (e != NULL, NULL);
++#line 33 "ease-undo-actions-element.vala"
++ self = (EaseElementAddUndoAction*) ease_undo_item_construct (object_type);
++#line 35 "ease-undo-actions-element.vala"
++ self->priv->element = (_tmp0_ = _g_object_ref0 (e), _g_object_unref0 (self->priv->element), _tmp0_);
++#line 167 "ease-undo-actions-element.c"
++ return self;
++}
++
++
++#line 33 "ease-undo-actions-element.vala"
++EaseElementAddUndoAction* ease_element_add_undo_action_new (EaseElement* e) {
++#line 33 "ease-undo-actions-element.vala"
++ return ease_element_add_undo_action_construct (EASE_TYPE_ELEMENT_ADD_UNDO_ACTION, e);
++#line 176 "ease-undo-actions-element.c"
++}
++
++
++#line 41 "ease-undo-actions-element.vala"
++static EaseUndoItem* ease_element_add_undo_action_real_apply (EaseUndoItem* base) {
++#line 182 "ease-undo-actions-element.c"
++ EaseElementAddUndoAction * self;
++ EaseUndoItem* result = NULL;
++ EaseElementRemoveUndoAction* action;
++ self = (EaseElementAddUndoAction*) base;
++#line 43 "ease-undo-actions-element.vala"
++ action = ease_element_remove_undo_action_new (self->priv->element);
++#line 44 "ease-undo-actions-element.vala"
++ ease_slide_remove_element (ease_element_get_parent (self->priv->element), self->priv->element);
++#line 191 "ease-undo-actions-element.c"
++ result = (EaseUndoItem*) action;
++#line 45 "ease-undo-actions-element.vala"
++ return result;
++#line 195 "ease-undo-actions-element.c"
++}
++
++
++static void ease_element_add_undo_action_class_init (EaseElementAddUndoActionClass * klass) {
++ ease_element_add_undo_action_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseElementAddUndoActionPrivate));
++ EASE_UNDO_ITEM_CLASS (klass)->apply = ease_element_add_undo_action_real_apply;
++ G_OBJECT_CLASS (klass)->finalize = ease_element_add_undo_action_finalize;
++}
++
++
++static void ease_element_add_undo_action_instance_init (EaseElementAddUndoAction * self) {
++ self->priv = EASE_ELEMENT_ADD_UNDO_ACTION_GET_PRIVATE (self);
++}
++
++
++static void ease_element_add_undo_action_finalize (GObject* obj) {
++ EaseElementAddUndoAction * self;
++ self = EASE_ELEMENT_ADD_UNDO_ACTION (obj);
++ _g_object_unref0 (self->priv->element);
++ G_OBJECT_CLASS (ease_element_add_undo_action_parent_class)->finalize (obj);
++}
++
++
++GType ease_element_add_undo_action_get_type (void) {
++ static volatile gsize ease_element_add_undo_action_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_element_add_undo_action_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseElementAddUndoActionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_element_add_undo_action_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseElementAddUndoAction), 0, (GInstanceInitFunc) ease_element_add_undo_action_instance_init, NULL };
++ GType ease_element_add_undo_action_type_id;
++ ease_element_add_undo_action_type_id = g_type_register_static (EASE_TYPE_UNDO_ITEM, "EaseElementAddUndoAction", &g_define_type_info, 0);
++ g_once_init_leave (&ease_element_add_undo_action_type_id__volatile, ease_element_add_undo_action_type_id);
++ }
++ return ease_element_add_undo_action_type_id__volatile;
++}
++
++
++#line 76 "ease-undo-actions-element.vala"
++EaseElementRemoveUndoAction* ease_element_remove_undo_action_construct (GType object_type, EaseElement* e) {
++#line 234 "ease-undo-actions-element.c"
++ EaseElementRemoveUndoAction * self;
++ EaseElement* _tmp0_;
++ EaseSlide* _tmp1_;
++#line 76 "ease-undo-actions-element.vala"
++ g_return_val_if_fail (e != NULL, NULL);
++#line 76 "ease-undo-actions-element.vala"
++ self = (EaseElementRemoveUndoAction*) ease_undo_item_construct (object_type);
++#line 78 "ease-undo-actions-element.vala"
++ self->priv->element = (_tmp0_ = _g_object_ref0 (e), _g_object_unref0 (self->priv->element), _tmp0_);
++#line 79 "ease-undo-actions-element.vala"
++ self->priv->slide = (_tmp1_ = _g_object_ref0 (ease_element_get_parent (e)), _g_object_unref0 (self->priv->slide), _tmp1_);
++#line 80 "ease-undo-actions-element.vala"
++ self->priv->index = ease_slide_index_of (ease_element_get_parent (e), e);
++#line 248 "ease-undo-actions-element.c"
++ return self;
++}
++
++
++#line 76 "ease-undo-actions-element.vala"
++EaseElementRemoveUndoAction* ease_element_remove_undo_action_new (EaseElement* e) {
++#line 76 "ease-undo-actions-element.vala"
++ return ease_element_remove_undo_action_construct (EASE_TYPE_ELEMENT_REMOVE_UNDO_ACTION, e);
++#line 257 "ease-undo-actions-element.c"
++}
++
++
++#line 86 "ease-undo-actions-element.vala"
++static EaseUndoItem* ease_element_remove_undo_action_real_apply (EaseUndoItem* base) {
++#line 263 "ease-undo-actions-element.c"
++ EaseElementRemoveUndoAction * self;
++ EaseUndoItem* result = NULL;
++ self = (EaseElementRemoveUndoAction*) base;
++#line 88 "ease-undo-actions-element.vala"
++ ease_slide_add_element (self->priv->slide, self->priv->index, self->priv->element);
++#line 269 "ease-undo-actions-element.c"
++ result = (EaseUndoItem*) ease_element_add_undo_action_new (self->priv->element);
++#line 89 "ease-undo-actions-element.vala"
++ return result;
++#line 273 "ease-undo-actions-element.c"
++}
++
++
++static void ease_element_remove_undo_action_class_init (EaseElementRemoveUndoActionClass * klass) {
++ ease_element_remove_undo_action_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseElementRemoveUndoActionPrivate));
++ EASE_UNDO_ITEM_CLASS (klass)->apply = ease_element_remove_undo_action_real_apply;
++ G_OBJECT_CLASS (klass)->finalize = ease_element_remove_undo_action_finalize;
++}
++
++
++static void ease_element_remove_undo_action_instance_init (EaseElementRemoveUndoAction * self) {
++ self->priv = EASE_ELEMENT_REMOVE_UNDO_ACTION_GET_PRIVATE (self);
++}
++
++
++static void ease_element_remove_undo_action_finalize (GObject* obj) {
++ EaseElementRemoveUndoAction * self;
++ self = EASE_ELEMENT_REMOVE_UNDO_ACTION (obj);
++ _g_object_unref0 (self->priv->element);
++ _g_object_unref0 (self->priv->slide);
++ G_OBJECT_CLASS (ease_element_remove_undo_action_parent_class)->finalize (obj);
++}
++
++
++GType ease_element_remove_undo_action_get_type (void) {
++ static volatile gsize ease_element_remove_undo_action_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_element_remove_undo_action_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseElementRemoveUndoActionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_element_remove_undo_action_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseElementRemoveUndoAction), 0, (GInstanceInitFunc) ease_element_remove_undo_action_instance_init, NULL };
++ GType ease_element_remove_undo_action_type_id;
++ ease_element_remove_undo_action_type_id = g_type_register_static (EASE_TYPE_UNDO_ITEM, "EaseElementRemoveUndoAction", &g_define_type_info, 0);
++ g_once_init_leave (&ease_element_remove_undo_action_type_id__volatile, ease_element_remove_undo_action_type_id);
++ }
++ return ease_element_remove_undo_action_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-undo-actions-slide.c
index 0000000,0000000..0b65c4b
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-undo-actions-slide.c
@@@ -1,0 -1,0 +1,313 @@@
++/* ease-undo-actions-slide.c generated by valac, the Vala compiler
++ * generated from ease-undo-actions-slide.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++typedef struct _EaseUndoItemPrivate EaseUndoItemPrivate;
++
++#define EASE_TYPE_SLIDE_ADD_UNDO_ACTION (ease_slide_add_undo_action_get_type ())
++#define EASE_SLIDE_ADD_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_ADD_UNDO_ACTION, EaseSlideAddUndoAction))
++#define EASE_SLIDE_ADD_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_ADD_UNDO_ACTION, EaseSlideAddUndoActionClass))
++#define EASE_IS_SLIDE_ADD_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_ADD_UNDO_ACTION))
++#define EASE_IS_SLIDE_ADD_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_ADD_UNDO_ACTION))
++#define EASE_SLIDE_ADD_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_ADD_UNDO_ACTION, EaseSlideAddUndoActionClass))
++
++typedef struct _EaseSlideAddUndoAction EaseSlideAddUndoAction;
++typedef struct _EaseSlideAddUndoActionClass EaseSlideAddUndoActionClass;
++typedef struct _EaseSlideAddUndoActionPrivate EaseSlideAddUndoActionPrivate;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++#define EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION (ease_slide_remove_undo_action_get_type ())
++#define EASE_SLIDE_REMOVE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION, EaseSlideRemoveUndoAction))
++#define EASE_SLIDE_REMOVE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION, EaseSlideRemoveUndoActionClass))
++#define EASE_IS_SLIDE_REMOVE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION))
++#define EASE_IS_SLIDE_REMOVE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION))
++#define EASE_SLIDE_REMOVE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION, EaseSlideRemoveUndoActionClass))
++
++typedef struct _EaseSlideRemoveUndoAction EaseSlideRemoveUndoAction;
++typedef struct _EaseSlideRemoveUndoActionClass EaseSlideRemoveUndoActionClass;
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++typedef struct _EaseSlideRemoveUndoActionPrivate EaseSlideRemoveUndoActionPrivate;
++
++struct _EaseUndoItem {
++ GObject parent_instance;
++ EaseUndoItemPrivate * priv;
++};
++
++struct _EaseUndoItemClass {
++ GObjectClass parent_class;
++ EaseUndoItem* (*apply) (EaseUndoItem* self);
++};
++
++struct _EaseSlideAddUndoAction {
++ EaseUndoItem parent_instance;
++ EaseSlideAddUndoActionPrivate * priv;
++};
++
++struct _EaseSlideAddUndoActionClass {
++ EaseUndoItemClass parent_class;
++};
++
++struct _EaseSlideAddUndoActionPrivate {
++ EaseSlide* slide;
++};
++
++struct _EaseSlideRemoveUndoAction {
++ EaseUndoItem parent_instance;
++ EaseSlideRemoveUndoActionPrivate * priv;
++};
++
++struct _EaseSlideRemoveUndoActionClass {
++ EaseUndoItemClass parent_class;
++};
++
++struct _EaseSlideRemoveUndoActionPrivate {
++ EaseSlide* slide;
++ EaseDocument* document;
++ gint index;
++};
++
++
++static gpointer ease_slide_add_undo_action_parent_class = NULL;
++static gpointer ease_slide_remove_undo_action_parent_class = NULL;
++
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++GType ease_slide_add_undo_action_get_type (void) G_GNUC_CONST;
++GType ease_slide_get_type (void) G_GNUC_CONST;
++#define EASE_SLIDE_ADD_UNDO_ACTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_SLIDE_ADD_UNDO_ACTION, EaseSlideAddUndoActionPrivate))
++enum {
++ EASE_SLIDE_ADD_UNDO_ACTION_DUMMY_PROPERTY
++};
++EaseUndoItem* ease_undo_item_construct (GType object_type);
++EaseSlideAddUndoAction* ease_slide_add_undo_action_new (EaseSlide* s);
++EaseSlideAddUndoAction* ease_slide_add_undo_action_construct (GType object_type, EaseSlide* s);
++EaseSlideRemoveUndoAction* ease_slide_remove_undo_action_new (EaseSlide* s);
++EaseSlideRemoveUndoAction* ease_slide_remove_undo_action_construct (GType object_type, EaseSlide* s);
++GType ease_slide_remove_undo_action_get_type (void) G_GNUC_CONST;
++GType ease_document_get_type (void) G_GNUC_CONST;
++EaseDocument* ease_slide_get_parent (EaseSlide* self);
++EaseSlide* ease_document_remove_slide (EaseDocument* self, EaseSlide* slide);
++static EaseUndoItem* ease_slide_add_undo_action_real_apply (EaseUndoItem* base);
++static void ease_slide_add_undo_action_finalize (GObject* obj);
++#define EASE_SLIDE_REMOVE_UNDO_ACTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION, EaseSlideRemoveUndoActionPrivate))
++enum {
++ EASE_SLIDE_REMOVE_UNDO_ACTION_DUMMY_PROPERTY
++};
++gint ease_document_index_of (EaseDocument* self, EaseSlide* slide);
++void ease_document_add_slide (EaseDocument* self, gint index, EaseSlide* s);
++static EaseUndoItem* ease_slide_remove_undo_action_real_apply (EaseUndoItem* base);
++static void ease_slide_remove_undo_action_finalize (GObject* obj);
++
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 33 "ease-undo-actions-slide.vala"
++EaseSlideAddUndoAction* ease_slide_add_undo_action_construct (GType object_type, EaseSlide* s) {
++#line 158 "ease-undo-actions-slide.c"
++ EaseSlideAddUndoAction * self;
++ EaseSlide* _tmp0_;
++#line 33 "ease-undo-actions-slide.vala"
++ g_return_val_if_fail (s != NULL, NULL);
++#line 33 "ease-undo-actions-slide.vala"
++ self = (EaseSlideAddUndoAction*) ease_undo_item_construct (object_type);
++#line 35 "ease-undo-actions-slide.vala"
++ self->priv->slide = (_tmp0_ = _g_object_ref0 (s), _g_object_unref0 (self->priv->slide), _tmp0_);
++#line 167 "ease-undo-actions-slide.c"
++ return self;
++}
++
++
++#line 33 "ease-undo-actions-slide.vala"
++EaseSlideAddUndoAction* ease_slide_add_undo_action_new (EaseSlide* s) {
++#line 33 "ease-undo-actions-slide.vala"
++ return ease_slide_add_undo_action_construct (EASE_TYPE_SLIDE_ADD_UNDO_ACTION, s);
++#line 176 "ease-undo-actions-slide.c"
++}
++
++
++#line 41 "ease-undo-actions-slide.vala"
++static EaseUndoItem* ease_slide_add_undo_action_real_apply (EaseUndoItem* base) {
++#line 182 "ease-undo-actions-slide.c"
++ EaseSlideAddUndoAction * self;
++ EaseUndoItem* result = NULL;
++ EaseSlideRemoveUndoAction* action;
++ EaseSlide* _tmp0_;
++ self = (EaseSlideAddUndoAction*) base;
++#line 43 "ease-undo-actions-slide.vala"
++ action = ease_slide_remove_undo_action_new (self->priv->slide);
++#line 44 "ease-undo-actions-slide.vala"
++ _tmp0_ = ease_document_remove_slide (ease_slide_get_parent (self->priv->slide), self->priv->slide);
++#line 192 "ease-undo-actions-slide.c"
++ _g_object_unref0 (_tmp0_);
++ result = (EaseUndoItem*) action;
++#line 45 "ease-undo-actions-slide.vala"
++ return result;
++#line 197 "ease-undo-actions-slide.c"
++}
++
++
++static void ease_slide_add_undo_action_class_init (EaseSlideAddUndoActionClass * klass) {
++ ease_slide_add_undo_action_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseSlideAddUndoActionPrivate));
++ EASE_UNDO_ITEM_CLASS (klass)->apply = ease_slide_add_undo_action_real_apply;
++ G_OBJECT_CLASS (klass)->finalize = ease_slide_add_undo_action_finalize;
++}
++
++
++static void ease_slide_add_undo_action_instance_init (EaseSlideAddUndoAction * self) {
++ self->priv = EASE_SLIDE_ADD_UNDO_ACTION_GET_PRIVATE (self);
++}
++
++
++static void ease_slide_add_undo_action_finalize (GObject* obj) {
++ EaseSlideAddUndoAction * self;
++ self = EASE_SLIDE_ADD_UNDO_ACTION (obj);
++ _g_object_unref0 (self->priv->slide);
++ G_OBJECT_CLASS (ease_slide_add_undo_action_parent_class)->finalize (obj);
++}
++
++
++GType ease_slide_add_undo_action_get_type (void) {
++ static volatile gsize ease_slide_add_undo_action_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_slide_add_undo_action_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseSlideAddUndoActionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_slide_add_undo_action_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseSlideAddUndoAction), 0, (GInstanceInitFunc) ease_slide_add_undo_action_instance_init, NULL };
++ GType ease_slide_add_undo_action_type_id;
++ ease_slide_add_undo_action_type_id = g_type_register_static (EASE_TYPE_UNDO_ITEM, "EaseSlideAddUndoAction", &g_define_type_info, 0);
++ g_once_init_leave (&ease_slide_add_undo_action_type_id__volatile, ease_slide_add_undo_action_type_id);
++ }
++ return ease_slide_add_undo_action_type_id__volatile;
++}
++
++
++#line 76 "ease-undo-actions-slide.vala"
++EaseSlideRemoveUndoAction* ease_slide_remove_undo_action_construct (GType object_type, EaseSlide* s) {
++#line 236 "ease-undo-actions-slide.c"
++ EaseSlideRemoveUndoAction * self;
++ EaseSlide* _tmp0_;
++ EaseDocument* _tmp1_;
++#line 76 "ease-undo-actions-slide.vala"
++ g_return_val_if_fail (s != NULL, NULL);
++#line 76 "ease-undo-actions-slide.vala"
++ self = (EaseSlideRemoveUndoAction*) ease_undo_item_construct (object_type);
++#line 78 "ease-undo-actions-slide.vala"
++ self->priv->slide = (_tmp0_ = _g_object_ref0 (s), _g_object_unref0 (self->priv->slide), _tmp0_);
++#line 79 "ease-undo-actions-slide.vala"
++ self->priv->document = (_tmp1_ = _g_object_ref0 (ease_slide_get_parent (s)), _g_object_unref0 (self->priv->document), _tmp1_);
++#line 80 "ease-undo-actions-slide.vala"
++ self->priv->index = ease_document_index_of (ease_slide_get_parent (s), s);
++#line 250 "ease-undo-actions-slide.c"
++ return self;
++}
++
++
++#line 76 "ease-undo-actions-slide.vala"
++EaseSlideRemoveUndoAction* ease_slide_remove_undo_action_new (EaseSlide* s) {
++#line 76 "ease-undo-actions-slide.vala"
++ return ease_slide_remove_undo_action_construct (EASE_TYPE_SLIDE_REMOVE_UNDO_ACTION, s);
++#line 259 "ease-undo-actions-slide.c"
++}
++
++
++#line 86 "ease-undo-actions-slide.vala"
++static EaseUndoItem* ease_slide_remove_undo_action_real_apply (EaseUndoItem* base) {
++#line 265 "ease-undo-actions-slide.c"
++ EaseSlideRemoveUndoAction * self;
++ EaseUndoItem* result = NULL;
++ self = (EaseSlideRemoveUndoAction*) base;
++#line 88 "ease-undo-actions-slide.vala"
++ ease_document_add_slide (self->priv->document, self->priv->index, self->priv->slide);
++#line 271 "ease-undo-actions-slide.c"
++ result = (EaseUndoItem*) ease_slide_add_undo_action_new (self->priv->slide);
++#line 89 "ease-undo-actions-slide.vala"
++ return result;
++#line 275 "ease-undo-actions-slide.c"
++}
++
++
++static void ease_slide_remove_undo_action_class_init (EaseSlideRemoveUndoActionClass * klass) {
++ ease_slide_remove_undo_action_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseSlideRemoveUndoActionPrivate));
++ EASE_UNDO_ITEM_CLASS (klass)->apply = ease_slide_remove_undo_action_real_apply;
++ G_OBJECT_CLASS (klass)->finalize = ease_slide_remove_undo_action_finalize;
++}
++
++
++static void ease_slide_remove_undo_action_instance_init (EaseSlideRemoveUndoAction * self) {
++ self->priv = EASE_SLIDE_REMOVE_UNDO_ACTION_GET_PRIVATE (self);
++}
++
++
++static void ease_slide_remove_undo_action_finalize (GObject* obj) {
++ EaseSlideRemoveUndoAction * self;
++ self = EASE_SLIDE_REMOVE_UNDO_ACTION (obj);
++ _g_object_unref0 (self->priv->slide);
++ _g_object_unref0 (self->priv->document);
++ G_OBJECT_CLASS (ease_slide_remove_undo_action_parent_class)->finalize (obj);
++}
++
++
++GType ease_slide_remove_undo_action_get_type (void) {
++ static volatile gsize ease_slide_remove_undo_action_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_slide_remove_undo_action_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseSlideRemoveUndoActionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_slide_remove_undo_action_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseSlideRemoveUndoAction), 0, (GInstanceInitFunc) ease_slide_remove_undo_action_instance_init, NULL };
++ GType ease_slide_remove_undo_action_type_id;
++ ease_slide_remove_undo_action_type_id = g_type_register_static (EASE_TYPE_UNDO_ITEM, "EaseSlideRemoveUndoAction", &g_define_type_info, 0);
++ g_once_init_leave (&ease_slide_remove_undo_action_type_id__volatile, ease_slide_remove_undo_action_type_id);
++ }
++ return ease_slide_remove_undo_action_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-undo-controller.c
index 0000000,0000000..4038bdb
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-undo-controller.c
@@@ -1,0 -1,0 +1,232 @@@
++/* ease-undo-controller.c generated by valac, the Vala compiler
++ * generated from ease-undo-controller.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gee.h>
++
++
++#define EASE_TYPE_UNDO_CONTROLLER (ease_undo_controller_get_type ())
++#define EASE_UNDO_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_CONTROLLER, EaseUndoController))
++#define EASE_UNDO_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_CONTROLLER, EaseUndoControllerClass))
++#define EASE_IS_UNDO_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_CONTROLLER))
++#define EASE_IS_UNDO_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_CONTROLLER))
++#define EASE_UNDO_CONTROLLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_CONTROLLER, EaseUndoControllerClass))
++
++typedef struct _EaseUndoController EaseUndoController;
++typedef struct _EaseUndoControllerClass EaseUndoControllerClass;
++typedef struct _EaseUndoControllerPrivate EaseUndoControllerPrivate;
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++struct _EaseUndoController {
++ GObject parent_instance;
++ EaseUndoControllerPrivate * priv;
++};
++
++struct _EaseUndoControllerClass {
++ GObjectClass parent_class;
++};
++
++struct _EaseUndoControllerPrivate {
++ GeeLinkedList* undos;
++ GeeLinkedList* redos;
++};
++
++
++static gpointer ease_undo_controller_parent_class = NULL;
++
++GType ease_undo_controller_get_type (void) G_GNUC_CONST;
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++#define EASE_UNDO_CONTROLLER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_UNDO_CONTROLLER, EaseUndoControllerPrivate))
++enum {
++ EASE_UNDO_CONTROLLER_DUMMY_PROPERTY
++};
++EaseUndoController* ease_undo_controller_new (void);
++EaseUndoController* ease_undo_controller_construct (GType object_type);
++gboolean ease_undo_controller_can_undo (EaseUndoController* self);
++gboolean ease_undo_controller_can_redo (EaseUndoController* self);
++static void ease_undo_controller_add_redo_action (EaseUndoController* self, EaseUndoItem* action);
++EaseUndoItem* ease_undo_item_apply (EaseUndoItem* self);
++void ease_undo_controller_undo (EaseUndoController* self);
++void ease_undo_controller_add_action (EaseUndoController* self, EaseUndoItem* action);
++void ease_undo_controller_redo (EaseUndoController* self);
++void ease_undo_controller_clear_redo (EaseUndoController* self);
++static void ease_undo_controller_finalize (GObject* obj);
++
++
++
++#line 38 "ease-undo-controller.vala"
++EaseUndoController* ease_undo_controller_construct (GType object_type) {
++#line 88 "ease-undo-controller.c"
++ EaseUndoController * self;
++#line 38 "ease-undo-controller.vala"
++ self = (EaseUndoController*) g_object_new (object_type, NULL);
++#line 92 "ease-undo-controller.c"
++ return self;
++}
++
++
++#line 38 "ease-undo-controller.vala"
++EaseUndoController* ease_undo_controller_new (void) {
++#line 38 "ease-undo-controller.vala"
++ return ease_undo_controller_construct (EASE_TYPE_UNDO_CONTROLLER);
++#line 101 "ease-undo-controller.c"
++}
++
++
++#line 43 "ease-undo-controller.vala"
++gboolean ease_undo_controller_can_undo (EaseUndoController* self) {
++#line 107 "ease-undo-controller.c"
++ gboolean result = FALSE;
++#line 43 "ease-undo-controller.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 111 "ease-undo-controller.c"
++ result = gee_collection_get_size ((GeeCollection*) self->priv->undos) > 0;
++#line 45 "ease-undo-controller.vala"
++ return result;
++#line 115 "ease-undo-controller.c"
++}
++
++
++#line 51 "ease-undo-controller.vala"
++gboolean ease_undo_controller_can_redo (EaseUndoController* self) {
++#line 121 "ease-undo-controller.c"
++ gboolean result = FALSE;
++#line 51 "ease-undo-controller.vala"
++ g_return_val_if_fail (self != NULL, FALSE);
++#line 125 "ease-undo-controller.c"
++ result = gee_collection_get_size ((GeeCollection*) self->priv->redos) > 0;
++#line 53 "ease-undo-controller.vala"
++ return result;
++#line 129 "ease-undo-controller.c"
++}
++
++
++#line 59 "ease-undo-controller.vala"
++void ease_undo_controller_undo (EaseUndoController* self) {
++#line 135 "ease-undo-controller.c"
++ EaseUndoItem* _tmp1_;
++ EaseUndoItem* _tmp0_;
++#line 59 "ease-undo-controller.vala"
++ g_return_if_fail (self != NULL);
++#line 61 "ease-undo-controller.vala"
++ ease_undo_controller_add_redo_action (self, _tmp1_ = ease_undo_item_apply (_tmp0_ = (EaseUndoItem*) gee_deque_poll_head ((GeeDeque*) self->priv->undos)));
++#line 142 "ease-undo-controller.c"
++ _g_object_unref0 (_tmp1_);
++ _g_object_unref0 (_tmp0_);
++}
++
++
++#line 67 "ease-undo-controller.vala"
++void ease_undo_controller_redo (EaseUndoController* self) {
++#line 150 "ease-undo-controller.c"
++ EaseUndoItem* _tmp1_;
++ EaseUndoItem* _tmp0_;
++#line 67 "ease-undo-controller.vala"
++ g_return_if_fail (self != NULL);
++#line 69 "ease-undo-controller.vala"
++ ease_undo_controller_add_action (self, _tmp1_ = ease_undo_item_apply (_tmp0_ = (EaseUndoItem*) gee_deque_poll_head ((GeeDeque*) self->priv->redos)));
++#line 157 "ease-undo-controller.c"
++ _g_object_unref0 (_tmp1_);
++ _g_object_unref0 (_tmp0_);
++}
++
++
++#line 75 "ease-undo-controller.vala"
++void ease_undo_controller_clear_redo (EaseUndoController* self) {
++#line 75 "ease-undo-controller.vala"
++ g_return_if_fail (self != NULL);
++#line 77 "ease-undo-controller.vala"
++ gee_abstract_collection_clear ((GeeAbstractCollection*) self->priv->redos);
++#line 169 "ease-undo-controller.c"
++}
++
++
++#line 85 "ease-undo-controller.vala"
++void ease_undo_controller_add_action (EaseUndoController* self, EaseUndoItem* action) {
++#line 85 "ease-undo-controller.vala"
++ g_return_if_fail (self != NULL);
++#line 85 "ease-undo-controller.vala"
++ g_return_if_fail (action != NULL);
++#line 87 "ease-undo-controller.vala"
++ gee_deque_offer_head ((GeeDeque*) self->priv->undos, action);
++#line 181 "ease-undo-controller.c"
++}
++
++
++#line 95 "ease-undo-controller.vala"
++static void ease_undo_controller_add_redo_action (EaseUndoController* self, EaseUndoItem* action) {
++#line 95 "ease-undo-controller.vala"
++ g_return_if_fail (self != NULL);
++#line 95 "ease-undo-controller.vala"
++ g_return_if_fail (action != NULL);
++#line 97 "ease-undo-controller.vala"
++ gee_deque_offer_head ((GeeDeque*) self->priv->redos, action);
++#line 193 "ease-undo-controller.c"
++}
++
++
++static void ease_undo_controller_class_init (EaseUndoControllerClass * klass) {
++ ease_undo_controller_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseUndoControllerPrivate));
++ G_OBJECT_CLASS (klass)->finalize = ease_undo_controller_finalize;
++}
++
++
++static void ease_undo_controller_instance_init (EaseUndoController * self) {
++ self->priv = EASE_UNDO_CONTROLLER_GET_PRIVATE (self);
++ self->priv->undos = gee_linked_list_new (EASE_TYPE_UNDO_ITEM, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
++ self->priv->redos = gee_linked_list_new (EASE_TYPE_UNDO_ITEM, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
++}
++
++
++static void ease_undo_controller_finalize (GObject* obj) {
++ EaseUndoController * self;
++ self = EASE_UNDO_CONTROLLER (obj);
++ _g_object_unref0 (self->priv->undos);
++ _g_object_unref0 (self->priv->redos);
++ G_OBJECT_CLASS (ease_undo_controller_parent_class)->finalize (obj);
++}
++
++
++GType ease_undo_controller_get_type (void) {
++ static volatile gsize ease_undo_controller_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_undo_controller_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseUndoControllerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_undo_controller_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseUndoController), 0, (GInstanceInitFunc) ease_undo_controller_instance_init, NULL };
++ GType ease_undo_controller_type_id;
++ ease_undo_controller_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseUndoController", &g_define_type_info, 0);
++ g_once_init_leave (&ease_undo_controller_type_id__volatile, ease_undo_controller_type_id);
++ }
++ return ease_undo_controller_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-undo-item.c
index 0000000,0000000..96e1193
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-undo-item.c
@@@ -1,0 -1,0 +1,123 @@@
++/* ease-undo-item.c generated by valac, the Vala compiler
++ * generated from ease-undo-item.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++typedef struct _EaseUndoItemPrivate EaseUndoItemPrivate;
++
++#define EASE_TYPE_UNDO_ACTION (ease_undo_action_get_type ())
++#define EASE_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoAction))
++#define EASE_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++#define EASE_IS_UNDO_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ACTION))
++#define EASE_IS_UNDO_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ACTION))
++#define EASE_UNDO_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ACTION, EaseUndoActionClass))
++
++typedef struct _EaseUndoAction EaseUndoAction;
++typedef struct _EaseUndoActionClass EaseUndoActionClass;
++
++struct _EaseUndoItem {
++ GObject parent_instance;
++ EaseUndoItemPrivate * priv;
++};
++
++struct _EaseUndoItemClass {
++ GObjectClass parent_class;
++ EaseUndoItem* (*apply) (EaseUndoItem* self);
++};
++
++
++static gpointer ease_undo_item_parent_class = NULL;
++
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++enum {
++ EASE_UNDO_ITEM_DUMMY_PROPERTY
++};
++EaseUndoItem* ease_undo_item_apply (EaseUndoItem* self);
++static EaseUndoItem* ease_undo_item_real_apply (EaseUndoItem* self);
++EaseUndoItem* ease_undo_item_construct (GType object_type);
++GType ease_undo_action_get_type (void) G_GNUC_CONST;
++
++
++
++#line 41 "ease-undo-item.vala"
++static EaseUndoItem* ease_undo_item_real_apply (EaseUndoItem* self) {
++#line 73 "ease-undo-item.c"
++ g_return_val_if_fail (self != NULL, NULL);
++ g_critical ("Type `%s' does not implement abstract method `ease_undo_item_apply'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
++ return NULL;
++}
++
++
++#line 41 "ease-undo-item.vala"
++EaseUndoItem* ease_undo_item_apply (EaseUndoItem* self) {
++#line 41 "ease-undo-item.vala"
++ return EASE_UNDO_ITEM_GET_CLASS (self)->apply (self);
++#line 84 "ease-undo-item.c"
++}
++
++
++#line 24 "ease-undo-item.vala"
++EaseUndoItem* ease_undo_item_construct (GType object_type) {
++#line 90 "ease-undo-item.c"
++ EaseUndoItem * self;
++#line 24 "ease-undo-item.vala"
++ self = (EaseUndoItem*) g_object_new (object_type, NULL);
++#line 94 "ease-undo-item.c"
++ return self;
++}
++
++
++static void ease_undo_item_class_init (EaseUndoItemClass * klass) {
++ ease_undo_item_parent_class = g_type_class_peek_parent (klass);
++ EASE_UNDO_ITEM_CLASS (klass)->apply = ease_undo_item_real_apply;
++ g_signal_new ("applied", EASE_TYPE_UNDO_ITEM, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_UNDO_ACTION);
++ g_signal_new ("pre_apply", EASE_TYPE_UNDO_ITEM, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_UNDO_ACTION);
++}
++
++
++static void ease_undo_item_instance_init (EaseUndoItem * self) {
++}
++
++
++GType ease_undo_item_get_type (void) {
++ static volatile gsize ease_undo_item_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_undo_item_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseUndoItemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_undo_item_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseUndoItem), 0, (GInstanceInitFunc) ease_undo_item_instance_init, NULL };
++ GType ease_undo_item_type_id;
++ ease_undo_item_type_id = g_type_register_static (G_TYPE_OBJECT, "EaseUndoItem", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
++ g_once_init_leave (&ease_undo_item_type_id__volatile, ease_undo_item_type_id);
++ }
++ return ease_undo_item_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-undo-source.c
index 0000000,0000000..6e7c7f6
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-undo-source.c
@@@ -1,0 -1,0 +1,122 @@@
++/* ease-undo-source.c generated by valac, the Vala compiler
++ * generated from ease-undo-source.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++
++#define EASE_TYPE_UNDO_ITEM (ease_undo_item_get_type ())
++#define EASE_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItem))
++#define EASE_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++#define EASE_IS_UNDO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_ITEM))
++#define EASE_IS_UNDO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_UNDO_ITEM))
++#define EASE_UNDO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_UNDO_ITEM, EaseUndoItemClass))
++
++typedef struct _EaseUndoItem EaseUndoItem;
++typedef struct _EaseUndoItemClass EaseUndoItemClass;
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++
++
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_undo_item_get_type (void) G_GNUC_CONST;
++void ease_undo_source_forward (EaseUndoSource* self, EaseUndoItem* action);
++static void _ease_undo_source_forward_ease_undo_source_undo (EaseUndoSource* _sender, EaseUndoItem* action, gpointer self);
++void ease_undo_source_listen (EaseUndoSource* self, EaseUndoSource* source);
++void ease_undo_source_silence (EaseUndoSource* self, EaseUndoSource* source);
++
++
++
++#line 34 "ease-undo-source.vala"
++void ease_undo_source_forward (EaseUndoSource* self, EaseUndoItem* action) {
++#line 34 "ease-undo-source.vala"
++ g_return_if_fail (action != NULL);
++#line 36 "ease-undo-source.vala"
++ g_signal_emit_by_name (self, "undo", action);
++#line 65 "ease-undo-source.c"
++}
++
++
++#line 34 "ease-undo-source.vala"
++static void _ease_undo_source_forward_ease_undo_source_undo (EaseUndoSource* _sender, EaseUndoItem* action, gpointer self) {
++#line 71 "ease-undo-source.c"
++ ease_undo_source_forward (self, action);
++}
++
++
++#line 43 "ease-undo-source.vala"
++void ease_undo_source_listen (EaseUndoSource* self, EaseUndoSource* source) {
++#line 43 "ease-undo-source.vala"
++ g_return_if_fail (source != NULL);
++#line 45 "ease-undo-source.vala"
++ g_signal_connect_object (source, "undo", (GCallback) _ease_undo_source_forward_ease_undo_source_undo, self, 0);
++#line 82 "ease-undo-source.c"
++}
++
++
++#line 51 "ease-undo-source.vala"
++void ease_undo_source_silence (EaseUndoSource* self, EaseUndoSource* source) {
++#line 88 "ease-undo-source.c"
++ guint _tmp0_;
++#line 51 "ease-undo-source.vala"
++ g_return_if_fail (source != NULL);
++#line 53 "ease-undo-source.vala"
++ g_signal_parse_name ("undo", EASE_TYPE_UNDO_SOURCE, &_tmp0_, NULL, FALSE);
++#line 53 "ease-undo-source.vala"
++ g_signal_handlers_disconnect_matched (source, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, 0, NULL, (GCallback) _ease_undo_source_forward_ease_undo_source_undo, self);
++#line 96 "ease-undo-source.c"
++}
++
++
++static void ease_undo_source_base_init (EaseUndoSourceIface * iface) {
++ static gboolean initialized = FALSE;
++ if (!initialized) {
++ initialized = TRUE;
++ g_signal_new ("undo", EASE_TYPE_UNDO_SOURCE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_UNDO_ITEM);
++ }
++}
++
++
++GType ease_undo_source_get_type (void) {
++ static volatile gsize ease_undo_source_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_undo_source_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseUndoSourceIface), (GBaseInitFunc) ease_undo_source_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
++ GType ease_undo_source_type_id;
++ ease_undo_source_type_id = g_type_register_static (G_TYPE_INTERFACE, "EaseUndoSource", &g_define_type_info, 0);
++ g_type_interface_add_prerequisite (ease_undo_source_type_id, G_TYPE_OBJECT);
++ g_once_init_leave (&ease_undo_source_type_id__volatile, ease_undo_source_type_id);
++ }
++ return ease_undo_source_type_id__volatile;
++}
++
++
++
++
diff --cc ease-core/ease-utilities.c
index 0000000,0000000..81a9679
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-utilities.c
@@@ -1,0 -1,0 +1,952 @@@
++/* ease-utilities.c generated by valac, the Vala compiler
++ * generated from ease-utilities.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <stdlib.h>
++#include <string.h>
++#include <gtk/gtk.h>
++#include <gio/gio.h>
++#include <glib/gstdio.h>
++#include <glib/gi18n-lib.h>
++#include <gdk/gdk.h>
++#include <clutter/clutter.h>
++#include <float.h>
++#include <math.h>
++
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_dir_close0(var) ((var == NULL) ? NULL : (var = (g_dir_close (var), NULL)))
++typedef struct _Block23Data Block23Data;
++
++typedef void (*EaseRecursiveDirAction) (const char* path, const char* full_path, void* user_data, GError** error);
++struct _Block23Data {
++ int _ref_count_;
++ char* to_dir;
++};
++
++
++
++#define EASE_LOCAL_DATA "data"
++#define EASE_SYS_DATA "ease"
++void ease_error_dialog (const char* title, const char* message);
++char* ease_query_file (const char* dir, const char* path);
++static char** _vala_array_dup1 (char** self, int length);
++char* ease_data_path (const char* path);
++void ease_do_recursive_directory (const char* directory, EaseRecursiveDirAction directory_action, void* directory_action_target, EaseRecursiveDirAction file_action, void* file_action_target, const char* rel_path, gboolean dir_first, GError** error);
++void ease_recursive_directory (const char* directory, EaseRecursiveDirAction directory_action, void* directory_action_target, EaseRecursiveDirAction file_action, void* file_action_target, GError** error);
++void ease_recursive_directory_after (const char* directory, EaseRecursiveDirAction directory_action, void* directory_action_target, EaseRecursiveDirAction file_action, void* file_action_target, GError** error);
++static void _lambda20_ (const char* p, const char* full_path, GError** error);
++static void __lambda20__ease_recursive_dir_action (const char* path, const char* full_path, gpointer self, GError** error);
++static void _lambda21_ (const char* p, const char* full_path, GError** error);
++static void __lambda21__ease_recursive_dir_action (const char* path, const char* full_path, gpointer self, GError** error);
++void ease_recursive_delete (const char* path, GError** error);
++static void _lambda0_ (const char* path, const char* full_path, Block23Data* _data23_, GError** error);
++static void __lambda0__ease_recursive_dir_action (const char* path, const char* full_path, gpointer self, GError** error);
++static void _lambda1_ (const char* path, const char* full_path, Block23Data* _data23_, GError** error);
++static void __lambda1__ease_recursive_dir_action (const char* path, const char* full_path, gpointer self, GError** error);
++static Block23Data* block23_data_ref (Block23Data* _data23_);
++static void block23_data_unref (Block23Data* _data23_);
++void ease_recursive_copy (const char* from_dir, const char* to_dir, GError** error);
++static GdkColor* _gdk_color_dup (GdkColor* self);
++GdkColor* ease_theme_color (const char* color);
++void ease_transformations_gdk_color_to_clutter_color (GdkColor* color, ClutterColor* result);
++void ease_theme_clutter_color (const char* color, ClutterColor* result);
++GtkWindow* ease_widget_window (GtkWidget* widg);
++char* ease_absolute_path (const char* path);
++double ease_dmax (double a, double b);
++double ease_dmin (double a, double b);
++gint ease_roundd (double num);
++static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
++static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
++static gint _vala_array_length (gpointer array);
++
++
++
++#line 36 "ease-utilities.vala"
++void ease_error_dialog (const char* title, const char* message) {
++#line 86 "ease-utilities.c"
++ GtkMessageDialog* dialog;
++#line 36 "ease-utilities.vala"
++ g_return_if_fail (title != NULL);
++#line 36 "ease-utilities.vala"
++ g_return_if_fail (message != NULL);
++#line 38 "ease-utilities.vala"
++ dialog = g_object_ref_sink ((GtkMessageDialog*) gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", message));
++#line 42 "ease-utilities.vala"
++ gtk_window_set_title ((GtkWindow*) dialog, title);
++#line 43 "ease-utilities.vala"
++ gtk_container_set_border_width ((GtkContainer*) dialog, (guint) 5);
++#line 44 "ease-utilities.vala"
++ gtk_dialog_run ((GtkDialog*) dialog);
++#line 45 "ease-utilities.vala"
++ gtk_object_destroy ((GtkObject*) dialog);
++#line 102 "ease-utilities.c"
++ _g_object_unref0 (dialog);
++}
++
++
++static char** _vala_array_dup1 (char** self, int length) {
++ char** result;
++ int i;
++ char** _tmp1_;
++ result = g_new0 (char*, length + 1);
++ for (i = 0; i < length; i++) {
++ result[i] = g_strdup (self[i]);
++ }
++ return result;
++}
++
++
++#line 54 "ease-utilities.vala"
++char* ease_data_path (const char* path) {
++#line 121 "ease-utilities.c"
++ char* result = NULL;
++ char* file;
++ char* _tmp0_;
++ char** _tmp3_;
++ gint _data_dirs_size_;
++ gint data_dirs_length1;
++ char** _tmp2_;
++ char** _tmp1_;
++ char** data_dirs;
++#line 54 "ease-utilities.vala"
++ g_return_val_if_fail (path != NULL, NULL);
++#line 133 "ease-utilities.c"
++ file = NULL;
++#line 57 "ease-utilities.vala"
++ file = (_tmp0_ = ease_query_file (EASE_LOCAL_DATA, path), _g_free0 (file), _tmp0_);
++#line 58 "ease-utilities.vala"
++ if (file != NULL) {
++#line 139 "ease-utilities.c"
++ result = file;
++#line 58 "ease-utilities.vala"
++ return result;
++#line 143 "ease-utilities.c"
++ }
++ data_dirs = (_tmp3_ = (_tmp2_ = _tmp1_ = g_get_system_data_dirs (), (_tmp2_ == NULL) ? ((gpointer) _tmp2_) : _vala_array_dup1 (_tmp2_, _vala_array_length (_tmp1_))), data_dirs_length1 = _vala_array_length (_tmp1_), _data_dirs_size_ = data_dirs_length1, _tmp3_);
++ {
++ char** dir_collection;
++ int dir_collection_length1;
++ int dir_it;
++#line 61 "ease-utilities.vala"
++ dir_collection = data_dirs;
++#line 152 "ease-utilities.c"
++ dir_collection_length1 = data_dirs_length1;
++ for (dir_it = 0; dir_it < data_dirs_length1; dir_it = dir_it + 1) {
++ char* dir;
++ dir = g_strdup (dir_collection[dir_it]);
++ {
++ char* _tmp4_;
++ char* _tmp5_;
++ char* sys_file;
++#line 63 "ease-utilities.vala"
++ sys_file = (_tmp5_ = ease_query_file (_tmp4_ = g_build_filename (dir, EASE_SYS_DATA, NULL), path), _g_free0 (_tmp4_), _tmp5_);
++#line 64 "ease-utilities.vala"
++ if (sys_file != NULL) {
++#line 165 "ease-utilities.c"
++ result = sys_file;
++ _g_free0 (dir);
++ data_dirs = (_vala_array_free (data_dirs, data_dirs_length1, (GDestroyNotify) g_free), NULL);
++ _g_free0 (file);
++#line 64 "ease-utilities.vala"
++ return result;
++#line 172 "ease-utilities.c"
++ }
++ _g_free0 (sys_file);
++ _g_free0 (dir);
++ }
++ }
++ }
++ result = NULL;
++ data_dirs = (_vala_array_free (data_dirs, data_dirs_length1, (GDestroyNotify) g_free), NULL);
++ _g_free0 (file);
++#line 67 "ease-utilities.vala"
++ return result;
++#line 184 "ease-utilities.c"
++}
++
++
++#line 78 "ease-utilities.vala"
++char* ease_query_file (const char* dir, const char* path) {
++#line 190 "ease-utilities.c"
++ char* result = NULL;
++ char* filename;
++ GFile* file;
++#line 78 "ease-utilities.vala"
++ g_return_val_if_fail (dir != NULL, NULL);
++#line 78 "ease-utilities.vala"
++ g_return_val_if_fail (path != NULL, NULL);
++#line 80 "ease-utilities.vala"
++ filename = g_build_filename (dir, path, NULL);
++#line 81 "ease-utilities.vala"
++ file = g_file_new_for_path (filename);
++#line 83 "ease-utilities.vala"
++ if (g_file_query_exists (file, NULL)) {
++#line 204 "ease-utilities.c"
++ result = filename;
++ _g_object_unref0 (file);
++#line 85 "ease-utilities.vala"
++ return result;
++#line 209 "ease-utilities.c"
++ }
++ result = NULL;
++ _g_object_unref0 (file);
++ _g_free0 (filename);
++#line 87 "ease-utilities.vala"
++ return result;
++#line 216 "ease-utilities.c"
++}
++
++
++#line 106 "ease-utilities.vala"
++void ease_recursive_directory (const char* directory, EaseRecursiveDirAction directory_action, void* directory_action_target, EaseRecursiveDirAction file_action, void* file_action_target, GError** error) {
++#line 222 "ease-utilities.c"
++ GError * _inner_error_;
++#line 106 "ease-utilities.vala"
++ g_return_if_fail (directory != NULL);
++#line 226 "ease-utilities.c"
++ _inner_error_ = NULL;
++#line 111 "ease-utilities.vala"
++ ease_do_recursive_directory (directory, directory_action, directory_action_target, file_action, file_action_target, "", TRUE, &_inner_error_);
++#line 230 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ return;
++ }
++}
++
++
++#line 134 "ease-utilities.vala"
++void ease_recursive_directory_after (const char* directory, EaseRecursiveDirAction directory_action, void* directory_action_target, EaseRecursiveDirAction file_action, void* file_action_target, GError** error) {
++#line 240 "ease-utilities.c"
++ GError * _inner_error_;
++#line 134 "ease-utilities.vala"
++ g_return_if_fail (directory != NULL);
++#line 244 "ease-utilities.c"
++ _inner_error_ = NULL;
++#line 139 "ease-utilities.vala"
++ ease_do_recursive_directory (directory, directory_action, directory_action_target, file_action, file_action_target, "", FALSE, &_inner_error_);
++#line 248 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ return;
++ }
++}
++
++
++#line 150 "ease-utilities.vala"
++void ease_do_recursive_directory (const char* directory, EaseRecursiveDirAction directory_action, void* directory_action_target, EaseRecursiveDirAction file_action, void* file_action_target, const char* rel_path, gboolean dir_first, GError** error) {
++#line 258 "ease-utilities.c"
++ GError * _inner_error_;
++ GDir* dir;
++ char* child_path;
++#line 150 "ease-utilities.vala"
++ g_return_if_fail (directory != NULL);
++#line 150 "ease-utilities.vala"
++ g_return_if_fail (rel_path != NULL);
++#line 266 "ease-utilities.c"
++ _inner_error_ = NULL;
++#line 157 "ease-utilities.vala"
++ dir = g_dir_open (directory, (guint) 0, &_inner_error_);
++#line 270 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ return;
++ }
++ child_path = NULL;
++#line 160 "ease-utilities.vala"
++ while (TRUE) {
++#line 278 "ease-utilities.c"
++ char* _tmp0_;
++ char* child_full_path;
++ char* child_rel_path;
++#line 160 "ease-utilities.vala"
++ if (!((child_path = (_tmp0_ = g_strdup (g_dir_read_name (dir)), _g_free0 (child_path), _tmp0_)) != NULL)) {
++#line 160 "ease-utilities.vala"
++ break;
++#line 286 "ease-utilities.c"
++ }
++#line 162 "ease-utilities.vala"
++ child_full_path = g_build_filename (directory, child_path, NULL);
++#line 163 "ease-utilities.vala"
++ child_rel_path = g_build_filename (rel_path, child_path, NULL);
++#line 164 "ease-utilities.vala"
++ if (g_file_test (child_full_path, G_FILE_TEST_IS_DIR)) {
++#line 294 "ease-utilities.c"
++ gboolean _tmp1_ = FALSE;
++ gboolean _tmp2_ = FALSE;
++#line 166 "ease-utilities.vala"
++ if (directory_action != NULL) {
++#line 166 "ease-utilities.vala"
++ _tmp1_ = dir_first;
++#line 301 "ease-utilities.c"
++ } else {
++#line 166 "ease-utilities.vala"
++ _tmp1_ = FALSE;
++#line 305 "ease-utilities.c"
++ }
++#line 166 "ease-utilities.vala"
++ if (_tmp1_) {
++#line 168 "ease-utilities.vala"
++ directory_action (child_rel_path, child_full_path, directory_action_target, &_inner_error_);
++#line 311 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_free0 (child_rel_path);
++ _g_free0 (child_full_path);
++ _g_free0 (child_path);
++ _g_dir_close0 (dir);
++ return;
++ }
++ }
++#line 172 "ease-utilities.vala"
++ ease_do_recursive_directory (child_full_path, directory_action, directory_action_target, file_action, file_action_target, child_rel_path, dir_first, &_inner_error_);
++#line 323 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_free0 (child_rel_path);
++ _g_free0 (child_full_path);
++ _g_free0 (child_path);
++ _g_dir_close0 (dir);
++ return;
++ }
++#line 177 "ease-utilities.vala"
++ if (directory_action != NULL) {
++#line 177 "ease-utilities.vala"
++ _tmp2_ = !dir_first;
++#line 336 "ease-utilities.c"
++ } else {
++#line 177 "ease-utilities.vala"
++ _tmp2_ = FALSE;
++#line 340 "ease-utilities.c"
++ }
++#line 177 "ease-utilities.vala"
++ if (_tmp2_) {
++#line 179 "ease-utilities.vala"
++ directory_action (child_rel_path, child_full_path, directory_action_target, &_inner_error_);
++#line 346 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_free0 (child_rel_path);
++ _g_free0 (child_full_path);
++ _g_free0 (child_path);
++ _g_dir_close0 (dir);
++ return;
++ }
++ }
++ } else {
++#line 184 "ease-utilities.vala"
++ if (file_action != NULL) {
++#line 186 "ease-utilities.vala"
++ file_action (child_rel_path, child_full_path, file_action_target, &_inner_error_);
++#line 361 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_free0 (child_rel_path);
++ _g_free0 (child_full_path);
++ _g_free0 (child_path);
++ _g_dir_close0 (dir);
++ return;
++ }
++ }
++ }
++ _g_free0 (child_rel_path);
++ _g_free0 (child_full_path);
++ }
++ _g_free0 (child_path);
++ _g_dir_close0 (dir);
++}
++
++
++#line 211 "ease-utilities.vala"
++static void _lambda20_ (const char* p, const char* full_path, GError** error) {
++#line 211 "ease-utilities.vala"
++ g_return_if_fail (p != NULL);
++#line 211 "ease-utilities.vala"
++ g_return_if_fail (full_path != NULL);
++#line 212 "ease-utilities.vala"
++ g_rmdir (full_path);
++#line 388 "ease-utilities.c"
++}
++
++
++#line 211 "ease-utilities.vala"
++static void __lambda20__ease_recursive_dir_action (const char* path, const char* full_path, gpointer self, GError** error) {
++#line 394 "ease-utilities.c"
++ _lambda20_ (path, full_path, error);
++}
++
++
++#line 214 "ease-utilities.vala"
++static void _lambda21_ (const char* p, const char* full_path, GError** error) {
++#line 214 "ease-utilities.vala"
++ g_return_if_fail (p != NULL);
++#line 214 "ease-utilities.vala"
++ g_return_if_fail (full_path != NULL);
++#line 215 "ease-utilities.vala"
++ g_unlink (full_path);
++#line 407 "ease-utilities.c"
++}
++
++
++#line 214 "ease-utilities.vala"
++static void __lambda21__ease_recursive_dir_action (const char* path, const char* full_path, gpointer self, GError** error) {
++#line 413 "ease-utilities.c"
++ _lambda21_ (path, full_path, error);
++}
++
++
++#line 200 "ease-utilities.vala"
++void ease_recursive_delete (const char* path, GError** error) {
++#line 420 "ease-utilities.c"
++ GError * _inner_error_;
++ GDir* dir;
++#line 200 "ease-utilities.vala"
++ g_return_if_fail (path != NULL);
++#line 425 "ease-utilities.c"
++ _inner_error_ = NULL;
++#line 202 "ease-utilities.vala"
++ dir = g_dir_open (path, (guint) 0, &_inner_error_);
++#line 429 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ return;
++ }
++#line 204 "ease-utilities.vala"
++ if (dir == NULL) {
++#line 436 "ease-utilities.c"
++ _inner_error_ = g_error_new (G_FILE_ERROR, G_FILE_ERROR_NOENT, _ ("Directory to remove doesn't exist: %s"), path);
++ {
++ g_propagate_error (error, _inner_error_);
++ _g_dir_close0 (dir);
++ return;
++ }
++ }
++#line 210 "ease-utilities.vala"
++ ease_recursive_directory_after (path, __lambda20__ease_recursive_dir_action, NULL, __lambda21__ease_recursive_dir_action, NULL, &_inner_error_);
++#line 446 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_dir_close0 (dir);
++ return;
++ }
++#line 218 "ease-utilities.vala"
++ g_rmdir (path);
++#line 454 "ease-utilities.c"
++ _g_dir_close0 (dir);
++}
++
++
++#line 236 "ease-utilities.vala"
++static void _lambda0_ (const char* path, const char* full_path, Block23Data* _data23_, GError** error) {
++#line 461 "ease-utilities.c"
++ GError * _inner_error_;
++ char* _tmp0_;
++ GFile* _tmp1_;
++ GFile* dir;
++#line 236 "ease-utilities.vala"
++ g_return_if_fail (path != NULL);
++#line 236 "ease-utilities.vala"
++ g_return_if_fail (full_path != NULL);
++#line 470 "ease-utilities.c"
++ _inner_error_ = NULL;
++#line 237 "ease-utilities.vala"
++ dir = (_tmp1_ = g_file_new_for_path (_tmp0_ = g_build_filename (_data23_->to_dir, path, NULL)), _g_free0 (_tmp0_), _tmp1_);
++#line 238 "ease-utilities.vala"
++ if (!g_file_query_exists (dir, NULL)) {
++#line 238 "ease-utilities.vala"
++ g_file_make_directory (dir, NULL, &_inner_error_);
++#line 478 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (dir);
++ return;
++ }
++ }
++ _g_object_unref0 (dir);
++}
++
++
++#line 236 "ease-utilities.vala"
++static void __lambda0__ease_recursive_dir_action (const char* path, const char* full_path, gpointer self, GError** error) {
++#line 491 "ease-utilities.c"
++ _lambda0_ (path, full_path, self, error);
++}
++
++
++#line 240 "ease-utilities.vala"
++static void _lambda1_ (const char* path, const char* full_path, Block23Data* _data23_, GError** error) {
++#line 498 "ease-utilities.c"
++ GError * _inner_error_;
++ GFile* from;
++ char* _tmp0_;
++ GFile* _tmp1_;
++ GFile* to;
++#line 240 "ease-utilities.vala"
++ g_return_if_fail (path != NULL);
++#line 240 "ease-utilities.vala"
++ g_return_if_fail (full_path != NULL);
++#line 508 "ease-utilities.c"
++ _inner_error_ = NULL;
++#line 241 "ease-utilities.vala"
++ from = g_file_new_for_path (full_path);
++#line 242 "ease-utilities.vala"
++ to = (_tmp1_ = g_file_new_for_path (_tmp0_ = g_build_filename (_data23_->to_dir, path, NULL)), _g_free0 (_tmp0_), _tmp1_);
++#line 243 "ease-utilities.vala"
++ g_file_copy (from, to, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, &_inner_error_);
++#line 516 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (to);
++ _g_object_unref0 (from);
++ return;
++ }
++ _g_object_unref0 (to);
++ _g_object_unref0 (from);
++}
++
++
++#line 240 "ease-utilities.vala"
++static void __lambda1__ease_recursive_dir_action (const char* path, const char* full_path, gpointer self, GError** error) {
++#line 530 "ease-utilities.c"
++ _lambda1_ (path, full_path, self, error);
++}
++
++
++static Block23Data* block23_data_ref (Block23Data* _data23_) {
++ g_atomic_int_inc (&_data23_->_ref_count_);
++ return _data23_;
++}
++
++
++static void block23_data_unref (Block23Data* _data23_) {
++ if (g_atomic_int_dec_and_test (&_data23_->_ref_count_)) {
++ _g_free0 (_data23_->to_dir);
++ g_slice_free (Block23Data, _data23_);
++ }
++}
++
++
++#line 227 "ease-utilities.vala"
++void ease_recursive_copy (const char* from_dir, const char* to_dir, GError** error) {
++#line 551 "ease-utilities.c"
++ GError * _inner_error_;
++ Block23Data* _data23_;
++ GFile* top;
++#line 227 "ease-utilities.vala"
++ g_return_if_fail (from_dir != NULL);
++#line 227 "ease-utilities.vala"
++ g_return_if_fail (to_dir != NULL);
++#line 559 "ease-utilities.c"
++ _inner_error_ = NULL;
++ _data23_ = g_slice_new0 (Block23Data);
++ _data23_->_ref_count_ = 1;
++ _data23_->to_dir = g_strdup (to_dir);
++#line 229 "ease-utilities.vala"
++ top = g_file_new_for_path (_data23_->to_dir);
++#line 230 "ease-utilities.vala"
++ if (!g_file_query_exists (top, NULL)) {
++#line 232 "ease-utilities.vala"
++ g_file_make_directory_with_parents (top, NULL, &_inner_error_);
++#line 570 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (top);
++ block23_data_unref (_data23_);
++ return;
++ }
++ }
++#line 235 "ease-utilities.vala"
++ ease_recursive_directory (from_dir, __lambda0__ease_recursive_dir_action, _data23_, __lambda1__ease_recursive_dir_action, _data23_, &_inner_error_);
++#line 580 "ease-utilities.c"
++ if (_inner_error_ != NULL) {
++ g_propagate_error (error, _inner_error_);
++ _g_object_unref0 (top);
++ block23_data_unref (_data23_);
++ return;
++ }
++ _g_object_unref0 (top);
++ block23_data_unref (_data23_);
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 1026 "glib-2.0.vapi"
++static char* string_strip (const char* self) {
++#line 599 "ease-utilities.c"
++ char* result = NULL;
++ char* _result_;
++#line 1026 "glib-2.0.vapi"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 1027 "glib-2.0.vapi"
++ _result_ = g_strdup (self);
++#line 1028 "glib-2.0.vapi"
++ g_strstrip (_result_);
++#line 608 "ease-utilities.c"
++ result = _result_;
++#line 1029 "glib-2.0.vapi"
++ return result;
++#line 612 "ease-utilities.c"
++}
++
++
++#line 1085 "glib-2.0.vapi"
++static char* string_substring (const char* self, glong offset, glong len) {
++#line 618 "ease-utilities.c"
++ char* result = NULL;
++ glong string_length;
++ const char* start;
++#line 1085 "glib-2.0.vapi"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 1086 "glib-2.0.vapi"
++ string_length = g_utf8_strlen (self, -1);
++#line 1087 "glib-2.0.vapi"
++ if (offset < 0) {
++#line 1088 "glib-2.0.vapi"
++ offset = string_length + offset;
++#line 1089 "glib-2.0.vapi"
++ g_return_val_if_fail (offset >= 0, NULL);
++#line 632 "ease-utilities.c"
++ } else {
++#line 1091 "glib-2.0.vapi"
++ g_return_val_if_fail (offset <= string_length, NULL);
++#line 636 "ease-utilities.c"
++ }
++#line 1093 "glib-2.0.vapi"
++ if (len < 0) {
++#line 1094 "glib-2.0.vapi"
++ len = string_length - offset;
++#line 642 "ease-utilities.c"
++ }
++#line 1096 "glib-2.0.vapi"
++ g_return_val_if_fail ((offset + len) <= string_length, NULL);
++#line 1097 "glib-2.0.vapi"
++ start = g_utf8_offset_to_pointer (self, offset);
++#line 648 "ease-utilities.c"
++ result = g_strndup (start, ((gchar*) g_utf8_offset_to_pointer (start, len)) - ((gchar*) start));
++#line 1098 "glib-2.0.vapi"
++ return result;
++#line 652 "ease-utilities.c"
++}
++
++
++static glong string_get_length (const char* self) {
++ glong result;
++ g_return_val_if_fail (self != NULL, 0L);
++ result = g_utf8_strlen (self, -1);
++#line 1166 "glib-2.0.vapi"
++ return result;
++#line 662 "ease-utilities.c"
++}
++
++
++static GdkColor* _gdk_color_dup (GdkColor* self) {
++ GdkColor* dup;
++ dup = g_new0 (GdkColor, 1);
++ memcpy (dup, self, sizeof (GdkColor));
++ return dup;
++}
++
++
++static gpointer __gdk_color_dup0 (gpointer self) {
++ return self ? _gdk_color_dup (self) : NULL;
++}
++
++
++#line 252 "ease-utilities.vala"
++GdkColor* ease_theme_color (const char* color) {
++#line 681 "ease-utilities.c"
++ GdkColor* result = NULL;
++ GtkSettings* settings;
++ char** _tmp4_;
++ gint _colors_size_;
++ gint colors_length1;
++ char** _tmp2_;
++ char* _tmp1_;
++ char* _tmp0_ = NULL;
++ char** _tmp3_;
++ char** colors;
++#line 252 "ease-utilities.vala"
++ g_return_val_if_fail (color != NULL, NULL);
++#line 255 "ease-utilities.vala"
++ settings = _g_object_ref0 (gtk_settings_get_default ());
++#line 696 "ease-utilities.c"
++ colors = (_tmp4_ = (_tmp3_ = _tmp2_ = g_strsplit_set (_tmp1_ = (g_object_get (settings, "gtk-color-scheme", &_tmp0_, NULL), _tmp0_), "\n;", 0), _g_free0 (_tmp1_), _tmp3_), colors_length1 = _vala_array_length (_tmp2_), _colors_size_ = colors_length1, _tmp4_);
++ {
++ gint i;
++#line 257 "ease-utilities.vala"
++ i = 0;
++#line 702 "ease-utilities.c"
++ {
++ gboolean _tmp5_;
++#line 257 "ease-utilities.vala"
++ _tmp5_ = TRUE;
++#line 257 "ease-utilities.vala"
++ while (TRUE) {
++#line 709 "ease-utilities.c"
++ char* _tmp6_;
++#line 257 "ease-utilities.vala"
++ if (!_tmp5_) {
++#line 257 "ease-utilities.vala"
++ i++;
++#line 715 "ease-utilities.c"
++ }
++#line 257 "ease-utilities.vala"
++ _tmp5_ = FALSE;
++#line 257 "ease-utilities.vala"
++ if (!(i < colors_length1)) {
++#line 257 "ease-utilities.vala"
++ break;
++#line 723 "ease-utilities.c"
++ }
++#line 259 "ease-utilities.vala"
++ colors[i] = (_tmp6_ = string_strip (colors[i]), _g_free0 (colors[i]), _tmp6_);
++#line 261 "ease-utilities.vala"
++ if (g_str_has_prefix (colors[i], color)) {
++#line 729 "ease-utilities.c"
++ GdkColor gdk_color = {0};
++ {
++ gboolean _tmp7_;
++#line 263 "ease-utilities.vala"
++ _tmp7_ = TRUE;
++#line 263 "ease-utilities.vala"
++ while (TRUE) {
++#line 737 "ease-utilities.c"
++ gboolean _tmp9_ = FALSE;
++#line 263 "ease-utilities.vala"
++ if (!_tmp7_) {
++#line 741 "ease-utilities.c"
++ char* _tmp8_;
++#line 264 "ease-utilities.vala"
++ colors[i] = (_tmp8_ = string_substring (colors[i], (glong) 1, string_get_length (colors[i]) - 1), _g_free0 (colors[i]), _tmp8_);
++#line 745 "ease-utilities.c"
++ }
++#line 263 "ease-utilities.vala"
++ _tmp7_ = FALSE;
++#line 263 "ease-utilities.vala"
++ if (!g_str_has_prefix (colors[i], "#")) {
++#line 263 "ease-utilities.vala"
++ _tmp9_ = string_get_length (colors[i]) > 3;
++#line 753 "ease-utilities.c"
++ } else {
++#line 263 "ease-utilities.vala"
++ _tmp9_ = FALSE;
++#line 757 "ease-utilities.c"
++ }
++#line 263 "ease-utilities.vala"
++ if (!_tmp9_) {
++#line 263 "ease-utilities.vala"
++ break;
++#line 763 "ease-utilities.c"
++ }
++ ;
++ }
++ }
++#line 267 "ease-utilities.vala"
++ gdk_color_parse (colors[i], &gdk_color);
++#line 770 "ease-utilities.c"
++ result = __gdk_color_dup0 (&gdk_color);
++ colors = (_vala_array_free (colors, colors_length1, (GDestroyNotify) g_free), NULL);
++ _g_object_unref0 (settings);
++#line 268 "ease-utilities.vala"
++ return result;
++#line 776 "ease-utilities.c"
++ }
++ }
++ }
++ }
++#line 272 "ease-utilities.vala"
++ g_warning ("ease-utilities.vala:272: Could not find color: %s", color);
++#line 783 "ease-utilities.c"
++ result = NULL;
++ colors = (_vala_array_free (colors, colors_length1, (GDestroyNotify) g_free), NULL);
++ _g_object_unref0 (settings);
++#line 273 "ease-utilities.vala"
++ return result;
++#line 789 "ease-utilities.c"
++}
++
++
++#line 281 "ease-utilities.vala"
++void ease_theme_clutter_color (const char* color, ClutterColor* result) {
++#line 795 "ease-utilities.c"
++ ClutterColor _tmp1_ = {0};
++ GdkColor* _tmp0_;
++ ClutterColor _tmp2_;
++#line 281 "ease-utilities.vala"
++ g_return_if_fail (color != NULL);
++#line 801 "ease-utilities.c"
++ *result = (_tmp2_ = (ease_transformations_gdk_color_to_clutter_color (_tmp0_ = ease_theme_color (color), &_tmp1_), _tmp1_), _g_free0 (_tmp0_), _tmp2_);
++#line 283 "ease-utilities.vala"
++ return;
++#line 805 "ease-utilities.c"
++}
++
++
++#line 289 "ease-utilities.vala"
++GtkWindow* ease_widget_window (GtkWidget* widg) {
++#line 811 "ease-utilities.c"
++ GtkWindow* result = NULL;
++ GtkWidget* _tmp0_;
++#line 289 "ease-utilities.vala"
++ g_return_val_if_fail (widg != NULL, NULL);
++#line 291 "ease-utilities.vala"
++ while (TRUE) {
++#line 291 "ease-utilities.vala"
++ if (!(gtk_widget_get_parent (widg) != NULL)) {
++#line 291 "ease-utilities.vala"
++ break;
++#line 822 "ease-utilities.c"
++ }
++#line 291 "ease-utilities.vala"
++ widg = gtk_widget_get_parent (widg);
++#line 826 "ease-utilities.c"
++ }
++ result = _g_object_ref0 ((_tmp0_ = widg, GTK_IS_WINDOW (_tmp0_) ? ((GtkWindow*) _tmp0_) : NULL));
++#line 292 "ease-utilities.vala"
++ return result;
++#line 831 "ease-utilities.c"
++}
++
++
++#line 298 "ease-utilities.vala"
++char* ease_absolute_path (const char* path) {
++#line 837 "ease-utilities.c"
++ char* result = NULL;
++ GFile* file;
++ GFile* _tmp0_;
++ char* _tmp1_;
++#line 298 "ease-utilities.vala"
++ g_return_val_if_fail (path != NULL, NULL);
++#line 300 "ease-utilities.vala"
++ file = g_file_new_for_path (path);
++#line 846 "ease-utilities.c"
++ result = (_tmp1_ = g_file_get_path (_tmp0_ = g_file_resolve_relative_path (file, ".")), _g_object_unref0 (_tmp0_), _tmp1_);
++ _g_object_unref0 (file);
++#line 301 "ease-utilities.vala"
++ return result;
++#line 851 "ease-utilities.c"
++ _g_object_unref0 (file);
++}
++
++
++#line 304 "ease-utilities.vala"
++double ease_dmax (double a, double b) {
++#line 858 "ease-utilities.c"
++ double result = 0.0;
++ double _tmp0_ = 0.0;
++#line 306 "ease-utilities.vala"
++ if (a > b) {
++#line 306 "ease-utilities.vala"
++ _tmp0_ = a;
++#line 865 "ease-utilities.c"
++ } else {
++#line 306 "ease-utilities.vala"
++ _tmp0_ = b;
++#line 869 "ease-utilities.c"
++ }
++ result = _tmp0_;
++#line 306 "ease-utilities.vala"
++ return result;
++#line 874 "ease-utilities.c"
++}
++
++
++#line 309 "ease-utilities.vala"
++double ease_dmin (double a, double b) {
++#line 880 "ease-utilities.c"
++ double result = 0.0;
++ double _tmp0_ = 0.0;
++#line 311 "ease-utilities.vala"
++ if (a < b) {
++#line 311 "ease-utilities.vala"
++ _tmp0_ = a;
++#line 887 "ease-utilities.c"
++ } else {
++#line 311 "ease-utilities.vala"
++ _tmp0_ = b;
++#line 891 "ease-utilities.c"
++ }
++ result = _tmp0_;
++#line 311 "ease-utilities.vala"
++ return result;
++#line 896 "ease-utilities.c"
++}
++
++
++#line 314 "ease-utilities.vala"
++gint ease_roundd (double num) {
++#line 902 "ease-utilities.c"
++ gint result = 0;
++ double _tmp0_ = 0.0;
++#line 316 "ease-utilities.vala"
++ if ((num - ((gint) num)) < 0.5) {
++#line 316 "ease-utilities.vala"
++ _tmp0_ = num;
++#line 909 "ease-utilities.c"
++ } else {
++#line 316 "ease-utilities.vala"
++ _tmp0_ = num + 1;
++#line 913 "ease-utilities.c"
++ }
++ result = (gint) _tmp0_;
++#line 316 "ease-utilities.vala"
++ return result;
++#line 918 "ease-utilities.c"
++}
++
++
++static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
++ if ((array != NULL) && (destroy_func != NULL)) {
++ int 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, gint array_length, GDestroyNotify destroy_func) {
++ _vala_array_destroy (array, array_length, destroy_func);
++ g_free (array);
++}
++
++
++static gint _vala_array_length (gpointer array) {
++ int length;
++ length = 0;
++ if (array) {
++ while (((gpointer*) array)[length]) {
++ length++;
++ }
++ }
++ return length;
++}
++
++
++
++
diff --cc ease-core/ease-welcome-actor.c
index 0000000,0000000..d37b083
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-welcome-actor.c
@@@ -1,0 -1,0 +1,578 @@@
++/* ease-welcome-actor.c generated by valac, the Vala compiler
++ * generated from ease-welcome-actor.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <clutter/clutter.h>
++#include <stdlib.h>
++#include <string.h>
++#include <float.h>
++#include <math.h>
++#include <pango/pango.h>
++#include <cairo.h>
++#include <glib/gi18n-lib.h>
++#include <gee.h>
++
++
++#define EASE_TYPE_WELCOME_ACTOR (ease_welcome_actor_get_type ())
++#define EASE_WELCOME_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_WELCOME_ACTOR, EaseWelcomeActor))
++#define EASE_WELCOME_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_WELCOME_ACTOR, EaseWelcomeActorClass))
++#define EASE_IS_WELCOME_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_WELCOME_ACTOR))
++#define EASE_IS_WELCOME_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_WELCOME_ACTOR))
++#define EASE_WELCOME_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_WELCOME_ACTOR, EaseWelcomeActorClass))
++
++typedef struct _EaseWelcomeActor EaseWelcomeActor;
++typedef struct _EaseWelcomeActorClass EaseWelcomeActorClass;
++typedef struct _EaseWelcomeActorPrivate EaseWelcomeActorPrivate;
++
++#define EASE_TYPE_THEME (ease_theme_get_type ())
++#define EASE_THEME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_THEME, EaseTheme))
++#define EASE_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_THEME, EaseThemeClass))
++#define EASE_IS_THEME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_THEME))
++#define EASE_IS_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_THEME))
++#define EASE_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_THEME, EaseThemeClass))
++
++typedef struct _EaseTheme EaseTheme;
++typedef struct _EaseThemeClass EaseThemeClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++typedef struct _EaseThemePrivate EaseThemePrivate;
++
++#define EASE_TYPE_SLIDE (ease_slide_get_type ())
++#define EASE_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SLIDE, EaseSlide))
++#define EASE_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SLIDE, EaseSlideClass))
++#define EASE_IS_SLIDE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SLIDE))
++#define EASE_IS_SLIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SLIDE))
++#define EASE_SLIDE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SLIDE, EaseSlideClass))
++
++typedef struct _EaseSlide EaseSlide;
++typedef struct _EaseSlideClass EaseSlideClass;
++#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL)))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++
++#define EASE_TYPE_UNDO_SOURCE (ease_undo_source_get_type ())
++#define EASE_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSource))
++#define EASE_IS_UNDO_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_UNDO_SOURCE))
++#define EASE_UNDO_SOURCE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), EASE_TYPE_UNDO_SOURCE, EaseUndoSourceIface))
++
++typedef struct _EaseUndoSource EaseUndoSource;
++typedef struct _EaseUndoSourceIface EaseUndoSourceIface;
++typedef struct _EaseSlidePrivate EaseSlidePrivate;
++
++#define EASE_TYPE_ELEMENT (ease_element_get_type ())
++#define EASE_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ELEMENT, EaseElement))
++#define EASE_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ELEMENT, EaseElementClass))
++#define EASE_IS_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ELEMENT))
++#define EASE_IS_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ELEMENT))
++#define EASE_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ELEMENT, EaseElementClass))
++
++typedef struct _EaseElement EaseElement;
++typedef struct _EaseElementClass EaseElementClass;
++
++#define EASE_TYPE_TEXT_ELEMENT (ease_text_element_get_type ())
++#define EASE_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElement))
++#define EASE_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++#define EASE_IS_TEXT_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_IS_TEXT_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_TEXT_ELEMENT))
++#define EASE_TEXT_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_TEXT_ELEMENT, EaseTextElementClass))
++
++typedef struct _EaseTextElement EaseTextElement;
++typedef struct _EaseTextElementClass EaseTextElementClass;
++
++struct _EaseWelcomeActor {
++ ClutterGroup parent_instance;
++ EaseWelcomeActorPrivate * priv;
++};
++
++struct _EaseWelcomeActorClass {
++ ClutterGroupClass parent_class;
++};
++
++struct _EaseWelcomeActorPrivate {
++ gboolean is_selected;
++ ClutterCairoTexture* slide_actor;
++ ClutterRectangle* rect;
++ ClutterRectangle* hilight_rect;
++ EaseTheme* _theme;
++ ClutterText* text;
++};
++
++struct _EaseTheme {
++ GObject parent_instance;
++ EaseThemePrivate * priv;
++ char* title;
++};
++
++struct _EaseThemeClass {
++ GObjectClass parent_class;
++};
++
++struct _EaseUndoSourceIface {
++ GTypeInterface parent_iface;
++};
++
++struct _EaseSlide {
++ GObject parent_instance;
++ EaseSlidePrivate * priv;
++ GeeArrayList* elements;
++};
++
++struct _EaseSlideClass {
++ GObjectClass parent_class;
++};
++
++
++static gpointer ease_welcome_actor_parent_class = NULL;
++
++GType ease_welcome_actor_get_type (void) G_GNUC_CONST;
++GType ease_theme_get_type (void) G_GNUC_CONST;
++#define EASE_WELCOME_ACTOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_WELCOME_ACTOR, EaseWelcomeActorPrivate))
++enum {
++ EASE_WELCOME_ACTOR_DUMMY_PROPERTY,
++ EASE_WELCOME_ACTOR_THEME
++};
++#define EASE_WELCOME_ACTOR_FONT_NAME "Sans 8"
++#define EASE_WELCOME_ACTOR_TEXT_OFFSET ((float) 5)
++#define EASE_WELCOME_ACTOR_TEXT_HEIGHT ((float) 12)
++#define EASE_WELCOME_ACTOR_FADE_TIME 200
++#define EASE_WELCOME_ACTOR_FADE_INIT_TIME 1000
++#define EASE_WELCOME_ACTOR_FADE_EASE ((gint) CLUTTER_EASE_IN_OUT_SINE)
++#define EASE_WELCOME_ACTOR_FADE_OPACITY 150
++#define EASE_WELCOME_ACTOR_RECT_B_W 1
++#define EASE_WELCOME_ACTOR_HLRECT_W 2
++#define EASE_THEME_TITLE "title"
++#define EASE_WELCOME_ACTOR_PREVIEW_SLIDE EASE_THEME_TITLE
++void ease_welcome_actor_set_theme (EaseWelcomeActor* self, EaseTheme* value);
++EaseTheme* ease_welcome_actor_get_theme (EaseWelcomeActor* self);
++static gboolean _lambda80_ (ClutterActor* _self_, ClutterButtonEvent* event, EaseWelcomeActor* self);
++static gboolean __lambda80__clutter_actor_button_press_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self);
++EaseWelcomeActor* ease_welcome_actor_new (EaseTheme* t);
++EaseWelcomeActor* ease_welcome_actor_construct (GType object_type, EaseTheme* t);
++GType ease_slide_get_type (void) G_GNUC_CONST;
++static EaseSlide* ease_welcome_actor_create_slide (EaseWelcomeActor* self, gint w, gint h);
++void ease_slide_set_theme (EaseSlide* self, EaseTheme* value);
++void ease_slide_cairo_render_sized (EaseSlide* self, cairo_t* context, gint w, gint h, GError** error);
++void ease_welcome_actor_set_slide_size (EaseWelcomeActor* self, gint w, gint h);
++gint ease_roundd (double num);
++void ease_welcome_actor_set_actor_size (EaseWelcomeActor* self, float w, float h);
++void ease_welcome_actor_fade (EaseWelcomeActor* self);
++void ease_welcome_actor_unfade (EaseWelcomeActor* self);
++EaseSlide* ease_theme_create_slide (EaseTheme* self, const char* master, gint width, gint height);
++GType ease_undo_source_get_type (void) G_GNUC_CONST;
++GType ease_element_get_type (void) G_GNUC_CONST;
++const char* ease_element_get_identifier (EaseElement* self);
++#define EASE_THEME_TITLE_TEXT "title-text"
++GType ease_text_element_get_type (void) G_GNUC_CONST;
++void ease_text_element_set_text (EaseTextElement* self, const char* value);
++#define EASE_THEME_AUTHOR_TEXT "author-text"
++static void ease_welcome_actor_finalize (GObject* obj);
++static void ease_welcome_actor_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_welcome_actor_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++
++static const ClutterColor EASE_WELCOME_ACTOR_TEXT_COLOR = {(guchar) 255, (guchar) 255, (guchar) 255, (guchar) 255};
++static const ClutterColor EASE_WELCOME_ACTOR_RECT_BG = {(guchar) 0, (guchar) 0, (guchar) 0, (guchar) 255};
++static const ClutterColor EASE_WELCOME_ACTOR_RECT_B_C = {(guchar) 150, (guchar) 150, (guchar) 150, (guchar) 255};
++static const ClutterColor EASE_WELCOME_ACTOR_HLRECT_C = {(guchar) 255, (guchar) 255, (guchar) 0, (guchar) 255};
++
++
++#line 133 "ease-welcome-actor.vala"
++static gboolean _lambda80_ (ClutterActor* _self_, ClutterButtonEvent* event, EaseWelcomeActor* self) {
++#line 197 "ease-welcome-actor.c"
++ gboolean result = FALSE;
++#line 133 "ease-welcome-actor.vala"
++ g_return_val_if_fail (_self_ != NULL, FALSE);
++#line 134 "ease-welcome-actor.vala"
++ if ((*event).click_count == 2) {
++#line 135 "ease-welcome-actor.vala"
++ g_signal_emit_by_name (self, "double-click", self);
++#line 205 "ease-welcome-actor.c"
++ result = FALSE;
++#line 136 "ease-welcome-actor.vala"
++ return result;
++#line 209 "ease-welcome-actor.c"
++ }
++#line 139 "ease-welcome-actor.vala"
++ if (!self->priv->is_selected) {
++#line 139 "ease-welcome-actor.vala"
++ g_signal_emit_by_name (self, "selected", self);
++#line 215 "ease-welcome-actor.c"
++ }
++ result = FALSE;
++#line 140 "ease-welcome-actor.vala"
++ return result;
++#line 220 "ease-welcome-actor.c"
++}
++
++
++#line 133 "ease-welcome-actor.vala"
++static gboolean __lambda80__clutter_actor_button_press_event (ClutterActor* _sender, ClutterButtonEvent* event, gpointer self) {
++#line 226 "ease-welcome-actor.c"
++ gboolean result;
++ result = _lambda80_ (_sender, event, self);
++ return result;
++}
++
++
++#line 94 "ease-welcome-actor.vala"
++EaseWelcomeActor* ease_welcome_actor_construct (GType object_type, EaseTheme* t) {
++#line 235 "ease-welcome-actor.c"
++ EaseWelcomeActor * self;
++ ClutterRectangle* _tmp0_;
++ ClutterColor _tmp1_;
++ ClutterColor _tmp2_;
++ ClutterRectangle* _tmp3_;
++ ClutterColor _tmp4_ = {0};
++ ClutterColor _tmp5_;
++ ClutterColor _tmp6_;
++ ClutterText* _tmp7_;
++ ClutterCairoTexture* _tmp8_;
++#line 94 "ease-welcome-actor.vala"
++ g_return_val_if_fail (t != NULL, NULL);
++#line 248 "ease-welcome-actor.c"
++ self = g_object_newv (object_type, 0, NULL);
++#line 96 "ease-welcome-actor.vala"
++ ease_welcome_actor_set_theme (self, t);
++#line 97 "ease-welcome-actor.vala"
++ clutter_actor_set_reactive ((ClutterActor*) self, TRUE);
++#line 100 "ease-welcome-actor.vala"
++ self->priv->rect = (_tmp0_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new ()), _g_object_unref0 (self->priv->rect), _tmp0_);
++#line 101 "ease-welcome-actor.vala"
++ clutter_rectangle_set_color (self->priv->rect, (_tmp1_ = EASE_WELCOME_ACTOR_RECT_BG, &_tmp1_));
++#line 102 "ease-welcome-actor.vala"
++ clutter_rectangle_set_border_color (self->priv->rect, (_tmp2_ = EASE_WELCOME_ACTOR_RECT_B_C, &_tmp2_));
++#line 103 "ease-welcome-actor.vala"
++ clutter_rectangle_set_border_width (self->priv->rect, (guint) EASE_WELCOME_ACTOR_RECT_B_W);
++#line 104 "ease-welcome-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) self->priv->rect, (float) (-EASE_WELCOME_ACTOR_RECT_B_W));
++#line 105 "ease-welcome-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) self->priv->rect, (float) (-EASE_WELCOME_ACTOR_RECT_B_W));
++#line 106 "ease-welcome-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) self->priv->rect);
++#line 109 "ease-welcome-actor.vala"
++ self->priv->hilight_rect = (_tmp3_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new ()), _g_object_unref0 (self->priv->hilight_rect), _tmp3_);
++#line 110 "ease-welcome-actor.vala"
++ clutter_rectangle_set_color (self->priv->hilight_rect, (_tmp5_ = (_tmp4_.red = (guchar) 0, _tmp4_.green = (guchar) 0, _tmp4_.blue = (guchar) 0, _tmp4_.alpha = (guchar) 255, _tmp4_), &_tmp5_));
++#line 111 "ease-welcome-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) self->priv->hilight_rect, (guint) 0);
++#line 112 "ease-welcome-actor.vala"
++ clutter_rectangle_set_border_color (self->priv->hilight_rect, (_tmp6_ = EASE_WELCOME_ACTOR_HLRECT_C, &_tmp6_));
++#line 113 "ease-welcome-actor.vala"
++ clutter_rectangle_set_border_width (self->priv->hilight_rect, (guint) EASE_WELCOME_ACTOR_HLRECT_W);
++#line 114 "ease-welcome-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) self->priv->hilight_rect, (float) (-EASE_WELCOME_ACTOR_HLRECT_W));
++#line 115 "ease-welcome-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) self->priv->hilight_rect, (float) (-EASE_WELCOME_ACTOR_HLRECT_W));
++#line 116 "ease-welcome-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) self->priv->hilight_rect);
++#line 119 "ease-welcome-actor.vala"
++ self->priv->text = (_tmp7_ = g_object_ref_sink ((ClutterText*) clutter_text_new_full (EASE_WELCOME_ACTOR_FONT_NAME, self->priv->_theme->title, &EASE_WELCOME_ACTOR_TEXT_COLOR)), _g_object_unref0 (self->priv->text), _tmp7_);
++#line 120 "ease-welcome-actor.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->text, EASE_WELCOME_ACTOR_TEXT_HEIGHT);
++#line 121 "ease-welcome-actor.vala"
++ clutter_text_set_line_alignment (self->priv->text, PANGO_ALIGN_RIGHT);
++#line 122 "ease-welcome-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) self->priv->text);
++#line 125 "ease-welcome-actor.vala"
++ self->priv->slide_actor = (_tmp8_ = g_object_ref_sink ((ClutterCairoTexture*) clutter_cairo_texture_new ((guint) 1024, (guint) 768)), _g_object_unref0 (self->priv->slide_actor), _tmp8_);
++#line 126 "ease-welcome-actor.vala"
++ clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) self->priv->slide_actor);
++#line 129 "ease-welcome-actor.vala"
++ clutter_actor_set_opacity ((ClutterActor*) self, (guint) 0);
++#line 130 "ease-welcome-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self, (gulong) EASE_WELCOME_ACTOR_FADE_EASE, (guint) EASE_WELCOME_ACTOR_FADE_INIT_TIME, "opacity", 255, NULL);
++#line 133 "ease-welcome-actor.vala"
++ g_signal_connect_object ((ClutterActor*) self, "button-press-event", (GCallback) __lambda80__clutter_actor_button_press_event, self, 0);
++#line 302 "ease-welcome-actor.c"
++ return self;
++}
++
++
++#line 94 "ease-welcome-actor.vala"
++EaseWelcomeActor* ease_welcome_actor_new (EaseTheme* t) {
++#line 94 "ease-welcome-actor.vala"
++ return ease_welcome_actor_construct (EASE_TYPE_WELCOME_ACTOR, t);
++#line 311 "ease-welcome-actor.c"
++}
++
++
++#line 150 "ease-welcome-actor.vala"
++void ease_welcome_actor_set_slide_size (EaseWelcomeActor* self, gint w, gint h) {
++#line 317 "ease-welcome-actor.c"
++ GError * _inner_error_;
++#line 150 "ease-welcome-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 321 "ease-welcome-actor.c"
++ _inner_error_ = NULL;
++#line 153 "ease-welcome-actor.vala"
++ clutter_cairo_texture_set_surface_size (self->priv->slide_actor, (guint) w, (guint) h);
++#line 325 "ease-welcome-actor.c"
++ {
++ EaseSlide* slide;
++ cairo_t* _tmp0_;
++#line 158 "ease-welcome-actor.vala"
++ slide = ease_welcome_actor_create_slide (self, w, h);
++#line 159 "ease-welcome-actor.vala"
++ ease_slide_set_theme (slide, self->priv->_theme);
++#line 160 "ease-welcome-actor.vala"
++ ease_slide_cairo_render_sized (slide, _tmp0_ = clutter_cairo_texture_create (self->priv->slide_actor), w, h, &_inner_error_);
++#line 335 "ease-welcome-actor.c"
++ _cairo_destroy0 (_tmp0_);
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (slide);
++ goto __catch26_g_error;
++ }
++ _g_object_unref0 (slide);
++ }
++ goto __finally26;
++ __catch26_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 164 "ease-welcome-actor.vala"
++ g_critical (_ ("Error rendering preview: %s"), e->message);
++#line 352 "ease-welcome-actor.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally26:
++ if (_inner_error_ != NULL) {
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++}
++
++
++#line 176 "ease-welcome-actor.vala"
++void ease_welcome_actor_set_actor_size (EaseWelcomeActor* self, float w, float h) {
++#line 176 "ease-welcome-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 178 "ease-welcome-actor.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->rect, (float) (ease_roundd ((double) w) + (EASE_WELCOME_ACTOR_RECT_B_W * 2)));
++#line 179 "ease-welcome-actor.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->rect, (float) (ease_roundd ((double) h) + (EASE_WELCOME_ACTOR_RECT_B_W * 2)));
++#line 181 "ease-welcome-actor.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->hilight_rect, (float) (ease_roundd ((double) w) + (EASE_WELCOME_ACTOR_HLRECT_W * 2)));
++#line 182 "ease-welcome-actor.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->hilight_rect, (float) (ease_roundd ((double) h) + (EASE_WELCOME_ACTOR_HLRECT_W * 2)));
++#line 184 "ease-welcome-actor.vala"
++ clutter_actor_set_x ((ClutterActor*) self->priv->text, (float) ease_roundd ((double) ((w / 2) - (clutter_actor_get_width ((ClutterActor*) self->priv->text) / 2))));
++#line 185 "ease-welcome-actor.vala"
++ clutter_actor_set_y ((ClutterActor*) self->priv->text, (float) ease_roundd ((double) (h + EASE_WELCOME_ACTOR_TEXT_OFFSET)));
++#line 187 "ease-welcome-actor.vala"
++ if (self->priv->slide_actor != NULL) {
++#line 189 "ease-welcome-actor.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->slide_actor, (float) ease_roundd ((double) w));
++#line 190 "ease-welcome-actor.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->slide_actor, (float) ease_roundd ((double) h));
++#line 387 "ease-welcome-actor.c"
++ }
++}
++
++
++#line 197 "ease-welcome-actor.vala"
++void ease_welcome_actor_fade (EaseWelcomeActor* self) {
++#line 197 "ease-welcome-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 199 "ease-welcome-actor.vala"
++ self->priv->is_selected = FALSE;
++#line 200 "ease-welcome-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->priv->slide_actor, (gulong) EASE_WELCOME_ACTOR_FADE_EASE, (guint) EASE_WELCOME_ACTOR_FADE_TIME, "opacity", EASE_WELCOME_ACTOR_FADE_OPACITY, NULL);
++#line 201 "ease-welcome-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->priv->hilight_rect, (gulong) EASE_WELCOME_ACTOR_FADE_EASE, (guint) EASE_WELCOME_ACTOR_FADE_TIME, "opacity", 0, NULL);
++#line 402 "ease-welcome-actor.c"
++}
++
++
++#line 207 "ease-welcome-actor.vala"
++void ease_welcome_actor_unfade (EaseWelcomeActor* self) {
++#line 207 "ease-welcome-actor.vala"
++ g_return_if_fail (self != NULL);
++#line 209 "ease-welcome-actor.vala"
++ self->priv->is_selected = TRUE;
++#line 210 "ease-welcome-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->priv->slide_actor, (gulong) EASE_WELCOME_ACTOR_FADE_EASE, (guint) EASE_WELCOME_ACTOR_FADE_TIME, "opacity", 255, NULL);
++#line 211 "ease-welcome-actor.vala"
++ clutter_actor_animate ((ClutterActor*) self->priv->hilight_rect, (gulong) EASE_WELCOME_ACTOR_FADE_EASE, (guint) EASE_WELCOME_ACTOR_FADE_TIME, "opacity", 255, NULL);
++#line 416 "ease-welcome-actor.c"
++}
++
++
++#line 225 "ease-welcome-actor.vala"
++static EaseSlide* ease_welcome_actor_create_slide (EaseWelcomeActor* self, gint w, gint h) {
++#line 422 "ease-welcome-actor.c"
++ EaseSlide* result = NULL;
++ EaseSlide* slide;
++#line 225 "ease-welcome-actor.vala"
++ g_return_val_if_fail (self != NULL, NULL);
++#line 227 "ease-welcome-actor.vala"
++ slide = ease_theme_create_slide (self->priv->_theme, EASE_WELCOME_ACTOR_PREVIEW_SLIDE, w, h);
++#line 429 "ease-welcome-actor.c"
++ {
++ GeeIterator* _element_it;
++#line 229 "ease-welcome-actor.vala"
++ _element_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) slide->elements);
++#line 229 "ease-welcome-actor.vala"
++ while (TRUE) {
++#line 436 "ease-welcome-actor.c"
++ EaseElement* element;
++ GQuark _tmp3_;
++ const char* _tmp2_;
++#line 229 "ease-welcome-actor.vala"
++ if (!gee_iterator_next (_element_it)) {
++#line 229 "ease-welcome-actor.vala"
++ break;
++#line 444 "ease-welcome-actor.c"
++ }
++#line 229 "ease-welcome-actor.vala"
++ element = (EaseElement*) gee_iterator_get (_element_it);
++#line 448 "ease-welcome-actor.c"
++ _tmp2_ = ease_element_get_identifier (element);
++ _tmp3_ = (NULL == _tmp2_) ? 0 : g_quark_from_string (_tmp2_);
++ if (_tmp3_ == g_quark_from_string (EASE_THEME_TITLE_TEXT))
++ switch (0) {
++ default:
++ {
++ EaseElement* _tmp0_;
++#line 234 "ease-welcome-actor.vala"
++ ease_text_element_set_text ((_tmp0_ = element, EASE_IS_TEXT_ELEMENT (_tmp0_) ? ((EaseTextElement*) _tmp0_) : NULL), "Hello World!");
++#line 235 "ease-welcome-actor.vala"
++ break;
++#line 460 "ease-welcome-actor.c"
++ }
++ } else if (_tmp3_ == g_quark_from_string (EASE_THEME_AUTHOR_TEXT))
++ switch (0) {
++ default:
++ {
++ EaseElement* _tmp1_;
++#line 237 "ease-welcome-actor.vala"
++ ease_text_element_set_text ((_tmp1_ = element, EASE_IS_TEXT_ELEMENT (_tmp1_) ? ((EaseTextElement*) _tmp1_) : NULL), g_get_real_name ());
++#line 238 "ease-welcome-actor.vala"
++ break;
++#line 471 "ease-welcome-actor.c"
++ }
++ }
++ _g_object_unref0 (element);
++ }
++ _g_object_unref0 (_element_it);
++ }
++ result = slide;
++#line 242 "ease-welcome-actor.vala"
++ return result;
++#line 481 "ease-welcome-actor.c"
++}
++
++
++EaseTheme* ease_welcome_actor_get_theme (EaseWelcomeActor* self) {
++ EaseTheme* result;
++ g_return_val_if_fail (self != NULL, NULL);
++ result = self->priv->_theme;
++#line 52 "ease-welcome-actor.vala"
++ return result;
++#line 491 "ease-welcome-actor.c"
++}
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++void ease_welcome_actor_set_theme (EaseWelcomeActor* self, EaseTheme* value) {
++ EaseTheme* _tmp0_;
++ g_return_if_fail (self != NULL);
++ self->priv->_theme = (_tmp0_ = _g_object_ref0 (value), _g_object_unref0 (self->priv->_theme), _tmp0_);
++ g_object_notify ((GObject *) self, "theme");
++}
++
++
++static void ease_welcome_actor_class_init (EaseWelcomeActorClass * klass) {
++ ease_welcome_actor_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseWelcomeActorPrivate));
++ G_OBJECT_CLASS (klass)->get_property = ease_welcome_actor_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_welcome_actor_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_welcome_actor_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_WELCOME_ACTOR_THEME, g_param_spec_object ("theme", "theme", "theme", EASE_TYPE_THEME, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_signal_new ("selected", EASE_TYPE_WELCOME_ACTOR, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_WELCOME_ACTOR);
++ g_signal_new ("double_click", EASE_TYPE_WELCOME_ACTOR, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, EASE_TYPE_WELCOME_ACTOR);
++}
++
++
++static void ease_welcome_actor_instance_init (EaseWelcomeActor * self) {
++ self->priv = EASE_WELCOME_ACTOR_GET_PRIVATE (self);
++ self->priv->is_selected = FALSE;
++}
++
++
++static void ease_welcome_actor_finalize (GObject* obj) {
++ EaseWelcomeActor * self;
++ self = EASE_WELCOME_ACTOR (obj);
++ _g_object_unref0 (self->priv->slide_actor);
++ _g_object_unref0 (self->priv->rect);
++ _g_object_unref0 (self->priv->hilight_rect);
++ _g_object_unref0 (self->priv->_theme);
++ _g_object_unref0 (self->priv->text);
++ G_OBJECT_CLASS (ease_welcome_actor_parent_class)->finalize (obj);
++}
++
++
++GType ease_welcome_actor_get_type (void) {
++ static volatile gsize ease_welcome_actor_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_welcome_actor_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseWelcomeActorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_welcome_actor_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseWelcomeActor), 0, (GInstanceInitFunc) ease_welcome_actor_instance_init, NULL };
++ GType ease_welcome_actor_type_id;
++ ease_welcome_actor_type_id = g_type_register_static (CLUTTER_TYPE_GROUP, "EaseWelcomeActor", &g_define_type_info, 0);
++ g_once_init_leave (&ease_welcome_actor_type_id__volatile, ease_welcome_actor_type_id);
++ }
++ return ease_welcome_actor_type_id__volatile;
++}
++
++
++static void ease_welcome_actor_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseWelcomeActor * self;
++ self = EASE_WELCOME_ACTOR (object);
++ switch (property_id) {
++ case EASE_WELCOME_ACTOR_THEME:
++ g_value_set_object (value, ease_welcome_actor_get_theme (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_welcome_actor_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseWelcomeActor * self;
++ self = EASE_WELCOME_ACTOR (object);
++ switch (property_id) {
++ case EASE_WELCOME_ACTOR_THEME:
++ ease_welcome_actor_set_theme (self, g_value_get_object (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
diff --cc ease-core/ease-welcome-window.c
index 0000000,0000000..81f2046
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-welcome-window.c
@@@ -1,0 -1,0 +1,1217 @@@
++/* ease-welcome-window.c generated by valac, the Vala compiler
++ * generated from ease-welcome-window.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <gee.h>
++#include <clutter/clutter.h>
++#include <float.h>
++#include <math.h>
++#include <stdlib.h>
++#include <string.h>
++#include <glib/gi18n-lib.h>
++#include <gio/gio.h>
++#include <gdk/gdk.h>
++
++
++#define EASE_TYPE_WELCOME_WINDOW (ease_welcome_window_get_type ())
++#define EASE_WELCOME_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_WELCOME_WINDOW, EaseWelcomeWindow))
++#define EASE_WELCOME_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_WELCOME_WINDOW, EaseWelcomeWindowClass))
++#define EASE_IS_WELCOME_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_WELCOME_WINDOW))
++#define EASE_IS_WELCOME_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_WELCOME_WINDOW))
++#define EASE_WELCOME_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_WELCOME_WINDOW, EaseWelcomeWindowClass))
++
++typedef struct _EaseWelcomeWindow EaseWelcomeWindow;
++typedef struct _EaseWelcomeWindowClass EaseWelcomeWindowClass;
++typedef struct _EaseWelcomeWindowPrivate EaseWelcomeWindowPrivate;
++
++#define EASE_TYPE_THEME (ease_theme_get_type ())
++#define EASE_THEME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_THEME, EaseTheme))
++#define EASE_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_THEME, EaseThemeClass))
++#define EASE_IS_THEME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_THEME))
++#define EASE_IS_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_THEME))
++#define EASE_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_THEME, EaseThemeClass))
++
++typedef struct _EaseTheme EaseTheme;
++typedef struct _EaseThemeClass EaseThemeClass;
++
++#define EASE_TYPE_SCROLLABLE_EMBED (ease_scrollable_embed_get_type ())
++#define EASE_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbed))
++#define EASE_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++#define EASE_IS_SCROLLABLE_EMBED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_IS_SCROLLABLE_EMBED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_SCROLLABLE_EMBED))
++#define EASE_SCROLLABLE_EMBED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_SCROLLABLE_EMBED, EaseScrollableEmbedClass))
++
++typedef struct _EaseScrollableEmbed EaseScrollableEmbed;
++typedef struct _EaseScrollableEmbedClass EaseScrollableEmbedClass;
++
++#define EASE_TYPE_WELCOME_ACTOR (ease_welcome_actor_get_type ())
++#define EASE_WELCOME_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_WELCOME_ACTOR, EaseWelcomeActor))
++#define EASE_WELCOME_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_WELCOME_ACTOR, EaseWelcomeActorClass))
++#define EASE_IS_WELCOME_ACTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_WELCOME_ACTOR))
++#define EASE_IS_WELCOME_ACTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_WELCOME_ACTOR))
++#define EASE_WELCOME_ACTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_WELCOME_ACTOR, EaseWelcomeActorClass))
++
++typedef struct _EaseWelcomeActor EaseWelcomeActor;
++typedef struct _EaseWelcomeActorClass EaseWelcomeActorClass;
++
++#define EASE_TYPE_ZOOM_SLIDER (ease_zoom_slider_get_type ())
++#define EASE_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ZOOM_SLIDER, EaseZoomSlider))
++#define EASE_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ZOOM_SLIDER, EaseZoomSliderClass))
++#define EASE_IS_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ZOOM_SLIDER))
++#define EASE_IS_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ZOOM_SLIDER))
++#define EASE_ZOOM_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ZOOM_SLIDER, EaseZoomSliderClass))
++
++typedef struct _EaseZoomSlider EaseZoomSlider;
++typedef struct _EaseZoomSliderClass EaseZoomSliderClass;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++#define _g_free0(var) (var = (g_free (var), NULL))
++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
++
++#define EASE_TYPE_ANIMATED_ZOOM_SLIDER (ease_animated_zoom_slider_get_type ())
++#define EASE_ANIMATED_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ANIMATED_ZOOM_SLIDER, EaseAnimatedZoomSlider))
++#define EASE_ANIMATED_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ANIMATED_ZOOM_SLIDER, EaseAnimatedZoomSliderClass))
++#define EASE_IS_ANIMATED_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ANIMATED_ZOOM_SLIDER))
++#define EASE_IS_ANIMATED_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ANIMATED_ZOOM_SLIDER))
++#define EASE_ANIMATED_ZOOM_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ANIMATED_ZOOM_SLIDER, EaseAnimatedZoomSliderClass))
++
++typedef struct _EaseAnimatedZoomSlider EaseAnimatedZoomSlider;
++typedef struct _EaseAnimatedZoomSliderClass EaseAnimatedZoomSliderClass;
++#define _g_dir_close0(var) ((var == NULL) ? NULL : (var = (g_dir_close (var), NULL)))
++
++#define EASE_TYPE_DOCUMENT (ease_document_get_type ())
++#define EASE_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_DOCUMENT, EaseDocument))
++#define EASE_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++#define EASE_IS_DOCUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_DOCUMENT))
++#define EASE_IS_DOCUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_DOCUMENT))
++#define EASE_DOCUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_DOCUMENT, EaseDocumentClass))
++
++typedef struct _EaseDocument EaseDocument;
++typedef struct _EaseDocumentClass EaseDocumentClass;
++
++#define EASE_TYPE_EDITOR_WINDOW (ease_editor_window_get_type ())
++#define EASE_EDITOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindow))
++#define EASE_EDITOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindowClass))
++#define EASE_IS_EDITOR_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_EDITOR_WINDOW))
++#define EASE_IS_EDITOR_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_EDITOR_WINDOW))
++#define EASE_EDITOR_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_EDITOR_WINDOW, EaseEditorWindowClass))
++
++typedef struct _EaseEditorWindow EaseEditorWindow;
++typedef struct _EaseEditorWindowClass EaseEditorWindowClass;
++
++struct _EaseWelcomeWindow {
++ GtkWindow parent_instance;
++ EaseWelcomeWindowPrivate * priv;
++};
++
++struct _EaseWelcomeWindowClass {
++ GtkWindowClass parent_class;
++};
++
++struct _EaseWelcomeWindowPrivate {
++ GtkButton* new_pres_button;
++ GtkButton* open_pres_button;
++ GtkComboBox* combores;
++ GtkSpinButton* x_res;
++ GtkSpinButton* y_res;
++ GeeArrayList* themes;
++ EaseTheme* selected_theme;
++ EaseScrollableEmbed* embed;
++ ClutterGroup* preview_container;
++ ClutterRectangle* preview_background;
++ GeeArrayList* previews;
++ gint preview_width;
++ float preview_aspect;
++ gint preview_row_count;
++ gboolean animate_resize;
++ ClutterTimeline* animate_alarm;
++ GeeArrayList* x_anims;
++ GeeArrayList* y_anims;
++ EaseZoomSlider* zoom_slider;
++ gint* ZOOM_VALUES;
++ gint ZOOM_VALUES_length1;
++ gint _ZOOM_VALUES_size_;
++};
++
++
++static gpointer ease_welcome_window_parent_class = NULL;
++
++GType ease_welcome_window_get_type (void) G_GNUC_CONST;
++GType ease_theme_get_type (void) G_GNUC_CONST;
++GType ease_scrollable_embed_get_type (void) G_GNUC_CONST;
++GType ease_welcome_actor_get_type (void) G_GNUC_CONST;
++GType ease_zoom_slider_get_type (void) G_GNUC_CONST;
++#define EASE_WELCOME_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_WELCOME_WINDOW, EaseWelcomeWindowPrivate))
++enum {
++ EASE_WELCOME_WINDOW_DUMMY_PROPERTY
++};
++#define EASE_WELCOME_WINDOW_PREVIEW_PADDING 20
++#define EASE_WELCOME_WINDOW_PREVIEW_VERT_PADDING 35
++#define EASE_WELCOME_WINDOW_DEFAULT_ACTIVE 2
++#define EASE_WELCOME_WINDOW_ANIM_TIME 300
++#define EASE_WELCOME_WINDOW_ANIM_EASE ((gint) CLUTTER_EASE_IN_OUT_SINE)
++#define EASE_WELCOME_WINDOW_SLIDER_START 190
++#define EASE_THEME_TITLE "title"
++#define EASE_WELCOME_WINDOW_PREVIEW_ID EASE_THEME_TITLE
++char* ease_data_path (const char* path);
++#define EASE_TEMP_UI_DIR "ui"
++EaseAnimatedZoomSlider* ease_animated_zoom_slider_new (GtkAdjustment* adjustment, gint* button_values, int button_values_length1);
++EaseAnimatedZoomSlider* ease_animated_zoom_slider_construct (GType object_type, GtkAdjustment* adjustment, gint* button_values, int button_values_length1);
++GType ease_animated_zoom_slider_get_type (void) G_GNUC_CONST;
++void ease_zoom_slider_set_sliderpos (EaseZoomSlider* self, double value);
++static void ease_welcome_window_reflow_previews (EaseWelcomeWindow* self);
++static void _lambda81_ (EaseWelcomeWindow* self);
++static void __lambda81__gtk_combo_box_changed (GtkComboBox* _sender, gpointer self);
++static void ease_welcome_window_set_resolution_box (EaseWelcomeWindow* self, gint width, gint height);
++void ease_welcome_actor_set_slide_size (EaseWelcomeActor* self, gint w, gint h);
++static void _lambda83_ (EaseWelcomeWindow* self);
++static void __lambda83__gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self);
++static void _lambda84_ (EaseWelcomeWindow* self);
++static void __lambda84__gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self);
++EaseScrollableEmbed* ease_scrollable_embed_new (gboolean horizontal, gboolean has_frame);
++EaseScrollableEmbed* ease_scrollable_embed_construct (GType object_type, gboolean horizontal, gboolean has_frame);
++ClutterStage* ease_scrollable_embed_get_stage (EaseScrollableEmbed* self);
++#define EASE_TEMP_TEMP_DIR "ease"
++#define EASE_TEMP_THEME_DIR "themes"
++EaseTheme* ease_theme_new (const char* dir_path);
++EaseTheme* ease_theme_construct (GType object_type, const char* dir_path);
++void ease_error_dialog (const char* title, const char* message);
++EaseWelcomeActor* ease_welcome_actor_new (EaseTheme* t);
++EaseWelcomeActor* ease_welcome_actor_construct (GType object_type, EaseTheme* t);
++EaseTheme* ease_welcome_actor_get_theme (EaseWelcomeActor* self);
++void ease_welcome_actor_fade (EaseWelcomeActor* self);
++void ease_welcome_actor_unfade (EaseWelcomeActor* self);
++static void _lambda85_ (EaseWelcomeActor* sender, EaseWelcomeWindow* self);
++static void __lambda85__ease_welcome_actor_selected (EaseWelcomeActor* _sender, EaseWelcomeActor* sender, gpointer self);
++void ease_welcome_window_create_new_document (GtkWidget* sender, EaseWelcomeWindow* self);
++static void _lambda86_ (EaseWelcomeActor* sender, EaseWelcomeWindow* self);
++static void __lambda86__ease_welcome_actor_double_click (EaseWelcomeActor* _sender, EaseWelcomeActor* sender, gpointer self);
++ClutterGroup* ease_scrollable_embed_get_contents (EaseScrollableEmbed* self);
++static void _lambda87_ (EaseWelcomeWindow* self);
++static void __lambda87__gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self);
++double ease_zoom_slider_get_value (EaseZoomSlider* self);
++static void _lambda88_ (EaseWelcomeWindow* self);
++static void __lambda88__ease_zoom_slider_value_changed (EaseZoomSlider* _sender, gpointer self);
++EaseWelcomeWindow* ease_welcome_window_new (void);
++EaseWelcomeWindow* ease_welcome_window_construct (GType object_type);
++void ease_open_dialog_run (void);
++void ease_welcome_window_on_open_pres_button_clicked (GtkWidget* sender, EaseWelcomeWindow* self);
++EaseDocument* ease_document_new_from_theme (EaseTheme* doc_theme, gint w, gint h, GError** error);
++EaseDocument* ease_document_construct_from_theme (GType object_type, EaseTheme* doc_theme, gint w, gint h, GError** error);
++GType ease_document_get_type (void) G_GNUC_CONST;
++EaseEditorWindow* ease_editor_window_new (EaseDocument* doc);
++EaseEditorWindow* ease_editor_window_construct (GType object_type, EaseDocument* doc);
++GType ease_editor_window_get_type (void) G_GNUC_CONST;
++void ease_main_add_window (EaseEditorWindow* win);
++void ease_main_remove_welcome (void);
++float ease_scrollable_embed_get_width (EaseScrollableEmbed* self);
++static void _lambda82_ (EaseWelcomeWindow* self);
++static void __lambda82__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self);
++gint ease_roundd (double num);
++void ease_welcome_actor_set_actor_size (EaseWelcomeActor* self, float w, float h);
++float ease_scrollable_embed_get_height (EaseScrollableEmbed* self);
++static void ease_welcome_window_finalize (GObject* obj);
++static gint _vala_array_length (gpointer array);
++
++static const gint EASE_WELCOME_WINDOW_RESOLUTIONS_X[6] = {640, 800, 1024, 1280, 1280, 1920};
++static const gint EASE_WELCOME_WINDOW_RESOLUTIONS_Y[6] = {480, 600, 768, 1024, 720, 1080};
++
++
++static gpointer _g_object_ref0 (gpointer self) {
++ return self ? g_object_ref (self) : NULL;
++}
++
++
++#line 127 "ease-welcome-window.vala"
++static void _lambda81_ (EaseWelcomeWindow* self) {
++#line 246 "ease-welcome-window.c"
++ gint val;
++#line 129 "ease-welcome-window.vala"
++ val = gtk_combo_box_get_active (self->priv->combores);
++#line 130 "ease-welcome-window.vala"
++ if (val > 0) {
++#line 131 "ease-welcome-window.vala"
++ gtk_spin_button_set_value (self->priv->x_res, (double) EASE_WELCOME_WINDOW_RESOLUTIONS_X[val - 1]);
++#line 132 "ease-welcome-window.vala"
++ gtk_spin_button_set_value (self->priv->y_res, (double) EASE_WELCOME_WINDOW_RESOLUTIONS_Y[val - 1]);
++#line 256 "ease-welcome-window.c"
++ }
++#line 134 "ease-welcome-window.vala"
++ ease_welcome_window_reflow_previews (self);
++#line 260 "ease-welcome-window.c"
++}
++
++
++#line 127 "ease-welcome-window.vala"
++static void __lambda81__gtk_combo_box_changed (GtkComboBox* _sender, gpointer self) {
++#line 266 "ease-welcome-window.c"
++ _lambda81_ (self);
++}
++
++
++#line 151 "ease-welcome-window.vala"
++static void _lambda83_ (EaseWelcomeWindow* self) {
++#line 152 "ease-welcome-window.vala"
++ ease_welcome_window_set_resolution_box (self, (gint) gtk_spin_button_get_value (self->priv->x_res), (gint) gtk_spin_button_get_value (self->priv->y_res));
++#line 275 "ease-welcome-window.c"
++ {
++ GeeIterator* _p_it;
++#line 154 "ease-welcome-window.vala"
++ _p_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) self->priv->previews);
++#line 154 "ease-welcome-window.vala"
++ while (TRUE) {
++#line 282 "ease-welcome-window.c"
++ EaseWelcomeActor* p;
++#line 154 "ease-welcome-window.vala"
++ if (!gee_iterator_next (_p_it)) {
++#line 154 "ease-welcome-window.vala"
++ break;
++#line 288 "ease-welcome-window.c"
++ }
++#line 154 "ease-welcome-window.vala"
++ p = (EaseWelcomeActor*) gee_iterator_get (_p_it);
++#line 156 "ease-welcome-window.vala"
++ ease_welcome_actor_set_slide_size (p, (gint) gtk_spin_button_get_value (self->priv->x_res), (gint) gtk_spin_button_get_value (self->priv->y_res));
++#line 294 "ease-welcome-window.c"
++ _g_object_unref0 (p);
++ }
++ _g_object_unref0 (_p_it);
++ }
++}
++
++
++#line 151 "ease-welcome-window.vala"
++static void __lambda83__gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self) {
++#line 304 "ease-welcome-window.c"
++ _lambda83_ (self);
++}
++
++
++#line 161 "ease-welcome-window.vala"
++static void _lambda84_ (EaseWelcomeWindow* self) {
++#line 162 "ease-welcome-window.vala"
++ ease_welcome_window_set_resolution_box (self, (gint) gtk_spin_button_get_value (self->priv->x_res), (gint) gtk_spin_button_get_value (self->priv->y_res));
++#line 313 "ease-welcome-window.c"
++ {
++ GeeIterator* _p_it;
++#line 164 "ease-welcome-window.vala"
++ _p_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) self->priv->previews);
++#line 164 "ease-welcome-window.vala"
++ while (TRUE) {
++#line 320 "ease-welcome-window.c"
++ EaseWelcomeActor* p;
++#line 164 "ease-welcome-window.vala"
++ if (!gee_iterator_next (_p_it)) {
++#line 164 "ease-welcome-window.vala"
++ break;
++#line 326 "ease-welcome-window.c"
++ }
++#line 164 "ease-welcome-window.vala"
++ p = (EaseWelcomeActor*) gee_iterator_get (_p_it);
++#line 166 "ease-welcome-window.vala"
++ ease_welcome_actor_set_slide_size (p, (gint) gtk_spin_button_get_value (self->priv->x_res), (gint) gtk_spin_button_get_value (self->priv->y_res));
++#line 332 "ease-welcome-window.c"
++ _g_object_unref0 (p);
++ }
++ _g_object_unref0 (_p_it);
++ }
++}
++
++
++#line 161 "ease-welcome-window.vala"
++static void __lambda84__gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self) {
++#line 342 "ease-welcome-window.c"
++ _lambda84_ (self);
++}
++
++
++#line 220 "ease-welcome-window.vala"
++static void _lambda85_ (EaseWelcomeActor* sender, EaseWelcomeWindow* self) {
++#line 349 "ease-welcome-window.c"
++ EaseTheme* _tmp1_;
++ EaseWelcomeActor* _tmp0_;
++#line 220 "ease-welcome-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 221 "ease-welcome-window.vala"
++ gtk_widget_set_sensitive ((GtkWidget*) self->priv->new_pres_button, TRUE);
++#line 222 "ease-welcome-window.vala"
++ self->priv->selected_theme = (_tmp1_ = _g_object_ref0 (ease_welcome_actor_get_theme ((_tmp0_ = sender, EASE_IS_WELCOME_ACTOR (_tmp0_) ? ((EaseWelcomeActor*) _tmp0_) : NULL))), _g_object_unref0 (self->priv->selected_theme), _tmp1_);
++#line 358 "ease-welcome-window.c"
++ {
++ GeeIterator* _t_it;
++#line 224 "ease-welcome-window.vala"
++ _t_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) self->priv->previews);
++#line 224 "ease-welcome-window.vala"
++ while (TRUE) {
++#line 365 "ease-welcome-window.c"
++ EaseWelcomeActor* t;
++#line 224 "ease-welcome-window.vala"
++ if (!gee_iterator_next (_t_it)) {
++#line 224 "ease-welcome-window.vala"
++ break;
++#line 371 "ease-welcome-window.c"
++ }
++#line 224 "ease-welcome-window.vala"
++ t = (EaseWelcomeActor*) gee_iterator_get (_t_it);
++#line 226 "ease-welcome-window.vala"
++ if (t != sender) {
++#line 226 "ease-welcome-window.vala"
++ ease_welcome_actor_fade (t);
++#line 379 "ease-welcome-window.c"
++ }
++ _g_object_unref0 (t);
++ }
++ _g_object_unref0 (_t_it);
++ }
++#line 228 "ease-welcome-window.vala"
++ ease_welcome_actor_unfade (sender);
++#line 387 "ease-welcome-window.c"
++}
++
++
++#line 220 "ease-welcome-window.vala"
++static void __lambda85__ease_welcome_actor_selected (EaseWelcomeActor* _sender, EaseWelcomeActor* sender, gpointer self) {
++#line 393 "ease-welcome-window.c"
++ _lambda85_ (sender, self);
++}
++
++
++#line 232 "ease-welcome-window.vala"
++static void _lambda86_ (EaseWelcomeActor* sender, EaseWelcomeWindow* self) {
++#line 400 "ease-welcome-window.c"
++ EaseTheme* _tmp1_;
++ EaseWelcomeActor* _tmp0_;
++#line 232 "ease-welcome-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 233 "ease-welcome-window.vala"
++ self->priv->selected_theme = (_tmp1_ = _g_object_ref0 (ease_welcome_actor_get_theme ((_tmp0_ = sender, EASE_IS_WELCOME_ACTOR (_tmp0_) ? ((EaseWelcomeActor*) _tmp0_) : NULL))), _g_object_unref0 (self->priv->selected_theme), _tmp1_);
++#line 234 "ease-welcome-window.vala"
++ ease_welcome_window_create_new_document (NULL, self);
++#line 409 "ease-welcome-window.c"
++}
++
++
++#line 232 "ease-welcome-window.vala"
++static void __lambda86__ease_welcome_actor_double_click (EaseWelcomeActor* _sender, EaseWelcomeActor* sender, gpointer self) {
++#line 415 "ease-welcome-window.c"
++ _lambda86_ (sender, self);
++}
++
++
++#line 249 "ease-welcome-window.vala"
++static void _lambda87_ (EaseWelcomeWindow* self) {
++#line 251 "ease-welcome-window.vala"
++ ease_welcome_window_reflow_previews (self);
++#line 424 "ease-welcome-window.c"
++}
++
++
++#line 249 "ease-welcome-window.vala"
++static void __lambda87__gtk_widget_size_allocate (GtkWidget* _sender, GdkRectangle* allocation, gpointer self) {
++#line 430 "ease-welcome-window.c"
++ _lambda87_ (self);
++}
++
++
++#line 255 "ease-welcome-window.vala"
++static void _lambda88_ (EaseWelcomeWindow* self) {
++#line 257 "ease-welcome-window.vala"
++ self->priv->preview_width = (gint) ease_zoom_slider_get_value (self->priv->zoom_slider);
++#line 258 "ease-welcome-window.vala"
++ ease_welcome_window_reflow_previews (self);
++#line 441 "ease-welcome-window.c"
++}
++
++
++#line 255 "ease-welcome-window.vala"
++static void __lambda88__ease_zoom_slider_value_changed (EaseZoomSlider* _sender, gpointer self) {
++#line 447 "ease-welcome-window.c"
++ _lambda88_ (self);
++}
++
++
++#line 86 "ease-welcome-window.vala"
++EaseWelcomeWindow* ease_welcome_window_construct (GType object_type) {
++#line 454 "ease-welcome-window.c"
++ GError * _inner_error_;
++ EaseWelcomeWindow * self;
++ GtkBuilder* builder;
++ GObject* _tmp2_;
++ GtkVBox* vbox;
++ GObject* _tmp3_;
++ GtkHBox* hbox;
++ GtkComboBox* _tmp5_;
++ GObject* _tmp4_;
++ GtkSpinButton* _tmp7_;
++ GObject* _tmp6_;
++ GtkSpinButton* _tmp9_;
++ GObject* _tmp8_;
++ GtkButton* _tmp11_;
++ GObject* _tmp10_;
++ GtkButton* _tmp13_;
++ GObject* _tmp12_;
++ EaseZoomSlider* _tmp15_;
++ GtkAdjustment* _tmp14_;
++ GtkComboBox* _tmp16_;
++ gint resolution_count;
++ GtkImage* _tmp19_;
++ EaseScrollableEmbed* _tmp20_;
++ ClutterStage* _tmp21_;
++ ClutterGroup* _tmp22_;
++ ClutterRectangle* _tmp25_;
++ ClutterColor _tmp24_;
++ ClutterColor _tmp23_ = {0};
++ _inner_error_ = NULL;
++ self = g_object_newv (object_type, 0, NULL);
++#line 88 "ease-welcome-window.vala"
++ g_assert (G_N_ELEMENTS (EASE_WELCOME_WINDOW_RESOLUTIONS_X) == G_N_ELEMENTS (EASE_WELCOME_WINDOW_RESOLUTIONS_Y));
++#line 90 "ease-welcome-window.vala"
++ gtk_window_set_title ((GtkWindow*) self, _ ("Pick a theme and start editing"));
++#line 91 "ease-welcome-window.vala"
++ gtk_window_set_default_size ((GtkWindow*) self, 640, 480);
++#line 93 "ease-welcome-window.vala"
++ builder = gtk_builder_new ();
++#line 493 "ease-welcome-window.c"
++ {
++ char* _tmp0_;
++ char* _tmp1_;
++ char* ui_path;
++#line 95 "ease-welcome-window.vala"
++ ui_path = (_tmp1_ = ease_data_path (_tmp0_ = g_build_filename (EASE_TEMP_UI_DIR, "welcome-window.ui", NULL)), _g_free0 (_tmp0_), _tmp1_);
++#line 97 "ease-welcome-window.vala"
++ gtk_builder_add_from_file (builder, ui_path, &_inner_error_);
++#line 502 "ease-welcome-window.c"
++ if (_inner_error_ != NULL) {
++ _g_free0 (ui_path);
++ goto __catch27_g_error;
++ }
++ _g_free0 (ui_path);
++ }
++ goto __finally27;
++ __catch27_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 99 "ease-welcome-window.vala"
++ g_error ("ease-welcome-window.vala:99: Unable to load UI : %s", e->message);
++#line 518 "ease-welcome-window.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally27:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (builder);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++#line 102 "ease-welcome-window.vala"
++ vbox = _g_object_ref0 ((_tmp2_ = gtk_builder_get_object (builder, "vbox1"), GTK_IS_VBOX (_tmp2_) ? ((GtkVBox*) _tmp2_) : NULL));
++#line 103 "ease-welcome-window.vala"
++ hbox = _g_object_ref0 ((_tmp3_ = gtk_builder_get_object (builder, "hbox1"), GTK_IS_HBOX (_tmp3_) ? ((GtkHBox*) _tmp3_) : NULL));
++#line 104 "ease-welcome-window.vala"
++ self->priv->combores = (_tmp5_ = _g_object_ref0 ((_tmp4_ = gtk_builder_get_object (builder, "combo_resolution"), GTK_IS_COMBO_BOX (_tmp4_) ? ((GtkComboBox*) _tmp4_) : NULL)), _g_object_unref0 (self->priv->combores), _tmp5_);
++#line 105 "ease-welcome-window.vala"
++ self->priv->x_res = (_tmp7_ = _g_object_ref0 ((_tmp6_ = gtk_builder_get_object (builder, "horiz_spin"), GTK_IS_SPIN_BUTTON (_tmp6_) ? ((GtkSpinButton*) _tmp6_) : NULL)), _g_object_unref0 (self->priv->x_res), _tmp7_);
++#line 106 "ease-welcome-window.vala"
++ self->priv->y_res = (_tmp9_ = _g_object_ref0 ((_tmp8_ = gtk_builder_get_object (builder, "vert_spin"), GTK_IS_SPIN_BUTTON (_tmp8_) ? ((GtkSpinButton*) _tmp8_) : NULL)), _g_object_unref0 (self->priv->y_res), _tmp9_);
++#line 107 "ease-welcome-window.vala"
++ self->priv->new_pres_button = (_tmp11_ = _g_object_ref0 ((_tmp10_ = gtk_builder_get_object (builder, "newpres"), GTK_IS_BUTTON (_tmp10_) ? ((GtkButton*) _tmp10_) : NULL)), _g_object_unref0 (self->priv->new_pres_button), _tmp11_);
++#line 108 "ease-welcome-window.vala"
++ self->priv->open_pres_button = (_tmp13_ = _g_object_ref0 ((_tmp12_ = gtk_builder_get_object (builder, "openpres"), GTK_IS_BUTTON (_tmp12_) ? ((GtkButton*) _tmp12_) : NULL)), _g_object_unref0 (self->priv->open_pres_button), _tmp13_);
++#line 111 "ease-welcome-window.vala"
++ self->priv->zoom_slider = (_tmp15_ = (EaseZoomSlider*) g_object_ref_sink (ease_animated_zoom_slider_new (_tmp14_ = g_object_ref_sink ((GtkAdjustment*) gtk_adjustment_new ((double) 100, (double) 100, (double) 400, (double) 10, (double) 50, (double) 50)), self->priv->ZOOM_VALUES, self->priv->ZOOM_VALUES_length1)), _g_object_unref0 (self->priv->zoom_slider), _tmp15_);
++#line 545 "ease-welcome-window.c"
++ _g_object_unref0 (_tmp14_);
++#line 113 "ease-welcome-window.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) self->priv->zoom_slider, TRUE, FALSE, (guint) 0);
++#line 114 "ease-welcome-window.vala"
++ gtk_box_reorder_child ((GtkBox*) hbox, (GtkWidget*) self->priv->zoom_slider, 4);
++#line 115 "ease-welcome-window.vala"
++ ease_zoom_slider_set_sliderpos (self->priv->zoom_slider, (double) EASE_WELCOME_WINDOW_SLIDER_START);
++#line 119 "ease-welcome-window.vala"
++ gtk_container_remove ((GtkContainer*) hbox, (GtkWidget*) self->priv->combores);
++#line 120 "ease-welcome-window.vala"
++ self->priv->combores = (_tmp16_ = g_object_ref_sink ((GtkComboBox*) gtk_combo_box_new_text ()), _g_object_unref0 (self->priv->combores), _tmp16_);
++#line 121 "ease-welcome-window.vala"
++ gtk_combo_box_insert_text (self->priv->combores, 0, _ ("Custom"));
++#line 559 "ease-welcome-window.c"
++ {
++ gint i;
++#line 122 "ease-welcome-window.vala"
++ i = 0;
++#line 564 "ease-welcome-window.c"
++ {
++ gboolean _tmp17_;
++#line 122 "ease-welcome-window.vala"
++ _tmp17_ = TRUE;
++#line 122 "ease-welcome-window.vala"
++ while (TRUE) {
++#line 571 "ease-welcome-window.c"
++ char* _tmp18_;
++#line 122 "ease-welcome-window.vala"
++ if (!_tmp17_) {
++#line 122 "ease-welcome-window.vala"
++ i++;
++#line 577 "ease-welcome-window.c"
++ }
++#line 122 "ease-welcome-window.vala"
++ _tmp17_ = FALSE;
++#line 122 "ease-welcome-window.vala"
++ if (!(i < G_N_ELEMENTS (EASE_WELCOME_WINDOW_RESOLUTIONS_X))) {
++#line 122 "ease-welcome-window.vala"
++ break;
++#line 585 "ease-welcome-window.c"
++ }
++#line 123 "ease-welcome-window.vala"
++ gtk_combo_box_append_text (self->priv->combores, _tmp18_ = g_strdup_printf (_ ("%i by %i"), EASE_WELCOME_WINDOW_RESOLUTIONS_X[i], EASE_WELCOME_WINDOW_RESOLUTIONS_Y[i]));
++#line 589 "ease-welcome-window.c"
++ _g_free0 (_tmp18_);
++ }
++ }
++ }
++#line 127 "ease-welcome-window.vala"
++ g_signal_connect_object (self->priv->combores, "changed", (GCallback) __lambda81__gtk_combo_box_changed, self, 0);
++#line 137 "ease-welcome-window.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) self->priv->combores, TRUE, TRUE, 0);
++#line 138 "ease-welcome-window.vala"
++ gtk_box_reorder_child ((GtkBox*) hbox, (GtkWidget*) self->priv->combores, 0);
++#line 144 "ease-welcome-window.vala"
++ resolution_count = G_N_ELEMENTS (EASE_WELCOME_WINDOW_RESOLUTIONS_X);
++#line 145 "ease-welcome-window.vala"
++ gtk_spin_button_set_range (self->priv->x_res, (double) EASE_WELCOME_WINDOW_RESOLUTIONS_X[0], (double) EASE_WELCOME_WINDOW_RESOLUTIONS_X[resolution_count - 1]);
++#line 148 "ease-welcome-window.vala"
++ gtk_spin_button_set_range (self->priv->y_res, (double) EASE_WELCOME_WINDOW_RESOLUTIONS_Y[0], (double) EASE_WELCOME_WINDOW_RESOLUTIONS_Y[resolution_count - 1]);
++#line 151 "ease-welcome-window.vala"
++ g_signal_connect_object (self->priv->x_res, "value-changed", (GCallback) __lambda83__gtk_spin_button_value_changed, self, 0);
++#line 161 "ease-welcome-window.vala"
++ g_signal_connect_object (self->priv->y_res, "value-changed", (GCallback) __lambda84__gtk_spin_button_value_changed, self, 0);
++#line 172 "ease-welcome-window.vala"
++ gtk_widget_set_sensitive ((GtkWidget*) self->priv->new_pres_button, FALSE);
++#line 174 "ease-welcome-window.vala"
++ gtk_button_set_image (self->priv->new_pres_button, (GtkWidget*) (_tmp19_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_stock ("gtk-new", GTK_ICON_SIZE_BUTTON))));
++#line 614 "ease-welcome-window.c"
++ _g_object_unref0 (_tmp19_);
++#line 179 "ease-welcome-window.vala"
++ self->priv->embed = (_tmp20_ = g_object_ref_sink (ease_scrollable_embed_new (FALSE, FALSE)), _g_object_unref0 (self->priv->embed), _tmp20_);
++#line 180 "ease-welcome-window.vala"
++ clutter_stage_set_use_fog (_tmp21_ = ease_scrollable_embed_get_stage (self->priv->embed), FALSE);
++#line 620 "ease-welcome-window.c"
++ _g_object_unref0 (_tmp21_);
++#line 183 "ease-welcome-window.vala"
++ self->priv->preview_container = (_tmp22_ = g_object_ref_sink ((ClutterGroup*) clutter_group_new ()), _g_object_unref0 (self->priv->preview_container), _tmp22_);
++#line 186 "ease-welcome-window.vala"
++ self->priv->preview_background = (_tmp25_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new_with_color ((_tmp24_ = (clutter_color_from_string (&_tmp23_, "black"), _tmp23_), &_tmp24_))), _g_object_unref0 (self->priv->preview_background), _tmp25_);
++#line 187 "ease-welcome-window.vala"
++ clutter_container_add_actor ((ClutterContainer*) self->priv->preview_container, (ClutterActor*) self->priv->preview_background);
++#line 628 "ease-welcome-window.c"
++ {
++ char** _tmp27_;
++ gint _data_dirs_size_;
++ gint data_dirs_length1;
++ char** _tmp26_;
++ char** data_dirs;
++ data_dirs = (_tmp27_ = _tmp26_ = g_get_system_data_dirs (), data_dirs_length1 = _vala_array_length (_tmp26_), _data_dirs_size_ = data_dirs_length1, _tmp27_);
++ {
++ char** dir_collection;
++ int dir_collection_length1;
++ int dir_it;
++#line 191 "ease-welcome-window.vala"
++ dir_collection = data_dirs;
++#line 642 "ease-welcome-window.c"
++ dir_collection_length1 = data_dirs_length1;
++ for (dir_it = 0; dir_it < data_dirs_length1; dir_it = dir_it + 1) {
++ char* dir;
++ dir = g_strdup (dir_collection[dir_it]);
++ {
++ char* filename;
++ GFile* file;
++#line 192 "ease-welcome-window.vala"
++ filename = g_build_filename (dir, EASE_TEMP_TEMP_DIR, EASE_TEMP_THEME_DIR, NULL);
++#line 195 "ease-welcome-window.vala"
++ file = g_file_new_for_path (filename);
++#line 197 "ease-welcome-window.vala"
++ if (g_file_query_exists (file, NULL)) {
++#line 656 "ease-welcome-window.c"
++ GDir* directory;
++ char* name;
++#line 198 "ease-welcome-window.vala"
++ directory = g_dir_open (filename, (guint) 0, &_inner_error_);
++#line 661 "ease-welcome-window.c"
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (file);
++ _g_free0 (filename);
++ _g_free0 (dir);
++ goto __catch28_g_error;
++ }
++#line 199 "ease-welcome-window.vala"
++ name = g_strdup (g_dir_read_name (directory));
++#line 200 "ease-welcome-window.vala"
++ while (TRUE) {
++#line 672 "ease-welcome-window.c"
++ char* path;
++ EaseTheme* _tmp28_;
++ char* _tmp29_;
++#line 200 "ease-welcome-window.vala"
++ if (!(name != NULL)) {
++#line 200 "ease-welcome-window.vala"
++ break;
++#line 680 "ease-welcome-window.c"
++ }
++#line 201 "ease-welcome-window.vala"
++ path = g_build_filename (filename, name, NULL);
++#line 202 "ease-welcome-window.vala"
++ gee_abstract_collection_add ((GeeAbstractCollection*) self->priv->themes, _tmp28_ = ease_theme_new (path));
++#line 686 "ease-welcome-window.c"
++ _g_object_unref0 (_tmp28_);
++#line 203 "ease-welcome-window.vala"
++ name = (_tmp29_ = g_strdup (g_dir_read_name (directory)), _g_free0 (name), _tmp29_);
++#line 690 "ease-welcome-window.c"
++ _g_free0 (path);
++ }
++ _g_free0 (name);
++ _g_dir_close0 (directory);
++ }
++ _g_object_unref0 (file);
++ _g_free0 (filename);
++ _g_free0 (dir);
++ }
++ }
++ }
++ }
++ goto __finally28;
++ __catch28_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 208 "ease-welcome-window.vala"
++ ease_error_dialog ("Error loading themes : %s", e->message);
++#line 712 "ease-welcome-window.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally28:
++ if (_inner_error_ != NULL) {
++ _g_object_unref0 (hbox);
++ _g_object_unref0 (vbox);
++ _g_object_unref0 (builder);
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return NULL;
++ }
++ {
++ GeeIterator* _theme_it;
++#line 212 "ease-welcome-window.vala"
++ _theme_it = gee_abstract_collection_iterator ((GeeAbstractCollection*) self->priv->themes);
++#line 212 "ease-welcome-window.vala"
++ while (TRUE) {
++#line 731 "ease-welcome-window.c"
++ EaseTheme* theme;
++ EaseWelcomeActor* act;
++#line 212 "ease-welcome-window.vala"
++ if (!gee_iterator_next (_theme_it)) {
++#line 212 "ease-welcome-window.vala"
++ break;
++#line 738 "ease-welcome-window.c"
++ }
++#line 212 "ease-welcome-window.vala"
++ theme = (EaseTheme*) gee_iterator_get (_theme_it);
++#line 215 "ease-welcome-window.vala"
++ act = g_object_ref_sink (ease_welcome_actor_new (theme));
++#line 216 "ease-welcome-window.vala"
++ gee_abstract_collection_add ((GeeAbstractCollection*) self->priv->previews, act);
++#line 217 "ease-welcome-window.vala"
++ clutter_container_add_actor ((ClutterContainer*) self->priv->preview_container, (ClutterActor*) act);
++#line 220 "ease-welcome-window.vala"
++ g_signal_connect_object (act, "selected", (GCallback) __lambda85__ease_welcome_actor_selected, self, 0);
++#line 232 "ease-welcome-window.vala"
++ g_signal_connect_object (act, "double-click", (GCallback) __lambda86__ease_welcome_actor_double_click, self, 0);
++#line 752 "ease-welcome-window.c"
++ _g_object_unref0 (act);
++ _g_object_unref0 (theme);
++ }
++ _g_object_unref0 (_theme_it);
++ }
++#line 238 "ease-welcome-window.vala"
++ clutter_container_add_actor ((ClutterContainer*) ease_scrollable_embed_get_contents (self->priv->embed), (ClutterActor*) self->priv->preview_container);
++#line 239 "ease-welcome-window.vala"
++ clutter_actor_show_all ((ClutterActor*) ease_scrollable_embed_get_contents (self->priv->embed));
++#line 240 "ease-welcome-window.vala"
++ gtk_box_pack_start ((GtkBox*) vbox, (GtkWidget*) self->priv->embed, TRUE, TRUE, (guint) 0);
++#line 241 "ease-welcome-window.vala"
++ gtk_box_reorder_child ((GtkBox*) vbox, (GtkWidget*) self->priv->embed, 0);
++#line 243 "ease-welcome-window.vala"
++ gtk_builder_connect_signals (builder, self);
++#line 244 "ease-welcome-window.vala"
++ gtk_container_add ((GtkContainer*) self, (GtkWidget*) vbox);
++#line 245 "ease-welcome-window.vala"
++ gtk_widget_show_all ((GtkWidget*) self);
++#line 249 "ease-welcome-window.vala"
++ g_signal_connect_object ((GtkWidget*) self->priv->embed, "size-allocate", (GCallback) __lambda87__gtk_widget_size_allocate, self, 0);
++#line 255 "ease-welcome-window.vala"
++ g_signal_connect_object (self->priv->zoom_slider, "value-changed", (GCallback) __lambda88__ease_zoom_slider_value_changed, self, 0);
++#line 261 "ease-welcome-window.vala"
++ gtk_combo_box_set_active (self->priv->combores, EASE_WELCOME_WINDOW_DEFAULT_ACTIVE + 1);
++#line 262 "ease-welcome-window.vala"
++ self->priv->preview_width = (gint) ease_zoom_slider_get_value (self->priv->zoom_slider);
++#line 265 "ease-welcome-window.vala"
++ self->priv->preview_row_count = -1;
++#line 266 "ease-welcome-window.vala"
++ ease_welcome_window_reflow_previews (self);
++#line 784 "ease-welcome-window.c"
++ _g_object_unref0 (builder);
++ _g_object_unref0 (vbox);
++ _g_object_unref0 (hbox);
++ return self;
++}
++
++
++#line 86 "ease-welcome-window.vala"
++EaseWelcomeWindow* ease_welcome_window_new (void) {
++#line 86 "ease-welcome-window.vala"
++ return ease_welcome_window_construct (EASE_TYPE_WELCOME_WINDOW);
++#line 796 "ease-welcome-window.c"
++}
++
++
++#line 270 "ease-welcome-window.vala"
++void ease_welcome_window_on_open_pres_button_clicked (GtkWidget* sender, EaseWelcomeWindow* self) {
++#line 270 "ease-welcome-window.vala"
++ g_return_if_fail (self != NULL);
++#line 270 "ease-welcome-window.vala"
++ g_return_if_fail (sender != NULL);
++#line 272 "ease-welcome-window.vala"
++ ease_open_dialog_run ();
++#line 808 "ease-welcome-window.c"
++}
++
++
++#line 276 "ease-welcome-window.vala"
++void ease_welcome_window_create_new_document (GtkWidget* sender, EaseWelcomeWindow* self) {
++#line 814 "ease-welcome-window.c"
++ GError * _inner_error_;
++#line 276 "ease-welcome-window.vala"
++ g_return_if_fail (self != NULL);
++#line 818 "ease-welcome-window.c"
++ _inner_error_ = NULL;
++ {
++ EaseDocument* document;
++ EaseEditorWindow* editor;
++#line 284 "ease-welcome-window.vala"
++ document = ease_document_new_from_theme (self->priv->selected_theme, (gint) gtk_spin_button_get_value (self->priv->x_res), (gint) gtk_spin_button_get_value (self->priv->y_res), &_inner_error_);
++#line 825 "ease-welcome-window.c"
++ if (_inner_error_ != NULL) {
++ goto __catch29_g_error;
++ }
++#line 288 "ease-welcome-window.vala"
++ editor = g_object_ref_sink (ease_editor_window_new (document));
++#line 290 "ease-welcome-window.vala"
++ ease_main_add_window (editor);
++#line 291 "ease-welcome-window.vala"
++ ease_main_remove_welcome ();
++#line 835 "ease-welcome-window.c"
++ _g_object_unref0 (editor);
++ _g_object_unref0 (document);
++ }
++ goto __finally29;
++ __catch29_g_error:
++ {
++ GError * e;
++ e = _inner_error_;
++ _inner_error_ = NULL;
++ {
++#line 295 "ease-welcome-window.vala"
++ ease_error_dialog (_ ("Error creating new document"), e->message);
++#line 848 "ease-welcome-window.c"
++ _g_error_free0 (e);
++ }
++ }
++ __finally29:
++ if (_inner_error_ != NULL) {
++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
++ g_clear_error (&_inner_error_);
++ return;
++ }
++}
++
++
++#line 299 "ease-welcome-window.vala"
++static void ease_welcome_window_set_resolution_box (EaseWelcomeWindow* self, gint width, gint height) {
++#line 299 "ease-welcome-window.vala"
++ g_return_if_fail (self != NULL);
++#line 865 "ease-welcome-window.c"
++ {
++ gint i;
++#line 301 "ease-welcome-window.vala"
++ i = 0;
++#line 870 "ease-welcome-window.c"
++ {
++ gboolean _tmp0_;
++#line 301 "ease-welcome-window.vala"
++ _tmp0_ = TRUE;
++#line 301 "ease-welcome-window.vala"
++ while (TRUE) {
++#line 877 "ease-welcome-window.c"
++ gboolean _tmp1_ = FALSE;
++#line 301 "ease-welcome-window.vala"
++ if (!_tmp0_) {
++#line 301 "ease-welcome-window.vala"
++ i++;
++#line 883 "ease-welcome-window.c"
++ }
++#line 301 "ease-welcome-window.vala"
++ _tmp0_ = FALSE;
++#line 301 "ease-welcome-window.vala"
++ if (!(i < G_N_ELEMENTS (EASE_WELCOME_WINDOW_RESOLUTIONS_X))) {
++#line 301 "ease-welcome-window.vala"
++ break;
++#line 891 "ease-welcome-window.c"
++ }
++#line 303 "ease-welcome-window.vala"
++ if (width == EASE_WELCOME_WINDOW_RESOLUTIONS_X[i]) {
++#line 303 "ease-welcome-window.vala"
++ _tmp1_ = height == EASE_WELCOME_WINDOW_RESOLUTIONS_Y[i];
++#line 897 "ease-welcome-window.c"
++ } else {
++#line 303 "ease-welcome-window.vala"
++ _tmp1_ = FALSE;
++#line 901 "ease-welcome-window.c"
++ }
++#line 303 "ease-welcome-window.vala"
++ if (_tmp1_) {
++#line 305 "ease-welcome-window.vala"
++ gtk_combo_box_set_active (self->priv->combores, i + 1);
++#line 306 "ease-welcome-window.vala"
++ return;
++#line 909 "ease-welcome-window.c"
++ }
++ }
++ }
++ }
++#line 309 "ease-welcome-window.vala"
++ gtk_combo_box_set_active (self->priv->combores, 0);
++#line 310 "ease-welcome-window.vala"
++ ease_welcome_window_reflow_previews (self);
++#line 918 "ease-welcome-window.c"
++}
++
++
++#line 346 "ease-welcome-window.vala"
++static void _lambda82_ (EaseWelcomeWindow* self) {
++#line 924 "ease-welcome-window.c"
++ GeeArrayList* _tmp0_;
++ GeeArrayList* _tmp1_;
++#line 347 "ease-welcome-window.vala"
++ self->priv->animate_resize = FALSE;
++#line 348 "ease-welcome-window.vala"
++ self->priv->x_anims = (_tmp0_ = NULL, _g_object_unref0 (self->priv->x_anims), _tmp0_);
++#line 349 "ease-welcome-window.vala"
++ self->priv->y_anims = (_tmp1_ = NULL, _g_object_unref0 (self->priv->y_anims), _tmp1_);
++#line 933 "ease-welcome-window.c"
++}
++
++
++#line 346 "ease-welcome-window.vala"
++static void __lambda82__clutter_timeline_completed (ClutterTimeline* _sender, gpointer self) {
++#line 939 "ease-welcome-window.c"
++ _lambda82_ (self);
++}
++
++
++#line 313 "ease-welcome-window.vala"
++static void ease_welcome_window_reflow_previews (EaseWelcomeWindow* self) {
++#line 946 "ease-welcome-window.c"
++ gint per_line;
++ float x_origin;
++ float y_pixels;
++ gint x_position;
++ float _tmp13_ = 0.0F;
++#line 313 "ease-welcome-window.vala"
++ g_return_if_fail (self != NULL);
++#line 316 "ease-welcome-window.vala"
++ self->priv->preview_aspect = (float) (gtk_spin_button_get_value (self->priv->y_res) / gtk_spin_button_get_value (self->priv->x_res));
++#line 319 "ease-welcome-window.vala"
++ per_line = 2;
++#line 958 "ease-welcome-window.c"
++ {
++ gboolean _tmp0_;
++#line 320 "ease-welcome-window.vala"
++ _tmp0_ = TRUE;
++#line 320 "ease-welcome-window.vala"
++ while (TRUE) {
++#line 320 "ease-welcome-window.vala"
++ if (!_tmp0_) {
++#line 322 "ease-welcome-window.vala"
++ per_line++;
++#line 969 "ease-welcome-window.c"
++ }
++#line 320 "ease-welcome-window.vala"
++ _tmp0_ = FALSE;
++#line 320 "ease-welcome-window.vala"
++ if (!(((per_line * (self->priv->preview_width + EASE_WELCOME_WINDOW_PREVIEW_PADDING)) + EASE_WELCOME_WINDOW_PREVIEW_PADDING) < ease_scrollable_embed_get_width (self->priv->embed))) {
++#line 320 "ease-welcome-window.vala"
++ break;
++#line 977 "ease-welcome-window.c"
++ }
++ ;
++ }
++ }
++#line 323 "ease-welcome-window.vala"
++ per_line--;
++#line 326 "ease-welcome-window.vala"
++ if (self->priv->preview_row_count == (-1)) {
++#line 328 "ease-welcome-window.vala"
++ self->priv->preview_row_count = per_line;
++#line 988 "ease-welcome-window.c"
++ }
++#line 332 "ease-welcome-window.vala"
++ if (self->priv->preview_row_count != per_line) {
++#line 992 "ease-welcome-window.c"
++ GeeArrayList* _tmp1_;
++ GeeArrayList* _tmp2_;
++ ClutterTimeline* _tmp3_;
++#line 334 "ease-welcome-window.vala"
++ self->priv->preview_row_count = per_line;
++#line 335 "ease-welcome-window.vala"
++ self->priv->animate_resize = TRUE;
++#line 337 "ease-welcome-window.vala"
++ if (self->priv->animate_alarm != NULL) {
++#line 338 "ease-welcome-window.vala"
++ clutter_timeline_stop (self->priv->animate_alarm);
++#line 1004 "ease-welcome-window.c"
++ }
++#line 341 "ease-welcome-window.vala"
++ self->priv->x_anims = (_tmp1_ = gee_array_list_new (CLUTTER_TYPE_ANIMATION, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL), _g_object_unref0 (self->priv->x_anims), _tmp1_);
++#line 342 "ease-welcome-window.vala"
++ self->priv->y_anims = (_tmp2_ = gee_array_list_new (CLUTTER_TYPE_ANIMATION, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL), _g_object_unref0 (self->priv->y_anims), _tmp2_);
++#line 344 "ease-welcome-window.vala"
++ self->priv->animate_alarm = (_tmp3_ = clutter_timeline_new ((guint) EASE_WELCOME_WINDOW_ANIM_TIME), _g_object_unref0 (self->priv->animate_alarm), _tmp3_);
++#line 345 "ease-welcome-window.vala"
++ clutter_timeline_start (self->priv->animate_alarm);
++#line 346 "ease-welcome-window.vala"
++ g_signal_connect_object (self->priv->animate_alarm, "completed", (GCallback) __lambda82__clutter_timeline_completed, self, 0);
++#line 1016 "ease-welcome-window.c"
++ }
++#line 354 "ease-welcome-window.vala"
++ x_origin = (ease_scrollable_embed_get_width (self->priv->embed) / 2) - (((self->priv->preview_width * per_line) + (EASE_WELCOME_WINDOW_PREVIEW_PADDING * (per_line - 1))) / 2);
++#line 358 "ease-welcome-window.vala"
++ y_pixels = (float) EASE_WELCOME_WINDOW_PREVIEW_PADDING;
++#line 361 "ease-welcome-window.vala"
++ x_position = 0;
++#line 1024 "ease-welcome-window.c"
++ {
++ gint i;
++#line 364 "ease-welcome-window.vala"
++ i = 0;
++#line 1029 "ease-welcome-window.c"
++ {
++ gboolean _tmp4_;
++#line 364 "ease-welcome-window.vala"
++ _tmp4_ = TRUE;
++#line 364 "ease-welcome-window.vala"
++ while (TRUE) {
++#line 1036 "ease-welcome-window.c"
++ EaseWelcomeActor* a;
++ float x_pixels;
++ float x_round;
++ float y_round;
++#line 364 "ease-welcome-window.vala"
++ if (!_tmp4_) {
++#line 364 "ease-welcome-window.vala"
++ i++;
++#line 1045 "ease-welcome-window.c"
++ }
++#line 364 "ease-welcome-window.vala"
++ _tmp4_ = FALSE;
++#line 364 "ease-welcome-window.vala"
++ if (!(i < gee_collection_get_size ((GeeCollection*) self->priv->previews))) {
++#line 364 "ease-welcome-window.vala"
++ break;
++#line 1053 "ease-welcome-window.c"
++ }
++#line 367 "ease-welcome-window.vala"
++ a = (EaseWelcomeActor*) gee_abstract_list_get ((GeeAbstractList*) self->priv->previews, i);
++#line 369 "ease-welcome-window.vala"
++ if (a == NULL) {
++#line 1059 "ease-welcome-window.c"
++ _g_object_unref0 (a);
++#line 371 "ease-welcome-window.vala"
++ continue;
++#line 1063 "ease-welcome-window.c"
++ }
++#line 375 "ease-welcome-window.vala"
++ x_pixels = x_origin + (x_position * (EASE_WELCOME_WINDOW_PREVIEW_PADDING + self->priv->preview_width));
++#line 378 "ease-welcome-window.vala"
++ x_round = (float) ease_roundd ((double) x_pixels);
++#line 379 "ease-welcome-window.vala"
++ y_round = (float) ease_roundd ((double) y_pixels);
++#line 381 "ease-welcome-window.vala"
++ if (self->priv->animate_resize) {
++#line 384 "ease-welcome-window.vala"
++ if (gee_collection_get_size ((GeeCollection*) self->priv->x_anims) == i) {
++#line 386 "ease-welcome-window.vala"
++ gee_abstract_collection_add ((GeeAbstractCollection*) self->priv->x_anims, clutter_actor_animate ((ClutterActor*) a, (gulong) EASE_WELCOME_WINDOW_ANIM_EASE, (guint) EASE_WELCOME_WINDOW_ANIM_TIME, "x", x_round, NULL));
++#line 387 "ease-welcome-window.vala"
++ gee_abstract_collection_add ((GeeAbstractCollection*) self->priv->y_anims, clutter_actor_animate ((ClutterActor*) a, (gulong) EASE_WELCOME_WINDOW_ANIM_EASE, (guint) EASE_WELCOME_WINDOW_ANIM_TIME, "y", y_round, NULL));
++#line 1079 "ease-welcome-window.c"
++ } else {
++ ClutterAnimation* _tmp5_;
++ ClutterAnimation* _tmp6_;
++ GValue _tmp9_;
++ GValue _tmp8_ = {0};
++ ClutterAnimation* _tmp7_;
++ GValue _tmp12_;
++ GValue _tmp11_ = {0};
++ ClutterAnimation* _tmp10_;
++#line 393 "ease-welcome-window.vala"
++ clutter_animation_unbind_property (_tmp5_ = (ClutterAnimation*) gee_abstract_list_get ((GeeAbstractList*) self->priv->x_anims, i), "x");
++#line 1091 "ease-welcome-window.c"
++ _g_object_unref0 (_tmp5_);
++#line 394 "ease-welcome-window.vala"
++ clutter_animation_unbind_property (_tmp6_ = (ClutterAnimation*) gee_abstract_list_get ((GeeAbstractList*) self->priv->y_anims, i), "y");
++#line 1095 "ease-welcome-window.c"
++ _g_object_unref0 (_tmp6_);
++#line 396 "ease-welcome-window.vala"
++ clutter_animation_bind (_tmp7_ = (ClutterAnimation*) gee_abstract_list_get ((GeeAbstractList*) self->priv->x_anims, i), "x", (_tmp9_ = (g_value_init (&_tmp8_, G_TYPE_FLOAT), g_value_set_float (&_tmp8_, x_round), _tmp8_), &_tmp9_));
++#line 1099 "ease-welcome-window.c"
++ _g_object_unref0 (_tmp7_);
++#line 397 "ease-welcome-window.vala"
++ clutter_animation_bind (_tmp10_ = (ClutterAnimation*) gee_abstract_list_get ((GeeAbstractList*) self->priv->y_anims, i), "y", (_tmp12_ = (g_value_init (&_tmp11_, G_TYPE_FLOAT), g_value_set_float (&_tmp11_, y_round), _tmp11_), &_tmp12_));
++#line 1103 "ease-welcome-window.c"
++ _g_object_unref0 (_tmp10_);
++ }
++ } else {
++#line 403 "ease-welcome-window.vala"
++ clutter_actor_set_x ((ClutterActor*) a, x_pixels);
++#line 404 "ease-welcome-window.vala"
++ clutter_actor_set_y ((ClutterActor*) a, y_pixels);
++#line 1111 "ease-welcome-window.c"
++ }
++#line 408 "ease-welcome-window.vala"
++ ease_welcome_actor_set_actor_size (a, (float) self->priv->preview_width, self->priv->preview_width * self->priv->preview_aspect);
++#line 411 "ease-welcome-window.vala"
++ if ((x_position = x_position + 1) >= per_line) {
++#line 413 "ease-welcome-window.vala"
++ x_position = 0;
++#line 414 "ease-welcome-window.vala"
++ y_pixels = y_pixels + (EASE_WELCOME_WINDOW_PREVIEW_VERT_PADDING + (self->priv->preview_width * self->priv->preview_aspect));
++#line 1121 "ease-welcome-window.c"
++ }
++ _g_object_unref0 (a);
++ }
++ }
++ }
++#line 419 "ease-welcome-window.vala"
++ clutter_actor_set_width ((ClutterActor*) self->priv->preview_background, ease_scrollable_embed_get_width (self->priv->embed));
++#line 420 "ease-welcome-window.vala"
++ if (x_position != 0) {
++#line 421 "ease-welcome-window.vala"
++ _tmp13_ = (y_pixels + (self->priv->preview_width * self->priv->preview_aspect)) + EASE_WELCOME_WINDOW_PREVIEW_VERT_PADDING;
++#line 1133 "ease-welcome-window.c"
++ } else {
++#line 423 "ease-welcome-window.vala"
++ _tmp13_ = y_pixels + EASE_WELCOME_WINDOW_PREVIEW_VERT_PADDING;
++#line 1137 "ease-welcome-window.c"
++ }
++#line 420 "ease-welcome-window.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->preview_background, _tmp13_);
++#line 426 "ease-welcome-window.vala"
++ if (clutter_actor_get_height ((ClutterActor*) self->priv->preview_background) < ease_scrollable_embed_get_height (self->priv->embed)) {
++#line 428 "ease-welcome-window.vala"
++ clutter_actor_set_height ((ClutterActor*) self->priv->preview_background, ease_scrollable_embed_get_height (self->priv->embed));
++#line 1145 "ease-welcome-window.c"
++ }
++}
++
++
++static void ease_welcome_window_class_init (EaseWelcomeWindowClass * klass) {
++ ease_welcome_window_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseWelcomeWindowPrivate));
++ G_OBJECT_CLASS (klass)->finalize = ease_welcome_window_finalize;
++}
++
++
++static void ease_welcome_window_instance_init (EaseWelcomeWindow * self) {
++ gint* _tmp0_ = NULL;
++ self->priv = EASE_WELCOME_WINDOW_GET_PRIVATE (self);
++ self->priv->themes = gee_array_list_new (EASE_TYPE_THEME, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
++ self->priv->previews = gee_array_list_new (EASE_TYPE_WELCOME_ACTOR, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL);
++ self->priv->preview_row_count = -1;
++ self->priv->animate_resize = FALSE;
++ self->priv->ZOOM_VALUES = (_tmp0_ = g_new0 (gint, 5), _tmp0_[0] = 100, _tmp0_[1] = 150, _tmp0_[2] = 200, _tmp0_[3] = 250, _tmp0_[4] = 400, _tmp0_);
++ self->priv->ZOOM_VALUES_length1 = 5;
++ self->priv->_ZOOM_VALUES_size_ = self->priv->ZOOM_VALUES_length1;
++}
++
++
++static void ease_welcome_window_finalize (GObject* obj) {
++ EaseWelcomeWindow * self;
++ self = EASE_WELCOME_WINDOW (obj);
++ _g_object_unref0 (self->priv->new_pres_button);
++ _g_object_unref0 (self->priv->open_pres_button);
++ _g_object_unref0 (self->priv->combores);
++ _g_object_unref0 (self->priv->x_res);
++ _g_object_unref0 (self->priv->y_res);
++ _g_object_unref0 (self->priv->themes);
++ _g_object_unref0 (self->priv->selected_theme);
++ _g_object_unref0 (self->priv->embed);
++ _g_object_unref0 (self->priv->preview_container);
++ _g_object_unref0 (self->priv->preview_background);
++ _g_object_unref0 (self->priv->previews);
++ _g_object_unref0 (self->priv->animate_alarm);
++ _g_object_unref0 (self->priv->x_anims);
++ _g_object_unref0 (self->priv->y_anims);
++ _g_object_unref0 (self->priv->zoom_slider);
++ self->priv->ZOOM_VALUES = (g_free (self->priv->ZOOM_VALUES), NULL);
++ G_OBJECT_CLASS (ease_welcome_window_parent_class)->finalize (obj);
++}
++
++
++GType ease_welcome_window_get_type (void) {
++ static volatile gsize ease_welcome_window_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_welcome_window_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseWelcomeWindowClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_welcome_window_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseWelcomeWindow), 0, (GInstanceInitFunc) ease_welcome_window_instance_init, NULL };
++ GType ease_welcome_window_type_id;
++ ease_welcome_window_type_id = g_type_register_static (GTK_TYPE_WINDOW, "EaseWelcomeWindow", &g_define_type_info, 0);
++ g_once_init_leave (&ease_welcome_window_type_id__volatile, ease_welcome_window_type_id);
++ }
++ return ease_welcome_window_type_id__volatile;
++}
++
++
++static gint _vala_array_length (gpointer array) {
++ int length;
++ length = 0;
++ if (array) {
++ while (((gpointer*) array)[length]) {
++ length++;
++ }
++ }
++ return length;
++}
++
++
++
++
diff --cc ease-core/ease-zoom-slider.c
index 0000000,0000000..4e109bb
new file mode 100644
--- /dev/null
+++ b/ease-core/ease-zoom-slider.c
@@@ -1,0 -1,0 +1,588 @@@
++/* ease-zoom-slider.c generated by valac, the Vala compiler
++ * generated from ease-zoom-slider.vala, do not modify */
++
++/* Ease, a GTK presentation application
++ Copyright (C) 2010 Nate Stedman
++
++ 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 <glib.h>
++#include <glib-object.h>
++#include <gtk/gtk.h>
++#include <float.h>
++#include <math.h>
++#include <stdlib.h>
++#include <string.h>
++
++
++#define EASE_TYPE_ZOOM_SLIDER (ease_zoom_slider_get_type ())
++#define EASE_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EASE_TYPE_ZOOM_SLIDER, EaseZoomSlider))
++#define EASE_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EASE_TYPE_ZOOM_SLIDER, EaseZoomSliderClass))
++#define EASE_IS_ZOOM_SLIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EASE_TYPE_ZOOM_SLIDER))
++#define EASE_IS_ZOOM_SLIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EASE_TYPE_ZOOM_SLIDER))
++#define EASE_ZOOM_SLIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EASE_TYPE_ZOOM_SLIDER, EaseZoomSliderClass))
++
++typedef struct _EaseZoomSlider EaseZoomSlider;
++typedef struct _EaseZoomSliderClass EaseZoomSliderClass;
++typedef struct _EaseZoomSliderPrivate EaseZoomSliderPrivate;
++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
++
++struct _EaseZoomSlider {
++ GtkAlignment parent_instance;
++ EaseZoomSliderPrivate * priv;
++};
++
++struct _EaseZoomSliderClass {
++ GtkAlignmentClass parent_class;
++ void (*change_zoom) (EaseZoomSlider* self, double value);
++};
++
++struct _EaseZoomSliderPrivate {
++ GtkHScale* zoom_slider;
++ GtkButton* zoom_in_button;
++ GtkButton* zoom_out_button;
++ gint* values;
++ gint values_length1;
++ gint _values_size_;
++ gboolean buttons_shown_priv;
++};
++
++
++static gpointer ease_zoom_slider_parent_class = NULL;
++
++GType ease_zoom_slider_get_type (void) G_GNUC_CONST;
++#define EASE_ZOOM_SLIDER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), EASE_TYPE_ZOOM_SLIDER, EaseZoomSliderPrivate))
++enum {
++ EASE_ZOOM_SLIDER_DUMMY_PROPERTY,
++ EASE_ZOOM_SLIDER_VALUE_POS,
++ EASE_ZOOM_SLIDER_DIGITS,
++ EASE_ZOOM_SLIDER_SLIDERPOS,
++ EASE_ZOOM_SLIDER_BUTTONS_SHOWN
++};
++static gint* _vala_array_dup2 (gint* self, int length);
++static void _lambda69_ (EaseZoomSlider* self);
++static void __lambda69__gtk_range_value_changed (GtkRange* _sender, gpointer self);
++void ease_zoom_slider_zoom_in (EaseZoomSlider* self);
++static void _lambda70_ (EaseZoomSlider* self);
++static void __lambda70__gtk_button_clicked (GtkButton* _sender, gpointer self);
++void ease_zoom_slider_zoom_out (EaseZoomSlider* self);
++static void _lambda71_ (EaseZoomSlider* self);
++static void __lambda71__gtk_button_clicked (GtkButton* _sender, gpointer self);
++static void ease_zoom_slider_buttons_show_handler (EaseZoomSlider* self, GtkWidget* sender);
++static void _ease_zoom_slider_buttons_show_handler_gtk_widget_show (GtkWidget* _sender, gpointer self);
++static char* _lambda72_ (double val, EaseZoomSlider* self);
++static char* __lambda72__gtk_scale_format_value (GtkScale* _sender, double value, gpointer self);
++EaseZoomSlider* ease_zoom_slider_new (GtkAdjustment* adjustment, gint* button_values, int button_values_length1);
++EaseZoomSlider* ease_zoom_slider_construct (GType object_type, GtkAdjustment* adjustment, gint* button_values, int button_values_length1);
++double ease_zoom_slider_get_value (EaseZoomSlider* self);
++void ease_zoom_slider_change_zoom (EaseZoomSlider* self, double value);
++void ease_zoom_slider_set_sliderpos (EaseZoomSlider* self, double value);
++static void ease_zoom_slider_real_change_zoom (EaseZoomSlider* self, double value);
++GtkPositionType ease_zoom_slider_get_value_pos (EaseZoomSlider* self);
++void ease_zoom_slider_set_value_pos (EaseZoomSlider* self, GtkPositionType value);
++gint ease_zoom_slider_get_digits (EaseZoomSlider* self);
++void ease_zoom_slider_set_digits (EaseZoomSlider* self, gint value);
++double ease_zoom_slider_get_sliderpos (EaseZoomSlider* self);
++gboolean ease_zoom_slider_get_buttons_shown (EaseZoomSlider* self);
++void ease_zoom_slider_set_buttons_shown (EaseZoomSlider* self, gboolean value);
++static void ease_zoom_slider_finalize (GObject* obj);
++static void ease_zoom_slider_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
++static void ease_zoom_slider_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
++
++
++
++static gint* _vala_array_dup2 (gint* self, int length) {
++ return g_memdup (self, length * sizeof (gint));
++}
++
++
++#line 126 "ease-zoom-slider.vala"
++static void _lambda69_ (EaseZoomSlider* self) {
++#line 126 "ease-zoom-slider.vala"
++ g_signal_emit_by_name (self, "value-changed");
++#line 116 "ease-zoom-slider.c"
++}
++
++
++#line 126 "ease-zoom-slider.vala"
++static void __lambda69__gtk_range_value_changed (GtkRange* _sender, gpointer self) {
++#line 122 "ease-zoom-slider.c"
++ _lambda69_ (self);
++}
++
++
++#line 128 "ease-zoom-slider.vala"
++static void _lambda70_ (EaseZoomSlider* self) {
++#line 128 "ease-zoom-slider.vala"
++ ease_zoom_slider_zoom_in (self);
++#line 131 "ease-zoom-slider.c"
++}
++
++
++#line 128 "ease-zoom-slider.vala"
++static void __lambda70__gtk_button_clicked (GtkButton* _sender, gpointer self) {
++#line 137 "ease-zoom-slider.c"
++ _lambda70_ (self);
++}
++
++
++#line 130 "ease-zoom-slider.vala"
++static void _lambda71_ (EaseZoomSlider* self) {
++#line 130 "ease-zoom-slider.vala"
++ ease_zoom_slider_zoom_out (self);
++#line 146 "ease-zoom-slider.c"
++}
++
++
++#line 130 "ease-zoom-slider.vala"
++static void __lambda71__gtk_button_clicked (GtkButton* _sender, gpointer self) {
++#line 152 "ease-zoom-slider.c"
++ _lambda71_ (self);
++}
++
++
++#line 140 "ease-zoom-slider.vala"
++static void _ease_zoom_slider_buttons_show_handler_gtk_widget_show (GtkWidget* _sender, gpointer self) {
++#line 159 "ease-zoom-slider.c"
++ ease_zoom_slider_buttons_show_handler (self, _sender);
++}
++
++
++#line 135 "ease-zoom-slider.vala"
++static char* _lambda72_ (double val, EaseZoomSlider* self) {
++#line 166 "ease-zoom-slider.c"
++ char* result = NULL;
++ result = g_strdup_printf ("%i%%", (gint) val);
++#line 136 "ease-zoom-slider.vala"
++ return result;
++#line 171 "ease-zoom-slider.c"
++}
++
++
++#line 135 "ease-zoom-slider.vala"
++static char* __lambda72__gtk_scale_format_value (GtkScale* _sender, double value, gpointer self) {
++#line 177 "ease-zoom-slider.c"
++ char* result;
++ result = _lambda72_ (value, self);
++ return result;
++}
++
++
++#line 86 "ease-zoom-slider.vala"
++EaseZoomSlider* ease_zoom_slider_construct (GType object_type, GtkAdjustment* adjustment, gint* button_values, int button_values_length1) {
++#line 186 "ease-zoom-slider.c"
++ EaseZoomSlider * self;
++ gint* _tmp1_;
++ gint* _tmp0_;
++ GtkHBox* hbox;
++ GtkHScale* _tmp2_;
++ GtkButton* _tmp3_;
++ GtkImage* _tmp4_;
++ GtkButton* _tmp5_;
++ GtkImage* _tmp6_;
++ GtkAlignment* align;
++ GtkAlignment* _tmp7_;
++ GtkAlignment* _tmp8_;
++#line 86 "ease-zoom-slider.vala"
++ g_return_val_if_fail (adjustment != NULL, NULL);
++#line 201 "ease-zoom-slider.c"
++ self = g_object_newv (object_type, 0, NULL);
++#line 88 "ease-zoom-slider.vala"
++ self->priv->values = (_tmp1_ = (_tmp0_ = button_values, (_tmp0_ == NULL) ? ((gpointer) _tmp0_) : _vala_array_dup2 (_tmp0_, button_values_length1)), self->priv->values = (g_free (self->priv->values), NULL), self->priv->values_length1 = button_values_length1, self->priv->_values_size_ = self->priv->values_length1, _tmp1_);
++#line 90 "ease-zoom-slider.vala"
++ hbox = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 5));
++#line 93 "ease-zoom-slider.vala"
++ self->priv->zoom_slider = (_tmp2_ = g_object_ref_sink ((GtkHScale*) gtk_hscale_new (adjustment)), _g_object_unref0 (self->priv->zoom_slider), _tmp2_);
++#line 94 "ease-zoom-slider.vala"
++ g_object_set ((GtkWidget*) self->priv->zoom_slider, "width-request", 200, NULL);
++#line 95 "ease-zoom-slider.vala"
++ gtk_scale_set_draw_value ((GtkScale*) self->priv->zoom_slider, FALSE);
++#line 96 "ease-zoom-slider.vala"
++ gtk_scale_set_digits ((GtkScale*) self->priv->zoom_slider, 0);
++#line 99 "ease-zoom-slider.vala"
++ self->priv->zoom_in_button = (_tmp3_ = g_object_ref_sink ((GtkButton*) gtk_button_new ()), _g_object_unref0 (self->priv->zoom_in_button), _tmp3_);
++#line 100 "ease-zoom-slider.vala"
++ gtk_container_add ((GtkContainer*) self->priv->zoom_in_button, (GtkWidget*) (_tmp4_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_stock ("gtk-zoom-in", GTK_ICON_SIZE_MENU))));
++#line 219 "ease-zoom-slider.c"
++ _g_object_unref0 (_tmp4_);
++#line 102 "ease-zoom-slider.vala"
++ gtk_button_set_relief (self->priv->zoom_in_button, GTK_RELIEF_NONE);
++#line 105 "ease-zoom-slider.vala"
++ self->priv->zoom_out_button = (_tmp5_ = g_object_ref_sink ((GtkButton*) gtk_button_new ()), _g_object_unref0 (self->priv->zoom_out_button), _tmp5_);
++#line 106 "ease-zoom-slider.vala"
++ gtk_container_add ((GtkContainer*) self->priv->zoom_out_button, (GtkWidget*) (_tmp6_ = g_object_ref_sink ((GtkImage*) gtk_image_new_from_stock ("gtk-zoom-out", GTK_ICON_SIZE_MENU))));
++#line 227 "ease-zoom-slider.c"
++ _g_object_unref0 (_tmp6_);
++#line 108 "ease-zoom-slider.vala"
++ gtk_button_set_relief (self->priv->zoom_out_button, GTK_RELIEF_NONE);
++#line 111 "ease-zoom-slider.vala"
++ align = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, 0.5f, (float) 1, (float) 0));
++#line 112 "ease-zoom-slider.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) self->priv->zoom_out_button);
++#line 113 "ease-zoom-slider.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0);
++#line 115 "ease-zoom-slider.vala"
++ align = (_tmp7_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, 0.5f, (float) 1, (float) 0)), _g_object_unref0 (align), _tmp7_);
++#line 116 "ease-zoom-slider.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) self->priv->zoom_slider);
++#line 117 "ease-zoom-slider.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0);
++#line 119 "ease-zoom-slider.vala"
++ align = (_tmp8_ = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new ((float) 0, 0.5f, (float) 1, (float) 0)), _g_object_unref0 (align), _tmp8_);
++#line 120 "ease-zoom-slider.vala"
++ gtk_container_add ((GtkContainer*) align, (GtkWidget*) self->priv->zoom_in_button);
++#line 121 "ease-zoom-slider.vala"
++ gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0);
++#line 123 "ease-zoom-slider.vala"
++ gtk_alignment_set ((GtkAlignment*) self, (float) 1, (float) 1, (float) 1, (float) 1);
++#line 124 "ease-zoom-slider.vala"
++ gtk_container_add ((GtkContainer*) self, (GtkWidget*) hbox);
++#line 126 "ease-zoom-slider.vala"
++ g_signal_connect_object ((GtkRange*) self->priv->zoom_slider, "value-changed", (GCallback) __lambda69__gtk_range_value_changed, self, 0);
++#line 128 "ease-zoom-slider.vala"
++ g_signal_connect_object (self->priv->zoom_in_button, "clicked", (GCallback) __lambda70__gtk_button_clicked, self, 0);
++#line 130 "ease-zoom-slider.vala"
++ g_signal_connect_object (self->priv->zoom_out_button, "clicked", (GCallback) __lambda71__gtk_button_clicked, self, 0);
++#line 132 "ease-zoom-slider.vala"
++ g_signal_connect_object ((GtkWidget*) self->priv->zoom_in_button, "show", (GCallback) _ease_zoom_slider_buttons_show_handler_gtk_widget_show, self, 0);
++#line 133 "ease-zoom-slider.vala"
++ g_signal_connect_object ((GtkWidget*) self->priv->zoom_out_button, "show", (GCallback) _ease_zoom_slider_buttons_show_handler_gtk_widget_show, self, 0);
++#line 135 "ease-zoom-slider.vala"
++ g_signal_connect_object ((GtkScale*) self->priv->zoom_slider, "format-value", (GCallback) __lambda72__gtk_scale_format_value, self, 0);
++#line 265 "ease-zoom-slider.c"
++ _g_object_unref0 (hbox);
++ _g_object_unref0 (align);
++ return self;
++}
++
++
++#line 86 "ease-zoom-slider.vala"
++EaseZoomSlider* ease_zoom_slider_new (GtkAdjustment* adjustment, gint* button_values, int button_values_length1) {
++#line 86 "ease-zoom-slider.vala"
++ return ease_zoom_slider_construct (EASE_TYPE_ZOOM_SLIDER, adjustment, button_values, button_values_length1);
++#line 276 "ease-zoom-slider.c"
++}
++
++
++#line 140 "ease-zoom-slider.vala"
++static void ease_zoom_slider_buttons_show_handler (EaseZoomSlider* self, GtkWidget* sender) {
++#line 140 "ease-zoom-slider.vala"
++ g_return_if_fail (self != NULL);
++#line 140 "ease-zoom-slider.vala"
++ g_return_if_fail (sender != NULL);
++#line 142 "ease-zoom-slider.vala"
++ self->priv->buttons_shown_priv = TRUE;
++#line 288 "ease-zoom-slider.c"
++}
++
++
++#line 148 "ease-zoom-slider.vala"
++double ease_zoom_slider_get_value (EaseZoomSlider* self) {
++#line 294 "ease-zoom-slider.c"
++ double result = 0.0;
++#line 148 "ease-zoom-slider.vala"
++ g_return_val_if_fail (self != NULL, 0.0);
++#line 298 "ease-zoom-slider.c"
++ result = gtk_range_get_value ((GtkRange*) self->priv->zoom_slider);
++#line 150 "ease-zoom-slider.vala"
++ return result;
++#line 302 "ease-zoom-slider.c"
++}
++
++
++#line 153 "ease-zoom-slider.vala"
++void ease_zoom_slider_zoom_out (EaseZoomSlider* self) {
++#line 153 "ease-zoom-slider.vala"
++ g_return_if_fail (self != NULL);
++#line 310 "ease-zoom-slider.c"
++ {
++ gint i;
++#line 155 "ease-zoom-slider.vala"
++ i = self->priv->values_length1 - 1;
++#line 315 "ease-zoom-slider.c"
++ {
++ gboolean _tmp0_;
++#line 155 "ease-zoom-slider.vala"
++ _tmp0_ = TRUE;
++#line 155 "ease-zoom-slider.vala"
++ while (TRUE) {
++#line 155 "ease-zoom-slider.vala"
++ if (!_tmp0_) {
++#line 155 "ease-zoom-slider.vala"
++ i--;
++#line 326 "ease-zoom-slider.c"
++ }
++#line 155 "ease-zoom-slider.vala"
++ _tmp0_ = FALSE;
++#line 155 "ease-zoom-slider.vala"
++ if (!(i > (-1))) {
++#line 155 "ease-zoom-slider.vala"
++ break;
++#line 334 "ease-zoom-slider.c"
++ }
++#line 157 "ease-zoom-slider.vala"
++ if (gtk_range_get_value ((GtkRange*) self->priv->zoom_slider) > self->priv->values[i]) {
++#line 159 "ease-zoom-slider.vala"
++ ease_zoom_slider_change_zoom (self, (double) self->priv->values[i]);
++#line 160 "ease-zoom-slider.vala"
++ break;
++#line 342 "ease-zoom-slider.c"
++ }
++ }
++ }
++ }
++}
++
++
++#line 165 "ease-zoom-slider.vala"
++void ease_zoom_slider_zoom_in (EaseZoomSlider* self) {
++#line 165 "ease-zoom-slider.vala"
++ g_return_if_fail (self != NULL);
++#line 354 "ease-zoom-slider.c"
++ {
++ gint i;
++#line 167 "ease-zoom-slider.vala"
++ i = 0;
++#line 359 "ease-zoom-slider.c"
++ {
++ gboolean _tmp0_;
++#line 167 "ease-zoom-slider.vala"
++ _tmp0_ = TRUE;
++#line 167 "ease-zoom-slider.vala"
++ while (TRUE) {
++#line 167 "ease-zoom-slider.vala"
++ if (!_tmp0_) {
++#line 167 "ease-zoom-slider.vala"
++ i++;
++#line 370 "ease-zoom-slider.c"
++ }
++#line 167 "ease-zoom-slider.vala"
++ _tmp0_ = FALSE;
++#line 167 "ease-zoom-slider.vala"
++ if (!(i < self->priv->values_length1)) {
++#line 167 "ease-zoom-slider.vala"
++ break;
++#line 378 "ease-zoom-slider.c"
++ }
++#line 169 "ease-zoom-slider.vala"
++ if (gtk_range_get_value ((GtkRange*) self->priv->zoom_slider) < self->priv->values[i]) {
++#line 171 "ease-zoom-slider.vala"
++ ease_zoom_slider_change_zoom (self, (double) self->priv->values[i]);
++#line 172 "ease-zoom-slider.vala"
++ break;
++#line 386 "ease-zoom-slider.c"
++ }
++ }
++ }
++ }
++}
++
++
++#line 177 "ease-zoom-slider.vala"
++static void ease_zoom_slider_real_change_zoom (EaseZoomSlider* self, double value) {
++#line 177 "ease-zoom-slider.vala"
++ g_return_if_fail (self != NULL);
++#line 179 "ease-zoom-slider.vala"
++ ease_zoom_slider_set_sliderpos (self, value);
++#line 400 "ease-zoom-slider.c"
++}
++
++
++#line 177 "ease-zoom-slider.vala"
++void ease_zoom_slider_change_zoom (EaseZoomSlider* self, double value) {
++#line 177 "ease-zoom-slider.vala"
++ EASE_ZOOM_SLIDER_GET_CLASS (self)->change_zoom (self, value);
++#line 408 "ease-zoom-slider.c"
++}
++
++
++GtkPositionType ease_zoom_slider_get_value_pos (EaseZoomSlider* self) {
++ GtkPositionType result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = gtk_scale_get_value_pos ((GtkScale*) self->priv->zoom_slider);
++#line 36 "ease-zoom-slider.vala"
++ return result;
++#line 418 "ease-zoom-slider.c"
++}
++
++
++void ease_zoom_slider_set_value_pos (EaseZoomSlider* self, GtkPositionType value) {
++ g_return_if_fail (self != NULL);
++#line 37 "ease-zoom-slider.vala"
++ gtk_scale_set_value_pos ((GtkScale*) self->priv->zoom_slider, value);
++#line 426 "ease-zoom-slider.c"
++ g_object_notify ((GObject *) self, "value-pos");
++}
++
++
++gint ease_zoom_slider_get_digits (EaseZoomSlider* self) {
++ gint result;
++ g_return_val_if_fail (self != NULL, 0);
++ result = gtk_scale_get_digits ((GtkScale*) self->priv->zoom_slider);
++#line 45 "ease-zoom-slider.vala"
++ return result;
++#line 437 "ease-zoom-slider.c"
++}
++
++
++void ease_zoom_slider_set_digits (EaseZoomSlider* self, gint value) {
++ g_return_if_fail (self != NULL);
++#line 46 "ease-zoom-slider.vala"
++ gtk_scale_set_digits ((GtkScale*) self->priv->zoom_slider, value);
++#line 445 "ease-zoom-slider.c"
++ g_object_notify ((GObject *) self, "digits");
++}
++
++
++double ease_zoom_slider_get_sliderpos (EaseZoomSlider* self) {
++ double result;
++ g_return_val_if_fail (self != NULL, 0.0);
++ result = gtk_range_get_value ((GtkRange*) self->priv->zoom_slider);
++#line 54 "ease-zoom-slider.vala"
++ return result;
++#line 456 "ease-zoom-slider.c"
++}
++
++
++void ease_zoom_slider_set_sliderpos (EaseZoomSlider* self, double value) {
++ g_return_if_fail (self != NULL);
++#line 55 "ease-zoom-slider.vala"
++ gtk_range_set_value ((GtkRange*) self->priv->zoom_slider, value);
++#line 464 "ease-zoom-slider.c"
++ g_object_notify ((GObject *) self, "sliderpos");
++}
++
++
++gboolean ease_zoom_slider_get_buttons_shown (EaseZoomSlider* self) {
++ gboolean result;
++ g_return_val_if_fail (self != NULL, FALSE);
++ result = ease_zoom_slider_get_buttons_shown (self);
++#line 68 "ease-zoom-slider.vala"
++ return result;
++#line 475 "ease-zoom-slider.c"
++}
++
++
++void ease_zoom_slider_set_buttons_shown (EaseZoomSlider* self, gboolean value) {
++ g_return_if_fail (self != NULL);
++#line 71 "ease-zoom-slider.vala"
++ if (value == self->priv->buttons_shown_priv) {
++#line 71 "ease-zoom-slider.vala"
++ return;
++#line 485 "ease-zoom-slider.c"
++ }
++#line 73 "ease-zoom-slider.vala"
++ self->priv->buttons_shown_priv = value;
++#line 74 "ease-zoom-slider.vala"
++ gtk_widget_set_visible ((GtkWidget*) self->priv->zoom_in_button, value);
++#line 75 "ease-zoom-slider.vala"
++ gtk_widget_set_visible ((GtkWidget*) self->priv->zoom_out_button, value);
++#line 493 "ease-zoom-slider.c"
++ g_object_notify ((GObject *) self, "buttons-shown");
++}
++
++
++static void ease_zoom_slider_class_init (EaseZoomSliderClass * klass) {
++ ease_zoom_slider_parent_class = g_type_class_peek_parent (klass);
++ g_type_class_add_private (klass, sizeof (EaseZoomSliderPrivate));
++ EASE_ZOOM_SLIDER_CLASS (klass)->change_zoom = ease_zoom_slider_real_change_zoom;
++ G_OBJECT_CLASS (klass)->get_property = ease_zoom_slider_get_property;
++ G_OBJECT_CLASS (klass)->set_property = ease_zoom_slider_set_property;
++ G_OBJECT_CLASS (klass)->finalize = ease_zoom_slider_finalize;
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ZOOM_SLIDER_VALUE_POS, g_param_spec_enum ("value-pos", "value-pos", "value-pos", GTK_TYPE_POSITION_TYPE, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ZOOM_SLIDER_DIGITS, g_param_spec_int ("digits", "digits", "digits", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ZOOM_SLIDER_SLIDERPOS, g_param_spec_double ("sliderpos", "sliderpos", "sliderpos", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_object_class_install_property (G_OBJECT_CLASS (klass), EASE_ZOOM_SLIDER_BUTTONS_SHOWN, g_param_spec_boolean ("buttons-shown", "buttons-shown", "buttons-shown", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
++ g_signal_new ("value_changed", EASE_TYPE_ZOOM_SLIDER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
++}
++
++
++static void ease_zoom_slider_instance_init (EaseZoomSlider * self) {
++ self->priv = EASE_ZOOM_SLIDER_GET_PRIVATE (self);
++ self->priv->buttons_shown_priv = TRUE;
++}
++
++
++static void ease_zoom_slider_finalize (GObject* obj) {
++ EaseZoomSlider * self;
++ self = EASE_ZOOM_SLIDER (obj);
++ _g_object_unref0 (self->priv->zoom_slider);
++ _g_object_unref0 (self->priv->zoom_in_button);
++ _g_object_unref0 (self->priv->zoom_out_button);
++ self->priv->values = (g_free (self->priv->values), NULL);
++ G_OBJECT_CLASS (ease_zoom_slider_parent_class)->finalize (obj);
++}
++
++
++GType ease_zoom_slider_get_type (void) {
++ static volatile gsize ease_zoom_slider_type_id__volatile = 0;
++ if (g_once_init_enter (&ease_zoom_slider_type_id__volatile)) {
++ static const GTypeInfo g_define_type_info = { sizeof (EaseZoomSliderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ease_zoom_slider_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EaseZoomSlider), 0, (GInstanceInitFunc) ease_zoom_slider_instance_init, NULL };
++ GType ease_zoom_slider_type_id;
++ ease_zoom_slider_type_id = g_type_register_static (GTK_TYPE_ALIGNMENT, "EaseZoomSlider", &g_define_type_info, 0);
++ g_once_init_leave (&ease_zoom_slider_type_id__volatile, ease_zoom_slider_type_id);
++ }
++ return ease_zoom_slider_type_id__volatile;
++}
++
++
++static void ease_zoom_slider_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
++ EaseZoomSlider * self;
++ self = EASE_ZOOM_SLIDER (object);
++ switch (property_id) {
++ case EASE_ZOOM_SLIDER_VALUE_POS:
++ g_value_set_enum (value, ease_zoom_slider_get_value_pos (self));
++ break;
++ case EASE_ZOOM_SLIDER_DIGITS:
++ g_value_set_int (value, ease_zoom_slider_get_digits (self));
++ break;
++ case EASE_ZOOM_SLIDER_SLIDERPOS:
++ g_value_set_double (value, ease_zoom_slider_get_sliderpos (self));
++ break;
++ case EASE_ZOOM_SLIDER_BUTTONS_SHOWN:
++ g_value_set_boolean (value, ease_zoom_slider_get_buttons_shown (self));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++static void ease_zoom_slider_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
++ EaseZoomSlider * self;
++ self = EASE_ZOOM_SLIDER (object);
++ switch (property_id) {
++ case EASE_ZOOM_SLIDER_VALUE_POS:
++ ease_zoom_slider_set_value_pos (self, g_value_get_enum (value));
++ break;
++ case EASE_ZOOM_SLIDER_DIGITS:
++ ease_zoom_slider_set_digits (self, g_value_get_int (value));
++ break;
++ case EASE_ZOOM_SLIDER_SLIDERPOS:
++ ease_zoom_slider_set_sliderpos (self, g_value_get_double (value));
++ break;
++ case EASE_ZOOM_SLIDER_BUTTONS_SHOWN:
++ ease_zoom_slider_set_buttons_shown (self, g_value_get_boolean (value));
++ break;
++ default:
++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
++ break;
++ }
++}
++
++
++
++
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
