Implement graceful shutdown

Author: codeation

call.c

@@ -11,8 +11,13 @@ static void commandVersion() {
 // exit
 
 static void commandExit(pipe_buffer *target) {
+    static int exitCount = 0;
+    if (exitCount++ == 0) {
+        top_signal_disconnect();
+    }
     io_stop(target);
     if (io_exited()) {
+        gtk_widget_destroy(top);
         g_application_quit(G_APPLICATION(app));
     }
 }
@@ -225,7 +230,6 @@ _Static_assert(sizeof size == 8, "wrong size align");
 static void setSize() {
     gtk_window_move(GTK_WINDOW(top), size.x, size.y);
     gtk_window_resize(GTK_WINDOW(top), size.width, size.height);
-    // gtk_widget_show(top);
 }
 
 static void commandSize(pipe_buffer *target) { parameters_to_call(target, &size, sizeof size, setSize); }

event.c

@@ -1,3 +1,4 @@
+#include "glib-object.h"
 #include "terminal.h"
 #include <gtk/gtk.h>
 #include <math.h>
@@ -46,7 +47,7 @@ static void write_configure_event_once(configure_event *e) {
     pipe_event_flush();
 }
 
-static void on_size_allocate(GtkWidget *widget, GtkAllocation *allocation, void *data) {
+static void on_size_allocate(GtkWidget *widget, GtkAllocation *allocation, gpointer data) {
     layoutOffsetX = allocation->x;
     layoutOffsetY = allocation->y;
     gint width, height;
@@ -201,7 +202,7 @@ void request_clipboard(int clipboardtypeid) {
 
 // Clipboard funcs
 
-void set_clipboard(int clipboardtypeid, void *data) {
+void set_clipboard(int clipboardtypeid, gpointer data) {
     GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
     gtk_clipboard_set_text(clipboard, data, -1); // TODO text only
 }
@@ -217,6 +218,18 @@ void top_signal_connect() {
     g_signal_connect(top, "scroll-event", G_CALLBACK(s_scroll), NULL);
 }
 
+void top_signal_disconnect() {
+    g_signal_handlers_disconnect_by_func(top, G_CALLBACK(on_delete), NULL);
+    g_signal_handlers_disconnect_by_func(top, G_CALLBACK(s_keypress), NULL);
+    g_signal_handlers_disconnect_by_func(top, G_CALLBACK(s_button), NULL);
+    g_signal_handlers_disconnect_by_func(top, G_CALLBACK(s_motion), NULL);
+    g_signal_handlers_disconnect_by_func(top, G_CALLBACK(s_scroll), NULL);
+}
+
 void layout_signal_connect(GtkWidget *layout) {
     g_signal_connect(layout, "size-allocate", G_CALLBACK(on_size_allocate), NULL);
 }
+
+void layout_signal_disconnect(GtkWidget *layout) {
+    g_signal_handlers_disconnect_by_func(layout, G_CALLBACK(on_size_allocate), NULL);
+}

four/call.c

@@ -11,8 +11,13 @@ static void commandVersion() {
 // exit
 
 static void commandExit(pipe_buffer *target) {
+    static int exitCount = 0;
+    if (exitCount++ == 0) {
+        top_signal_disconnect();
+    }
     io_stop(target);
     if (io_exited()) {
+        gtk_window_destroy(GTK_WINDOW(top));
         g_application_quit(G_APPLICATION(app));
     }
 }

four/event.c

@@ -1,3 +1,4 @@
+#include "glib-object.h"
 #include "terminal.h"
 #include <gtk/gtk.h>
 
@@ -48,7 +49,7 @@ static void write_configure_event_once(configure_event *e) {
 static int idle_count = 0;
 static GtkWidget *inner_size_widget = NULL;
 
-static void on_configure_event(gpointer user_data) {
+static void on_configure_event(gpointer data) {
     int inner_width = gtk_widget_get_width(inner_size_widget);
     int inner_height = gtk_widget_get_height(inner_size_widget);
     if (inner_width == 0 && inner_height == 0) {
@@ -64,25 +65,25 @@ static void on_configure_event(gpointer user_data) {
     write_configure_event_once(&e);
 }
 
-static gboolean idle_func(gpointer user_data) {
+static gboolean idle_func(gpointer data) {
     idle_count--;
     if (idle_count > 0) {
         return G_SOURCE_CONTINUE;
     }
-    on_configure_event(user_data);
+    on_configure_event(data);
     return G_SOURCE_REMOVE;
 }
 
-static void size_notify(GObject *self, GParamSpec *pspec, gpointer user_data) {
+static void size_notify(GObject *self, GParamSpec *pspec, gpointer data) {
     if (idle_count <= 0) {
-        g_idle_add(idle_func, user_data);
+        g_idle_add(idle_func, data);
     }
     idle_count++;
 }
 
-static void adjustment_notify(GtkAdjustment *self, gpointer user_data) {
+static void adjustment_notify(GtkAdjustment *self, gpointer data) {
     if (idle_count <= 0) {
-        g_idle_add(idle_func, user_data);
+        g_idle_add(idle_func, data);
     }
     idle_count++;
 }
@@ -100,7 +101,7 @@ typedef struct {
 _Static_assert(sizeof(keyboard_event) == 8, "wrong keyboard_event align");
 
 static gboolean key_pressed(GtkEventControllerKey *self, guint keyval, guint keycode, GdkModifierType state,
-                            gpointer user_data) {
+                            gpointer data) {
     char command_type = 'k';
     keyboard_event e;
     e.unicode = gdk_keyval_to_unicode(keyval);
@@ -142,7 +143,7 @@ static int buttonType(int n_press) {
 static guint32 prev_button_time = 0;
 static GdkEventType prev_button_type = 0;
 
-static void button_pressed(GtkGestureClick *self, gint n_press, gdouble x, gdouble y, gpointer user_data) {
+static void button_pressed(GtkGestureClick *self, gint n_press, gdouble x, gdouble y, gpointer data) {
     GdkEvent *event = gtk_event_controller_get_current_event(GTK_EVENT_CONTROLLER(self));
     if (gdk_event_get_time(event) == prev_button_time && gdk_event_get_event_type(event) == prev_button_type) {
         return;
@@ -160,7 +161,7 @@ static void button_pressed(GtkGestureClick *self, gint n_press, gdouble x, gdoub
     pipe_event_flush();
 }
 
-static void button_released(GtkGestureClick *self, gint n_press, gdouble x, gdouble y, gpointer user_data) {
+static void button_released(GtkGestureClick *self, gint n_press, gdouble x, gdouble y, gpointer data) {
     GdkEvent *event = gtk_event_controller_get_current_event(GTK_EVENT_CONTROLLER(self));
     if (gdk_event_get_time(event) == prev_button_time && gdk_event_get_event_type(event) == prev_button_type) {
         return;
@@ -188,7 +189,7 @@ typedef struct {
 
 _Static_assert(sizeof(motion_event) == 8, "wrong motion_event align");
 
-static void motion_notify(GtkEventControllerMotion *self, gdouble x, gdouble y, gpointer user_data) {
+static void motion_notify(GtkEventControllerMotion *self, gdouble x, gdouble y, gpointer data) {
     GdkEvent *event = gtk_event_controller_get_current_event(GTK_EVENT_CONTROLLER(self));
     if (gdk_event_get_time(event) == prev_button_time && gdk_event_get_event_type(event) == prev_button_type) {
         return;
@@ -216,7 +217,7 @@ typedef struct {
 
 _Static_assert(sizeof(scroll_event) == 6, "wrong scroll_event align");
 
-static gboolean scroll_notify(GtkEventControllerScroll *self, gdouble dx, gdouble dy, gpointer user_data) {
+static gboolean scroll_notify(GtkEventControllerScroll *self, gdouble dx, gdouble dy, gpointer data) {
     char command_type = 's';
     scroll_event e;
     e.direction = 4;
@@ -276,30 +277,51 @@ void set_clipboard(int clipboardtypeid, void *data) {
 
 void top_signal_connect() { g_signal_connect(top, "close-request", G_CALLBACK(on_delete), NULL); }
 
+void top_signal_disconnect() { g_signal_handlers_disconnect_by_func(top, G_CALLBACK(on_delete), NULL); }
+
+static GtkEventController *keyEventController;
+static GtkGesture *getstureConroller;
+static GtkEventController *motionEventController;
+static GtkEventController *scrollEventController;
+
 void layout_signal_connect(GtkWidget *scrolled, GtkAdjustment *adjustment) {
     inner_size_widget = scrolled;
     g_signal_connect(top, "notify::default-width", G_CALLBACK(size_notify), NULL);
     g_signal_connect(top, "notify::default-height", G_CALLBACK(size_notify), NULL);
     g_signal_connect(adjustment, "changed", G_CALLBACK(adjustment_notify), NULL);
     g_signal_connect(adjustment, "value-changed", G_CALLBACK(adjustment_notify), NULL);
 
-    GtkEventController *keyEventController = gtk_event_controller_key_new();
+    keyEventController = gtk_event_controller_key_new();
     g_signal_connect(keyEventController, "key-pressed", G_CALLBACK(key_pressed), NULL);
     gtk_widget_add_controller(scrolled, keyEventController);
 
-    GtkGesture *getstureConroller = gtk_gesture_click_new();
+    getstureConroller = gtk_gesture_click_new();
     gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(getstureConroller), 0);
     gtk_gesture_single_set_touch_only(GTK_GESTURE_SINGLE(getstureConroller), FALSE);
     g_signal_connect(getstureConroller, "pressed", G_CALLBACK(button_pressed), NULL);
     g_signal_connect(getstureConroller, "released", G_CALLBACK(button_released), NULL);
     g_signal_connect(getstureConroller, "unpaired-release", G_CALLBACK(button_released), NULL);
     gtk_widget_add_controller(scrolled, GTK_EVENT_CONTROLLER(getstureConroller));
 
-    GtkEventController *motionEventController = gtk_event_controller_motion_new();
+    motionEventController = gtk_event_controller_motion_new();
     g_signal_connect(motionEventController, "motion", G_CALLBACK(motion_notify), NULL);
     gtk_widget_add_controller(scrolled, motionEventController);
 
-    GtkEventController *scrollEventController = gtk_event_controller_scroll_new(GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES);
+    scrollEventController = gtk_event_controller_scroll_new(GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES);
     g_signal_connect(scrollEventController, "scroll", G_CALLBACK(scroll_notify), NULL);
     gtk_widget_add_controller(scrolled, scrollEventController);
 }
+
+void layout_signal_disconnect(GtkWidget *scrolled, GtkAdjustment *adjustment) {
+    g_signal_handlers_disconnect_by_func(top, G_CALLBACK(size_notify), NULL);
+    g_signal_handlers_disconnect_by_func(adjustment, G_CALLBACK(adjustment_notify), NULL);
+
+    g_signal_handlers_disconnect_by_func(keyEventController, G_CALLBACK(key_pressed), NULL);
+
+    g_signal_handlers_disconnect_by_func(getstureConroller, G_CALLBACK(button_pressed), NULL);
+    g_signal_handlers_disconnect_by_func(getstureConroller, G_CALLBACK(button_released), NULL);
+
+    g_signal_handlers_disconnect_by_func(motionEventController, G_CALLBACK(motion_notify), NULL);
+
+    g_signal_handlers_disconnect_by_func(scrollEventController, G_CALLBACK(scroll_notify), NULL);
+}

four/layout.c

@@ -1,3 +1,4 @@
+#include "glib-object.h"
 #include "terminal.h"
 #include <gtk/gtk.h>
 
@@ -41,8 +42,11 @@ static void layout_main_create(int id) {
 static void layout_main_destroy(int id) {
     layout_main *l = g_hash_table_lookup(layout_table, GINT_TO_POINTER(id));
     g_hash_table_remove(layout_table, GINT_TO_POINTER(id));
-    // gtk_widget_unparent(l->layout);
-    // gtk_widget_unparent(l->scrolled);
+    layout_signal_disconnect(l->scrolled, l->adjustment);
+    gtk_scrolled_window_set_hadjustment(GTK_SCROLLED_WINDOW(l->scrolled), NULL);
+    gtk_scrolled_window_set_vadjustment(GTK_SCROLLED_WINDOW(l->scrolled), NULL);
+    gtk_scrolled_window_set_child(GTK_SCROLLED_WINDOW(l->scrolled), NULL);
+    gtk_window_set_child(GTK_WINDOW(top), NULL);
     g_free(l);
 }
 
@@ -62,7 +66,7 @@ static void layout_node_create(int id, int parent_id) {
     l->layout = gtk_fixed_new();
     gtk_widget_set_overflow(l->layout, GTK_OVERFLOW_HIDDEN);
     l->parent = layout_get_widget(parent_id);
-    gtk_widget_set_parent(l->layout, l->parent);
+    gtk_fixed_put(GTK_FIXED(l->parent), l->layout, 0, 0);
     l->x = 0;
     l->y = 0;
     gtk_widget_set_visible(l->layout, TRUE);
@@ -72,7 +76,7 @@ static void layout_node_create(int id, int parent_id) {
 static void layout_node_destroy(int id) {
     layout_elem *l = g_hash_table_lookup(layout_table, GINT_TO_POINTER(id));
     g_hash_table_remove(layout_table, GINT_TO_POINTER(id));
-    gtk_widget_unparent(l->layout);
+    gtk_fixed_remove(GTK_FIXED(l->parent), l->layout);
     g_free(l);
 }
 
@@ -87,10 +91,9 @@ static void layout_node_size(int id, int x, int y, int width, int height) {
 static void layout_node_raise(int id) {
     layout_elem *l = g_hash_table_lookup(layout_table, GINT_TO_POINTER(id));
     g_object_ref(l->layout);
-    gtk_widget_unparent(l->layout);
-    gtk_widget_set_parent(l->layout, l->parent);
+    gtk_fixed_remove(GTK_FIXED(l->parent), l->layout);
+    gtk_fixed_put(GTK_FIXED(l->parent), l->layout, l->x, l->y);
     g_object_unref(l->layout);
-    gtk_fixed_move(GTK_FIXED(l->parent), l->layout, l->x, l->y);
 }
 
 GtkWidget *layout_get_widget(int id) {

four/main.c

@@ -19,11 +19,7 @@ static void on_app_activate(GApplication *application, gpointer data) {
     pipe_init(pipe_suffix);
 }
 
-static void on_app_shutdown(GApplication *application, gpointer data) {
-    pipe_done();
-    // gtk_window_destroy(GTK_WINDOW(top));
-    // g_application_quit(G_APPLICATION(app));
-}
+static void on_app_shutdown(GApplication *application, gpointer data) { pipe_done(); }
 
 int main(int argc, char **argv) {
     if (argc != 2) {
@@ -42,6 +38,10 @@ int main(int argc, char **argv) {
     g_signal_connect(app, "shutdown", G_CALLBACK(on_app_shutdown), NULL);
 
     int status = g_application_run(G_APPLICATION(app), 1, argv);
+
+    g_signal_handlers_disconnect_by_func(app, G_CALLBACK(on_app_activate), NULL);
+    g_signal_handlers_disconnect_by_func(app, G_CALLBACK(on_app_shutdown), NULL);
+
     g_object_unref(app);
     return status;
 }

four/pipe.c

@@ -23,6 +23,13 @@ static FILE *pipe_open(char *name, char *suffix, char *filemode) {
     return handle;
 }
 
+static void pipe_close(FILE *handle) {
+    if (fclose(handle) != 0) {
+        perror("pipe close failed");
+        exit(EXIT_FAILURE);
+    }
+}
+
 void pipe_init(char *pipe_suffix) {
     handle_output = pipe_open(FIFO_OUTPUT_PATH, pipe_suffix, "w");
     handle_event = pipe_open(FIFO_EVENT_PATH, pipe_suffix, "w");
@@ -33,22 +40,10 @@ void pipe_init(char *pipe_suffix) {
 }
 
 void pipe_done() {
-    if (fclose(handle_input) != 0) {
-        perror("pipe close failed (i)");
-        exit(EXIT_FAILURE);
-    }
-    if (fclose(handle_stream) != 0) {
-        perror("pipe close failed (s)");
-        exit(EXIT_FAILURE);
-    }
-    if (fclose(handle_output) != 0) {
-        perror("pipe close failed (o)");
-        exit(EXIT_FAILURE);
-    }
-    if (fclose(handle_event) != 0) {
-        perror("pipe close failed (e)");
-        exit(EXIT_FAILURE);
-    }
+    pipe_close(handle_input);
+    pipe_close(handle_stream);
+    pipe_close(handle_output);
+    pipe_close(handle_event);
 }
 
 void pipe_output_write(const void *data, const int length) {

four/terminal.h

@@ -36,7 +36,9 @@ gboolean io_exited();
 // event
 
 void top_signal_connect();
+void top_signal_disconnect();
 void layout_signal_connect(GtkWidget *scrolled, GtkAdjustment *adjustment);
+void layout_signal_disconnect(GtkWidget *scrolled, GtkAdjustment *adjustment);
 
 void s_menu_action(char *action);
 void request_clipboard(int clipboardtypeid);

four/window.c

@@ -24,7 +24,7 @@ void window_create(int id, int layout_id) {
     w->y = 0;
     w->draw_list = g_ptr_array_new_with_free_func(elem_draw_destroy);
     gtk_drawing_area_set_draw_func(GTK_DRAWING_AREA(w->draw), draw_callback, w->draw_list, NULL);
-    gtk_widget_set_parent(w->draw, w->layout);
+    gtk_fixed_put(GTK_FIXED(w->layout), w->draw, 0, 0);
     gtk_widget_set_visible(w->draw, TRUE);
     if (window_table == NULL) {
         window_table = g_hash_table_new(g_direct_hash, g_direct_equal);
@@ -36,7 +36,7 @@ void window_destroy(int id) {
     window_elem *w = g_hash_table_lookup(window_table, GINT_TO_POINTER(id));
     g_hash_table_remove(window_table, GINT_TO_POINTER(id));
     g_ptr_array_free(w->draw_list, TRUE);
-    gtk_widget_unparent(w->draw);
+    gtk_fixed_remove(GTK_FIXED(w->layout), w->draw);
     g_free(w);
 }
 
@@ -62,10 +62,9 @@ void window_size(int id, int x, int y, int width, int height) {
 void window_raise(int id) {
     window_elem *w = g_hash_table_lookup(window_table, GINT_TO_POINTER(id));
     g_object_ref(w->draw);
-    gtk_widget_unparent(w->draw);
-    gtk_widget_set_parent(w->draw, w->layout);
+    gtk_fixed_remove(GTK_FIXED(w->layout), w->draw);
+    gtk_fixed_put(GTK_FIXED(w->layout), w->draw, w->x, w->y);
     g_object_unref(w->draw);
-    gtk_fixed_move(GTK_FIXED(w->layout), w->draw, w->x, w->y);
 }
 
 void window_redraw(int id) {

layout.c

@@ -39,6 +39,9 @@ void layout_create(int id, int parent_id) {
 void layout_destroy(int id) {
     layout_elem *l = g_hash_table_lookup(layout_table, GINT_TO_POINTER(id));
     g_hash_table_remove(layout_table, GINT_TO_POINTER(id));
+    if (id == 1) {
+        layout_signal_disconnect(l->layout);
+    }
     gtk_widget_destroy(GTK_WIDGET(l->layout));
     g_free(l);
 }