From a564e1a071c758849081a8ed7acbd4190f859ad0 Mon Sep 17 00:00:00 2001 From: Joaquin Date: Tue, 31 Oct 2023 15:22:25 +0200 Subject: [PATCH] [BACKUP] Add Progress Bar --- HeaderBar.c | 244 +++++++ Main.c | 59 ++ Nostalgia.c | 130 ++++ Window.c | 1965 ++++++++++++++++++++++++++++++++++++++++++++++++++ Window.vala | 130 +++- listbox | Bin 0 -> 21664 bytes listbox.vala | 53 ++ nostalgia | Bin 57720 -> 62680 bytes 8 files changed, 2573 insertions(+), 8 deletions(-) create mode 100644 HeaderBar.c create mode 100644 Main.c create mode 100644 Nostalgia.c create mode 100644 Window.c create mode 100755 listbox create mode 100644 listbox.vala diff --git a/HeaderBar.c b/HeaderBar.c new file mode 100644 index 0000000..a0bbb73 --- /dev/null +++ b/HeaderBar.c @@ -0,0 +1,244 @@ +/* HeaderBar.c generated by valac 0.56.13, the Vala compiler + * generated from HeaderBar.vala, do not modify */ + +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define MY_APP_TYPE_HEADER_BAR (my_app_header_bar_get_type ()) +#define MY_APP_HEADER_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_APP_TYPE_HEADER_BAR, MyAppHeaderBar)) +#define MY_APP_HEADER_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MY_APP_TYPE_HEADER_BAR, MyAppHeaderBarClass)) +#define MY_APP_IS_HEADER_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_APP_TYPE_HEADER_BAR)) +#define MY_APP_IS_HEADER_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MY_APP_TYPE_HEADER_BAR)) +#define MY_APP_HEADER_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MY_APP_TYPE_HEADER_BAR, MyAppHeaderBarClass)) + +typedef struct _MyAppHeaderBar MyAppHeaderBar; +typedef struct _MyAppHeaderBarClass MyAppHeaderBarClass; +typedef struct _MyAppHeaderBarPrivate MyAppHeaderBarPrivate; +enum { + MY_APP_HEADER_BAR_0_PROPERTY, + MY_APP_HEADER_BAR_WINDOW_STACK_PROPERTY, + MY_APP_HEADER_BAR_NUM_PROPERTIES +}; +static GParamSpec* my_app_header_bar_properties[MY_APP_HEADER_BAR_NUM_PROPERTIES]; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +struct _MyAppHeaderBar { + GtkHeaderBar parent_instance; + MyAppHeaderBarPrivate * priv; +}; + +struct _MyAppHeaderBarClass { + GtkHeaderBarClass parent_class; +}; + +struct _MyAppHeaderBarPrivate { + GtkStack* _window_stack; +}; + +static gint MyAppHeaderBar_private_offset; +static gpointer my_app_header_bar_parent_class = NULL; + +VALA_EXTERN GType my_app_header_bar_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (MyAppHeaderBar, g_object_unref) +VALA_EXTERN MyAppHeaderBar* my_app_header_bar_new (GtkStack* stack); +VALA_EXTERN MyAppHeaderBar* my_app_header_bar_construct (GType object_type, + GtkStack* stack); +VALA_EXTERN GtkStack* my_app_header_bar_get_window_stack (MyAppHeaderBar* self); +static void my_app_header_bar_set_window_stack (MyAppHeaderBar* self, + GtkStack* value); +static GObject * my_app_header_bar_constructor (GType type, + guint n_construct_properties, + GObjectConstructParam * construct_properties); +static void my_app_header_bar_finalize (GObject * obj); +static GType my_app_header_bar_get_type_once (void); +static void _vala_my_app_header_bar_get_property (GObject * object, + guint property_id, + GValue * value, + GParamSpec * pspec); +static void _vala_my_app_header_bar_set_property (GObject * object, + guint property_id, + const GValue * value, + GParamSpec * pspec); + +static inline gpointer +my_app_header_bar_get_instance_private (MyAppHeaderBar* self) +{ + return G_STRUCT_MEMBER_P (self, MyAppHeaderBar_private_offset); +} + +MyAppHeaderBar* +my_app_header_bar_construct (GType object_type, + GtkStack* stack) +{ + MyAppHeaderBar * self = NULL; + g_return_val_if_fail (stack != NULL, NULL); + self = (MyAppHeaderBar*) g_object_new (object_type, "window-stack", stack, NULL); + return self; +} + +MyAppHeaderBar* +my_app_header_bar_new (GtkStack* stack) +{ + return my_app_header_bar_construct (MY_APP_TYPE_HEADER_BAR, stack); +} + +GtkStack* +my_app_header_bar_get_window_stack (MyAppHeaderBar* self) +{ + GtkStack* result; + GtkStack* _tmp0_; + g_return_val_if_fail (self != NULL, NULL); + _tmp0_ = self->priv->_window_stack; + result = _tmp0_; + return result; +} + +static gpointer +_g_object_ref0 (gpointer self) +{ + return self ? g_object_ref (self) : NULL; +} + +static void +my_app_header_bar_set_window_stack (MyAppHeaderBar* self, + GtkStack* value) +{ + GtkStack* old_value; + g_return_if_fail (self != NULL); + old_value = my_app_header_bar_get_window_stack (self); + if (old_value != value) { + GtkStack* _tmp0_; + _tmp0_ = _g_object_ref0 (value); + _g_object_unref0 (self->priv->_window_stack); + self->priv->_window_stack = _tmp0_; + g_object_notify_by_pspec ((GObject *) self, my_app_header_bar_properties[MY_APP_HEADER_BAR_WINDOW_STACK_PROPERTY]); + } +} + +static GObject * +my_app_header_bar_constructor (GType type, + guint n_construct_properties, + GObjectConstructParam * construct_properties) +{ + GObject * obj; + GObjectClass * parent_class; + MyAppHeaderBar * self; + GtkStackSwitcher* stack_switcher = NULL; + GtkStackSwitcher* _tmp0_; + GtkStackSwitcher* _tmp1_; + GtkStack* _tmp2_; + GtkStackSwitcher* _tmp3_; + parent_class = G_OBJECT_CLASS (my_app_header_bar_parent_class); + obj = parent_class->constructor (type, n_construct_properties, construct_properties); + self = G_TYPE_CHECK_INSTANCE_CAST (obj, MY_APP_TYPE_HEADER_BAR, MyAppHeaderBar); + gtk_header_bar_set_show_close_button ((GtkHeaderBar*) self, TRUE); + _tmp0_ = (GtkStackSwitcher*) gtk_stack_switcher_new (); + g_object_ref_sink (_tmp0_); + stack_switcher = _tmp0_; + _tmp1_ = stack_switcher; + _tmp2_ = self->priv->_window_stack; + gtk_stack_switcher_set_stack (_tmp1_, _tmp2_); + _tmp3_ = stack_switcher; + gtk_header_bar_set_custom_title ((GtkHeaderBar*) self, (GtkWidget*) _tmp3_); + _g_object_unref0 (stack_switcher); + return obj; +} + +static void +my_app_header_bar_class_init (MyAppHeaderBarClass * klass, + gpointer klass_data) +{ + my_app_header_bar_parent_class = g_type_class_peek_parent (klass); + g_type_class_adjust_private_offset (klass, &MyAppHeaderBar_private_offset); + G_OBJECT_CLASS (klass)->get_property = _vala_my_app_header_bar_get_property; + G_OBJECT_CLASS (klass)->set_property = _vala_my_app_header_bar_set_property; + G_OBJECT_CLASS (klass)->constructor = my_app_header_bar_constructor; + G_OBJECT_CLASS (klass)->finalize = my_app_header_bar_finalize; + g_object_class_install_property (G_OBJECT_CLASS (klass), MY_APP_HEADER_BAR_WINDOW_STACK_PROPERTY, my_app_header_bar_properties[MY_APP_HEADER_BAR_WINDOW_STACK_PROPERTY] = g_param_spec_object ("window-stack", "window-stack", "window-stack", gtk_stack_get_type (), G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)); +} + +static void +my_app_header_bar_instance_init (MyAppHeaderBar * self, + gpointer klass) +{ + self->priv = my_app_header_bar_get_instance_private (self); +} + +static void +my_app_header_bar_finalize (GObject * obj) +{ + MyAppHeaderBar * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, MY_APP_TYPE_HEADER_BAR, MyAppHeaderBar); + _g_object_unref0 (self->priv->_window_stack); + G_OBJECT_CLASS (my_app_header_bar_parent_class)->finalize (obj); +} + +static GType +my_app_header_bar_get_type_once (void) +{ + static const GTypeInfo g_define_type_info = { sizeof (MyAppHeaderBarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) my_app_header_bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MyAppHeaderBar), 0, (GInstanceInitFunc) my_app_header_bar_instance_init, NULL }; + GType my_app_header_bar_type_id; + my_app_header_bar_type_id = g_type_register_static (gtk_header_bar_get_type (), "MyAppHeaderBar", &g_define_type_info, 0); + MyAppHeaderBar_private_offset = g_type_add_instance_private (my_app_header_bar_type_id, sizeof (MyAppHeaderBarPrivate)); + return my_app_header_bar_type_id; +} + +GType +my_app_header_bar_get_type (void) +{ + static volatile gsize my_app_header_bar_type_id__once = 0; + if (g_once_init_enter (&my_app_header_bar_type_id__once)) { + GType my_app_header_bar_type_id; + my_app_header_bar_type_id = my_app_header_bar_get_type_once (); + g_once_init_leave (&my_app_header_bar_type_id__once, my_app_header_bar_type_id); + } + return my_app_header_bar_type_id__once; +} + +static void +_vala_my_app_header_bar_get_property (GObject * object, + guint property_id, + GValue * value, + GParamSpec * pspec) +{ + MyAppHeaderBar * self; + self = G_TYPE_CHECK_INSTANCE_CAST (object, MY_APP_TYPE_HEADER_BAR, MyAppHeaderBar); + switch (property_id) { + case MY_APP_HEADER_BAR_WINDOW_STACK_PROPERTY: + g_value_set_object (value, my_app_header_bar_get_window_stack (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +_vala_my_app_header_bar_set_property (GObject * object, + guint property_id, + const GValue * value, + GParamSpec * pspec) +{ + MyAppHeaderBar * self; + self = G_TYPE_CHECK_INSTANCE_CAST (object, MY_APP_TYPE_HEADER_BAR, MyAppHeaderBar); + switch (property_id) { + case MY_APP_HEADER_BAR_WINDOW_STACK_PROPERTY: + my_app_header_bar_set_window_stack (self, g_value_get_object (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + diff --git a/Main.c b/Main.c new file mode 100644 index 0000000..9fea0fd --- /dev/null +++ b/Main.c @@ -0,0 +1,59 @@ +/* Main.c generated by valac 0.56.13, the Vala compiler + * generated from Main.vala, do not modify */ + +#include +#include +#include +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define TYPE_NOSTALGIA (nostalgia_get_type ()) +#define NOSTALGIA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOSTALGIA, Nostalgia)) +#define NOSTALGIA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOSTALGIA, NostalgiaClass)) +#define IS_NOSTALGIA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOSTALGIA)) +#define IS_NOSTALGIA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOSTALGIA)) +#define NOSTALGIA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOSTALGIA, NostalgiaClass)) + +typedef struct _Nostalgia Nostalgia; +typedef struct _NostalgiaClass NostalgiaClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +static gint _vala_main (gchar** args, + gint args_length1); +VALA_EXTERN GType nostalgia_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Nostalgia, g_object_unref) +VALA_EXTERN Nostalgia* nostalgia_new (void); +VALA_EXTERN Nostalgia* nostalgia_construct (GType object_type); + +static gint +_vala_main (gchar** args, + gint args_length1) +{ + Nostalgia* nostalgia = NULL; + Nostalgia* _tmp0_; + gint result; + _tmp0_ = nostalgia_new (); + nostalgia = _tmp0_; + result = g_application_run ((GApplication*) nostalgia, (gint) args_length1, args); + _g_object_unref0 (nostalgia); + return result; +} + +int +main (int argc, + char ** argv) +{ + return _vala_main (argv, argc); +} + diff --git a/Nostalgia.c b/Nostalgia.c new file mode 100644 index 0000000..3ca4b58 --- /dev/null +++ b/Nostalgia.c @@ -0,0 +1,130 @@ +/* Nostalgia.c generated by valac 0.56.13, the Vala compiler + * generated from Nostalgia.vala, do not modify */ + +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define TYPE_NOSTALGIA (nostalgia_get_type ()) +#define NOSTALGIA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOSTALGIA, Nostalgia)) +#define NOSTALGIA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOSTALGIA, NostalgiaClass)) +#define IS_NOSTALGIA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOSTALGIA)) +#define IS_NOSTALGIA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOSTALGIA)) +#define NOSTALGIA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOSTALGIA, NostalgiaClass)) + +typedef struct _Nostalgia Nostalgia; +typedef struct _NostalgiaClass NostalgiaClass; +typedef struct _NostalgiaPrivate NostalgiaPrivate; +enum { + NOSTALGIA_0_PROPERTY, + NOSTALGIA_NUM_PROPERTIES +}; +static GParamSpec* nostalgia_properties[NOSTALGIA_NUM_PROPERTIES]; + +#define MY_APP_TYPE_WINDOW (my_app_window_get_type ()) +#define MY_APP_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_APP_TYPE_WINDOW, MyAppWindow)) +#define MY_APP_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MY_APP_TYPE_WINDOW, MyAppWindowClass)) +#define MY_APP_IS_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_APP_TYPE_WINDOW)) +#define MY_APP_IS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MY_APP_TYPE_WINDOW)) +#define MY_APP_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MY_APP_TYPE_WINDOW, MyAppWindowClass)) + +typedef struct _MyAppWindow MyAppWindow; +typedef struct _MyAppWindowClass MyAppWindowClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +struct _Nostalgia { + GtkApplication parent_instance; + NostalgiaPrivate * priv; +}; + +struct _NostalgiaClass { + GtkApplicationClass parent_class; +}; + +static gpointer nostalgia_parent_class = NULL; + +VALA_EXTERN GType nostalgia_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Nostalgia, g_object_unref) +VALA_EXTERN Nostalgia* nostalgia_new (void); +VALA_EXTERN Nostalgia* nostalgia_construct (GType object_type); +static void nostalgia_real_activate (GApplication* base); +VALA_EXTERN GType my_app_window_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (MyAppWindow, g_object_unref) +VALA_EXTERN MyAppWindow* my_app_window_new (Nostalgia* application); +VALA_EXTERN MyAppWindow* my_app_window_construct (GType object_type, + Nostalgia* application); +static GType nostalgia_get_type_once (void); + +Nostalgia* +nostalgia_construct (GType object_type) +{ + Nostalgia * self = NULL; + self = (Nostalgia*) g_object_new (object_type, "application-id", "com.github.konickss.nostalgia", "flags", G_APPLICATION_FLAGS_NONE, NULL); + return self; +} + +Nostalgia* +nostalgia_new (void) +{ + return nostalgia_construct (TYPE_NOSTALGIA); +} + +static void +nostalgia_real_activate (GApplication* base) +{ + Nostalgia * self; + MyAppWindow* window = NULL; + MyAppWindow* _tmp0_; + self = (Nostalgia*) base; + _tmp0_ = my_app_window_new (self); + g_object_ref_sink (_tmp0_); + window = _tmp0_; + gtk_application_add_window ((GtkApplication*) self, (GtkWindow*) window); + _g_object_unref0 (window); +} + +static void +nostalgia_class_init (NostalgiaClass * klass, + gpointer klass_data) +{ + nostalgia_parent_class = g_type_class_peek_parent (klass); + ((GApplicationClass *) klass)->activate = (void (*) (GApplication*)) nostalgia_real_activate; +} + +static void +nostalgia_instance_init (Nostalgia * self, + gpointer klass) +{ +} + +static GType +nostalgia_get_type_once (void) +{ + static const GTypeInfo g_define_type_info = { sizeof (NostalgiaClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) nostalgia_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Nostalgia), 0, (GInstanceInitFunc) nostalgia_instance_init, NULL }; + GType nostalgia_type_id; + nostalgia_type_id = g_type_register_static (gtk_application_get_type (), "Nostalgia", &g_define_type_info, 0); + return nostalgia_type_id; +} + +GType +nostalgia_get_type (void) +{ + static volatile gsize nostalgia_type_id__once = 0; + if (g_once_init_enter (&nostalgia_type_id__once)) { + GType nostalgia_type_id; + nostalgia_type_id = nostalgia_get_type_once (); + g_once_init_leave (&nostalgia_type_id__once, nostalgia_type_id); + } + return nostalgia_type_id__once; +} + diff --git a/Window.c b/Window.c new file mode 100644 index 0000000..8c9f76a --- /dev/null +++ b/Window.c @@ -0,0 +1,1965 @@ +/* Window.c generated by valac 0.56.13, the Vala compiler + * generated from Window.vala, do not modify */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define MY_APP_TYPE_WINDOW (my_app_window_get_type ()) +#define MY_APP_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_APP_TYPE_WINDOW, MyAppWindow)) +#define MY_APP_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MY_APP_TYPE_WINDOW, MyAppWindowClass)) +#define MY_APP_IS_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_APP_TYPE_WINDOW)) +#define MY_APP_IS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MY_APP_TYPE_WINDOW)) +#define MY_APP_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MY_APP_TYPE_WINDOW, MyAppWindowClass)) + +typedef struct _MyAppWindow MyAppWindow; +typedef struct _MyAppWindowClass MyAppWindowClass; +typedef struct _MyAppWindowPrivate MyAppWindowPrivate; +enum { + MY_APP_WINDOW_0_PROPERTY, + MY_APP_WINDOW_NUM_PROPERTIES +}; +static GParamSpec* my_app_window_properties[MY_APP_WINDOW_NUM_PROPERTIES]; +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) + +#define TYPE_NOSTALGIA (nostalgia_get_type ()) +#define NOSTALGIA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOSTALGIA, Nostalgia)) +#define NOSTALGIA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOSTALGIA, NostalgiaClass)) +#define IS_NOSTALGIA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOSTALGIA)) +#define IS_NOSTALGIA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOSTALGIA)) +#define NOSTALGIA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOSTALGIA, NostalgiaClass)) + +typedef struct _Nostalgia Nostalgia; +typedef struct _NostalgiaClass NostalgiaClass; +typedef struct _Block1Data Block1Data; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +#define MY_APP_TYPE_HEADER_BAR (my_app_header_bar_get_type ()) +#define MY_APP_HEADER_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_APP_TYPE_HEADER_BAR, MyAppHeaderBar)) +#define MY_APP_HEADER_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MY_APP_TYPE_HEADER_BAR, MyAppHeaderBarClass)) +#define MY_APP_IS_HEADER_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_APP_TYPE_HEADER_BAR)) +#define MY_APP_IS_HEADER_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MY_APP_TYPE_HEADER_BAR)) +#define MY_APP_HEADER_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MY_APP_TYPE_HEADER_BAR, MyAppHeaderBarClass)) + +typedef struct _MyAppHeaderBar MyAppHeaderBar; +typedef struct _MyAppHeaderBarClass MyAppHeaderBarClass; +typedef struct _Block2Data Block2Data; +typedef struct _UpdateLabelFromIstreamData UpdateLabelFromIstreamData; + +struct _MyAppWindow { + GtkApplicationWindow parent_instance; + MyAppWindowPrivate * priv; +}; + +struct _MyAppWindowClass { + GtkApplicationWindowClass parent_class; +}; + +struct _MyAppWindowPrivate { + gchar* laoutput; + gboolean upol; +}; + +struct _Block1Data { + int _ref_count_; + MyAppWindow* self; + gboolean ssnap; + GtkStack* actualstack; + GtkStack* createstack; + GtkBox* cr1; + GtkBox* progresscr; + GdkRGBA black_color; + GtkFileChooserButton* crloc1; +}; + +struct _Block2Data { + int _ref_count_; + Block1Data * _data1_; + GSubprocess* ChildProcessBackup; +}; + +struct _UpdateLabelFromIstreamData { + int _state_; + GObject* _source_object_; + GAsyncResult* _res_; + GTask* _async_result; + GInputStream* istream; + GtkTextView* label; + GtkProgressBar* ProgBar; + GtkLabel* ProgLabel; + GDataInputStream* dis; + GDataInputStream* _tmp0_; + gchar* line; + GDataInputStream* _tmp1_; + gchar* _tmp2_; + const gchar* _tmp3_; + GtkTextBuffer* _tmp4_; + GtkTextBuffer* _tmp5_; + GtkTextBuffer* _tmp6_; + GtkTextBuffer* _tmp7_; + GtkTextBuffer* _tmp8_; + GtkTextBuffer* _tmp9_; + gchar* _tmp10_; + gchar* _tmp11_; + gchar* _tmp12_; + const gchar* _tmp13_; + gchar* _tmp14_; + gchar* _tmp15_; + gchar* _tmp16_; + gchar* _tmp17_; + const gchar* _tmp18_; + gchar** words; + const gchar* _tmp19_; + gchar** _tmp20_; + gchar** _tmp21_; + gint words_length1; + gint _words_size_; + gchar** _tmp22_; + gint _tmp22__length1; + gchar** word_collection; + gint word_collection_length1; + gint _word_collection_size_; + gint word_it; + const gchar* word; + const gchar* _tmp23_; + const gchar* _tmp24_; + gint _tmp25_; + gint _tmp26_; + gchar* word_trimmed; + const gchar* _tmp27_; + const gchar* _tmp28_; + gint _tmp29_; + gint _tmp30_; + gchar* _tmp31_; + gdouble procDone; + const gchar* _tmp32_; + const gchar* _tmp33_; + const gchar* _tmp34_; + gchar* _tmp35_; + gchar* _tmp36_; + gchar* _tmp37_; + gchar* _tmp38_; + gchar* _tmp39_; + gchar* _tmp40_; + gint _tmp41_; + gchar* _tmp42_; + GDataInputStream* _tmp43_; + gchar* _tmp44_; + gchar* _tmp45_; + GError* _inner_error0_; +}; + +static gint MyAppWindow_private_offset; +static gpointer my_app_window_parent_class = NULL; +VALA_EXTERN gint timer; +gint timer = 0; + +VALA_EXTERN GType my_app_window_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (MyAppWindow, g_object_unref) +VALA_EXTERN gboolean my_app_window_process_line (MyAppWindow* self, + GIOChannel* channel, + GIOCondition condition, + const gchar* stream_name, + gchar** x, + gboolean* y); +VALA_EXTERN GType nostalgia_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Nostalgia, g_object_unref) +VALA_EXTERN MyAppWindow* my_app_window_new (Nostalgia* application); +VALA_EXTERN MyAppWindow* my_app_window_construct (GType object_type, + Nostalgia* application); +static GObject * my_app_window_constructor (GType type, + guint n_construct_properties, + GObjectConstructParam * construct_properties); +static Block1Data* block1_data_ref (Block1Data* _data1_); +static void block1_data_unref (void * _userdata_); +static void _my_app_window___lambda4_ (Block1Data* _data1_); +VALA_EXTERN GType my_app_header_bar_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (MyAppHeaderBar, g_object_unref) +VALA_EXTERN MyAppHeaderBar* my_app_header_bar_new (GtkStack* stack); +VALA_EXTERN MyAppHeaderBar* my_app_header_bar_construct (GType object_type, + GtkStack* stack); +static void __my_app_window___lambda4__gtk_button_clicked (GtkButton* _sender, + gpointer self); +static void _my_app_window___lambda5_ (Block1Data* _data1_); +static void __my_app_window___lambda5__gtk_button_clicked (GtkButton* _sender, + gpointer self); +static void _my_app_window___lambda6_ (Block1Data* _data1_); +static Block2Data* block2_data_ref (Block2Data* _data2_); +static void block2_data_unref (void * _userdata_); +static void ____lambda7_ (Block2Data* _data2_, + GObject* obj, + GAsyncResult* res); +static void _____lambda7__gasync_ready_callback (GObject* source_object, + GAsyncResult* res, + gpointer self); +VALA_EXTERN void update_label_from_istream (GInputStream* istream, + GtkTextView* label, + GtkProgressBar* ProgBar, + GtkLabel* ProgLabel, + GAsyncReadyCallback _callback_, + gpointer _user_data_); +VALA_EXTERN void update_label_from_istream_finish (GAsyncResult* _res_); +static void __my_app_window___lambda6__gtk_button_clicked (GtkButton* _sender, + gpointer self); +static void my_app_window_finalize (GObject * obj); +static GType my_app_window_get_type_once (void); +static void update_label_from_istream_data_free (gpointer _data); +static gboolean update_label_from_istream_co (UpdateLabelFromIstreamData* _data_); +static void update_label_from_istream_ready (GObject* source_object, + GAsyncResult* _res_, + gpointer _user_data_); +VALA_EXTERN gint StrToInt (const gchar* str); +static void _vala_array_destroy (gpointer array, + gssize array_length, + GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, + gssize array_length, + GDestroyNotify destroy_func); +static gssize _vala_array_length (gpointer array); + +static inline gpointer +my_app_window_get_instance_private (MyAppWindow* self) +{ + return G_STRUCT_MEMBER_P (self, MyAppWindow_private_offset); +} + +gboolean +my_app_window_process_line (MyAppWindow* self, + GIOChannel* channel, + GIOCondition condition, + const gchar* stream_name, + gchar** x, + gboolean* y) +{ + gchar* _vala_x = NULL; + gboolean _vala_y = FALSE; + GError* _inner_error0_ = NULL; + gboolean result; + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (channel != NULL, FALSE); + g_return_val_if_fail (stream_name != NULL, FALSE); + if (condition == G_IO_HUP) { + g_print ("%s: The fd has been closed.\n", stream_name); + result = FALSE; + if (x) { + *x = _vala_x; + } else { + _g_free0 (_vala_x); + } + if (y) { + *y = _vala_y; + } + return result; + } + { + gchar* line = NULL; + gchar* _tmp0_ = NULL; + const gchar* _tmp2_; + const gchar* _tmp3_; + gchar* _tmp4_; + g_io_channel_read_line (channel, &_tmp0_, NULL, NULL, &_inner_error0_); + _g_free0 (line); + line = _tmp0_; + if (G_UNLIKELY (_inner_error0_ != NULL)) { + gboolean _tmp1_ = FALSE; + _g_free0 (line); + if (_inner_error0_->domain == G_IO_CHANNEL_ERROR) { + goto __catch0_g_io_channel_error; + } + if (_inner_error0_->domain == G_CONVERT_ERROR) { + goto __catch0_g_convert_error; + } + _g_free0 (_vala_x); + g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code); + g_clear_error (&_inner_error0_); + return _tmp1_; + } + _tmp2_ = line; + g_print ("%s: %s", stream_name, _tmp2_); + _tmp3_ = line; + _tmp4_ = g_strdup (_tmp3_); + _g_free0 (_vala_x); + _vala_x = _tmp4_; + _vala_y = TRUE; + _g_free0 (line); + } + goto __finally0; + __catch0_g_io_channel_error: + { + GError* e = NULL; + GError* _tmp5_; + const gchar* _tmp6_; + e = _inner_error0_; + _inner_error0_ = NULL; + _tmp5_ = e; + _tmp6_ = _tmp5_->message; + g_print ("%s: IOChannelError: %s\n", stream_name, _tmp6_); + result = FALSE; + _g_error_free0 (e); + if (x) { + *x = _vala_x; + } else { + _g_free0 (_vala_x); + } + if (y) { + *y = _vala_y; + } + return result; + } + goto __finally0; + __catch0_g_convert_error: + { + GError* e = NULL; + GError* _tmp7_; + const gchar* _tmp8_; + e = _inner_error0_; + _inner_error0_ = NULL; + _tmp7_ = e; + _tmp8_ = _tmp7_->message; + g_print ("%s: ConvertError: %s\n", stream_name, _tmp8_); + result = FALSE; + _g_error_free0 (e); + if (x) { + *x = _vala_x; + } else { + _g_free0 (_vala_x); + } + if (y) { + *y = _vala_y; + } + return result; + } + __finally0: + if (G_UNLIKELY (_inner_error0_ != NULL)) { + gboolean _tmp9_ = FALSE; + _g_free0 (_vala_x); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code); + g_clear_error (&_inner_error0_); + return _tmp9_; + } + result = TRUE; + if (x) { + *x = _vala_x; + } else { + _g_free0 (_vala_x); + } + if (y) { + *y = _vala_y; + } + return result; +} + +MyAppWindow* +my_app_window_construct (GType object_type, + Nostalgia* application) +{ + MyAppWindow * self = NULL; + g_return_val_if_fail (application != NULL, NULL); + self = (MyAppWindow*) g_object_new (object_type, "application", application, NULL); + return self; +} + +MyAppWindow* +my_app_window_new (Nostalgia* application) +{ + return my_app_window_construct (MY_APP_TYPE_WINDOW, application); +} + +static Block1Data* +block1_data_ref (Block1Data* _data1_) +{ + g_atomic_int_inc (&_data1_->_ref_count_); + return _data1_; +} + +static void +block1_data_unref (void * _userdata_) +{ + Block1Data* _data1_; + _data1_ = (Block1Data*) _userdata_; + if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) { + MyAppWindow* self; + self = _data1_->self; + _g_object_unref0 (_data1_->crloc1); + _g_object_unref0 (_data1_->progresscr); + _g_object_unref0 (_data1_->cr1); + _g_object_unref0 (_data1_->createstack); + _g_object_unref0 (_data1_->actualstack); + _g_object_unref0 (self); + g_slice_free (Block1Data, _data1_); + } +} + +static void +_my_app_window___lambda4_ (Block1Data* _data1_) +{ + MyAppWindow* self; + GtkStack* _tmp0_; + GtkBox* _tmp1_; + GtkStack* _tmp2_; + GtkStack* _tmp3_; + GtkStack* _tmp4_; + GtkBox* _tmp5_; + MyAppHeaderBar* crtitlebar = NULL; + GtkStack* _tmp6_; + MyAppHeaderBar* _tmp7_; + MyAppHeaderBar* _tmp8_; + self = _data1_->self; + _tmp0_ = _data1_->createstack; + _tmp1_ = _data1_->cr1; + gtk_stack_set_visible_child (_tmp0_, (GtkWidget*) _tmp1_); + g_print ("Create Button Pressed \n"); + _tmp2_ = _data1_->actualstack; + gtk_container_remove ((GtkContainer*) self, (GtkWidget*) _tmp2_); + _tmp3_ = _data1_->createstack; + gtk_container_add ((GtkContainer*) self, (GtkWidget*) _tmp3_); + _tmp4_ = _data1_->createstack; + _tmp5_ = _data1_->cr1; + gtk_stack_set_visible_child (_tmp4_, (GtkWidget*) _tmp5_); + _tmp6_ = _data1_->createstack; + _tmp7_ = my_app_header_bar_new (_tmp6_); + g_object_ref_sink (_tmp7_); + crtitlebar = _tmp7_; + _tmp8_ = crtitlebar; + gtk_window_set_titlebar ((GtkWindow*) self, (GtkWidget*) _tmp8_); + gtk_widget_show_all ((GtkWidget*) self); + _g_object_unref0 (crtitlebar); +} + +static void +__my_app_window___lambda4__gtk_button_clicked (GtkButton* _sender, + gpointer self) +{ + _my_app_window___lambda4_ (self); +} + +static void +_my_app_window___lambda5_ (Block1Data* _data1_) +{ + MyAppWindow* self; + self = _data1_->self; + if (!_data1_->ssnap) { + GtkStack* _tmp0_; + GtkStack* _tmp1_; + MyAppHeaderBar* hmtitlebar = NULL; + GtkStack* _tmp2_; + MyAppHeaderBar* _tmp3_; + MyAppHeaderBar* _tmp4_; + gchar* x = NULL; + g_print ("Menu Button Pressed \n"); + _tmp0_ = _data1_->createstack; + gtk_container_remove ((GtkContainer*) self, (GtkWidget*) _tmp0_); + _tmp1_ = _data1_->actualstack; + gtk_container_add ((GtkContainer*) self, (GtkWidget*) _tmp1_); + _tmp2_ = _data1_->actualstack; + _tmp3_ = my_app_header_bar_new (_tmp2_); + g_object_ref_sink (_tmp3_); + hmtitlebar = _tmp3_; + _tmp4_ = hmtitlebar; + gtk_window_set_titlebar ((GtkWindow*) self, (GtkWidget*) _tmp4_); + gtk_widget_show_all ((GtkWidget*) self); + _g_free0 (x); + _g_object_unref0 (hmtitlebar); + } +} + +static void +__my_app_window___lambda5__gtk_button_clicked (GtkButton* _sender, + gpointer self) +{ + _my_app_window___lambda5_ (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 (void * _userdata_) +{ + Block2Data* _data2_; + _data2_ = (Block2Data*) _userdata_; + if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) { + MyAppWindow* self; + self = _data2_->_data1_->self; + _g_object_unref0 (_data2_->ChildProcessBackup); + block1_data_unref (_data2_->_data1_); + _data2_->_data1_ = NULL; + g_slice_free (Block2Data, _data2_); + } +} + +static void +____lambda7_ (Block2Data* _data2_, + GObject* obj, + GAsyncResult* res) +{ + Block1Data* _data1_; + MyAppWindow* self; + GError* _inner_error0_ = NULL; + _data1_ = _data2_->_data1_; + self = _data1_->self; + g_return_if_fail (res != NULL); + { + GSubprocess* _tmp0_; + GtkStack* _tmp1_; + GtkBox* _tmp2_; + NotifyNotification* notification = NULL; + NotifyNotification* _tmp3_; + NotifyNotification* _tmp4_; + NotifyNotification* _tmp5_; + GList* progresscrChildren = NULL; + GtkBox* _tmp6_; + GList* _tmp7_; + GList* _tmp8_; + _tmp0_ = _data2_->ChildProcessBackup; + g_subprocess_wait_check_finish (_tmp0_, res, &_inner_error0_); + if (G_UNLIKELY (_inner_error0_ != NULL)) { + goto __catch0_g_error; + } + g_print ("\n\n-------SUCCESFULL------\n\n"); + _data1_->ssnap = FALSE; + _tmp1_ = _data1_->createstack; + _tmp2_ = _data1_->cr1; + gtk_stack_set_visible_child (_tmp1_, (GtkWidget*) _tmp2_); + notify_init ("Nostalgia"); + _tmp3_ = notify_notification_new ("Nostalgia", "Your snapshot is ready", "deja-dup"); + notification = _tmp3_; + _tmp4_ = notification; + notify_notification_set_timeout (_tmp4_, 0); + _tmp5_ = notification; + notify_notification_show (_tmp5_, &_inner_error0_); + if (G_UNLIKELY (_inner_error0_ != NULL)) { + _g_object_unref0 (notification); + goto __catch0_g_error; + } + g_print ("\nREMOVING CHILDREN FROM PAGE\n"); + _tmp6_ = _data1_->progresscr; + _tmp7_ = gtk_container_get_children ((GtkContainer*) _tmp6_); + progresscrChildren = _tmp7_; + _tmp8_ = progresscrChildren; + { + GList* element_collection = NULL; + GList* element_it = NULL; + element_collection = _tmp8_; + for (element_it = element_collection; element_it != NULL; element_it = element_it->next) { + GtkWidget* _tmp9_; + GtkWidget* element = NULL; + _tmp9_ = _g_object_ref0 ((GtkWidget*) element_it->data); + element = _tmp9_; + { + GtkBox* _tmp10_; + GtkWidget* _tmp11_; + _tmp10_ = _data1_->progresscr; + _tmp11_ = element; + gtk_container_remove ((GtkContainer*) _tmp10_, _tmp11_); + _g_object_unref0 (element); + } + } + } + (progresscrChildren == NULL) ? NULL : (progresscrChildren = (g_list_free (progresscrChildren), NULL)); + _g_object_unref0 (notification); + } + goto __finally0; + __catch0_g_error: + { + GError* err = NULL; + GError* _tmp12_; + const gchar* _tmp13_; + GtkStack* _tmp14_; + GtkBox* _tmp15_; + GtkDialog* ibl = NULL; + GtkDialog* _tmp16_; + GtkBox* iblca = NULL; + GtkDialog* _tmp17_; + GtkBox* _tmp18_; + GtkBox* _tmp19_; + GtkBox* _tmp20_; + GtkLabel* _tmp21_; + GtkLabel* _tmp22_; + GtkBox* _tmp23_; + GtkLabel* _tmp24_; + GtkLabel* _tmp25_; + GtkBox* _tmp26_; + GtkLabel* _tmp27_; + GtkLabel* _tmp28_; + GtkDialog* _tmp29_; + GList* progresscrChildren = NULL; + GtkBox* _tmp30_; + GList* _tmp31_; + GList* _tmp32_; + err = _inner_error0_; + _inner_error0_ = NULL; + _tmp12_ = err; + _tmp13_ = _tmp12_->message; + g_print ("\n\n------ERROR!!!------\n%s\n\n", _tmp13_); + _tmp14_ = _data1_->createstack; + _tmp15_ = _data1_->cr1; + gtk_stack_set_visible_child (_tmp14_, (GtkWidget*) _tmp15_); + _tmp16_ = (GtkDialog*) gtk_dialog_new_with_buttons ("Error Spawning Process", (GtkWindow*) self, (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT) | GTK_DIALOG_USE_HEADER_BAR, NULL, NULL); + g_object_ref_sink (_tmp16_); + ibl = _tmp16_; + _tmp17_ = ibl; + _tmp18_ = gtk_dialog_get_content_area (_tmp17_); + _tmp19_ = _g_object_ref0 (_tmp18_); + iblca = _tmp19_; + _tmp20_ = iblca; + _tmp21_ = (GtkLabel*) gtk_label_new ("\n\n "); + g_object_ref_sink (_tmp21_); + _tmp22_ = _tmp21_; + gtk_container_add ((GtkContainer*) _tmp20_, (GtkWidget*) _tmp22_); + _g_object_unref0 (_tmp22_); + _tmp23_ = iblca; + _tmp24_ = (GtkLabel*) gtk_label_new (" Make sure /usr/bin/rsync is installed, up to date and that you have r" \ +"oot privileges and have inputed your correct user password "); + g_object_ref_sink (_tmp24_); + _tmp25_ = _tmp24_; + gtk_container_add ((GtkContainer*) _tmp23_, (GtkWidget*) _tmp25_); + _g_object_unref0 (_tmp25_); + _tmp26_ = iblca; + _tmp27_ = (GtkLabel*) gtk_label_new ("\n \n "); + g_object_ref_sink (_tmp27_); + _tmp28_ = _tmp27_; + gtk_container_add ((GtkContainer*) _tmp26_, (GtkWidget*) _tmp28_); + _g_object_unref0 (_tmp28_); + _tmp29_ = ibl; + gtk_widget_show_all ((GtkWidget*) _tmp29_); + g_print ("\nREMOVING CHILDREN FROM PAGE\n"); + _tmp30_ = _data1_->progresscr; + _tmp31_ = gtk_container_get_children ((GtkContainer*) _tmp30_); + progresscrChildren = _tmp31_; + _tmp32_ = progresscrChildren; + { + GList* element_collection = NULL; + GList* element_it = NULL; + element_collection = _tmp32_; + for (element_it = element_collection; element_it != NULL; element_it = element_it->next) { + GtkWidget* _tmp33_; + GtkWidget* element = NULL; + _tmp33_ = _g_object_ref0 ((GtkWidget*) element_it->data); + element = _tmp33_; + { + GtkBox* _tmp34_; + GtkWidget* _tmp35_; + _tmp34_ = _data1_->progresscr; + _tmp35_ = element; + gtk_container_remove ((GtkContainer*) _tmp34_, _tmp35_); + _g_object_unref0 (element); + } + } + } + _data1_->ssnap = FALSE; + (progresscrChildren == NULL) ? NULL : (progresscrChildren = (g_list_free (progresscrChildren), NULL)); + _g_object_unref0 (iblca); + _g_object_unref0 (ibl); + _g_error_free0 (err); + } + __finally0: + if (G_UNLIKELY (_inner_error0_ != NULL)) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code); + g_clear_error (&_inner_error0_); + return; + } +} + +static void +_____lambda7__gasync_ready_callback (GObject* source_object, + GAsyncResult* res, + gpointer self) +{ + ____lambda7_ (self, source_object, res); + block2_data_unref (self); +} + +static void +_my_app_window___lambda6_ (Block1Data* _data1_) +{ + MyAppWindow* self; + GError* _inner_error0_ = NULL; + self = _data1_->self; + if (!_data1_->ssnap) { + GtkFileChooserButton* _tmp0_; + gchar* _tmp1_; + gchar* _tmp2_; + gchar* loc = NULL; + GtkFileChooserButton* _tmp3_; + gchar* _tmp4_; + GtkFileChooserButton* _tmp5_; + gchar* _tmp6_; + gchar* _tmp7_; + GtkFileChooserButton* _tmp8_; + gchar* _tmp9_; + gchar* _tmp10_; + gboolean _tmp11_; + _tmp0_ = _data1_->crloc1; + _tmp1_ = gtk_file_chooser_get_filename ((GtkFileChooser*) _tmp0_); + _tmp2_ = _tmp1_; + g_print ("%s", _tmp2_); + _g_free0 (_tmp2_); + _tmp3_ = _data1_->crloc1; + _tmp4_ = gtk_file_chooser_get_filename ((GtkFileChooser*) _tmp3_); + loc = _tmp4_; + g_print ("\n"); + _tmp5_ = _data1_->crloc1; + _tmp6_ = gtk_file_chooser_get_filename ((GtkFileChooser*) _tmp5_); + _tmp7_ = _tmp6_; + g_print ("%s", _tmp7_); + _g_free0 (_tmp7_); + _tmp8_ = _data1_->crloc1; + _tmp9_ = gtk_file_chooser_get_filename ((GtkFileChooser*) _tmp8_); + _tmp10_ = _tmp9_; + _tmp11_ = _tmp10_ == NULL; + _g_free0 (_tmp10_); + if (_tmp11_) { + GtkDialog* ibl = NULL; + GtkDialog* _tmp12_; + GtkBox* iblca = NULL; + GtkDialog* _tmp13_; + GtkBox* _tmp14_; + GtkBox* _tmp15_; + GtkBox* _tmp16_; + GtkLabel* _tmp17_; + GtkLabel* _tmp18_; + GtkBox* _tmp19_; + GtkLabel* _tmp20_; + GtkLabel* _tmp21_; + GtkBox* _tmp22_; + GtkLabel* _tmp23_; + GtkLabel* _tmp24_; + GtkDialog* _tmp25_; + _tmp12_ = (GtkDialog*) gtk_dialog_new_with_buttons ("Invaild backup location", (GtkWindow*) self, (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT) | GTK_DIALOG_USE_HEADER_BAR, NULL, NULL); + g_object_ref_sink (_tmp12_); + ibl = _tmp12_; + _tmp13_ = ibl; + _tmp14_ = gtk_dialog_get_content_area (_tmp13_); + _tmp15_ = _g_object_ref0 (_tmp14_); + iblca = _tmp15_; + _tmp16_ = iblca; + _tmp17_ = (GtkLabel*) gtk_label_new ("\n\n "); + g_object_ref_sink (_tmp17_); + _tmp18_ = _tmp17_; + gtk_container_add ((GtkContainer*) _tmp16_, (GtkWidget*) _tmp18_); + _g_object_unref0 (_tmp18_); + _tmp19_ = iblca; + _tmp20_ = (GtkLabel*) gtk_label_new (" Make sure the folder you picked is mounted and exists "); + g_object_ref_sink (_tmp20_); + _tmp21_ = _tmp20_; + gtk_container_add ((GtkContainer*) _tmp19_, (GtkWidget*) _tmp21_); + _g_object_unref0 (_tmp21_); + _tmp22_ = iblca; + _tmp23_ = (GtkLabel*) gtk_label_new ("\n \n "); + g_object_ref_sink (_tmp23_); + _tmp24_ = _tmp23_; + gtk_container_add ((GtkContainer*) _tmp22_, (GtkWidget*) _tmp24_); + _g_object_unref0 (_tmp24_); + _tmp25_ = ibl; + gtk_widget_show_all ((GtkWidget*) _tmp25_); + _g_object_unref0 (iblca); + _g_object_unref0 (ibl); + } else { + Block2Data* _data2_; + GtkStack* _tmp26_; + GtkBox* _tmp27_; + gchar* isfile = NULL; + GtkFileChooserButton* _tmp28_; + gchar* _tmp29_; + gchar* _tmp30_; + gchar* _tmp31_; + gchar* _tmp32_; + gchar* _tmp33_; + gchar* _tmp34_; + gchar* _tmp35_ = NULL; + gchar* isft = NULL; + GtkFileChooserButton* _tmp36_; + gchar* _tmp37_; + gchar* _tmp38_; + gchar* _tmp39_; + gchar* _tmp40_; + const gchar* _tmp41_; + const gchar* _tmp42_; + GtkTextView* lbl = NULL; + GtkTextView* _tmp43_; + GtkTextView* _tmp44_; + GtkTextView* _tmp45_; + GdkRGBA _tmp46_; + GtkScrolledWindow* lblScroll = NULL; + GtkScrolledWindow* _tmp47_; + GtkScrolledWindow* _tmp48_; + GtkTextView* _tmp49_; + GtkScrolledWindow* _tmp50_; + GtkBox* _tmp51_; + GtkScrolledWindow* _tmp52_; + GtkProgressBar* ProgBar = NULL; + GtkProgressBar* _tmp53_; + GtkBox* _tmp54_; + GtkProgressBar* _tmp55_; + GtkLabel* ProgLabel = NULL; + GtkLabel* _tmp56_; + GtkBox* _tmp57_; + GtkLabel* _tmp58_; + const gchar* _tmp59_; + const gchar* _tmp60_; + gchar** spawn_env1 = NULL; + gchar** _tmp68_; + gchar** _tmp69_; + gint spawn_env1_length1; + gint _spawn_env1_size_; + GPid rpid = 0; + gint otcr = 0; + gint dum = 0; + gboolean lop = FALSE; + gchar** backup_command = NULL; + gchar* _tmp70_; + gchar* _tmp71_; + gchar* _tmp72_; + gchar* _tmp73_; + gchar* _tmp74_; + gchar* _tmp75_; + gchar* _tmp76_; + gchar* _tmp77_; + gchar** _tmp78_; + gint backup_command_length1; + gint _backup_command_size_; + gchar** _tmp79_; + gint _tmp79__length1; + GSubprocess* _tmp80_; + GSubprocess* _tmp81_; + GInputStream* OutputPipeBackup = NULL; + GSubprocess* _tmp82_; + GInputStream* _tmp83_; + GInputStream* _tmp84_; + GInputStream* _tmp85_; + GtkTextView* _tmp86_; + GtkProgressBar* _tmp87_; + GtkLabel* _tmp88_; + _data2_ = g_slice_new0 (Block2Data); + _data2_->_ref_count_ = 1; + _data2_->_data1_ = block1_data_ref (_data1_); + _data1_->ssnap = TRUE; + _tmp26_ = _data1_->createstack; + _tmp27_ = _data1_->progresscr; + gtk_stack_set_visible_child (_tmp26_, (GtkWidget*) _tmp27_); + _tmp28_ = _data1_->crloc1; + _tmp29_ = gtk_file_chooser_get_filename ((GtkFileChooser*) _tmp28_); + _tmp30_ = _tmp29_; + _tmp31_ = g_strconcat ("file ", _tmp30_, NULL); + _tmp32_ = _tmp31_; + _tmp33_ = g_strconcat (_tmp32_, "/nostalgia.file", NULL); + _tmp34_ = _tmp33_; + g_spawn_command_line_sync (_tmp34_, &_tmp35_, NULL, NULL, &_inner_error0_); + _g_free0 (isfile); + isfile = _tmp35_; + _g_free0 (_tmp34_); + _g_free0 (_tmp32_); + _g_free0 (_tmp30_); + if (G_UNLIKELY (_inner_error0_ != NULL)) { + _g_free0 (isfile); + block2_data_unref (_data2_); + _data2_ = NULL; + _g_free0 (loc); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code); + g_clear_error (&_inner_error0_); + return; + } + _tmp36_ = _data1_->crloc1; + _tmp37_ = gtk_file_chooser_get_filename ((GtkFileChooser*) _tmp36_); + _tmp38_ = _tmp37_; + _tmp39_ = g_strconcat (_tmp38_, "/nostalgia.file: empty ", NULL); + _tmp40_ = _tmp39_; + _g_free0 (_tmp38_); + isft = _tmp40_; + _tmp41_ = isfile; + g_print ("%s", _tmp41_); + _tmp42_ = isft; + g_print ("%s", _tmp42_); + _tmp43_ = (GtkTextView*) gtk_text_view_new (); + g_object_ref_sink (_tmp43_); + lbl = _tmp43_; + _tmp44_ = lbl; + gtk_text_view_set_wrap_mode (_tmp44_, GTK_WRAP_WORD); + _tmp45_ = lbl; + _tmp46_ = _data1_->black_color; + gtk_widget_override_background_color ((GtkWidget*) _tmp45_, GTK_STATE_FLAG_NORMAL, &_tmp46_); + _tmp47_ = (GtkScrolledWindow*) gtk_scrolled_window_new (NULL, NULL); + g_object_ref_sink (_tmp47_); + lblScroll = _tmp47_; + _tmp48_ = lblScroll; + _tmp49_ = lbl; + gtk_container_add ((GtkContainer*) _tmp48_, (GtkWidget*) _tmp49_); + _tmp50_ = lblScroll; + gtk_scrolled_window_set_max_content_height (_tmp50_, 600); + _tmp51_ = _data1_->progresscr; + _tmp52_ = lblScroll; + gtk_box_pack_start (_tmp51_, (GtkWidget*) _tmp52_, TRUE, TRUE, (guint) 0); + _tmp53_ = (GtkProgressBar*) gtk_progress_bar_new (); + g_object_ref_sink (_tmp53_); + ProgBar = _tmp53_; + _tmp54_ = _data1_->progresscr; + _tmp55_ = ProgBar; + gtk_box_pack_end (_tmp54_, (GtkWidget*) _tmp55_, TRUE, TRUE, (guint) 0); + _tmp56_ = (GtkLabel*) gtk_label_new ("Nostalgia Progress: 0%"); + g_object_ref_sink (_tmp56_); + ProgLabel = _tmp56_; + _tmp57_ = _data1_->progresscr; + _tmp58_ = ProgLabel; + gtk_box_pack_end (_tmp57_, (GtkWidget*) _tmp58_, TRUE, TRUE, (guint) 0); + _tmp59_ = isfile; + _tmp60_ = isft; + if (g_utf8_strlen (_tmp59_, (gssize) -1) != g_utf8_strlen (_tmp60_, (gssize) -1)) { + gchar* testx = NULL; + GtkBox* _tmp61_; + const gchar* _tmp62_; + GtkLabel* _tmp63_; + GtkLabel* _tmp64_; + GtkBox* _tmp65_; + GtkLabel* _tmp66_; + GtkLabel* _tmp67_; + g_print ("\n root backup \n"); + _tmp61_ = _data1_->progresscr; + _tmp62_ = testx; + _tmp63_ = (GtkLabel*) gtk_label_new (_tmp62_); + g_object_ref_sink (_tmp63_); + _tmp64_ = _tmp63_; + gtk_box_pack_start (_tmp61_, (GtkWidget*) _tmp64_, TRUE, TRUE, (guint) 0); + _g_object_unref0 (_tmp64_); + _tmp65_ = _data1_->progresscr; + _tmp66_ = (GtkLabel*) gtk_label_new ("This seems to be your first nostalgia backup on this harddrive, so it " \ +"will take a while"); + g_object_ref_sink (_tmp66_); + _tmp67_ = _tmp66_; + gtk_box_pack_start (_tmp65_, (GtkWidget*) _tmp67_, FALSE, FALSE, (guint) 10); + _g_object_unref0 (_tmp67_); + gtk_widget_show_all ((GtkWidget*) self); + _g_free0 (testx); + } + _tmp69_ = _tmp68_ = g_get_environ (); + spawn_env1 = _tmp69_; + spawn_env1_length1 = _vala_array_length (_tmp68_); + _spawn_env1_size_ = spawn_env1_length1; + lop = TRUE; + _tmp70_ = g_strdup ("/usr/bin/pkexec"); + _tmp71_ = g_strdup ("/usr/bin/rsync"); + _tmp72_ = g_strdup ("-ahv"); + _tmp73_ = g_strdup ("/home/ioachim/Music"); + _tmp74_ = g_strdup ("/home/ioachim/Music2"); + _tmp75_ = g_strdup ("--no-i-r"); + _tmp76_ = g_strdup ("--info=progress2"); + _tmp77_ = g_strdup ("--fsync"); + _tmp78_ = g_new0 (gchar*, 9 + 1); + _tmp78_[0] = _tmp70_; + _tmp78_[1] = _tmp71_; + _tmp78_[2] = _tmp72_; + _tmp78_[3] = _tmp73_; + _tmp78_[4] = _tmp74_; + _tmp78_[5] = _tmp75_; + _tmp78_[6] = _tmp76_; + _tmp78_[7] = _tmp77_; + _tmp78_[8] = NULL; + backup_command = _tmp78_; + backup_command_length1 = 9; + _backup_command_size_ = backup_command_length1; + _tmp79_ = backup_command; + _tmp79__length1 = backup_command_length1; + _tmp80_ = g_subprocess_newv (_tmp79_, G_SUBPROCESS_FLAGS_STDOUT_PIPE, &_inner_error0_); + _data2_->ChildProcessBackup = _tmp80_; + if (G_UNLIKELY (_inner_error0_ != NULL)) { + backup_command = (_vala_array_free (backup_command, backup_command_length1, (GDestroyNotify) g_free), NULL); + spawn_env1 = (_vala_array_free (spawn_env1, spawn_env1_length1, (GDestroyNotify) g_free), NULL); + _g_object_unref0 (ProgLabel); + _g_object_unref0 (ProgBar); + _g_object_unref0 (lblScroll); + _g_object_unref0 (lbl); + _g_free0 (isft); + _g_free0 (isfile); + block2_data_unref (_data2_); + _data2_ = NULL; + _g_free0 (loc); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code); + g_clear_error (&_inner_error0_); + return; + } + _tmp81_ = _data2_->ChildProcessBackup; + g_subprocess_wait_check_async (_tmp81_, NULL, _____lambda7__gasync_ready_callback, block2_data_ref (_data2_)); + _tmp82_ = _data2_->ChildProcessBackup; + _tmp83_ = g_subprocess_get_stdout_pipe (_tmp82_); + _tmp84_ = _g_object_ref0 (_tmp83_); + OutputPipeBackup = _tmp84_; + _tmp85_ = OutputPipeBackup; + _tmp86_ = lbl; + _tmp87_ = ProgBar; + _tmp88_ = ProgLabel; + update_label_from_istream (_tmp85_, _tmp86_, _tmp87_, _tmp88_, NULL, NULL); + _g_object_unref0 (OutputPipeBackup); + backup_command = (_vala_array_free (backup_command, backup_command_length1, (GDestroyNotify) g_free), NULL); + spawn_env1 = (_vala_array_free (spawn_env1, spawn_env1_length1, (GDestroyNotify) g_free), NULL); + _g_object_unref0 (ProgLabel); + _g_object_unref0 (ProgBar); + _g_object_unref0 (lblScroll); + _g_object_unref0 (lbl); + _g_free0 (isft); + _g_free0 (isfile); + block2_data_unref (_data2_); + _data2_ = NULL; + } + _g_free0 (loc); + } +} + +static void +__my_app_window___lambda6__gtk_button_clicked (GtkButton* _sender, + gpointer self) +{ + _my_app_window___lambda6_ (self); +} + +static GObject * +my_app_window_constructor (GType type, + guint n_construct_properties, + GObjectConstructParam * construct_properties) +{ + GObject * obj; + GObjectClass * parent_class; + MyAppWindow * self; + Block1Data* _data1_; + GtkStack* _tmp0_; + GtkStack* _tmp1_; + GtkStack* _tmp2_; + GtkStack* _tmp3_; + GtkBox* memc = NULL; + GtkBox* _tmp4_; + GtkBox* memr = NULL; + GtkBox* _tmp5_; + GtkBox* _tmp6_; + GtkBox* _tmp7_; + GtkStack* _tmp8_; + GtkBox* _tmp9_; + GtkStack* _tmp10_; + GtkBox* _tmp11_; + GtkStack* _tmp12_; + GtkBox* _tmp13_; + GtkStack* _tmp14_; + GtkBox* _tmp15_; + GtkStack* _tmp16_; + GtkStack* _tmp17_; + GtkStack* _tmp18_; + GtkStack* _tmp19_; + GtkLabel* label1 = NULL; + GtkLabel* _tmp20_; + GtkLabel* _tmp21_; + GtkBox* _tmp22_; + GtkLabel* _tmp23_; + GtkBox* _tmp24_; + GtkLabel* _tmp25_; + GtkLabel* _tmp26_; + GtkButton* button1 = NULL; + GtkButton* _tmp27_; + GdkRGBA blue_color = {0}; + GdkRGBA green_color = {0}; + GtkButton* _tmp28_; + GdkRGBA _tmp29_; + GtkGrid* gridfb = NULL; + GtkGrid* _tmp30_; + GtkGrid* _tmp31_; + GtkButton* _tmp32_; + GtkButton* _tmp33_; + GtkGrid* _tmp34_; + GtkLabel* _tmp35_; + GtkLabel* _tmp36_; + GtkGrid* _tmp37_; + GtkLabel* _tmp38_; + GtkLabel* _tmp39_; + GtkGrid* _tmp40_; + GtkGrid* _tmp41_; + GtkBox* _tmp42_; + GtkGrid* _tmp43_; + GtkLabel* label1r = NULL; + GtkLabel* _tmp44_; + GtkLabel* _tmp45_; + GtkBox* _tmp46_; + GtkLabel* _tmp47_; + GtkBox* _tmp48_; + GtkLabel* _tmp49_; + GtkLabel* _tmp50_; + GtkButton* button1r = NULL; + GtkButton* _tmp51_; + GtkButton* _tmp52_; + GdkRGBA _tmp53_; + GtkGrid* gridfbr = NULL; + GtkGrid* _tmp54_; + GtkGrid* _tmp55_; + GtkButton* _tmp56_; + GtkGrid* _tmp57_; + GtkLabel* _tmp58_; + GtkLabel* _tmp59_; + GtkGrid* _tmp60_; + GtkLabel* _tmp61_; + GtkLabel* _tmp62_; + GtkGrid* _tmp63_; + GtkGrid* _tmp64_; + GtkBox* _tmp65_; + GtkGrid* _tmp66_; + GtkBox* _tmp67_; + GtkLabel* _tmp68_; + GtkLabel* _tmp69_; + GtkBox* cr11 = NULL; + GtkBox* _tmp70_; + GtkBox* _tmp71_; + GtkLabel* _tmp72_; + GtkLabel* _tmp73_; + GtkLabel* cr1label = NULL; + GtkLabel* _tmp74_; + GtkLabel* _tmp75_; + GtkBox* _tmp76_; + GtkLabel* _tmp77_; + GtkFileChooserButton* _tmp78_; + GtkBox* _tmp79_; + GtkFileChooserButton* _tmp80_; + GtkBox* _tmp81_; + GtkLabel* _tmp82_; + GtkLabel* _tmp83_; + GtkBox* _tmp84_; + GtkBox* _tmp85_; + GtkBox* _tmp86_; + GtkLabel* _tmp87_; + GtkLabel* _tmp88_; + GtkBox* cr12 = NULL; + GtkBox* _tmp89_; + GtkButton* crbackbutton = NULL; + GtkButton* _tmp90_; + GtkButton* _tmp91_; + GtkBox* _tmp92_; + GtkButton* _tmp93_; + GtkBox* cr15 = NULL; + GtkBox* _tmp94_; + GtkScrolledWindow* ExcludePanel = NULL; + GtkScrolledWindow* _tmp95_; + GtkLabel* ExcludeListLabel = NULL; + GtkLabel* _tmp96_; + GtkTextView* ExcludeList = NULL; + GtkTextView* _tmp97_; + GtkTextView* _tmp98_; + GtkTextView* _tmp99_; + GtkTextView* _tmp100_; + GdkRGBA _tmp101_; + GtkScrolledWindow* _tmp102_; + GtkScrolledWindow* _tmp103_; + GtkScrolledWindow* _tmp104_; + GtkTextView* _tmp105_; + GtkBox* _tmp106_; + GtkLabel* _tmp107_; + GtkBox* cr151 = NULL; + GtkBox* _tmp108_; + GtkBox* _tmp109_; + GtkLabel* _tmp110_; + GtkLabel* _tmp111_; + GtkBox* _tmp112_; + GtkScrolledWindow* _tmp113_; + GtkBox* _tmp114_; + GtkLabel* _tmp115_; + GtkLabel* _tmp116_; + GtkBox* _tmp117_; + GtkBox* _tmp118_; + GtkBox* _tmp119_; + GtkBox* _tmp120_; + GtkButton* finbutcr = NULL; + GtkButton* _tmp121_; + GtkButton* _tmp122_; + GdkRGBA _tmp123_; + GtkBox* _tmp124_; + GtkButton* _tmp125_; + GtkButton* _tmp126_; + GtkBox* _tmp127_; + GtkBox* _tmp128_; + GtkStack* _tmp129_; + MyAppHeaderBar* headerbar = NULL; + GtkStack* _tmp130_; + MyAppHeaderBar* _tmp131_; + MyAppHeaderBar* _tmp132_; + parent_class = G_OBJECT_CLASS (my_app_window_parent_class); + obj = parent_class->constructor (type, n_construct_properties, construct_properties); + self = G_TYPE_CHECK_INSTANCE_CAST (obj, MY_APP_TYPE_WINDOW, MyAppWindow); + _data1_ = g_slice_new0 (Block1Data); + _data1_->_ref_count_ = 1; + _data1_->self = g_object_ref (self); + _data1_->ssnap = FALSE; + _tmp0_ = (GtkStack*) gtk_stack_new (); + g_object_ref_sink (_tmp0_); + _data1_->actualstack = _tmp0_; + _tmp1_ = _data1_->actualstack; + g_object_set ((GtkWidget*) _tmp1_, "expand", TRUE, NULL); + _tmp2_ = (GtkStack*) gtk_stack_new (); + g_object_ref_sink (_tmp2_); + _data1_->createstack = _tmp2_; + _tmp3_ = _data1_->createstack; + g_object_set ((GtkWidget*) _tmp3_, "expand", TRUE, NULL); + _tmp4_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + g_object_ref_sink (_tmp4_); + memc = _tmp4_; + _tmp5_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + g_object_ref_sink (_tmp5_); + memr = _tmp5_; + _tmp6_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + g_object_ref_sink (_tmp6_); + _data1_->cr1 = _tmp6_; + _tmp7_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + g_object_ref_sink (_tmp7_); + _data1_->progresscr = _tmp7_; + _tmp8_ = _data1_->actualstack; + _tmp9_ = memc; + gtk_stack_add_titled (_tmp8_, (GtkWidget*) _tmp9_, "memc", "Create"); + _tmp10_ = _data1_->actualstack; + _tmp11_ = memr; + gtk_stack_add_titled (_tmp10_, (GtkWidget*) _tmp11_, "memr", "Restore"); + _tmp12_ = _data1_->createstack; + _tmp13_ = _data1_->cr1; + gtk_stack_add_titled (_tmp12_, (GtkWidget*) _tmp13_, "cr1", "Backup Options"); + _tmp14_ = _data1_->createstack; + _tmp15_ = _data1_->progresscr; + gtk_stack_add_titled (_tmp14_, (GtkWidget*) _tmp15_, "progresscr", "Snapshot Progress"); + _tmp16_ = _data1_->actualstack; + gtk_stack_set_transition_type (_tmp16_, GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN); + _tmp17_ = _data1_->actualstack; + gtk_stack_set_transition_duration (_tmp17_, (guint) 750); + _tmp18_ = _data1_->createstack; + gtk_stack_set_transition_type (_tmp18_, GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN); + _tmp19_ = _data1_->createstack; + gtk_stack_set_transition_duration (_tmp19_, (guint) 750); + _tmp20_ = (GtkLabel*) gtk_label_new ("Back up all your files and memorie" \ +"s,\n" \ +"For when you need them the most"); + g_object_ref_sink (_tmp20_); + label1 = _tmp20_; + _tmp21_ = label1; + gtk_label_set_use_markup (_tmp21_, TRUE); + _tmp22_ = memc; + _tmp23_ = label1; + gtk_box_pack_start (_tmp22_, (GtkWidget*) _tmp23_, TRUE, TRUE, (guint) 50); + _tmp24_ = memc; + _tmp25_ = (GtkLabel*) gtk_label_new ("Nostalgia makes incremental snapshots, that means:\n" \ +"✔ Only the first snapshot contains the full file system\n" \ +"✔ All snapshots after the first only document changes\n" \ +"✔ It takes up significantly less space compared to full system snapsho" \ +"ts\n" \ +"✔ You can hold lots of backups on a drive"); + g_object_ref_sink (_tmp25_); + _tmp26_ = _tmp25_; + gtk_box_pack_start (_tmp24_, (GtkWidget*) _tmp26_, TRUE, FALSE, (guint) 0); + _g_object_unref0 (_tmp26_); + _tmp27_ = (GtkButton*) gtk_button_new_with_label ("Create memory"); + g_object_ref_sink (_tmp27_); + button1 = _tmp27_; + memset (&blue_color, 0, sizeof (GdkRGBA)); + gdk_rgba_parse (&blue_color, "#0860F2"); + memset (&green_color, 0, sizeof (GdkRGBA)); + gdk_rgba_parse (&green_color, "#59C837"); + memset (&_data1_->black_color, 0, sizeof (GdkRGBA)); + gdk_rgba_parse (&_data1_->black_color, "#15161E"); + _tmp28_ = button1; + _tmp29_ = green_color; + gtk_widget_override_background_color ((GtkWidget*) _tmp28_, GTK_STATE_FLAG_NORMAL, &_tmp29_); + _tmp30_ = (GtkGrid*) gtk_grid_new (); + g_object_ref_sink (_tmp30_); + gridfb = _tmp30_; + _tmp31_ = gridfb; + _tmp32_ = button1; + gtk_grid_attach (_tmp31_, (GtkWidget*) _tmp32_, 1, 1, 1, 1); + _tmp33_ = button1; + g_signal_connect_data (_tmp33_, "clicked", (GCallback) __my_app_window___lambda4__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0); + _tmp34_ = gridfb; + _tmp35_ = (GtkLabel*) gtk_label_new (""); + g_object_ref_sink (_tmp35_); + _tmp36_ = _tmp35_; + gtk_grid_attach (_tmp34_, (GtkWidget*) _tmp36_, 2, 1, 1, 1); + _g_object_unref0 (_tmp36_); + _tmp37_ = gridfb; + _tmp38_ = (GtkLabel*) gtk_label_new (""); + g_object_ref_sink (_tmp38_); + _tmp39_ = _tmp38_; + gtk_grid_attach (_tmp37_, (GtkWidget*) _tmp39_, 0, 1, 1, 1); + _g_object_unref0 (_tmp39_); + _tmp40_ = gridfb; + gtk_grid_set_column_homogeneous (_tmp40_, TRUE); + _tmp41_ = gridfb; + gtk_grid_set_row_homogeneous (_tmp41_, TRUE); + _tmp42_ = memc; + _tmp43_ = gridfb; + gtk_box_pack_start (_tmp42_, (GtkWidget*) _tmp43_, TRUE, TRUE, (guint) 60); + _tmp44_ = (GtkLabel*) gtk_label_new ("For when the worst happens,\n" \ +"I'm here to get you back online"); + g_object_ref_sink (_tmp44_); + label1r = _tmp44_; + _tmp45_ = label1r; + gtk_label_set_use_markup (_tmp45_, TRUE); + _tmp46_ = memr; + _tmp47_ = label1r; + gtk_box_pack_start (_tmp46_, (GtkWidget*) _tmp47_, TRUE, TRUE, (guint) 50); + _tmp48_ = memr; + _tmp49_ = (GtkLabel*) gtk_label_new ("You can use this option to restore your lost files\n" \ +"and configurations from any of your backups. Keep in mind\n" \ +"restoring your entire system using this tool may take a while,\n" \ +"so please be patient and let us get your system back and running"); + g_object_ref_sink (_tmp49_); + _tmp50_ = _tmp49_; + gtk_box_pack_start (_tmp48_, (GtkWidget*) _tmp50_, TRUE, FALSE, (guint) 0); + _g_object_unref0 (_tmp50_); + _tmp51_ = (GtkButton*) gtk_button_new_with_label ("Restore Memory"); + g_object_ref_sink (_tmp51_); + button1r = _tmp51_; + _tmp52_ = button1r; + _tmp53_ = blue_color; + gtk_widget_override_background_color ((GtkWidget*) _tmp52_, GTK_STATE_FLAG_NORMAL, &_tmp53_); + _tmp54_ = (GtkGrid*) gtk_grid_new (); + g_object_ref_sink (_tmp54_); + gridfbr = _tmp54_; + _tmp55_ = gridfbr; + _tmp56_ = button1r; + gtk_grid_attach (_tmp55_, (GtkWidget*) _tmp56_, 1, 1, 1, 1); + _tmp57_ = gridfbr; + _tmp58_ = (GtkLabel*) gtk_label_new (""); + g_object_ref_sink (_tmp58_); + _tmp59_ = _tmp58_; + gtk_grid_attach (_tmp57_, (GtkWidget*) _tmp59_, 0, 1, 1, 1); + _g_object_unref0 (_tmp59_); + _tmp60_ = gridfbr; + _tmp61_ = (GtkLabel*) gtk_label_new (""); + g_object_ref_sink (_tmp61_); + _tmp62_ = _tmp61_; + gtk_grid_attach (_tmp60_, (GtkWidget*) _tmp62_, 2, 1, 1, 1); + _g_object_unref0 (_tmp62_); + _tmp63_ = gridfbr; + gtk_grid_set_column_homogeneous (_tmp63_, TRUE); + _tmp64_ = gridfbr; + gtk_grid_set_row_homogeneous (_tmp64_, TRUE); + _tmp65_ = memr; + _tmp66_ = gridfbr; + gtk_box_pack_start (_tmp65_, (GtkWidget*) _tmp66_, TRUE, TRUE, (guint) 60); + _tmp67_ = _data1_->cr1; + _tmp68_ = (GtkLabel*) gtk_label_new (""); + g_object_ref_sink (_tmp68_); + _tmp69_ = _tmp68_; + gtk_box_pack_start (_tmp67_, (GtkWidget*) _tmp69_, FALSE, FALSE, (guint) 100); + _g_object_unref0 (_tmp69_); + _tmp70_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + g_object_ref_sink (_tmp70_); + cr11 = _tmp70_; + _tmp71_ = cr11; + _tmp72_ = (GtkLabel*) gtk_label_new (""); + g_object_ref_sink (_tmp72_); + _tmp73_ = _tmp72_; + gtk_box_pack_start (_tmp71_, (GtkWidget*) _tmp73_, TRUE, TRUE, (guint) 40); + _g_object_unref0 (_tmp73_); + _tmp74_ = (GtkLabel*) gtk_label_new ("Select your backup drive:"); + g_object_ref_sink (_tmp74_); + cr1label = _tmp74_; + _tmp75_ = cr1label; + gtk_label_set_use_markup (_tmp75_, TRUE); + _tmp76_ = cr11; + _tmp77_ = cr1label; + gtk_box_pack_start (_tmp76_, (GtkWidget*) _tmp77_, TRUE, TRUE, (guint) 10); + _tmp78_ = (GtkFileChooserButton*) gtk_file_chooser_button_new ("Set location", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); + g_object_ref_sink (_tmp78_); + _data1_->crloc1 = _tmp78_; + _tmp79_ = cr11; + _tmp80_ = _data1_->crloc1; + gtk_box_pack_start (_tmp79_, (GtkWidget*) _tmp80_, TRUE, TRUE, (guint) 0); + _tmp81_ = cr11; + _tmp82_ = (GtkLabel*) gtk_label_new (""); + g_object_ref_sink (_tmp82_); + _tmp83_ = _tmp82_; + gtk_box_pack_start (_tmp81_, (GtkWidget*) _tmp83_, TRUE, TRUE, (guint) 10); + _g_object_unref0 (_tmp83_); + _tmp84_ = _data1_->cr1; + _tmp85_ = cr11; + gtk_box_pack_start (_tmp84_, (GtkWidget*) _tmp85_, FALSE, FALSE, (guint) 0); + _tmp86_ = _data1_->cr1; + _tmp87_ = (GtkLabel*) gtk_label_new (""); + g_object_ref_sink (_tmp87_); + _tmp88_ = _tmp87_; + gtk_box_pack_start (_tmp86_, (GtkWidget*) _tmp88_, FALSE, FALSE, (guint) 15); + _g_object_unref0 (_tmp88_); + _tmp89_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + g_object_ref_sink (_tmp89_); + cr12 = _tmp89_; + _tmp90_ = (GtkButton*) gtk_button_new_with_label ("↩ Go back"); + g_object_ref_sink (_tmp90_); + crbackbutton = _tmp90_; + _tmp91_ = crbackbutton; + g_signal_connect_data (_tmp91_, "clicked", (GCallback) __my_app_window___lambda5__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0); + _tmp92_ = cr12; + _tmp93_ = crbackbutton; + gtk_box_pack_start (_tmp92_, (GtkWidget*) _tmp93_, FALSE, FALSE, (guint) 10); + _tmp94_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 20); + g_object_ref_sink (_tmp94_); + cr15 = _tmp94_; + _tmp95_ = (GtkScrolledWindow*) gtk_scrolled_window_new (NULL, NULL); + g_object_ref_sink (_tmp95_); + ExcludePanel = _tmp95_; + _tmp96_ = (GtkLabel*) gtk_label_new ("Type Every Folder to be EXCLUDED from the Backup, using ABSOLUTE paths" \ +", one per line"); + g_object_ref_sink (_tmp96_); + ExcludeListLabel = _tmp96_; + _tmp97_ = (GtkTextView*) gtk_text_view_new (); + g_object_ref_sink (_tmp97_); + ExcludeList = _tmp97_; + _tmp98_ = ExcludeList; + gtk_text_view_set_editable (_tmp98_, TRUE); + _tmp99_ = ExcludeList; + gtk_text_view_set_cursor_visible (_tmp99_, TRUE); + _tmp100_ = ExcludeList; + _tmp101_ = _data1_->black_color; + gtk_widget_override_background_color ((GtkWidget*) _tmp100_, GTK_STATE_FLAG_NORMAL, &_tmp101_); + _tmp102_ = ExcludePanel; + gtk_container_set_border_width ((GtkContainer*) _tmp102_, (guint) 10); + _tmp103_ = ExcludePanel; + gtk_scrolled_window_set_max_content_height (_tmp103_, 50); + _tmp104_ = ExcludePanel; + _tmp105_ = ExcludeList; + gtk_container_add ((GtkContainer*) _tmp104_, (GtkWidget*) _tmp105_); + _tmp106_ = cr15; + _tmp107_ = ExcludeListLabel; + gtk_box_pack_start (_tmp106_, (GtkWidget*) _tmp107_, TRUE, TRUE, (guint) 0); + _tmp108_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20); + g_object_ref_sink (_tmp108_); + cr151 = _tmp108_; + _tmp109_ = cr151; + _tmp110_ = (GtkLabel*) gtk_label_new (NULL); + g_object_ref_sink (_tmp110_); + _tmp111_ = _tmp110_; + gtk_box_pack_start (_tmp109_, (GtkWidget*) _tmp111_, FALSE, FALSE, (guint) 5); + _g_object_unref0 (_tmp111_); + _tmp112_ = cr151; + _tmp113_ = ExcludePanel; + gtk_box_pack_start (_tmp112_, (GtkWidget*) _tmp113_, TRUE, TRUE, (guint) 0); + _tmp114_ = cr151; + _tmp115_ = (GtkLabel*) gtk_label_new (NULL); + g_object_ref_sink (_tmp115_); + _tmp116_ = _tmp115_; + gtk_box_pack_start (_tmp114_, (GtkWidget*) _tmp116_, FALSE, FALSE, (guint) 5); + _g_object_unref0 (_tmp116_); + _tmp117_ = cr15; + _tmp118_ = cr151; + gtk_box_pack_start (_tmp117_, (GtkWidget*) _tmp118_, FALSE, FALSE, (guint) 0); + _tmp119_ = _data1_->cr1; + _tmp120_ = cr15; + gtk_box_pack_start (_tmp119_, (GtkWidget*) _tmp120_, FALSE, FALSE, (guint) 0); + _tmp121_ = (GtkButton*) gtk_button_new_with_label ("✔ Make snapshot"); + g_object_ref_sink (_tmp121_); + finbutcr = _tmp121_; + _tmp122_ = finbutcr; + _tmp123_ = green_color; + gtk_widget_override_background_color ((GtkWidget*) _tmp122_, GTK_STATE_FLAG_NORMAL, &_tmp123_); + _tmp124_ = cr12; + _tmp125_ = finbutcr; + gtk_box_pack_end (_tmp124_, (GtkWidget*) _tmp125_, FALSE, FALSE, (guint) 10); + _tmp126_ = finbutcr; + g_signal_connect_data (_tmp126_, "clicked", (GCallback) __my_app_window___lambda6__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0); + _tmp127_ = _data1_->cr1; + _tmp128_ = cr12; + gtk_box_pack_end (_tmp127_, (GtkWidget*) _tmp128_, FALSE, FALSE, (guint) 10); + _tmp129_ = _data1_->actualstack; + gtk_container_add ((GtkContainer*) self, (GtkWidget*) _tmp129_); + _tmp130_ = _data1_->actualstack; + _tmp131_ = my_app_header_bar_new (_tmp130_); + g_object_ref_sink (_tmp131_); + headerbar = _tmp131_; + _tmp132_ = headerbar; + gtk_window_set_titlebar ((GtkWindow*) self, (GtkWidget*) _tmp132_); + g_object_set ((GtkWindow*) self, "window-position", GTK_WIN_POS_CENTER, NULL); + g_object_set ((GtkWindow*) self, "window-position", GTK_WIN_POS_CENTER, NULL); + gtk_window_set_default_size ((GtkWindow*) self, 800, 600); + gtk_window_set_resizable ((GtkWindow*) self, FALSE); + gtk_widget_show_all ((GtkWidget*) self); + g_print ("Hey, thanks for choosing nostalgia! \n"); + g_print ("If you're looking at the debug output most probably you're having some" \ +" trouble with this program, so feel free to contact me and I'll see if" \ +" I can help \n"); + g_print ("\n\n"); + g_print ("email: [ioachim.radu@protonmail.com]\n"); + g_print ("webpage: [ioachim.eu.org]\n"); + g_print ("pgp: [C2462D5103FA6059E1E3279C9E9299CD96C65EC6]\n"); + g_print ("\n\n"); + _g_object_unref0 (headerbar); + _g_object_unref0 (finbutcr); + _g_object_unref0 (cr151); + _g_object_unref0 (ExcludeList); + _g_object_unref0 (ExcludeListLabel); + _g_object_unref0 (ExcludePanel); + _g_object_unref0 (cr15); + _g_object_unref0 (crbackbutton); + _g_object_unref0 (cr12); + _g_object_unref0 (cr1label); + _g_object_unref0 (cr11); + _g_object_unref0 (gridfbr); + _g_object_unref0 (button1r); + _g_object_unref0 (label1r); + _g_object_unref0 (gridfb); + _g_object_unref0 (button1); + _g_object_unref0 (label1); + _g_object_unref0 (memr); + _g_object_unref0 (memc); + block1_data_unref (_data1_); + _data1_ = NULL; + return obj; +} + +static void +my_app_window_class_init (MyAppWindowClass * klass, + gpointer klass_data) +{ + my_app_window_parent_class = g_type_class_peek_parent (klass); + g_type_class_adjust_private_offset (klass, &MyAppWindow_private_offset); + G_OBJECT_CLASS (klass)->constructor = my_app_window_constructor; + G_OBJECT_CLASS (klass)->finalize = my_app_window_finalize; +} + +static void +my_app_window_instance_init (MyAppWindow * self, + gpointer klass) +{ + self->priv = my_app_window_get_instance_private (self); +} + +static void +my_app_window_finalize (GObject * obj) +{ + MyAppWindow * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, MY_APP_TYPE_WINDOW, MyAppWindow); + _g_free0 (self->priv->laoutput); + G_OBJECT_CLASS (my_app_window_parent_class)->finalize (obj); +} + +static GType +my_app_window_get_type_once (void) +{ + static const GTypeInfo g_define_type_info = { sizeof (MyAppWindowClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) my_app_window_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MyAppWindow), 0, (GInstanceInitFunc) my_app_window_instance_init, NULL }; + GType my_app_window_type_id; + my_app_window_type_id = g_type_register_static (gtk_application_window_get_type (), "MyAppWindow", &g_define_type_info, 0); + MyAppWindow_private_offset = g_type_add_instance_private (my_app_window_type_id, sizeof (MyAppWindowPrivate)); + return my_app_window_type_id; +} + +GType +my_app_window_get_type (void) +{ + static volatile gsize my_app_window_type_id__once = 0; + if (g_once_init_enter (&my_app_window_type_id__once)) { + GType my_app_window_type_id; + my_app_window_type_id = my_app_window_get_type_once (); + g_once_init_leave (&my_app_window_type_id__once, my_app_window_type_id); + } + return my_app_window_type_id__once; +} + +static void +update_label_from_istream_data_free (gpointer _data) +{ + UpdateLabelFromIstreamData* _data_; + _data_ = _data; + _g_object_unref0 (_data_->istream); + _g_object_unref0 (_data_->label); + _g_object_unref0 (_data_->ProgBar); + _g_object_unref0 (_data_->ProgLabel); + g_slice_free (UpdateLabelFromIstreamData, _data_); +} + +void +update_label_from_istream (GInputStream* istream, + GtkTextView* label, + GtkProgressBar* ProgBar, + GtkLabel* ProgLabel, + GAsyncReadyCallback _callback_, + gpointer _user_data_) +{ + UpdateLabelFromIstreamData* _data_; + GInputStream* _tmp0_; + GtkTextView* _tmp1_; + GtkProgressBar* _tmp2_; + GtkLabel* _tmp3_; + g_return_if_fail (istream != NULL); + g_return_if_fail (label != NULL); + g_return_if_fail (ProgBar != NULL); + g_return_if_fail (ProgLabel != NULL); + _data_ = g_slice_new0 (UpdateLabelFromIstreamData); + _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_); + g_task_set_task_data (_data_->_async_result, _data_, update_label_from_istream_data_free); + _tmp0_ = _g_object_ref0 (istream); + _g_object_unref0 (_data_->istream); + _data_->istream = _tmp0_; + _tmp1_ = _g_object_ref0 (label); + _g_object_unref0 (_data_->label); + _data_->label = _tmp1_; + _tmp2_ = _g_object_ref0 (ProgBar); + _g_object_unref0 (_data_->ProgBar); + _data_->ProgBar = _tmp2_; + _tmp3_ = _g_object_ref0 (ProgLabel); + _g_object_unref0 (_data_->ProgLabel); + _data_->ProgLabel = _tmp3_; + update_label_from_istream_co (_data_); +} + +void +update_label_from_istream_finish (GAsyncResult* _res_) +{ + UpdateLabelFromIstreamData* _data_; + _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL); +} + +static void +update_label_from_istream_ready (GObject* source_object, + GAsyncResult* _res_, + gpointer _user_data_) +{ + UpdateLabelFromIstreamData* _data_; + _data_ = _user_data_; + _data_->_source_object_ = source_object; + _data_->_res_ = _res_; + update_label_from_istream_co (_data_); +} + +static gchar +string_get (const gchar* self, + glong index) +{ + gchar _tmp0_; + gchar result; + g_return_val_if_fail (self != NULL, '\0'); + _tmp0_ = ((gchar*) self)[index]; + result = _tmp0_; + return result; +} + +static glong +string_strnlen (gchar* str, + glong maxlen) +{ + gchar* end = NULL; + gchar* _tmp0_; + gchar* _tmp1_; + glong result; + _tmp0_ = memchr (str, 0, (gsize) maxlen); + end = _tmp0_; + _tmp1_ = end; + if (_tmp1_ == NULL) { + result = maxlen; + return result; + } else { + gchar* _tmp2_; + _tmp2_ = end; + result = (glong) (_tmp2_ - str); + return result; + } +} + +static gchar* +string_substring (const gchar* self, + glong offset, + glong len) +{ + glong string_length = 0L; + gboolean _tmp0_ = FALSE; + gchar* _tmp3_; + gchar* result; + g_return_val_if_fail (self != NULL, NULL); + if (offset >= ((glong) 0)) { + _tmp0_ = len >= ((glong) 0); + } else { + _tmp0_ = FALSE; + } + if (_tmp0_) { + string_length = string_strnlen ((gchar*) self, offset + len); + } else { + gint _tmp1_; + gint _tmp2_; + _tmp1_ = strlen (self); + _tmp2_ = _tmp1_; + string_length = (glong) _tmp2_; + } + if (offset < ((glong) 0)) { + offset = string_length + offset; + g_return_val_if_fail (offset >= ((glong) 0), NULL); + } else { + g_return_val_if_fail (offset <= string_length, NULL); + } + if (len < ((glong) 0)) { + len = string_length - offset; + } + g_return_val_if_fail ((offset + len) <= string_length, NULL); + _tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len); + result = _tmp3_; + return result; +} + +static gchar* +double_to_string (gdouble self) +{ + gchar* _tmp0_; + gchar* _tmp1_; + gint _tmp1__length1; + const gchar* _tmp2_; + gchar* _tmp3_; + gchar* _tmp4_; + gchar* result; + _tmp0_ = g_new0 (gchar, G_ASCII_DTOSTR_BUF_SIZE); + _tmp1_ = _tmp0_; + _tmp1__length1 = G_ASCII_DTOSTR_BUF_SIZE; + _tmp2_ = g_ascii_dtostr (_tmp1_, (gint) G_ASCII_DTOSTR_BUF_SIZE, self); + _tmp3_ = g_strdup (_tmp2_); + _tmp4_ = _tmp3_; + _tmp1_ = (g_free (_tmp1_), NULL); + result = _tmp4_; + return result; +} + +static gboolean +update_label_from_istream_co (UpdateLabelFromIstreamData* _data_) +{ + switch (_data_->_state_) { + case 0: + goto _state_0; + case 1: + goto _state_1; + case 2: + goto _state_2; + default: + g_assert_not_reached (); + } + _state_0: + { + _data_->_tmp0_ = g_data_input_stream_new (_data_->istream); + _data_->dis = _data_->_tmp0_; + _data_->_tmp1_ = _data_->dis; + _data_->_state_ = 1; + g_data_input_stream_read_line_async (_data_->_tmp1_, G_PRIORITY_DEFAULT, NULL, update_label_from_istream_ready, _data_); + return FALSE; + _state_1: + _data_->_tmp2_ = g_data_input_stream_read_line_finish (_data_->_tmp1_, _data_->_res_, NULL, &_data_->_inner_error0_); + _data_->line = _data_->_tmp2_; + if (G_UNLIKELY (_data_->_inner_error0_ != NULL)) { + _g_object_unref0 (_data_->dis); + goto __catch0_g_error; + } + while (TRUE) { + _data_->_tmp3_ = _data_->line; + if (!(_data_->_tmp3_ != NULL)) { + break; + } + if (timer == 5) { + _data_->_tmp4_ = gtk_text_view_get_buffer (_data_->label); + _data_->_tmp5_ = _data_->_tmp4_; + g_object_set (_data_->_tmp5_, "text", "", NULL); + timer = 0; + } + _data_->_tmp6_ = gtk_text_view_get_buffer (_data_->label); + _data_->_tmp7_ = _data_->_tmp6_; + _data_->_tmp8_ = gtk_text_view_get_buffer (_data_->label); + _data_->_tmp9_ = _data_->_tmp8_; + g_object_get (_data_->_tmp9_, "text", &_data_->_tmp10_, NULL); + _data_->_tmp11_ = _data_->_tmp10_; + _data_->_tmp12_ = _data_->_tmp11_; + _data_->_tmp13_ = _data_->line; + _data_->_tmp14_ = g_strconcat (_data_->_tmp13_, "\n", NULL); + _data_->_tmp15_ = _data_->_tmp14_; + _data_->_tmp16_ = g_strconcat (_data_->_tmp12_, _data_->_tmp15_, NULL); + _data_->_tmp17_ = _data_->_tmp16_; + g_object_set (_data_->_tmp9_, "text", _data_->_tmp17_, NULL); + _g_free0 (_data_->_tmp17_); + _g_free0 (_data_->_tmp15_); + _g_free0 (_data_->_tmp12_); + _data_->_tmp18_ = _data_->line; + g_print ("%s", _data_->_tmp18_); + g_print ("\n"); + _data_->_tmp19_ = _data_->line; + _data_->_tmp21_ = _data_->_tmp20_ = g_strsplit (_data_->_tmp19_, " ", 0); + _data_->words = _data_->_tmp21_; + _data_->words_length1 = _vala_array_length (_data_->_tmp20_); + _data_->_words_size_ = _data_->words_length1; + _data_->_tmp22_ = _data_->words; + _data_->_tmp22__length1 = _data_->words_length1; + { + _data_->word_collection_length1 = 0; + _data_->_word_collection_size_ = 0; + _data_->word_collection = _data_->_tmp22_; + _data_->word_collection_length1 = _data_->_tmp22__length1; + for (_data_->word_it = 0; _data_->word_it < _data_->word_collection_length1; _data_->word_it = _data_->word_it + 1) { + _data_->word = _data_->word_collection[_data_->word_it]; + { + _data_->_tmp23_ = _data_->word; + _data_->_tmp24_ = _data_->word; + _data_->_tmp25_ = strlen (_data_->_tmp24_); + _data_->_tmp26_ = _data_->_tmp25_; + if (string_get (_data_->_tmp23_, (glong) (_data_->_tmp26_ - 1)) == '%') { + _data_->_tmp27_ = _data_->word; + _data_->_tmp28_ = _data_->word; + _data_->_tmp29_ = strlen (_data_->_tmp28_); + _data_->_tmp30_ = _data_->_tmp29_; + _data_->_tmp31_ = string_substring (_data_->_tmp27_, (glong) 0, (glong) (_data_->_tmp30_ - 1)); + _data_->word_trimmed = _data_->_tmp31_; + _data_->_tmp32_ = _data_->word_trimmed; + _data_->procDone = ((gdouble) StrToInt (_data_->_tmp32_)) / ((gdouble) 100); + gtk_progress_bar_set_fraction (_data_->ProgBar, _data_->procDone); + _data_->_tmp33_ = _data_->word_trimmed; + gtk_progress_bar_set_text (_data_->ProgBar, _data_->_tmp33_); + _data_->_tmp34_ = _data_->word_trimmed; + _data_->_tmp35_ = g_strconcat (_data_->_tmp34_, "%", NULL); + _data_->_tmp36_ = _data_->_tmp35_; + gtk_label_set_text (_data_->ProgLabel, _data_->_tmp36_); + _g_free0 (_data_->_tmp36_); + _data_->_tmp37_ = double_to_string (_data_->procDone); + _data_->_tmp38_ = _data_->_tmp37_; + _data_->_tmp39_ = g_strconcat (_data_->_tmp38_, " ", NULL); + _data_->_tmp40_ = _data_->_tmp39_; + g_print ("%s", _data_->_tmp40_); + _g_free0 (_data_->_tmp40_); + _g_free0 (_data_->_tmp38_); + _g_free0 (_data_->word_trimmed); + } + } + } + } + _data_->_tmp41_ = timer; + timer = _data_->_tmp41_ + 1; + _data_->_tmp43_ = _data_->dis; + _data_->_state_ = 2; + g_data_input_stream_read_line_async (_data_->_tmp43_, G_PRIORITY_DEFAULT, NULL, update_label_from_istream_ready, _data_); + return FALSE; + _state_2: + _data_->_tmp44_ = g_data_input_stream_read_line_finish (_data_->_tmp43_, _data_->_res_, NULL, &_data_->_inner_error0_); + _data_->_tmp42_ = _data_->_tmp44_; + if (G_UNLIKELY (_data_->_inner_error0_ != NULL)) { + _data_->words = (_vala_array_free (_data_->words, _data_->words_length1, (GDestroyNotify) g_free), NULL); + _g_free0 (_data_->line); + _g_object_unref0 (_data_->dis); + goto __catch0_g_error; + } + _data_->_tmp45_ = _data_->_tmp42_; + _data_->_tmp42_ = NULL; + _g_free0 (_data_->line); + _data_->line = _data_->_tmp45_; + _g_free0 (_data_->_tmp42_); + _data_->words = (_vala_array_free (_data_->words, _data_->words_length1, (GDestroyNotify) g_free), NULL); + } + _g_free0 (_data_->line); + _g_object_unref0 (_data_->dis); + } + goto __finally0; + __catch0_g_error: + { + g_clear_error (&_data_->_inner_error0_); + } + __finally0: + if (G_UNLIKELY (_data_->_inner_error0_ != NULL)) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error0_->message, g_quark_to_string (_data_->_inner_error0_->domain), _data_->_inner_error0_->code); + g_clear_error (&_data_->_inner_error0_); + g_object_unref (_data_->_async_result); + return FALSE; + } + g_task_return_pointer (_data_->_async_result, _data_, NULL); + if (_data_->_state_ != 0) { + while (!g_task_get_completed (_data_->_async_result)) { + g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE); + } + } + g_object_unref (_data_->_async_result); + return FALSE; +} + +gint +StrToInt (const gchar* str) +{ + gint ret = 0; + gint result; + g_return_val_if_fail (str != NULL, 0); + ret = 0; + { + gint i = 0; + i = 0; + { + gboolean _tmp0_ = FALSE; + _tmp0_ = TRUE; + while (TRUE) { + gint _tmp2_; + gint _tmp3_; + if (!_tmp0_) { + gint _tmp1_; + _tmp1_ = i; + i = _tmp1_ + 1; + } + _tmp0_ = FALSE; + _tmp2_ = strlen (str); + _tmp3_ = _tmp2_; + if (!(i < _tmp3_)) { + break; + } + ret *= 10; + ret += (gint) (string_get (str, (glong) i) - '0'); + } + } + } + result = ret; + return result; +} + +static void +_vala_array_destroy (gpointer array, + gssize array_length, + GDestroyNotify destroy_func) +{ + if ((array != NULL) && (destroy_func != NULL)) { + gssize i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + +static void +_vala_array_free (gpointer array, + gssize array_length, + GDestroyNotify destroy_func) +{ + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + +static gssize +_vala_array_length (gpointer array) +{ + gssize length; + length = 0; + if (array) { + while (((gpointer*) array)[length]) { + length++; + } + } + return length; +} + diff --git a/Window.vala b/Window.vala index 792e693..ed4526e 100644 --- a/Window.vala +++ b/Window.vala @@ -66,6 +66,8 @@ For when you need them the most"); blue_color.parse("#0860F2"); var green_color = new Gdk.RGBA(); green_color.parse("#59C837"); + var black_color = new Gdk.RGBA(); + black_color.parse("#15161E"); button1.override_background_color(Gtk.StateFlags.NORMAL, green_color); var gridfb = new Gtk.Grid(); gridfb.attach(button1, 1, 1); @@ -135,7 +137,7 @@ so please be patient and let us get your system back and running"), true, false, } }); cr12.pack_start(crbackbutton, false, false, 10); - var packhome = new Gtk.Switch(); + /*var packhome = new Gtk.Switch(); packhome.set_state(true); var cr14 = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 0); cr14.pack_start(new Gtk.Label(""), true, true, 10); @@ -145,6 +147,37 @@ so please be patient and let us get your system back and running"), true, false, cr14.pack_start(packhome, false, false, 10); cr14.pack_start(new Gtk.Label(""), true, true, 10); cr1.pack_start(cr14, false, false, 0); + */ + + var cr15 = new Gtk.Box(Gtk.Orientation.VERTICAL, 20); + + var ExcludePanel = new Gtk.ScrolledWindow(null, null); + + var ExcludeListLabel = new Gtk.Label("Type Every Folder to be EXCLUDED from the Backup, using ABSOLUTE paths, one per line"); + + var ExcludeList = new Gtk.TextView(); + ExcludeList.set_editable(true); + ExcludeList.set_cursor_visible(true); + ExcludeList.override_background_color(Gtk.StateFlags.NORMAL, black_color); + + ExcludePanel.set_border_width(10); + ExcludePanel.set_max_content_height(50); + + ExcludePanel.add(ExcludeList); + + cr15.pack_start(ExcludeListLabel); + + var cr151 = new Gtk.Box(Gtk.Orientation.HORIZONTAL, 20); + cr151.pack_start(new Gtk.Label(null), false, false, 5); + + cr151.pack_start(ExcludePanel); + + cr151.pack_start(new Gtk.Label(null), false, false, 5); + + cr15.pack_start(cr151, false, false ,0); + + cr1.pack_start(cr15, false, false, 0); + var finbutcr = new Gtk.Button.with_label("✔ Make snapshot"); finbutcr.override_background_color(Gtk.StateFlags.NORMAL, green_color); cr12.pack_end(finbutcr, false, false, 10); @@ -153,6 +186,7 @@ so please be patient and let us get your system back and running"), true, false, print(crloc1.get_filename()); string loc = crloc1.get_filename(); print("\n"); + print(crloc1.get_filename()); if (crloc1.get_filename() == null){ var ibl = new Gtk.Dialog.with_buttons("Invaild backup location", this, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT | Gtk.DialogFlags.USE_HEADER_BAR, null); var iblca = ibl.get_content_area(); @@ -176,13 +210,24 @@ so please be patient and let us get your system back and running"), true, false, var lbl = new Gtk.TextView(); lbl.set_wrap_mode (Gtk.WrapMode.WORD); - lbl.set_monospace(true); + //lbl.set_monospace(true); + lbl.override_background_color(Gtk.StateFlags.NORMAL, black_color); var lblScroll = new Gtk.ScrolledWindow(null, null); lblScroll.add(lbl); - lblScroll.set_max_content_height(100); + lblScroll.set_max_content_height(600); progresscr.pack_start(lblScroll); + + var ProgBar = new Gtk.ProgressBar(); + + progresscr.pack_end(ProgBar); + + var ProgLabel = new Gtk.Label("Nostalgia Progress: 0%"); + + progresscr.pack_end(ProgLabel); + + //The length will never be the same if the file is not found if(isfile.char_count() != isft.char_count()){ print("\n root backup \n"); @@ -199,7 +244,12 @@ so please be patient and let us get your system back and running"), true, false, int dum; bool lop=true; - string[] backup_command = {"/usr/bin/rsync", "-av", "/home/ioachim/Music", "/home/ioachim/Music2", "--no-i-r", "--info=progress2", null}; + string[] backup_command_template = {"/usr/bin/pkexec", "/usr/bin/rsync", "-ahv", "/home/ioachim/Music", "/home/ioachim/Music2", "--no-i-r", "--info=progress2", "--fsync", null}; + + var ExcludeFolders = ExcludeList.get_text().split('\n'); + + + var ChildProcessBackup = new Subprocess.newv(backup_command, SubprocessFlags.STDOUT_PIPE); @@ -215,16 +265,41 @@ so please be patient and let us get your system back and running"), true, false, notification.set_timeout(0); notification.show(); + print("\nREMOVING CHILDREN FROM PAGE\n"); + var progresscrChildren = progresscr.get_children(); + foreach (Gtk.Widget element in progresscrChildren) + progresscr.remove(element); + }catch(Error err){ print("\n\n------ERROR!!!------\n%s\n\n", err.message); + + createstack.set_visible_child(cr1); + + var ibl = new Gtk.Dialog.with_buttons("Error Spawning Process", this, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT | Gtk.DialogFlags.USE_HEADER_BAR, null); + var iblca = ibl.get_content_area(); + iblca.add(new Gtk.Label(" + + ")); + iblca.add(new Gtk.Label(" Make sure /usr/bin/rsync is installed, up to date and that you have root privileges and have inputed your correct user password ")); + iblca.add(new Gtk.Label(" + + ")); + ibl.show_all(); + + print("\nREMOVING CHILDREN FROM PAGE\n"); + var progresscrChildren = progresscr.get_children(); + foreach (Gtk.Widget element in progresscrChildren) + progresscr.remove(element); + + ssnap = false; } }); var OutputPipeBackup = ChildProcessBackup.get_stdout_pipe(); - update_label_from_istream.begin(OutputPipeBackup, lbl); + update_label_from_istream.begin(OutputPipeBackup, lbl, ProgBar, ProgLabel); } } @@ -241,19 +316,58 @@ so please be patient and let us get your system back and running"), true, false, set_resizable(false); show_all(); print("Hey, thanks for choosing nostalgia! \n"); - print("If you're looking at the debug output most probably you're having some trouble with this program, so feel free to email me at [ioachim.radu@protonmail.com] and I'll see if I can help \n"); + print("If you're looking at the debug output most probably you're having some trouble with this program, so feel free to contact me and I'll see if I can help \n"); + print("\n\n"); + print("email: [ioachim.radu@protonmail.com]\n"); + print("webpage: [ioachim.eu.org]\n"); + print("pgp: [C2462D5103FA6059E1E3279C9E9299CD96C65EC6]\n"); + print("\n\n"); } } +int timer = 0; - -async void update_label_from_istream (InputStream istream, Gtk.TextView label) { +async void update_label_from_istream (InputStream istream, Gtk.TextView label, Gtk.ProgressBar ProgBar, Gtk.Label ProgLabel) { try { + var dis = new DataInputStream (istream); var line = yield dis.read_line_async (); while (line != null) { + if(timer == 5){ + label.buffer.text = ""; + timer = 0; + } label.buffer.text += line + "\n"; + print(line); + print("\n"); + + var words = line.split(" "); + + foreach(unowned string word in words){ + if(word[word.length - 1] == '%'){ + var word_trimmed = word.substring(0, word.length - 1); + double procDone = (double)StrToInt(word_trimmed) / (double)100; + ProgBar.set_fraction(procDone); + ProgBar.set_text(word_trimmed); + ProgLabel.set_text(word_trimmed + "%"); + + print(procDone.to_string() + " "); + } + } + + timer++; line = yield dis.read_line_async (); } } catch (Error err) {} } + + +int StrToInt(string str){ + int ret = 0; + for(int i = 0; i < str.length; i++){ + ret *= 10; + ret += (str[i] - '0'); //get char code offset to zero of digit + } + + return ret; +} diff --git a/listbox b/listbox new file mode 100755 index 0000000000000000000000000000000000000000..bff3888771b596239d15b8c4d96a4d9ab9bd920e GIT binary patch literal 21664 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 literal 0 HcmV?d00001 diff --git a/listbox.vala b/listbox.vala new file mode 100644 index 0000000..ed4fae2 --- /dev/null +++ b/listbox.vala @@ -0,0 +1,53 @@ +/* + * A Notebook can be used to provide tabulated pages on which different content + * can be added. + * + * Compile using: + * valac notebook.vala --pkg gtk+-3.0 + * + * Author: Andrew Steele +*/ + +using Gtk; + +public class Example : Window +{ + private Notebook notebook; + + public Example() + { + this.title = "Notebook"; + this.set_default_size(200, 200); + this.destroy.connect(Gtk.main_quit); + + notebook = new Notebook(); + this.add(notebook); + + int count; + + for (count = 1; count <= 3; count++) + { + var text1 = "Tab %i".printf(count); + + var label = new Label(null); + label.set_label(text1); + + var text2 = "Button %i in Tab %i".printf(count, count); + + var button = new Button.with_label(text2); + notebook.append_page(button, label); + } + } + + public static int main(string[] args) + { + Gtk.init(ref args); + + var window = new Example(); + window.show_all(); + + Gtk.main(); + + return 0; + } +} diff --git a/nostalgia b/nostalgia index 24a36c02ecf19a349576182aaf7cf27ff517d67d..f108dc537a1ca143269e6bc25e624af7102e73aa 100755 GIT binary patch literal 62680 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 E51CvtB>(^b