gresource.xml

@@ -8,6 +8,15 @@
     <file>ubinstall-gtk-documentation.glade</file>
     <file>ubinstall-gtk-log-view.glade</file>
     <file>ubinstall-gtk-warning.glade</file>
+    <file>ubinstall-gtk-user.glade</file>
+    <file>ubinstall-gtk-menu.glade</file>
+    <file>ubinstall-gtk-menu-item.glade</file>
+    <file>ubinstall-gtk-kernel-row.glade</file>
+    <file>ubinstall-gtk-os-row.glade</file>
+    <file>ubinstall-gtk-service-window.glade</file>
+    <file>ubinstall-gtk-bootloader-user.glade</file>
+    <file>ubinstall-gtk-network-box.glade</file>
+    <file>ubinstall-gtk-advanced-box.glade</file>
   </gresource>
   <gresource prefix="/com/ublinux/css">
     <file>ubinstall-gtk.css</file>
@@ -37,5 +46,9 @@
   </gresource>
   <gresource prefix="/com/ublinux/csv">
     <file>modules.csv</file>
+    <file>kernel-list.csv</file>
+    <file>kernel-list-addon.csv</file>
+    <file>services-list.csv</file>
+    <file>network-list.csv</file>
   </gresource>
 </gresources>

kernel-list-addon.csv

@@ -0,0 +1,13 @@
+NAME;PAСKAGE_UBM;PAСKAGE;DESCRIPTION
+Linux 5.15 headers;ubm-002-linux515-headers;linux515-headers;The Linux kernel headers v5.15
+Linux 5.15 Docs;ubm-003-linux515-docs;linux515-docs;The Linux kernel docs v5.15
+Linux 5.15 DKMS modules;ubm-linux515-dkms;;The Linux kernel DKMS modules v5.15 : v4l2loopback, rtl88x2bu, r8125, rtl8192eu
+Linux 5.15 DKMS modules;ubm-linux515-r8168-8136;;The Linux kernel DKMS modules v5.15 : r8168-8136
+Linux 6.1 headers;ubm-002-linux61-headers;linux61-headers;The Linux kernel headers v6.1
+Linux 6.1 Docs;ubm-003-linux61-docs;linux61-docs;The Linux kernel docs v6.1
+Linux 6.1 DKMS modules;ubm-linux61-dkms;;The Linux kernel DKMS modules v6.1 : v4l2loopback, rtl88x2bu, r8125, rtl8192eu
+Linux 6.1 DKMS modules;ubm-linux61-r8168-8136;;The Linux kernel DKMS modules v6.1 : r8168-8136
+Linux 6.6 headers;ubm-002-linux66-headers;linux66-headers;The Linux kernel headers v6.6
+Linux 6.6 Docs;ubm-003-linux66-docs;linux66-docs;The Linux kernel docs v6.6
+Linux 6.6 DKMS modules;ubm-linux66-dkms;;The Linux kernel DKMS modules v6.6 : v4l2loopback, rtl88x2bu, r8125, rtl8192eu
+Linux 6.6 DKMS modules;ubm-linux66-dkms-r8168-8136;;The Linux kernel DKMS modules v6.6 : r8168-8136

kernel-list.csv

@@ -0,0 +1,5 @@
+NAME;PAСKAGE_UBM;PAСKAGE;PAСKAGE_UBM_REQUIRED;PAСKAGE_REQUIRED;TAG;DESCRIPTION
+Linux 5.15;ubm-001-linux515-test;linux515-test;ubm-002-linux515-test-headers;linux515-test-headers;LTS, Stable, RealTime, Hardened, Recomended;The Linux kernel v5.15 and modules, headers. Additional kernel modules: acpi_call, bbswitch, broadcom-wl, r8168, rtl8723bu, tp_smapi, vhba-module, virtualbox-host-modules, zfs
+Linux 5.15;ubm-001-linux515;linux515;ubm-002-linux515-headers;linux515-headers;LTS, Stable;The Linux kernel v5.15 and modules, headers. Additional kernel modules: acpi_call, bbswitch, broadcom-wl, r8168, rtl8723bu, tp_smapi, vhba-module, virtualbox-host-modules, zfs
+Linux 6.1;ubm-001-linux61;linux61;ubm-002-linux61-headers;linux61-headers;LTS, Stable, Recomended;The Linux kernel v6.1 and modules, headers. Additional kernel modules: acpi_call, bbswitch, broadcom-wl, r8168, rtl8723bu, tp_smapi, vhba-module, virtualbox-host-modules, zfs
+Linux 6.6;ubm-001-linux66;linux66;ubm-002-linux66-headers;linux66-headers;LTS, Stable;The Linux kernel v6.6 and modules, headers. Additional kernel modules: acpi_call, bbswitch, broadcom-wl, r8168, rtl8723bu, tp_smapi, vhba-module, virtualbox-host-modules, zfs

network-list.csv

@@ -0,0 +1,45 @@
+TYPE;NAME
+Ethernet;enp0s0
+Ethernet;enp0s1
+Ethernet;enp0s2
+Ethernet;enp0s3
+Ethernet;enp1s0
+Ethernet;enp1s1
+Ethernet;enp1s2
+Ethernet;enp1s3
+Ethernet;enp2s0
+Ethernet;enp2s1
+Ethernet;enp2s2
+Ethernet;enp2s3
+Ethernet;enp3s0
+Ethernet;enp3s1
+Ethernet;enp3s2
+Ethernet;enp3s3
+Ethernet;ens160
+Ethernet;ens35
+WiFi;wifi
+WiFi;wl0
+WiFi;wl1
+WiFi;wl2
+WiFi;wl3
+WiFi;wlan0
+WiFi;wlan1
+WiFi;wlan2
+WiFi;wlan3
+VPN;tap0
+VPN;tap1
+VPN;tap2
+VPN;tap3
+VPN;tun0
+VPN;tun0
+VPN;tun1
+VPN;tun2
+VPN;tun3
+VPN;pppoe0
+VPN;pppoe1
+VPN;pppoe2
+VPN;pppoe3
+Bridge;br0
+Bridge;br1
+Bridge;br2
+Bridge;br3

services-list.csv

@@ -0,0 +1,11 @@
+NAME;NAME_SERVICES;DESCRIPTION
+UBManager WebPanel;cockpit.socket;Operating system monitoring and management manager service
+Network Manager;NetworkManager;Is a program for providing detection and configuration for systems to automatically connect to networks
+SSH;sshd;The daemon that listens for connections from clients on port 22
+NTP Client;systemd-timesyncd;Is a system service that may be used to synchronize the local system clock with a remote Network Time Protocol (NTP) server
+Avahi;avahi-daemon,avahi-dnsconfd;Is a free zero-configuration networking (zeroconf) implementation, including a system for multicast DNS and DNS Service Discovery
+CUPS;cups;Is a modular printing system for Unix-like computer operating systems which allows a computer to act as a print server
+Samba;smb,nmb;Provides network shares for folders and printers using the SMB/CIFS protocol commonly used on Windows. SMB and NMB Daemon
+Samba winbind;winbind;Provides network shares for folders and printers using the SMB/CIFS protocol commonly used on Windows. Winbind Daemon
+SwapSpace;swapspace;Operating system dynamic swap file management service
+Bluetouth;bluetooth;A Service is a container for logically related Bluetooth data items

source/CMakeLists.txt

@@ -65,9 +65,22 @@ set(DEPENDFILES
                 ../ubinstall-gtk-documentation.glade
                 ../ubinstall-gtk-log-view.glade
                 ../ubinstall-gtk-warning.glade
+                ../ubinstall-gtk-user.glade
+                ../ubinstall-gtk-menu.glade
+                ../ubinstall-gtk-menu-item.glade
+                ../ubinstall-gtk-kernel-row.glade
+                ../ubinstall-gtk-os-row.glade
+                ../ubinstall-gtk-service-window.glade
+                ../ubinstall-gtk-bootloader-user.glade
+                ../ubinstall-gtk-network-box.glade
+                ../ubinstall-gtk-advanced-box.glade
                 ../gresource.xml
                 ../ubinstall-gtk.css
                 ../modules.csv
+                ../kernel-list.csv
+                ../kernel-list-addon.csv
+                ../services-list.csv
+                ../network-list.csv
         )
 
 file(COPY ${DEPENDFILES} DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
@@ -105,6 +118,25 @@ endif()
 
 set(SOURCE_FILES
         ubinstall-gtk.c
+        ubinstall-gtk-page-switch.c
+        ubinstall-gtk-keyboard.c
+        ubinstall-gtk-region.c
+        ubinstall-gtk-bootloader.c
+        ubinstall-gtk-components.c
+        ubinstall-gtk-grub.c
+        ubinstall-gtk-installation.c
+        ubinstall-gtk-network.c
+        ubinstall-gtk-separate.c
+        ubinstall-gtk-users.c
+        ubinstall-gtk-configuration-mode.c
+        ubinstall-gtk-decorations.c
+        ubinstall-gtk-log.c
+        ubinstall-gtk-password.c
+        ubinstall-gtk-saving.c
+        ubinstall-gtk-standard.c
+        ubinstall-gtk-install-start.c
+        ubinstall-gtk-startup-services.c
+        ubinstall-gtk-kernel.c
         ubinstall-gtk.h
         ubl-strings.h
         )
@@ -118,6 +150,7 @@ set(LIBRARIES
         pthread
         ublsettings
         ublsettings-gtk3
+        ublsettingsui-gtk3
         )
 
 

source/ubinstall-gtk-bootloader.c

@@ -0,0 +1,441 @@
+#include "ubinstall-gtk.h"
+
+int yon_bootloader_save(main_window *widgets){
+    if (gtk_switch_get_active(GTK_SWITCH(widgets->BootloadTimerSwitch))){
+        long time = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widgets->BootloadTimerSpin));
+        yon_config_register(GRUB_TIMEOUT_parameter,GRUB_TIMEOUT_parameter_command,yon_char_from_long(time));
+    } else {
+        yon_config_remove_by_key(GRUB_TIMEOUT_parameter);
+    }
+    char *OS = (char*)gtk_entry_get_text(GTK_ENTRY(widgets->BootloadDefaultOSEntry));
+    if (strcmp(OS,DEFAULT_BOOTLOAD_MENU_ITEM_LABEL)){
+        yon_config_register(GRUB_DEFAULT_parameter,GRUB_DEFAULT_parameter_command,OS);
+    } else {
+        yon_config_remove_by_key(GRUB_DEFAULT_parameter);
+    }
+    if (gtk_switch_get_active(GTK_SWITCH(widgets->BootloadNoPasswordSwitch))){
+        GtkTreeIter iter;
+            yon_config_register(AUTOLOGINUSER_parameter,AUTOLOGINUSER_parameter_command,"yes");
+        GtkTreeModel *model = GTK_TREE_MODEL(widgets->BootloadUsersList);
+        int admin_size=0;
+        config_str admin_list = NULL;
+        for_iter(model,&iter){
+            int is_admin;
+            char *username, *password;
+            gtk_tree_model_get(model,&iter,0,&is_admin,1,&username,2,&password,-1);
+            if (is_admin){
+                yon_char_parsed_add_or_create_if_exists(admin_list,&admin_size,username);
+            }
+            char *admin_string = yon_char_parsed_to_string(admin_list,admin_size,",");
+            yon_config_register(GRUB_PASSWORD_parameter(username),GRUB_PASSWORD_parameter_command(username),password);
+            yon_config_register(GRUB_SUPERUSERS_parameter,GRUB_SUPERUSERS_parameter_command,admin_string);
+            free(admin_string);
+        }
+    } else {
+        int size;
+        config_str users = yon_config_get_all_by_key(GRUB_PASSWORD_parameter_search,&size);
+        for (int i=0;i<size;i++){
+            yon_config_remove_by_key(GRUB_PASSWORD_parameter(users[i]));
+        }
+        yon_config_register(AUTOLOGINUSER_parameter,AUTOLOGINUSER_parameter_command,"no");
+        yon_config_remove_by_key(GRUB_PASSWORD_parameter_all);
+        yon_config_remove_by_key(GRUB_SUPERUSERS_parameter);
+    }
+    yon_bootloader_interface_update(widgets);
+    return 1;
+}
+
+void yon_password_change(GtkWidget *, bootloader_user_window *window){
+	GtkEntry *output_target = GTK_ENTRY(window->PasswordEntry);
+	yon_password_window *dialog = yon_password_open(output_target);
+    yon_gtk_window_setup(GTK_WINDOW(dialog->Window),GTK_WINDOW(window->Window),NULL,icon_path,"password_window");
+    gtk_widget_show(window->Window);
+
+}
+
+void on_bootloader_user_accept(GtkWidget *, bootloader_user_window *window){
+    main_window *widgets = g_object_get_data(G_OBJECT(window->AcceptButton),"widgets");
+    const char *username = gtk_entry_get_text(GTK_ENTRY(window->UsernameEntry));
+
+    if (yon_char_is_empty(window->prev_name)){
+        GtkTreeIter iter;
+        GtkTreeModel *model = GTK_TREE_MODEL(widgets->BootloadUsersList);
+        for_iter(model,&iter){
+            char *name;
+            gtk_tree_model_get(model,&iter,1,&name,-1);
+            if (!strcmp(name,username)){
+                dialog_confirmation_data *data = yon_confirmation_dialog_data_new();
+                data->action_text = BOOTLOADER_USER_EXIST_LABEL(username);
+                if (yon_confirmation_dialog_call(window->Window,data)!=GTK_RESPONSE_ACCEPT){
+                    return;
+                }
+            }
+        }
+    }
+    const char *password = gtk_entry_get_text(GTK_ENTRY(window->PasswordEntry));
+    if (yon_char_is_empty(username)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(window->UsernameEntry);
+        return;
+    }
+    if (yon_char_is_empty(password)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(window->PasswordEntry);
+        return;
+    }
+    if (!yon_char_is_empty(window->prev_name)&&strcmp(username,window->prev_name)){
+        yon_config_remove_by_key(GRUB_PASSWORD(window->prev_name));
+        int size;
+        char *superusers = config(GRUB_SUPERUSERS_parameter);
+        config_str parsed = yon_char_parse(superusers,&size,",");
+        int pos = yon_char_parsed_check_exist(parsed,size,(char*)username);
+        if (pos>-1){
+            parsed = yon_char_parsed_rip(parsed,&size,pos);
+            char *superusers = yon_char_parsed_to_string(parsed,size,",");
+            if (!yon_char_is_empty(superusers)){
+                yon_config_register(GRUB_SUPERUSERS_parameter,GRUB_SUPERUSERS_parameter_command,superusers);
+            } else {
+                yon_config_remove_by_key(GRUB_SUPERUSERS_parameter);
+            }
+        }
+    }
+    yon_config_register(GRUB_PASSWORD(username),GRUB_SUPERUSERS_parameter_command,(char*)password);
+    GtkTreeIter iter;
+    gtk_list_store_append(widgets->BootloadUsersList,&iter);
+    gtk_list_store_set(widgets->BootloadUsersList,&iter,0,gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->AdminCheck)),1,username,2,"******",-1);
+
+    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->AdminCheck))){
+        int size;
+        char *superusers = config(GRUB_SUPERUSERS_parameter);
+        config_str parsed = yon_char_parse(superusers,&size,",");
+        if (yon_char_parsed_check_exist(parsed,size,(char*)username)==-1){
+            yon_char_parsed_add_or_create_if_exists(parsed,&size,(char*)username);
+            char *superusers = yon_char_parsed_to_string(parsed,size,",");
+            yon_config_register(GRUB_SUPERUSERS_parameter,GRUB_SUPERUSERS_parameter_command,superusers);
+        }
+    } else {
+        int size;
+        char *superusers = config(GRUB_SUPERUSERS_parameter);
+        config_str parsed = yon_char_parse(superusers,&size,",");
+        int pos = yon_char_parsed_check_exist(parsed,size,(char*)username);
+        if (pos!=-1){
+            parsed = yon_char_parsed_rip(parsed,&size,pos);
+
+            char *superusers = yon_char_parsed_to_string(parsed,size,",");
+            yon_config_register(GRUB_SUPERUSERS_parameter,GRUB_SUPERUSERS_parameter_command,superusers);
+        }
+    }
+    on_subwindow_close(window->Window);
+}
+
+bootloader_user_window *yon_bootloader_user_window_new(){
+    bootloader_user_window *window = new(bootloader_user_window);
+
+    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_bootloader_user);
+
+    window->Window = yon_gtk_builder_get_widget(builder,"MainWindow");
+    window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
+    window->TitleLabel = yon_gtk_builder_get_widget(builder,"TitleLabel");
+    window->AdminCheck = yon_gtk_builder_get_widget(builder,"AdminCheck");
+    window->UsernameEntry = yon_gtk_builder_get_widget(builder,"UsernameEntry");
+    window->PasswordEntry = yon_gtk_builder_get_widget(builder,"PasswordEntry");
+    window->PasswordButton = yon_gtk_builder_get_widget(builder,"PasswordButton");
+    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
+    window->AcceptButton = yon_gtk_builder_get_widget(builder,"AcceptButton");
+    window->prev_name = NULL;
+
+    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
+    g_signal_connect(G_OBJECT(window->PasswordButton),"clicked",G_CALLBACK(yon_password_change),window);
+    yon_gtk_entry_set_password_visibility_icon(GTK_ENTRY(window->PasswordEntry));
+    yon_gtk_entry_block_restricted_symbols(GTK_ENTRY(window->UsernameEntry));
+    return window;
+}
+
+void on_bootloader_user_add(GtkWidget *, main_window *widgets){
+    bootloader_user_window *window = yon_bootloader_user_window_new();
+    g_object_set_data(G_OBJECT(window->AcceptButton),"widgets",widgets);
+    g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_bootloader_user_accept),window);
+    yon_gtk_window_setup(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->MainWindow),NULL,icon_path,"bootloader_window");
+    gtk_widget_show(window->Window);
+}
+
+void on_menu_chosen(GtkWidget *, yon_menu_item *item){
+    if (strcmp(item->target,DEFAULT_MENU_ITEM_LABEL)){
+        gtk_entry_set_text(GTK_ENTRY(item->widgets->BootloadDefaultOSEntry),item->target);
+    } else {
+        gtk_entry_set_text(GTK_ENTRY(item->widgets->BootloadDefaultOSEntry),DEFAULT_MENU_ITEM_LABEL);
+    }
+        GdkDisplay *display = gdk_display_get_default();
+        GdkSeat *seat = gdk_display_get_default_seat(display);
+        if (item->window->seat_grab)
+            gdk_seat_ungrab(seat);
+        else
+            gtk_grab_remove(item->window->MenuWindow);
+        gtk_widget_destroy(item->window->MenuWindow);
+
+}
+
+void on_submenu_open(GtkWidget *,yon_menu_item *item){
+    yon_menu_window *window = item->window;
+
+    dictionary *dact = NULL;
+    for_dictionaries(dact,item->children){
+        yon_menu_item *child =  yon_dictionary_get_data(dact,yon_menu_item*);
+        gtk_widget_hide(child->NextIconButton);
+        gtk_list_box_insert(GTK_LIST_BOX(window->ChildrenListBox),child->MenuItemBox,-1);
+            g_signal_connect(G_OBJECT(child->MenuButton),"clicked",G_CALLBACK(on_menu_chosen),dact->data);
+        
+    }
+    gtk_revealer_set_reveal_child(GTK_REVEALER(item->window->ItemsRevealer),0);
+    gtk_revealer_set_reveal_child(GTK_REVEALER(item->window->ChildrenRevealer),1);
+    gtk_box_set_child_packing(GTK_BOX(gtk_widget_get_parent(window->ChildrenRevealer)),window->ChildrenRevealer,1,1,0,GTK_PACK_START);
+    gtk_box_set_child_packing(GTK_BOX(gtk_widget_get_parent(window->ItemsRevealer)),window->ItemsRevealer,0,0,0,GTK_PACK_START);
+    yon_on_revealer_switched(window);
+    g_signal_connect(G_OBJECT(window->MenuWindow),"size-allocate",G_CALLBACK(on_menu_window_size_reallocated),window);
+
+}
+
+yon_menu_window *yon_menu_window_open(GtkWidget *, main_window *widgets){
+    yon_menu_window *window = yon_menu_window_new();
+    gtk_window_set_transient_for(GTK_WINDOW(window->MenuWindow),GTK_WINDOW(widgets->MainWindow));
+        {
+            yon_menu_item *item = yon_menu_item_new();
+            item->widgets=widgets;
+            item->window=window;
+            item->children=NULL;
+            gtk_label_set_text(GTK_LABEL(item->MenuTextLabel),DEFAULT_MENU_ITEM_LABEL);
+            item->target=yon_char_new(DEFAULT_MENU_ITEM_LABEL);
+            gtk_list_box_insert(GTK_LIST_BOX(window->ItemsListBox),item->MenuItemBox,-1);
+            yon_dictionary_add_or_create_if_exists_with_data(window->menu_items,DEFAULT_MENU_ITEM_LABEL,item);
+            gtk_widget_show(item->MenuItemBox);
+            gtk_widget_hide(item->NextIconButton);
+            g_signal_connect(G_OBJECT(item->MenuButton),"clicked",G_CALLBACK(on_menu_chosen),item);
+        }
+    int size;
+    config_str parsed = yon_config_load(get_menus_entry_command,&size);
+    for (int i=0;i<size;i++){
+        yon_char_remove_last_symbol(parsed[i],'\n');
+        int param_size;
+        config_str parameter = yon_char_parse(parsed[i],&param_size,">");
+        dictionary * cur_item = NULL;
+        if (param_size==2&&(cur_item=yon_dictionary_get(&window->menu_items,parameter[0]))){
+            yon_menu_item *item = (yon_menu_item*)cur_item->data;
+            yon_menu_item *item_child = yon_menu_item_new();
+            gtk_widget_hide(item_child->NextIconButton);
+            gtk_label_set_text(GTK_LABEL(item_child->MenuTextLabel),parameter[1]);
+            item_child->target=yon_char_new(parsed[i]);
+            gtk_widget_show(item_child->MenuItemBox);
+            yon_dictionary_add_or_create_if_exists_with_data(item->children,parameter[1],item_child);
+            item_child->widgets=widgets;
+            item_child->window=window;
+            
+        } else {
+            yon_menu_item *item = yon_menu_item_new();
+            item->widgets=widgets;
+            item->window=window;
+            gtk_label_set_text(GTK_LABEL(item->MenuTextLabel),parameter[0]);
+            item->target=yon_char_new(parsed[i]);
+            gtk_list_box_insert(GTK_LIST_BOX(window->ItemsListBox),item->MenuItemBox,-1);
+            yon_dictionary_add_or_create_if_exists_with_data(window->menu_items,parameter[0],item);
+            gtk_widget_show(item->MenuItemBox);
+            if (param_size==2){
+                yon_menu_item *item_child = yon_menu_item_new();
+                gtk_widget_show(item->NextIconButton);
+                gtk_widget_hide(item_child->NextIconButton);
+                gtk_label_set_text(GTK_LABEL(item_child->MenuTextLabel),parameter[1]);
+                item_child->target=yon_char_new(parsed[i]);
+                gtk_widget_show(item_child->MenuItemBox);
+                item_child->widgets=widgets;
+                item_child->window=window;
+                g_signal_connect(G_OBJECT(item->MenuButton),"clicked",G_CALLBACK(on_submenu_open),item);
+                yon_dictionary_add_or_create_if_exists_with_data(item->children,parameter[1],item_child);
+            } else {
+                gtk_widget_hide(item->NextIconButton);
+                g_signal_connect(G_OBJECT(item->MenuButton),"clicked",G_CALLBACK(on_menu_chosen),item);
+            }
+        }
+
+    }
+    gtk_window_set_transient_for(GTK_WINDOW(window->MenuWindow), GTK_WINDOW(widgets->MainWindow));
+
+    int x,y,width;
+    gtk_widget_realize(window->MenuWindow);
+    gdk_window_get_position(gtk_widget_get_window(widgets->BootloadDefaulOSButton),&x,&y);
+    gtk_widget_translate_coordinates(widgets->BootloadDefaulOSButton,widgets->MainWindow,x,y,&window->button_pos_x,&window->button_pos_y);
+    gtk_window_get_size(GTK_WINDOW(window->MenuWindow),&width,NULL);
+    GtkAllocation alloc;
+    gtk_widget_get_allocation(widgets->BootloadDefaulOSButton, &alloc);
+    gtk_window_get_position(GTK_WINDOW(widgets->MainWindow),&x,&y);
+    gtk_window_move(GTK_WINDOW(window->MenuWindow),window->button_pos_x-width,window->button_pos_y);
+    gtk_widget_show(window->MenuWindow);
+    GdkGrabStatus status = gdk_seat_grab(gdk_display_get_default_seat(gdk_display_get_default()),gtk_widget_get_window(window->MenuWindow),GDK_SEAT_CAPABILITY_POINTER,TRUE,NULL,NULL,NULL,NULL);
+    if (status != GDK_GRAB_SUCCESS) {
+        window->seat_grab=0;
+        gtk_grab_add(window->MenuWindow);
+    } else {
+        window->seat_grab=1;
+    }
+    return window;
+}
+
+gboolean on_menu_clicked(GtkWidget *, GdkEventButton *event, yon_menu_window *window){
+    int x,y,width,height;
+    gtk_window_get_size(GTK_WINDOW(window->MenuWindow),&width,&height);
+    gtk_window_get_position(GTK_WINDOW(window->MenuWindow),&x,&y);
+    if (event->x_root<x||event->y_root<y||event->x_root>x+width||event->y_root>y+height){
+
+        GdkDisplay *display = gdk_display_get_default();
+        GdkSeat *seat = gdk_display_get_default_seat(display);
+        if (window->seat_grab)
+            gdk_seat_ungrab(seat);
+        else 
+            gtk_grab_remove(window->MenuWindow);
+        gtk_widget_destroy(window->MenuWindow);
+    }
+    return 1;
+
+}
+
+gboolean yon_on_revealer_switched (yon_menu_window *window){
+    if (gtk_revealer_get_reveal_child(GTK_REVEALER(window->ItemsRevealer))){
+        gtk_widget_hide(window->ChildrenRevealer);
+        gtk_widget_show(window->ItemsRevealer);
+    } else {
+        gtk_widget_hide(window->ItemsRevealer);
+        gtk_widget_show(window->ChildrenRevealer);
+
+    }
+    return G_SOURCE_REMOVE;
+}
+
+void on_children_clean(GtkWidget*, yon_menu_window *window){
+    GList *list = gtk_container_get_children(GTK_CONTAINER(window->ChildrenListBox));
+    list = g_list_last(list);
+    for (guint i=0;i<g_list_length(list);i++){
+        GList *item = gtk_container_get_children(GTK_CONTAINER(list->data));
+        g_object_ref(G_OBJECT(item->data));
+        gtk_container_remove(GTK_CONTAINER(list->data),GTK_WIDGET(item->data));
+        gtk_widget_destroy(GTK_WIDGET(list->data));
+        g_list_free(item);
+        list=list->prev;
+    }
+
+    gtk_revealer_set_reveal_child(GTK_REVEALER(window->ItemsRevealer),1);
+    gtk_revealer_set_reveal_child(GTK_REVEALER(window->ChildrenRevealer),0);
+    gtk_box_set_child_packing(GTK_BOX(gtk_widget_get_parent(window->ItemsRevealer)),window->ItemsRevealer,1,1,0,GTK_PACK_START);
+    yon_on_revealer_switched(window);
+    g_signal_connect(G_OBJECT(window->MenuWindow),"size-allocate",G_CALLBACK(on_menu_window_size_reallocated),window);
+    gtk_box_set_child_packing(GTK_BOX(gtk_widget_get_parent(window->ChildrenRevealer)),window->ChildrenRevealer,0,0,0,GTK_PACK_START);
+
+}
+
+void on_menu_window_size_reallocated(GtkWidget *self,GtkAllocation *,yon_menu_window *window){
+    int x,y,width;
+    gtk_window_get_size(GTK_WINDOW(window->MenuWindow),&width,NULL);
+    gtk_window_get_position(GTK_WINDOW(gtk_window_get_transient_for(GTK_WINDOW(window->MenuWindow))),&x,&y);
+    gtk_window_move(GTK_WINDOW(window->MenuWindow),window->button_pos_x-width,window->button_pos_y);
+    g_signal_handlers_disconnect_by_func(self,on_menu_window_size_reallocated,window);
+}
+
+ yon_menu_window *yon_menu_window_new(){
+    yon_menu_window *window = new(yon_menu_window);
+    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_menu_window);
+    window->MenuWindow = yon_gtk_builder_get_widget(builder,"MainWindow");
+    window->ItemsRevealer = yon_gtk_builder_get_widget(builder,"ItemsRevealer");
+    window->BackButton = yon_gtk_builder_get_widget(builder,"BackButton");
+    window->ItemsListBox = yon_gtk_builder_get_widget(builder,"ItemsListBox");
+    window->ChildrenRevealer = yon_gtk_builder_get_widget(builder,"ChildrenRevealer");
+    window->ChildrenListBox = yon_gtk_builder_get_widget(builder,"ChildrenListBox");
+
+    window->menu_items=NULL;
+
+    g_signal_connect(G_OBJECT(window->BackButton),"clicked",G_CALLBACK(on_children_clean),window);
+    g_signal_connect(G_OBJECT(window->MenuWindow),"button-press-event",G_CALLBACK(on_menu_clicked),window);
+    return window;
+}
+
+yon_menu_item *yon_menu_item_new(){
+    yon_menu_item *item = new(yon_menu_item);
+    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_menu_item);
+    item->MenuItemBox = yon_gtk_builder_get_widget(builder,"MenuItemBox");
+    item->MenuButton = yon_gtk_builder_get_widget(builder,"MenuButton");
+    item->MenuTextLabel = yon_gtk_builder_get_widget(builder,"MenuTextLabel");
+    item->NextIconButton = yon_gtk_builder_get_widget(builder,"NextIconButton");
+    item->children=NULL;
+
+    return item;
+}
+
+void yon_bootloader_interface_update(main_window *widgets){
+    char *timeout = config(GRUB_TIMEOUT_parameter);
+    char *admins = config(GRUB_SUPERUSERS_parameter);
+    char *autologin = config(AUTOLOGINUSER_parameter);
+    char *os = config(GRUB_DEFAULT_parameter);
+    int size;
+    config_str users = yon_config_get_all_by_key(GRUB_PASSWORD_parameter_search,&size);
+    if (!yon_char_is_empty(timeout)){
+        long timeout_l = atol(timeout);
+        gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->BootloadTimerSpin),timeout_l);
+    }
+    if (!yon_char_is_empty(os)){
+        gtk_entry_set_text(GTK_ENTRY(widgets->BootloadDefaultOSEntry),os);
+    } else {
+        gtk_entry_set_text(GTK_ENTRY(widgets->BootloadDefaultOSEntry),DEFAULT_MENU_ITEM_LABEL);
+    }
+    if (!yon_char_is_empty(autologin)&&(!strcmp(autologin,"yes")||!strcmp(autologin,"enable"))){
+        gtk_switch_set_active(GTK_SWITCH(widgets->BootloadNoPasswordSwitch),1);
+    } else {
+        int admins_size;
+        config_str admins_parsed = yon_char_parse(admins,&admins_size,",");
+        for (int i=0;i<size;i++){
+            char *value = yon_char_new(users[i]);
+            char *parameter = yon_char_divide_search(value,"=",-1);
+            char *key = yon_config_parameter_get_key(parameter);
+
+            GtkTreeIter iter;
+            gtk_list_store_append(widgets->BootloadUsersList,&iter);
+            gtk_list_store_set(widgets->BootloadUsersList,&iter,0,yon_char_parsed_check_exist(admins_parsed,admins_size,key),1,key,2,value,-1);
+        }
+    }
+
+}
+
+void yon_bootloader_init(main_window *widgets){
+    char *timeout = config(GRUB_TIMEOUT_parameter);
+    char *os = config(GRUB_DEFAULT_parameter);
+    char *autologin = config(AUTOLOGINUSER_parameter);
+    char *admins = config(GRUB_SUPERUSERS_parameter);
+    int size;
+    config_str users = yon_config_get_all_by_key(GRUB_PASSWORD_parameter_search,&size);
+    if (!yon_char_is_empty(timeout)){
+        long timeout_long = atol(timeout);
+        gtk_switch_set_active(GTK_SWITCH(widgets->BootloadTimerSwitch),1);
+        gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->BootloadTimerSpin),timeout_long);
+    } else{
+        gtk_switch_set_active(GTK_SWITCH(widgets->BootloadTimerSwitch),0);
+        gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->BootloadTimerSpin),0);
+    }
+    if (!yon_char_is_empty(os)){
+        gtk_entry_set_text(GTK_ENTRY(widgets->BootloadDefaultOSEntry),os);
+    } else {
+        gtk_entry_set_text(GTK_ENTRY(widgets->BootloadDefaultOSEntry),DEFAULT_BOOTLOAD_MENU_ITEM_LABEL);
+    }
+    if (!yon_char_is_empty(autologin)&&(!strcmp(autologin,"yes")||!strcmp(autologin,"enable"))){
+        gtk_switch_set_active(GTK_SWITCH(widgets->BootloadNoPasswordSwitch),1);
+        int admins_size;
+        config_str admins_parsed = yon_char_parse(admins,&admins_size,",");
+        GtkTreeIter iter;
+        for (int i=0;i<size;i++){
+            char *parameter = yon_char_new(users[i]);
+            char *parameter_name = yon_char_divide_search(parameter,"=",-1);
+            char *key = yon_config_parameter_get_key(parameter_name);
+
+            gtk_list_store_append(widgets->BootloadUsersList,&iter);
+            gtk_list_store_set(widgets->BootloadUsersList,&iter,0,yon_char_parsed_check_exist(admins_parsed,admins_size,key),1,key,2,parameter,3,"******",-1);
+            free(parameter);
+            free(parameter_name);
+            free(key);
+        }
+        yon_char_parsed_free(admins_parsed,admins_size);
+    }
+}

source/ubinstall-gtk-components.c

@@ -0,0 +1,261 @@
+#include "ubinstall-gtk.h"
+
+int yon_kernel_save(main_window *widgets){
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->KernelListBox));
+    char *install_modules = "";
+    char *enabled_module = NULL;
+    for(GList *iter = list;iter;iter = iter->next){
+        kernel_row *row = g_object_get_data(G_OBJECT(iter->data),"kernel_row");
+        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(row->InstallCheck))){
+            char *temp = yon_char_unite(install_modules,!yon_char_is_empty(install_modules)?" ":"",row->modules,NULL);
+            if (!yon_char_is_empty(install_modules)) free(install_modules);
+            install_modules = temp;
+            if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(row->EnableRadio))){
+                enabled_module = row->package;
+            }
+        }
+    }
+
+    if (yon_char_is_empty(enabled_module)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),ENABLED_KERNEL_MISSING_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        return 0;
+    }
+
+    if (!yon_char_is_empty(install_modules)){
+        yon_config_register(modules_extra_parameter,modules_extra_parameter_command,install_modules);
+    } else {
+        yon_config_remove_by_key(modules_extra_parameter);
+    }
+    yon_config_register(KERNEL_BOOT_parameter,KERNEL_BOOT_parameter_command,enabled_module);
+    return 1;
+}
+
+int yon_kernel_addon_save(main_window *widgets){
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->KernelAddonListBox));
+    char *install_modules = "";
+    for(GList *iter = list;iter;iter = iter->next){
+        kernel_row *row = g_object_get_data(G_OBJECT(iter->data),"kernel_row");
+        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(row->InstallCheck))){
+            char *temp = yon_char_unite(install_modules,!yon_char_is_empty(install_modules)?" ":"",row->modules,NULL);
+            if (!yon_char_is_empty(install_modules)) free(install_modules);
+            install_modules = temp;
+        }
+    }
+
+    if (!yon_char_is_empty(install_modules)){
+        char *parameter = config(modules_extra_parameter);
+        char *parameter_new = yon_char_unite(!yon_char_is_empty(parameter)?parameter:"",!yon_char_is_empty(parameter)?",":"",install_modules,NULL);
+        yon_config_register(modules_extra_parameter,modules_extra_parameter_command,parameter_new);
+        free(parameter_new);
+    }
+    return 1;
+}
+
+int yon_os_components_save(main_window *widgets){
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->OSSoftwareListBox));
+    GList *iter;
+    int size;
+    config_str modules = NULL;
+    for(iter = list;iter;iter=iter->next){
+        os_row *row = g_object_get_data(iter->data,"kernel_row");
+        char *target = row->name;
+        int status = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(row->InstallCheck));
+        if (status){
+            yon_char_parsed_add_or_create_if_exists(modules,&size,target);
+        }
+    }
+    g_list_free(list);
+    if (size){
+        char *final = yon_char_parsed_to_string(modules,size,",");
+        yon_config_register(modules_parameter,modules_parameter_command,final);
+    } else {
+        yon_config_remove_by_key(modules_parameter);
+    }
+    return 1;
+}
+
+os_row *yon_os_row_new(){
+    os_row *row = new(os_row);
+    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_os_row);
+    row->RowBox = yon_gtk_builder_get_widget(builder,"TableRow");
+    row->InstallCheck = yon_gtk_builder_get_widget(builder,"InstallCheck");
+    row->NameLabel = yon_gtk_builder_get_widget(builder,"NameLabel");
+    row->TagsBox = yon_gtk_builder_get_widget(builder,"TagsBox");
+    row->VersionLabel = yon_gtk_builder_get_widget(builder,"VersionLabel");
+    row->DescriptionLabel = yon_gtk_builder_get_widget(builder,"DescriptionLabel");
+    row->name=NULL;
+    row->modules=NULL;
+    row->version=NULL;
+
+    g_signal_connect(G_OBJECT(row->InstallCheck),"toggled",G_CALLBACK(on_kernel_install_enabled),row);
+
+    row->row = gtk_list_box_row_new();
+    gtk_container_add(GTK_CONTAINER(row->row),row->RowBox);
+    gtk_widget_show(row->row);
+
+    g_object_set_data(G_OBJECT(row->InstallCheck),"kernel_row",row);
+    g_object_set_data(G_OBJECT(row->row),"kernel_row",row);
+
+    return row;
+}
+
+void yon_os_row_setup(os_row *row, char *name, char *version,char *tags, char *description){
+    row->name = yon_char_new(name);
+
+    char *description_full = yon_char_new(description);
+    if (strlen(description)>100){
+        guint size;
+        config_str description_wrapped = yon_char_wrap_to_lines(description,3,&size);
+        description_full = yon_char_parsed_to_string(description_wrapped,size,"\n");
+        yon_char_parsed_free(description_wrapped,size);
+    }
+    gtk_label_set_label(GTK_LABEL(row->NameLabel),name);
+    gtk_label_set_label(GTK_LABEL(row->VersionLabel),version);
+    gtk_label_set_label(GTK_LABEL(row->DescriptionLabel),description_full);
+
+    yon_kernel_row_setup_tags((kernel_row*)row,tags);
+    free(description_full);
+}
+
+void yon_os_components_init(main_window *widgets){
+        int size = 0;
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->OSSoftwareListBox));
+        GList *iter;
+    if (!list){
+        int base_size;
+        config_str base = yon_config_load(get_modules_command,&base_size);
+        for (int i=0;i<base_size;i++){
+            yon_char_remove_last_symbol(base[i],'\n');
+            int parsed_size;
+            config_str parsed = yon_char_parse(base[i],&parsed_size,";");
+            char *version = parsed[1];
+            char *name = parsed[0];
+            char *tags = yon_char_replace(parsed[2]," ",", ");
+            char *description = parsed[3];
+            os_row *row = yon_os_row_new();
+            yon_os_row_setup(row,name,version,tags,description);
+            gtk_list_box_insert(GTK_LIST_BOX(widgets->OSSoftwareListBox),row->row,-1);
+            int min_size=0;
+            gtk_widget_get_preferred_width(row->NameLabel,&min_size,NULL);
+            if (min_size>size) size=min_size;
+
+
+        }
+        yon_char_parsed_free(base,base_size);
+        while(gtk_events_pending()) gtk_main_iteration();
+        list = gtk_container_get_children(GTK_CONTAINER(widgets->OSSoftwareListBox));
+        for(iter = list;iter;iter=iter->next){
+            os_row *row = g_object_get_data(iter->data,"kernel_row");
+            gtk_widget_set_size_request(row->NameLabel,size,-1);
+        }
+    }
+
+    char *modules = config(modules_parameter);
+    if (!yon_char_is_empty(modules)){
+        int parsed_size;
+        config_str parsed = yon_char_parse(modules,&parsed_size,",");
+        for(iter = list;iter;iter=iter->next){
+            os_row *row = g_object_get_data(iter->data,"kernel_row");
+            char *target = row->name;
+            if (yon_char_parsed_check_exist(parsed,parsed_size,target)>-1){
+                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(row->InstallCheck),1);
+            } else {
+                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(row->InstallCheck),1);
+            }
+        }
+        yon_char_parsed_free(parsed,parsed_size);
+    }
+}
+
+int yon_software_save(main_window *widgets){
+
+    GtkTreeIter iter;
+    GtkTreeModel *model = GTK_TREE_MODEL(widgets->AdditionalSoftwareList);
+    int size = 0;
+    config_str modules = NULL;
+    for_iter(model,&iter){
+        char *target;
+        int status;
+        gtk_tree_model_get(model,&iter,0,&status,1,&target,-1);
+        if (status){
+            yon_char_parsed_add_or_create_if_exists(modules,&size,target);
+        }
+    }
+    if (size){
+        char *final = yon_char_parsed_to_string(modules,size,",");
+        char *parameter = config(modules_extra_parameter);
+        char *parameter_new = yon_char_unite(!yon_char_is_empty(parameter)?parameter:"",!yon_char_is_empty(parameter)?",":"",final,NULL);
+        yon_config_register(modules_extra_parameter,modules_extra_parameter_command,parameter_new);
+        free(parameter_new);
+    }
+    return 1;
+}
+
+void yon_software_init(main_window *widgets){
+    GtkTreeIter iter;
+    if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(widgets->AdditionalSoftwareList),&iter)){
+        int size;
+        config_str parsed = NULL;
+        parsed = yon_resource_open_file(additional_software_path,&size);
+        for (int i=1;i<size;i++){
+            int module_size;
+            config_str module_parsed = yon_char_parse(parsed[i],&module_size,"|");
+            if (module_size){
+                gtk_list_store_append(widgets->AdditionalSoftwareList,&iter);
+                gtk_list_store_set(widgets->AdditionalSoftwareList,&iter,0,1,1,module_parsed[0],2,module_parsed[1],3,module_parsed[2],-1); //2,module_parsed[2]
+                yon_char_parsed_free(module_parsed,module_size);
+            }
+        }
+        if (size) yon_char_parsed_free(parsed,size);
+    }
+
+    char *modules = config(modules_extra_parameter);
+
+    int size;
+    config_str parsed = yon_char_parse(modules,&size,",");
+    for_iter(GTK_TREE_MODEL(widgets->AdditionalSoftwareList),&iter){
+        char *target;
+        gtk_tree_model_get(GTK_TREE_MODEL(widgets->AdditionalSoftwareList),&iter,1,&target);
+        if (yon_char_parsed_check_exist(parsed,size,target)>-1){
+            gtk_list_store_set(widgets->AdditionalSoftwareList,&iter,0,1,-1);
+        } else {
+            gtk_list_store_set(widgets->AdditionalSoftwareList,&iter,0,0,-1);
+        }
+    }
+    yon_char_parsed_free(parsed,size);
+}
+
+int yon_pacman_software_save(main_window *widgets){
+    GtkTreeIter iter;
+    GtkTreeModel *model = GTK_TREE_MODEL(widgets->PacmanSoftwareChosenList);
+    int size;
+    config_str parameters = NULL;
+    for_iter(model,&iter){
+        char *target;
+        gtk_tree_model_get(model,&iter,1,&target,-1);
+        yon_char_parsed_add_or_create_if_exists(parameters,&size,target);        
+    }
+    char *final = yon_char_parsed_to_string(parameters,size,",");
+    yon_char_parsed_free(parameters,size);
+    if (!yon_char_is_empty(final)){
+        yon_config_register(packages_parameter,packages_parameter_command,final);
+    } else {
+        yon_config_remove_by_key(packages_parameter);
+    }
+    return 1;
+}
+
+void yon_pacman_init(main_window *widgets){
+    char *pacman_packages = config(packages_parameter);
+
+    int size;
+    config_str parsed = yon_char_parse(pacman_packages,&size,",");
+    for (int i=0;i<size;i++){
+        char *description = yon_packages_get_description(YON_PACKAGES_SYNC,parsed[i]);
+        char *version = yon_packages_get_version(YON_PACKAGES_SYNC,parsed[i]);
+        GtkTreeIter iter;
+        gtk_list_store_append(widgets->PacmanSoftwareChosenList,&iter);
+        gtk_list_store_set(widgets->PacmanSoftwareChosenList,&iter,0,1,1,parsed[i],2,version,3,description,-1);
+    }
+    yon_char_parsed_free(parsed,size);
+}

source/ubinstall-gtk-configuration-mode.c

@@ -0,0 +1,25 @@
+#include "ubinstall-gtk.h"
+
+void on_configuration_mode_switch(GtkWidget *self,main_window *widgets){
+    if (getuid()) {
+        if (main_config.configure_mode==1){
+            char *argline = LocaleName;
+            for (int i=1;i<main_config.arg_size;i++){
+                if (!strcmp(main_config.arg_target[i],"socket-id")||!strcmp(main_config.arg_target[i],"socket-ext-id")||!strcmp(main_config.arg_target[i],"socket-trd-id")){ i++;
+                    continue;
+                }
+                char *temp = yon_char_unite(argline," ", main_config.arg_target[i],NULL);
+                if(strcmp(argline,"")&&strcmp(argline,LocaleName))
+                    free(argline);
+                argline=temp;
+            }
+            if (getuid()!=0){
+                argline = yon_char_unite("setsid /usr/bin/bash -c 'pkexec ",argline,"'; exit",NULL);
+                pthread_t thread_id;
+                pthread_create(&thread_id, NULL, (void *)on_root_get_root,argline);
+                gtk_widget_destroy(widgets->MainWindow);
+            }
+        }
+    }
+    main_config.configure_mode = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(self));
+}

source/ubinstall-gtk-grub.c

@@ -0,0 +1,47 @@
+#include "ubinstall-gtk.h"
+
+int yon_grub_install_save(main_window *widgets){
+    GtkTreeIter iter;
+    GtkTreeModel *model;
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->GrubInstallDevicesTree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->GrubInstallDevicesTree));
+        return 0;
+    }
+    char *cur_device;
+    gtk_tree_model_get(model,&iter,0,&cur_device,-1);
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->GrubInstallPartitionTree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->GrubInstallPartitionTree));
+        return 0;
+    }
+    char *partition;
+    gtk_tree_model_get(model,&iter,0,&partition,-1);
+    yon_config_register(AUTOINSTALL_DEVICE,AUTOINSTALL_DEVICE_command,cur_device);
+    yon_config_register(part_parameter,part_parameter_command,partition);
+    yon_config_register(AUTOINSTALL_TYPE_INSTALL,AUTOINSTALL_TYPE_INSTALL_command,"grub_install");
+    return 1;
+}
+
+int yon_grub_update_save(main_window *widgets){
+    GtkTreeIter iter;
+    GtkTreeModel *model;
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->GrubUpdateDevicesTree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->GrubUpdateDevicesTree));
+        return 0;
+    }
+    char *cur_device;
+    gtk_tree_model_get(model,&iter,0,&cur_device,-1);
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->GrubUpdatePartitionTree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->GrubUpdatePartitionTree));
+        return 0;
+    }
+    char *partition;
+    gtk_tree_model_get(model,&iter,0,&partition,-1);
+    yon_config_register(AUTOINSTALL_DEVICE,AUTOINSTALL_DEVICE_command,cur_device);
+    yon_config_register(part_parameter,part_parameter_command,partition);
+    yon_config_register(AUTOINSTALL_TYPE_INSTALL,AUTOINSTALL_TYPE_INSTALL_command,"grub_update");
+    return 1;
+}

source/ubinstall-gtk-install-start.c

@@ -0,0 +1,11 @@
+#include "ubinstall-gtk.h"
+
+int yon_installation_start(main_window *widgets){
+    return !pthread_create(&main_config.install_thread,NULL,on_config_save,widgets);
+}
+
+void yon_quick_install(GtkWidget *, main_window *widgets){
+    main_config.save_configured=1;
+    pthread_create(&main_config.install_thread,NULL,on_config_save,widgets);
+    gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets->Notebook),YON_PAGE_INSTALLATION);
+}

source/ubinstall-gtk-installation.c

@@ -0,0 +1,810 @@
+#include "ubinstall-gtk.h"
+
+int yon_install_common_save(main_window *widgets){
+    GtkTreeModel *model;
+    GtkTreeIter iter;
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->CommonInstallationDevicesTree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->CommonInstallationDevicesTree));
+        return 0;
+    }
+    char *device;
+    yon_config_remove_by_key(part_size_parameter);
+    yon_config_remove_by_key(part_parameter);
+    gtk_tree_model_get(model,&iter,0,&device,-1);
+    yon_config_register(AUTOINSTALL_TYPE_INSTALL,AUTOINSTALL_TYPE_INSTALL_command,"fast");
+    yon_config_register(AUTOINSTALL_DEVICE,AUTOINSTALL_DEVICE_command,device);
+
+    char *device_name = (char*)gtk_entry_get_text(GTK_ENTRY(widgets->CommonInstallationSectionNameEntry));
+    if (!yon_char_is_empty(device_name)){
+        yon_config_register(part_label_parameter,part_label_parameter_command,device_name);
+    } else {
+        yon_config_remove_by_key(part_label_parameter);
+    }
+
+    char *file_system_type = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->CommonInstallationFilesystemTypeCombo));
+    if (!yon_char_is_empty(file_system_type)){
+        yon_config_register(part_fs_type_parameter,part_fs_type_parameter_command,file_system_type);
+    } else {
+        yon_config_remove_by_key(part_fs_type_parameter);
+    }
+    return 1;
+}
+
+int yon_install_separate_save(main_window *widgets){
+    GtkTreeModel *model;
+    GtkTreeIter iter;
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->NextInstallationSysDevicesTree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->CommonInstallationDevicesTree));
+        return 0;
+    }
+    char *device;
+    gtk_tree_model_get(model,&iter,0,&device,-1);
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->NextInstallationSysSectionTree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->CommonInstallationDevicesTree));
+        return 0;
+    }
+    if (gtk_switch_get_active(GTK_SWITCH(widgets->NextInstallationFormatSwitch))){
+        yon_config_register(part_format_parameter,part_format_parameter_command,"yes");
+        double part_size = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widgets->NextInstallationSizeSpin));
+        if (part_size){
+            char *size_letter = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(widgets->NextInstallationSizeTypeSpin));
+            char *size_final = yon_char_append(yon_char_from_long((long)part_size),size_letter);
+            yon_config_register(part_size_parameter,part_size_parameter_command,size_final);
+        } else {
+            yon_config_remove_by_key(part_size_parameter);
+        }
+
+            char *device_name = (char*)gtk_entry_get_text(GTK_ENTRY(widgets->NextInstallationSectionNameEntry));
+        if (!yon_char_is_empty(device_name)){
+            yon_config_register(part_label_parameter,part_label_parameter_command,device_name);
+        } else {
+            yon_config_remove_by_key(part_label_parameter);
+
+        }
+
+        char *file_system_type = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->NextInstallationFilesystemTypeCombo));
+        if (!yon_char_is_empty(file_system_type)){
+            yon_config_register(part_fs_type_parameter,part_fs_type_parameter_command,file_system_type);
+
+        } else {
+            yon_config_remove_by_key(part_fs_type_parameter);
+
+        }
+    } else {
+            yon_config_register(part_format_parameter,part_format_parameter_command,"no");
+            yon_config_remove_by_key(part_label_parameter);
+            yon_config_remove_by_key(part_fs_type_parameter);
+            yon_config_remove_by_key(part_format_parameter);
+            yon_config_remove_by_key(part_fs_type_parameter);
+            yon_config_remove_by_key(part_format_parameter);
+    }
+    
+    char *part;
+    gtk_tree_model_get(model,&iter,0,&part,-1);
+    yon_config_register(AUTOINSTALL_TYPE_INSTALL,AUTOINSTALL_TYPE_INSTALL_command,"next");
+    yon_config_register(AUTOINSTALL_DEVICE,AUTOINSTALL_DEVICE_command,device);
+    yon_config_register(part_parameter,part_parameter_command,part);
+    return 1;
+}
+
+int yon_install_same_partition_save(main_window *widgets){
+    GtkTreeModel *model;
+    GtkTreeIter iter;
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->SamePlaceDeviceTree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->CommonInstallationDevicesTree));
+        return 0;
+    }
+    char *device;
+    gtk_tree_model_get(model,&iter,0,&device,-1);
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->SamePlacePartTree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->CommonInstallationDevicesTree));
+        return 0;
+    }
+    yon_config_remove_by_key(part_size_parameter);
+    char *part;
+    gtk_tree_model_get(model,&iter,0,&part,-1);
+        yon_config_register(AUTOINSTALL_TYPE_INSTALL,AUTOINSTALL_TYPE_INSTALL_command,"part");
+        yon_config_register(AUTOINSTALL_DEVICE,AUTOINSTALL_DEVICE_command,device);
+        yon_config_register(part_parameter,part_parameter_command,part);
+
+    if (gtk_switch_get_active(GTK_SWITCH(widgets->SameInstallationFormatSwitch))){
+        yon_config_register(part_format_parameter,part_format_parameter_command,"yes");
+        char *device_name = (char*)gtk_entry_get_text(GTK_ENTRY(widgets->SameInstallationSectionNameEntry));
+        if (!yon_char_is_empty(device_name)){
+            yon_config_register(part_label_parameter,part_label_parameter_command,device_name);
+        } else {
+            yon_config_remove_by_key(part_label_parameter);
+        }
+
+        char *file_system_type = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->SameInstallationFilesystemTypeCombo));
+        if (!yon_char_is_empty(file_system_type)){
+            yon_config_register(part_fs_type_parameter,part_fs_type_parameter_command,file_system_type);
+        } else {
+            yon_config_remove_by_key(part_fs_type_parameter);
+
+        }
+    } else {
+        yon_config_register(part_format_parameter,part_format_parameter_command,"no");
+        yon_config_remove_by_key(part_label_parameter);
+        yon_config_remove_by_key(part_format_parameter);
+        yon_config_remove_by_key(part_fs_type_parameter);
+    }
+    return 1;
+}
+
+int yon_advanced_sections_save(dictionary *dict){
+    if (!dict) return 0;
+    advanced_partition *first_section = yon_dictionary_get_data(dict->first,advanced_partition*);
+    advanced_partition *last_section = NULL;
+    if (dict->first->next){
+        last_section = yon_dictionary_get_data(dict->first->next,advanced_partition*);
+    }
+
+    char *part_first = first_section->part;
+    char *part_last = last_section?last_section->part:NULL;
+    char *part = yon_char_unite(part_first,last_section?",":NULL,part_last,NULL);
+    yon_config_register(part_parameter,part_parameter_command,part);
+
+    char * format_first = gtk_switch_get_active(GTK_SWITCH(first_section->FormatSwitch))?"yes":"no";
+    char * format_last = last_section?gtk_switch_get_active(GTK_SWITCH(last_section->FormatSwitch))?"yes":"no":NULL;
+    char *format = yon_char_unite(format_first,part_last?",":NULL,format_last,NULL);
+    yon_config_register(part_format_parameter,part_format_parameter_command,format);
+
+    if (!yon_char_is_empty(format)){
+        char *size_first = g_strdup_printf("%d%s",gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(first_section->SizeSpin)),yon_size_get_mod(gtk_combo_box_get_active(GTK_COMBO_BOX(first_section->SizeCombo))));
+        char *size_last = last_section&&!strcmp(format_last,"yes")?g_strdup_printf("%d%s",gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(last_section->SizeSpin)),yon_size_get_mod(gtk_combo_box_get_active(GTK_COMBO_BOX(last_section->SizeCombo)))):NULL;
+        char *size = yon_char_unite(size_first,size_last?",":NULL,size_last,NULL);
+        yon_config_register(part_size_parameter,part_size_parameter_command,size);
+        
+        char *part_label_first = (char*)gtk_entry_get_text(GTK_ENTRY(first_section->SectionMarkEntry));
+        char *part_label_last = last_section&&!strcmp(format_last,"yes")?(char*)gtk_entry_get_text(GTK_ENTRY(last_section->SectionMarkEntry)):NULL;
+        char *part_label = yon_char_unite(part_label_first,part_label_last?",":NULL,part_label_last,NULL);
+        yon_config_register(part_label_parameter,part_label_parameter_command,part_label);
+
+        char *fs_label_first = (char*)gtk_entry_get_text(GTK_ENTRY(first_section->FileSystemMarkentry));
+        char *fs_label_last = last_section&&!strcmp(format_last,"yes")?(char*)gtk_entry_get_text(GTK_ENTRY(last_section->FileSystemMarkentry)):NULL;
+        char *fs_label = yon_char_unite(fs_label_first,fs_label_last?",":NULL,fs_label_last,NULL);
+        yon_config_register(part_fs_label_parameter,part_fs_label_parameter_command,fs_label);
+
+        char *fs_type_first = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(first_section->FileSystemTypeCombo));
+        char *fs_type_last = last_section&&!strcmp(format_last,"yes")?(char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(last_section->FileSystemTypeCombo)):NULL;
+        char *fs_type = yon_char_unite(fs_type_first,fs_type_last?",":NULL,fs_type_last,NULL);
+        yon_config_register(part_fs_type_parameter,part_fs_type_parameter_command,fs_type);
+
+        char *part_crypt_first = gtk_combo_box_get_active(GTK_COMBO_BOX(first_section->EncryptionCombo))?(char*)gtk_entry_get_text(GTK_ENTRY(first_section->EncryptionEntry)):NULL;
+        char *part_crypt_last = last_section&&!strcmp(format_last,"yes")&&gtk_combo_box_get_active(GTK_COMBO_BOX(last_section->EncryptionCombo))?(char*)gtk_entry_get_text(GTK_ENTRY(first_section->EncryptionEntry)):NULL;
+        char *part_crypt = NULL;
+        if (part_crypt_first||part_crypt_last){
+            part_crypt = yon_char_unite(part_crypt_first,part_crypt_last?",":NULL,part_crypt_last,NULL);
+        }
+        if (part_crypt){
+            yon_config_register(part_crypt_parameter,part_crypt_parameter_command,part_crypt);
+        } else {
+            yon_config_remove_by_key(part_crypt_parameter);
+        }
+    }
+    return 1;
+}
+
+int yon_install_advanced_save(main_window *widgets){
+
+    GtkTreeModel *model;
+    GtkTreeIter iter;
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->AdvancedDeviceTree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->AdvancedDeviceTree));
+        return 0;
+    }
+    char *device;
+    gtk_tree_model_get(model,&iter,0,&device,-1);
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->AdvancedPartitionTree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->AdvancedPartitionTree));
+        return 0;
+    }
+    yon_config_remove_by_key(part_size_parameter);
+    char *part;
+    gtk_tree_model_get(model,&iter,0,&part,-1);
+
+    if (!yon_advanced_sections_save(widgets->advanced_sections)){
+        return 0;
+    }
+
+    if (gtk_switch_get_active(GTK_SWITCH(widgets->AdvancedSwapSwitch))){
+        if (gtk_switch_get_active(GTK_SWITCH(widgets->AdvancedSwapAutoSwitch))){
+            yon_config_register(swap_parameter,swap_parameter_command,"auto");
+        } else if (gtk_switch_get_active(GTK_SWITCH(widgets->AdvancedSwapRamSwitch))){
+            yon_config_register(swap_parameter,swap_parameter_command,"yes");
+            yon_config_register(swap_size_parameter,swap_size_parameter_command,"ram");
+        } else {
+            yon_config_register(swap_parameter,swap_parameter_command,"yes");
+            char *swap = g_strdup_printf("%d%s",gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->AdvancedSwapFixedSpin)),yon_size_get_mod(gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->AdvancedSwapFixedSizeSwitch))+1));
+            yon_config_register(swap_size_parameter,swap_size_parameter_command,swap);
+        }
+    }
+    const char *device_typevfs = gtk_combo_box_get_active_id(GTK_COMBO_BOX(widgets->AdvancedVirtualDeviceCombo));
+    if (!yon_char_is_empty(device_typevfs)){
+        yon_config_register(device_typevfs_parameter,device_typevfs_parameter_command,(char*)device_typevfs);
+    } else {
+        yon_config_remove_by_key(device_typevfs_parameter);
+    }
+    if (gtk_switch_get_active(GTK_SWITCH(widgets->AdvancedLoadTypeSwitch))){
+        char *bios = gtk_switch_get_active(GTK_SWITCH(widgets->AdvancedBiosSectorSwitch))?"bios":"";
+        char *efi = gtk_switch_get_active(GTK_SWITCH(widgets->AdvancedEFISwitch))?"efi":NULL;
+        char *boot = yon_char_unite(bios,!yon_char_is_empty(bios)&&!yon_char_is_empty(efi)?"+":"",efi,NULL);
+        yon_config_register(boot_parameter,boot_parameter_command,boot);
+    } else {
+        yon_config_register(boot_parameter,boot_parameter_command,"none");
+    }
+
+    return 1;
+}
+
+void yon_install_advanced_init(main_window *){
+    // char *boot = config(boot_parameter);
+    // char *swap = config(swap_parameter);
+}
+
+void yon_set_max_size_from_partition(GtkTreeView *table, GtkSpinButton *spin_button, GtkComboBox *spin_combo){
+    GtkTreeModel *model;
+    GtkTreeIter iter;
+    long selected_size;
+    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(table),&model,&iter)){
+        gtk_tree_model_get(model,&iter,6,&selected_size,-1);
+        if (!selected_size){
+            gtk_tree_model_get(model,&iter,5,&selected_size,-1);
+        }
+        if (selected_size){
+            GtkAdjustment *adj = gtk_spin_button_get_adjustment(spin_button);
+            const char *sizemod = gtk_combo_box_get_active_id(spin_combo);
+            double new_size = yon_size_long_convert_to_mod(selected_size,sizemod[0]);
+            gtk_adjustment_set_upper(adj,new_size);
+            gdouble old_value = gtk_adjustment_get_value(adj);
+            if (old_value>new_size){
+                gtk_adjustment_set_value(adj,new_size);
+            }
+        }
+    }
+}
+
+void on_partition_changed(GtkWidget *self, main_window *widgets){
+    if (self==widgets->NextInstallationSysSectionTree||self == widgets->NextInstallationSizeTypeSpin){
+        yon_set_max_size_from_partition(GTK_TREE_VIEW(widgets->NextInstallationSysSectionTree),GTK_SPIN_BUTTON(widgets->NextInstallationSizeSpin),GTK_COMBO_BOX(widgets->NextInstallationSizeTypeSpin));
+    }
+
+}
+
+void on_device_selection_changed(GtkWidget *self, main_window *widgets){
+    gtk_list_store_clear(widgets->PartitionsList);
+    GtkTreeIter iter;
+    GtkTreeModel *model;
+    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(self)),&model,&iter)){
+        char *disk_path;
+        gtk_tree_model_get(model,&iter,0,&disk_path,-1);
+        int size;
+        config_str partitions;
+        partitions = yon_config_load(yon_debug_output("%s\n",get_parts_and_devices_command),&size);
+        for (int i=0;i<size;i++){
+            yon_char_remove_last_symbol(partitions[i],'\n');
+            int parsed_size;
+            config_str parsed = yon_char_parse(partitions[i],&parsed_size,";");
+            if (!strcmp(parsed[0],"part")){
+                char *name = parsed[1];
+                if (strstr(name,disk_path)){
+                    char *capacity = NULL;
+                    long capacity_long = 0;
+                    char *free_space = NULL;
+                    long free_space_long = 0;
+                    char *fs_type = NULL;
+                    char *label = NULL;
+
+                    if (parsed_size>2){
+                        char sizemod='\0';
+                        capacity_long = atol(parsed[2]);
+                        
+                        char *temp = yon_char_from_double(yon_size_long_convert_automatic(capacity_long,&sizemod));
+                        capacity = yon_char_append_c(temp,sizemod);
+                        free(temp);
+                    }
+                    if (parsed_size>7&&!yon_char_is_empty(parsed[7])){
+                        char sizemod='\0';
+                        free_space_long = capacity_long-atol(parsed[7]);
+                        char *temp = yon_char_from_double(yon_size_long_convert_automatic(free_space_long,&sizemod));
+                        free_space = yon_char_append_c(temp,sizemod);
+                        free(temp);
+                    }
+                    if (parsed_size>3){
+                        fs_type = parsed[3];
+                    }
+                    if (parsed_size>4){
+                        label = parsed[4];
+                    }
+
+                    gtk_list_store_append(widgets->PartitionsList,&iter);
+                    gtk_list_store_set(widgets->PartitionsList,&iter,0,name,1,capacity,2,free_space,3,fs_type,4,label,5,capacity_long,6,free_space_long,-1);
+                }
+                yon_char_parsed_free(parsed,parsed_size);
+            }
+        }
+        gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->NextInstallationSizeSpin),0.0);
+        gtk_adjustment_set_upper(gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(widgets->NextInstallationSizeSpin)),0.0);
+    }
+}
+
+void yon_devices_setup(main_window *widgets){
+    GtkTreeIter iter;
+    if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(widgets->DevicesList),&iter)) return;
+    int size;
+    config_str parsed = NULL;
+    parsed = yon_config_load(yon_debug_output("%s\n",get_devices_command),&size);
+    char *string = yon_char_parsed_to_string(parsed,size,"");
+    struct json_object *root;
+    struct json_object *blockdevices;
+    root = json_tokener_parse(string);
+    free(string);
+    json_object_object_get_ex(root, "blockdevices", &blockdevices);
+    for (long unsigned int i = 0; i < json_object_array_length(blockdevices); i++) {
+        struct json_object *device = json_object_array_get_idx(blockdevices, i);
+        struct json_object *path, *size, *model, *vendor, *serial;
+
+        json_object_object_get_ex(device, "path", &path);
+        json_object_object_get_ex(device, "size", &size);
+        json_object_object_get_ex(device, "model", &model);
+        json_object_object_get_ex(device, "vendor", &vendor);
+        json_object_object_get_ex(device, "serial", &serial);
+
+        gtk_list_store_append(widgets->DevicesList,&iter);
+        gtk_list_store_set(widgets->DevicesList,&iter,0,json_object_get_string(path),1,json_object_get_string(model),2,json_object_get_string(serial),3,json_object_get_string(size),4,json_object_get_string(vendor),6,1,-1);
+        
+    }
+    yon_char_parsed_free(parsed,size);
+}
+
+void yon_install_init(main_window *widgets, enum YON_PAGES page){
+    yon_devices_setup(widgets);
+    
+    GtkWidget *device_tree = NULL;
+    GtkWidget *partition_tree = NULL;
+    GtkWidget *format_switch = NULL;
+    GtkWidget *device_label = NULL;
+    GtkWidget *fs_type_combo = NULL;
+    GtkWidget *partition_size_spin = NULL;
+    GtkWidget *partition_size_combo = NULL;
+    GtkWidget *partition_mark_entry = NULL;
+    GtkWidget *partition_fs_mark_entry = NULL;
+    GtkWidget *partition_encryption_combo = NULL;
+    GtkWidget *partition_encryption_entry = NULL;
+
+    switch(page){
+        case YON_PAGE_INSTALL_COMMON:
+            device_tree = widgets->CommonInstallationDevicesTree;
+            device_label = widgets->CommonInstallationSectionNameEntry;
+            format_switch = widgets->CommonFormatSwitch;
+            fs_type_combo = widgets->CommonInstallationFilesystemTypeCombo;
+        break;
+        case YON_PAGE_INSTALL_SAME_PARTITION:
+            device_tree = widgets->SamePlaceDeviceTree;
+            partition_tree = widgets->SamePlacePartTree;
+            format_switch = widgets->SameInstallationFormatSwitch;
+            partition_mark_entry = widgets->SameInstallationSectionNameEntry;
+            fs_type_combo = widgets->SameInstallationFilesystemTypeCombo;
+        break;
+        case YON_PAGE_INSTALL_SEPARATE:
+            device_tree = widgets->NextInstallationSysDevicesTree;
+            partition_tree = widgets->NextInstallationSysSectionTree;
+            format_switch = widgets->NextInstallationFormatSwitch;
+            partition_size_spin = widgets->NextInstallationSizeSpin;
+            partition_size_combo = widgets->NextInstallationSizeTypeSpin;
+            partition_mark_entry = widgets->NextInstallationSectionNameEntry;
+            fs_type_combo = widgets->NextInstallationFilesystemTypeCombo;
+
+        break;
+        case YON_PAGE_INSTALL_ADVANCED:
+            yon_install_advanced_init(widgets);
+            return;
+        break;
+        case YON_PAGE_RECOVERY_GRUB_INSTALL:
+            device_tree = widgets->GrubInstallDevicesTree;
+            partition_tree = widgets->GrubInstallPartitionTree;
+
+        break;
+        case YON_PAGE_RECOVERY_GRUB_UPDATE:
+            device_tree = widgets->GrubUpdateDevicesTree;
+            partition_tree = widgets->GrubUpdatePartitionTree;
+
+        break;
+        case YON_PAGE_RECOVERY_OS_ONLY:
+            device_tree = widgets->OSDevicesTree;
+            partition_tree = widgets->OSSysSectionTree;
+            format_switch = widgets->OSFormatSwitch;
+            partition_size_spin = widgets->OSFormatSizeSpin;
+            partition_size_combo = widgets->OSFormatSizeCombo;
+            partition_mark_entry = widgets->OSFormatPartitionEntry;
+            fs_type_combo = widgets->OSFilesystemTypeCombo;
+            partition_fs_mark_entry = widgets->OSFormatFSMarkEntry;
+            partition_encryption_combo = widgets->OSFormatEncryptionCombo;
+            partition_encryption_entry = widgets->OSFormatEncryptionEntry;
+
+        break;
+        case YON_PAGE_RECOVERY_USRDATA_ONLY:
+            device_tree = widgets->UserdataDevicesTree;
+            partition_tree = widgets->UserdataSysSectionTree;
+            format_switch = widgets->OSFormatSwitch;
+            partition_size_spin = widgets->UserdataFormatSwitch;
+            partition_size_combo = widgets->UserdataFormatSizeCombo;
+            partition_mark_entry = widgets->UserdataFormatPartitionEntry;
+            fs_type_combo = widgets->UserdataFilesystemTypeCombo;
+            partition_fs_mark_entry = widgets->UserdataFormatFSMarkEntry;
+            partition_encryption_combo = widgets->UserdataFormatEncryptionCombo;
+            partition_encryption_entry = widgets->UserdataFormatEncryptionEntry;
+        break;
+        default:return;
+    }
+
+
+    char *device = config(AUTOINSTALL_DEVICE);
+    char *part = config(part_parameter);
+
+
+    if (!yon_char_is_empty(device)){
+        GtkTreeIter iter;
+        GtkTreeModel *model = GTK_TREE_MODEL(widgets->DevicesList);
+        for_iter(model,&iter){
+            char *target;
+            gtk_tree_model_get(model,&iter,0,&target,-1);
+            if (!yon_char_is_empty(target)&&!strcmp(target,device)){
+                gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(device_tree)),&iter);
+                break;
+            }
+        }
+        if (partition_tree&&!yon_char_is_empty(part)){
+            model = GTK_TREE_MODEL(widgets->PartitionsList);
+            for_iter(model,&iter){
+                char *target;
+                gtk_tree_model_get(model,&iter,0,&target,-1);
+                if (!yon_char_is_empty(target)&&!strcmp(target,device)){
+                    gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(partition_tree)),&iter);
+                    break;
+                }
+            }
+        }
+    }
+    if (format_switch){
+        char *format = config(part_format_parameter);
+        if ((!yon_char_is_empty(format)&&!strcmp(format,"yes"))||format_switch==widgets->CommonFormatSwitch){
+            gtk_switch_set_active(GTK_SWITCH(format_switch),1);
+            if (device_label){
+                char *parameter = config(part_label_parameter);
+                if (!yon_char_is_empty(parameter)){
+                    gtk_entry_set_text(GTK_ENTRY(device_label),parameter);
+                } else {
+                    gtk_entry_set_text(GTK_ENTRY(device_label),"");
+                }
+            }
+            if (fs_type_combo){
+                char *parameter = config(part_fs_type_parameter);
+                if (!yon_char_is_empty(parameter)){
+                    gtk_combo_box_set_active_id(GTK_COMBO_BOX(fs_type_combo),parameter);
+                } else {
+                    gtk_combo_box_set_active(GTK_COMBO_BOX(fs_type_combo),0);
+                }
+            }
+            if (partition_size_spin&&partition_size_combo){
+                char *parameter = config(part_size_parameter);
+                if (!yon_char_is_empty(parameter)){
+                    gtk_spin_button_set_value(GTK_SPIN_BUTTON(partition_size_spin),atol(parameter));
+                    gtk_combo_box_set_active(GTK_COMBO_BOX(partition_size_combo),yon_get_size_get_from_letter(parameter[strlen(parameter)-1]));
+                } else {
+                    gtk_spin_button_set_value(GTK_SPIN_BUTTON(partition_size_spin),0);
+                    gtk_combo_box_set_active(GTK_COMBO_BOX(partition_size_combo),0);
+                }
+            }
+            if (partition_mark_entry){
+                char *parameter = config(part_label_parameter);
+                if (!yon_char_is_empty(parameter)){
+                    gtk_entry_set_text(GTK_ENTRY(partition_mark_entry),parameter);
+                } else {
+                    gtk_entry_set_text(GTK_ENTRY(partition_mark_entry),"");
+                }
+            }
+            if (partition_fs_mark_entry){
+                char *parameter = config(part_fs_label_parameter);
+                if (!yon_char_is_empty(parameter)){
+                    gtk_entry_set_text(GTK_ENTRY(partition_fs_mark_entry),parameter);
+                } else {
+                    gtk_entry_set_text(GTK_ENTRY(partition_fs_mark_entry),"");
+                }
+            }
+            if (partition_encryption_combo && partition_encryption_entry){
+                char *parameter = config(part_crypt_parameter);
+                if (!yon_char_is_empty(parameter)&&!strstr(parameter,",")){
+                    char *password = yon_char_new(parameter);
+                    char *crypt = yon_char_divide_search(password,":",-1);
+                    gtk_combo_box_set_active_id(GTK_COMBO_BOX(partition_encryption_combo),crypt);
+                    gtk_entry_set_text(GTK_ENTRY(partition_encryption_entry),password);
+                    free(password);
+                    free(crypt);
+                } else {
+                    gtk_combo_box_set_active(GTK_COMBO_BOX(partition_encryption_combo),0);
+                    gtk_entry_set_text(GTK_ENTRY(partition_encryption_entry),"");
+                }
+            }
+        } else {
+            gtk_switch_set_active(GTK_SWITCH(format_switch),0);
+        }
+    }
+
+}
+
+void on_advanced_password_clicked(GtkWidget *, advanced_partition *part){
+    yon_password_open(GTK_ENTRY(part->EncryptionEntry));
+}
+
+void yon_advanced_partition_clear(main_window *widgets){
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->AdvancedPartitionAddBox));
+    GList *iter;
+    for (iter=list;iter;iter=iter->next){
+        advanced_partition *part = g_object_get_data(G_OBJECT(iter->data),"advanced_partition");
+        gtk_widget_destroy(GTK_WIDGET(iter->data));
+        free(part);
+    }
+    on_advanced_parts_removed(NULL,NULL,widgets);
+}
+
+int yon_advanced_get_part_size(main_window *widgets){
+    int size = 0;
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->AdvancedPartitionAddBox));
+    size = g_list_length(list);
+    g_list_free(list);
+    return size;
+}
+
+void yon_advanced_set_part_sensitivity(main_window *widgets, gboolean state){
+    GtkTreeIter iter;
+    GtkTreeModel *model = GTK_TREE_MODEL(widgets->PartitionsList);
+    int status;
+    for_iter(model,&iter){
+        gtk_tree_model_get(model,&iter,8,&status,-1);
+        if (!status){
+            gtk_list_store_set(widgets->PartitionsList,&iter,8,state?state:0,-1);
+        } else {
+            gtk_list_store_set(widgets->PartitionsList,&iter,8,1,-1);
+        }
+    }
+}
+
+void yon_advanced_set_device_sensitivity(main_window *widgets, gboolean state){
+    GtkTreeIter iter;
+    GtkTreeModel *model = GTK_TREE_MODEL(widgets->DevicesList);
+    for_iter(model,&iter){
+        gtk_list_store_set(widgets->DevicesList,&iter,6,state,-1);
+    }
+}
+
+advanced_partition *yon_advanced_partition_new(){
+    advanced_partition *part = new(advanced_partition);
+    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_advanced_part);
+    part->MainBox = yon_gtk_builder_get_widget(builder,"MainBox");
+    part->SectionLabel = yon_gtk_builder_get_widget(builder,"SectionLabel");
+    part->SystemSectionToggle = yon_gtk_builder_get_widget(builder,"SystemSectionToggle");
+    part->UserDataSectionToggle = yon_gtk_builder_get_widget(builder,"UserDataSectionToggle");
+    part->RemoveButton = yon_gtk_builder_get_widget(builder,"RemoveButton");
+    part->FormatSwitch = yon_gtk_builder_get_widget(builder,"FormatSwitch");
+    part->SizeSpin = yon_gtk_builder_get_widget(builder,"SizeSpin");
+    part->SizeCombo = yon_gtk_builder_get_widget(builder,"SizeCombo");
+    part->SectionMarkEntry = yon_gtk_builder_get_widget(builder,"SectionMarkEntry");
+    part->FileSystemTypeCombo = yon_gtk_builder_get_widget(builder,"FileSystemTypeCombo");
+    part->FileSystemMarkentry = yon_gtk_builder_get_widget(builder,"FileSystemMarkentry");
+    part->EncryptionCombo = yon_gtk_builder_get_widget(builder,"EncryptionCombo");
+    part->EncryptionEntry = yon_gtk_builder_get_widget(builder,"EncryptionEntry");
+    part->EncryptionButton = yon_gtk_builder_get_widget(builder,"EncryptionButton");
+    part->FormatRevealer = yon_gtk_builder_get_widget(builder,"FormatRevealer");
+    part->order_iter = NULL;
+    part->part = NULL;
+
+    yon_gtk_revealer_set_from_switch(GTK_REVEALER(part->FormatRevealer),GTK_SWITCH(part->FormatSwitch));
+    g_signal_connect(G_OBJECT(part->EncryptionButton),"clicked",G_CALLBACK(on_advanced_password_clicked),part);
+    // g_signal_connect(G_OBJECT(part->SystemSectionToggle),"clicked",G_CALLBACK(on_advanced_system_toggled),part);
+    // g_signal_connect(G_OBJECT(part->UserDataSectionToggle),"clicked",G_CALLBACK(on_advanced_user_toggled),part);
+
+    g_object_set_data(G_OBJECT(part->MainBox),"advanced_partition",part);
+    g_object_set_data(G_OBJECT(part->RemoveButton),"advanced_partition",part);
+
+    return part;
+}
+
+void on_advanced_part_remove(GtkWidget *self, main_window *widgets){
+    advanced_partition *part = g_object_get_data(G_OBJECT(self),"advanced_partition");
+
+    if (part->part_type == ADVANCED_PART_EXISTING){
+        GtkTreeIter iter;
+        GtkTreeModel *model = GTK_TREE_MODEL(widgets->PartitionsList);
+        for_iter(model,&iter){
+            int status;
+            char *target;
+            gtk_tree_model_get(model,&iter,0,&target,7,&status,-1);
+            if (status&&!strcmp(target,part->part)){
+                gtk_list_store_set(GTK_LIST_STORE(model),&iter,7,0,-1);
+                yon_advanced_set_part_sensitivity(widgets,1);
+            }
+            
+        }
+    }
+    g_object_set_data(G_OBJECT(widgets->AdvancedPartitionAddBox),part->part,NULL);
+    g_sequence_remove(part->order_iter);
+    gtk_widget_destroy(part->MainBox);
+    on_advanced_parts_removed(NULL,NULL,widgets);
+    free(part);
+
+}
+
+void on_advanced_parts_added(GtkWidget *,GtkWidget*,main_window *widgets){
+    if (yon_advanced_get_part_size(widgets)>=2){
+        yon_advanced_set_part_sensitivity(widgets,0);
+        gtk_widget_hide(widgets->AdvancedAddButton);
+    }
+}
+
+void on_advanced_parts_removed(GtkWidget *,GtkWidget*,main_window *widgets){
+    int size = yon_advanced_get_part_size(widgets);
+    if (size<2){
+        yon_advanced_set_part_sensitivity(widgets,1);
+        gtk_widget_show(widgets->AdvancedAddButton);
+    }
+    if (!size){
+
+    }
+}
+
+void yon_advanced_partition_setup(advanced_partition *part,main_window *widgets){
+    g_signal_connect(G_OBJECT(part->RemoveButton),"clicked",G_CALLBACK(on_advanced_part_remove),widgets);
+    g_object_set_data(G_OBJECT(widgets->AdvancedPartitionAddBox),part->part,part);
+}
+
+void on_install_advanced_add_new(GtkWidget *, main_window *widgets){
+    advanced_partition *part = yon_advanced_partition_new();
+    part->part_type = ADVANCED_PART_NEW;
+    part->order_iter = g_sequence_append(widgets->advanced_partition_order,part);
+    gtk_box_pack_start(GTK_BOX(widgets->AdvancedPartitionAddBox),part->MainBox,0,0,0);
+    gtk_widget_show(part->MainBox);
+    yon_advanced_partition_setup(part,widgets);
+            on_advanced_parts_added(NULL,NULL,widgets);
+}
+
+void on_install_advanced_device_chosen(GtkCellRenderer *, gchar *path, main_window *widgets){
+    gtk_list_store_clear(widgets->PartitionsList);
+    yon_advanced_partition_clear(widgets);
+
+    int size;
+    config_str partitions;
+    partitions = yon_config_load(yon_debug_output("%s\n",get_parts_and_devices_command),&size);
+    for (int i=0;i<size;i++){
+        yon_char_remove_last_symbol(partitions[i],'\n');
+    }
+
+    GtkTreeIter iter;
+    GtkTreeModel *model = GTK_TREE_MODEL(widgets->DevicesList);
+
+    int chosen = 0;
+    chosen = yon_advanced_get_part_size(widgets);
+    
+    if (gtk_tree_model_get_iter_from_string(model,&iter,path)){
+        int status;
+        gtk_tree_model_get(model,&iter,5,&status,-1);
+        if (!status){
+            if (chosen <2){
+                gtk_list_store_set(widgets->DevicesList,&iter,5,!status,-1);
+                chosen++;
+            } else {
+                for_iter (model,&iter){
+                    gtk_tree_model_get(model,&iter,5,&status,-1);
+                    if (!status){
+                        gtk_list_store_set(widgets->DevicesList,&iter,6,0,-1);
+                    }
+                }
+
+            }
+        } else {
+            gtk_list_store_set(widgets->DevicesList,&iter,5,!status,-1);
+            if (chosen == 2){
+                for_iter (model,&iter){
+                        gtk_list_store_set(widgets->DevicesList,&iter,6,1,-1);
+                }
+            }
+            chosen--;
+        }
+    }
+
+    if (chosen) gtk_widget_set_sensitive(widgets->AdvancedAddButton,1);
+    else gtk_widget_set_sensitive(widgets->AdvancedAddButton,0);
+    
+    for_iter (model,&iter){
+        char *disk_path;
+        int status;
+        gtk_tree_model_get(model,&iter,0,&disk_path,5,&status,-1);
+        if (!status) continue;
+
+        for (int i=0;i<size;i++){
+            int parsed_size;
+            config_str parsed = yon_char_parse(partitions[i],&parsed_size,";");
+            if (!strcmp(parsed[0],"part")){
+                char *name = parsed[1];
+                if (strstr(name,disk_path)){
+                    char *capacity = NULL;
+                    long capacity_long = 0;
+                    char *free_space = NULL;
+                    long free_space_long = 0;
+                    char *fs_type = NULL;
+                    char *label = NULL;
+
+                    if (parsed_size>2){
+                        char sizemod='\0';
+                        capacity_long = atol(parsed[2]);
+                        
+                        char *temp = yon_char_from_double(yon_size_long_convert_automatic(capacity_long,&sizemod));
+                        capacity = yon_char_append_c(temp,sizemod);
+                        free(temp);
+                    }
+                    if (parsed_size>7&&!yon_char_is_empty(parsed[7])){
+                        char sizemod='\0';
+                        free_space_long = capacity_long-atol(parsed[7]);
+                        char *temp = yon_char_from_double(yon_size_long_convert_automatic(free_space_long,&sizemod));
+                        free_space = yon_char_append_c(temp,sizemod);
+                        free(temp);
+                    }
+                    if (parsed_size>3){
+                        fs_type = parsed[3];
+                    }
+                    if (parsed_size>4){
+                        label = parsed[4];
+                    }
+
+                    GtkTreeIter itar;
+                    gtk_list_store_append(widgets->PartitionsList,&itar);
+                    gtk_list_store_set(widgets->PartitionsList,&itar,0,name,1,capacity,2,free_space,3,fs_type,4,label,5,capacity_long,6,free_space_long,8,1,-1);
+                }
+                yon_char_parsed_free(parsed,parsed_size);
+            }
+        }
+    }
+    
+}
+
+void on_install_advanced_partition_chosen(GtkCellRenderer*, gchar *path, main_window *widgets){
+    GtkTreeIter iter;
+    GtkTreeModel *model = GTK_TREE_MODEL(widgets->PartitionsList);
+
+    int chosen = 0;
+    chosen = yon_advanced_get_part_size(widgets);
+
+    gtk_tree_model_get_iter_from_string(model,&iter,path);
+    int status;
+    char *target_part;
+    gtk_tree_model_get(model,&iter,0,&target_part,7,&status,-1);
+    
+    if (!status){
+        if (chosen<2){
+            gtk_list_store_set(widgets->PartitionsList,&iter,7,!status,-1);
+            chosen++;
+            advanced_partition *part = yon_advanced_partition_new();
+            part->part_type = ADVANCED_PART_EXISTING;
+            part->order_iter = g_sequence_append(widgets->advanced_partition_order,part);
+            part->part = target_part;
+            gtk_box_pack_start(GTK_BOX(widgets->AdvancedPartitionAddBox),part->MainBox,0,0,0);
+            gtk_widget_show(part->MainBox);
+            yon_advanced_partition_setup(part,widgets);
+            on_advanced_parts_added(NULL,NULL,widgets);
+        }
+    } else {
+        gtk_list_store_set(widgets->PartitionsList,&iter,7,!status,-1);
+        advanced_partition *part = g_object_get_data(G_OBJECT(widgets->AdvancedPartitionAddBox),target_part);
+        if (part){
+            on_advanced_part_remove(part->RemoveButton,widgets);
+        }
+    }
+}

source/ubinstall-gtk-kernel.c

@@ -0,0 +1,299 @@
+#include "ubinstall-gtk.h"
+
+void on_kernel_install_enabled(GtkWidget *, kernel_row *row){
+    int active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(row->InstallCheck));
+    gtk_widget_set_sensitive(row->EnableRadio,active);
+    if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(row->InstallCheck))){
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(main_config.kernel_unchosen_radio),1);
+    }
+}
+
+kernel_row *yon_kernel_row_new(){
+    kernel_row *row = new(kernel_row);
+    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_kernel_row);
+
+    row->RowBox = yon_gtk_builder_get_widget(builder,"TableRow");
+    row->InstallCheck = yon_gtk_builder_get_widget(builder,"InstallCheck");
+    row->EnableRadio = yon_gtk_builder_get_widget(builder,"EnableRadio");
+    row->EnableSeparator = yon_gtk_builder_get_widget(builder,"EnableSeparator");
+    row->NameLabel = yon_gtk_builder_get_widget(builder,"NameLabel");
+    row->TagsBox = yon_gtk_builder_get_widget(builder,"TagsBox");
+    row->TagsSeparator = yon_gtk_builder_get_widget(builder,"TagsSeparator");
+    row->ModulesLabel = yon_gtk_builder_get_widget(builder,"ModulesLabel");
+    row->DescriptionLabel = yon_gtk_builder_get_widget(builder,"DescriptionLabel");
+    row->name=NULL;
+    row->modules=NULL;
+    row->package=NULL;
+
+    g_signal_connect(G_OBJECT(row->InstallCheck),"toggled",G_CALLBACK(on_kernel_install_enabled),row);
+
+    row->row = gtk_list_box_row_new();
+    gtk_container_add(GTK_CONTAINER(row->row),row->RowBox);
+    gtk_widget_show(row->row);
+
+    g_object_set_data(G_OBJECT(row->InstallCheck),"kernel_row",row);
+    g_object_set_data(G_OBJECT(row->EnableRadio),"kernel_row",row);
+    g_object_set_data(G_OBJECT(row->row),"kernel_row",row);
+
+    return row;
+}
+
+int yon_tag_add(GtkBox *target,char *tag_label, char *tag_style, char *icon_name){
+    if (GTK_IS_BOX(target)&&!yon_char_is_empty(tag_label)&&!yon_char_is_empty(tag_style)){
+        GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,2);
+        GtkWidget *label = gtk_label_new(tag_label);
+        PangoAttrList *attr = pango_attr_list_new();
+        PangoAttribute *scale_attr = pango_attr_size_new_absolute(12 * PANGO_SCALE);
+        gtk_label_set_attributes(GTK_LABEL(label),attr);
+
+        g_object_set_data(G_OBJECT(box),"label",label);
+
+        pango_attr_list_insert(attr,scale_attr);
+
+        gtk_style_context_add_class(gtk_widget_get_style_context(label),tag_style);
+        GtkWidget *icon = NULL;
+        if (icon_name){
+            icon = gtk_image_new_from_icon_name(icon_name,GTK_ICON_SIZE_BUTTON);
+            gtk_box_pack_start(GTK_BOX(box),icon,0,0,0);
+        }
+        gtk_box_pack_start(GTK_BOX(box),label,1,1,0);
+        gtk_widget_show(label);
+        gtk_widget_show(box);
+        gtk_box_pack_start(target,box,0,0,0);
+        return 1;
+    }
+    return 0;
+}
+
+void yon_kernel_row_setup_tags(kernel_row *row, char *tags){
+    int size;
+    config_str parsed = yon_char_parse(tags,&size,", ");
+    for (int i=0;i<size;i++){
+        char *passw = parsed[i][0]==' '?yon_char_divide(parsed[i],0):NULL;
+        if (passw) free(passw);
+        char *tag_name = _(parsed[i]);
+        char *tag_type = NULL;
+        if (!strcmp(_(parsed[i]),LTS_TAG)){
+            tag_type = "tag_blue";
+        } else if (!strcmp(tag_name,STABLE_TAG)){
+            tag_type = "tag_green";
+        } else if (!strcmp(tag_name,REALTIME_TAG)){
+            tag_type = "tag_orange";
+        } else if (!strcmp(tag_name,HARDENED_TAG)){
+            tag_type = "tag_yellow";
+        } else if (!strcmp(tag_name,RECOMENDED_TAG)){
+            tag_type = "tag_blue";
+        } else if (!strcmp(tag_name,REACTIVE_TAG)){
+            tag_type = "tag_purple";
+        } else{
+            tag_type = "tag_green";
+        };
+        yon_tag_add(GTK_BOX(row->TagsBox),tag_name,tag_type,NULL);
+    }
+}
+
+void yon_kernel_row_setup(kernel_row *row, char *name, char *modules,char *package, char *tags, char *description){
+    row->name = yon_char_new(name);
+    row->modules = yon_char_new(modules);
+    row->package = yon_char_new(package);
+
+    char *description_full = yon_char_new(description);
+    if (strlen(description)>100){
+        guint size;
+        config_str description_wrapped = yon_char_wrap_to_lines(description,3,&size);
+        description_full = yon_char_parsed_to_string(description_wrapped,size,"\n");
+        yon_char_parsed_free(description_wrapped,size);
+    }
+    gtk_label_set_label(GTK_LABEL(row->NameLabel),name);
+    gtk_label_set_label(GTK_LABEL(row->ModulesLabel),modules);
+    gtk_label_set_label(GTK_LABEL(row->DescriptionLabel),description_full);
+
+    yon_kernel_row_setup_tags(row,tags);
+    free(description_full);
+}
+
+void yon_kernel_resize(main_window *widgets){
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->KernelListBox));
+    GList *iter = list;
+    // gtk_widget_realize(widgets->KernelListBox);
+    int install_size=0;
+    int enable_size=0;
+    int name_size=0;
+    int modules_size=0;
+        gtk_widget_get_preferred_width(widgets->KernelInstallLabel,&install_size,NULL);
+        gtk_widget_get_preferred_width(widgets->KernelEnableLabel,&enable_size,NULL);
+        gtk_widget_get_preferred_width(widgets->KernelNameLabel,&name_size,NULL);
+        gtk_widget_get_preferred_width(widgets->KernelModulesLabel,&modules_size,NULL);
+
+    for (;iter;iter=iter->next){
+        kernel_row *row = g_object_get_data(G_OBJECT(iter->data),"kernel_row");
+        int cur_name_size;
+        int cur_modules_size;
+
+        gtk_widget_get_preferred_width(row->NameLabel,&cur_name_size,NULL);
+        gtk_widget_get_preferred_width(row->ModulesLabel,&cur_modules_size,NULL);
+        if (name_size<cur_name_size) name_size=cur_name_size;
+        if (modules_size<cur_modules_size) modules_size=cur_modules_size;
+    }
+        gtk_widget_set_size_request(GTK_WIDGET(widgets->KernelNameLabel),name_size,-1);
+        gtk_widget_set_size_request(GTK_WIDGET(widgets->KernelModulesLabel),modules_size,-1);
+    for (iter = list;iter;iter = iter->next){
+        kernel_row *row = g_object_get_data(G_OBJECT(iter->data),"kernel_row");
+        gtk_widget_set_size_request(GTK_WIDGET(row->InstallCheck),install_size,-1);
+        gtk_widget_set_size_request(GTK_WIDGET(row->EnableRadio),enable_size,-1);
+        gtk_widget_set_size_request(row->NameLabel,name_size,-1);
+        gtk_widget_set_size_request(row->ModulesLabel,modules_size,-1);
+    }
+        g_list_free(list);
+}
+
+void yon_kernel_addon_resize(main_window *widgets){
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->KernelAddonListBox));
+    GList *iter = list;
+    // gtk_widget_realize(widgets->KernelListBox);
+    int install_size=0;
+    int name_size=0;
+    int modules_size=0;
+        gtk_widget_get_preferred_width(widgets->KernelAddonInstallLabel,&install_size,NULL);
+        gtk_widget_get_preferred_width(widgets->KernelAddonNameLabel,&name_size,NULL);
+        gtk_widget_get_preferred_width(widgets->KernelAddonModulesLabel,&modules_size,NULL);
+
+    for (;iter;iter=iter->next){
+        kernel_row *row = g_object_get_data(G_OBJECT(iter->data),"kernel_row");
+        int cur_name_size;
+        int cur_modules_size;
+
+        gtk_widget_get_preferred_width(row->NameLabel,&cur_name_size,NULL);
+        gtk_widget_get_preferred_width(row->ModulesLabel,&cur_modules_size,NULL);
+        if (name_size<cur_name_size) name_size=cur_name_size;
+        if (modules_size<cur_modules_size) modules_size=cur_modules_size;
+    }
+        gtk_widget_set_size_request(GTK_WIDGET(widgets->KernelAddonNameLabel),name_size,-1);
+        gtk_widget_set_size_request(GTK_WIDGET(widgets->KernelAddonModulesLabel),modules_size,-1);
+    for (iter = list;iter;iter = iter->next){
+        kernel_row *row = g_object_get_data(G_OBJECT(iter->data),"kernel_row");
+        gtk_widget_set_size_request(GTK_WIDGET(row->InstallCheck),install_size,-1);
+        gtk_widget_set_size_request(row->NameLabel,name_size,-1);
+        gtk_widget_set_size_request(row->ModulesLabel,modules_size,-1);
+    }
+        g_list_free(list);
+}
+
+void yon_kernel_setup(main_window *widgets){
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->KernelListBox));
+    GList *iter;
+    for (iter = list; iter; iter = iter->next){
+        kernel_row *row = g_object_get_data(G_OBJECT(iter->data),"kernel_row");
+        if (row){
+            if (row->name) free(row->name);
+            if (!yon_char_is_empty(row->modules)) free(row->modules);
+            free(row);
+            gtk_widget_destroy(GTK_WIDGET(iter->data));
+        }
+    }
+    g_list_free(list);
+
+    char *modules = config(modules_extra_parameter);
+    char *enabled = config(KERNEL_BOOT_parameter);
+
+    int modules_size;
+    config_str modules_parsed = NULL;
+    if (!yon_char_is_empty(modules)){
+        modules_parsed = yon_char_parse(modules,&modules_size," ");
+    }
+
+    int size;
+    config_str kernels = yon_resource_open_file(kernel_list_path,&size);
+        gtk_size_group_add_widget(widgets->KernelSizeGroup,widgets->KernelTagsLabel);
+
+    for (int i=1;i<size;i++){
+        int parsed_size;
+        config_str parsed = yon_char_parse(kernels[i],&parsed_size,";");
+        char *name = parsed[0];
+        char *modules = yon_char_unite(parsed[1]," ",parsed[3],NULL);
+        char *tags = parsed[5];
+        char *package = parsed[2];
+        
+        char *description = parsed[6];
+        kernel_row *row = yon_kernel_row_new();
+        gtk_list_box_insert(GTK_LIST_BOX(widgets->KernelListBox),row->row,-1);
+        gtk_size_group_add_widget(widgets->KernelSizeGroup,row->TagsBox);
+
+        gtk_radio_button_join_group(GTK_RADIO_BUTTON(row->EnableRadio),GTK_RADIO_BUTTON(main_config.kernel_unchosen_radio));
+
+        yon_kernel_row_setup(row,name,modules,package,tags,description);
+
+        if (yon_char_parsed_check_exist(modules_parsed,modules_size,parsed[1])>-1){
+            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(row->InstallCheck),1);
+        } else {
+            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(row->InstallCheck),0);
+        }
+        if (!yon_char_is_empty(enabled)&&!strcmp(package,enabled)){
+            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(row->EnableRadio),1);
+        }
+        yon_char_parsed_free(parsed,parsed_size);
+    }
+    yon_kernel_resize(widgets);
+
+    yon_char_parsed_free(kernels,size);
+
+    yon_char_parsed_free(modules_parsed,modules_size);
+}
+
+void yon_kernel_addon_setup(main_window *widgets){
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->KernelAddonListBox));
+    GList *iter;
+    for (iter = list; iter; iter = iter->next){
+        kernel_row *row = g_object_get_data(G_OBJECT(iter->data),"kernel_row");
+        if (row){
+            if (row->name) free(row->name);
+            if (!yon_char_is_empty(row->modules)) free(row->modules);
+            free(row);
+            gtk_widget_destroy(GTK_WIDGET(iter->data));
+        }
+    }
+    g_list_free(list);
+
+    char *modules = config(modules_extra_parameter);
+
+    int modules_size;
+    config_str modules_parsed = NULL;
+    if (!yon_char_is_empty(modules)){
+        modules_parsed = yon_char_parse(modules,&modules_size," ");
+    }
+
+    int size;
+    config_str kernels = yon_resource_open_file(kernel_list_addon_path,&size);
+
+    for (int i=1;i<size;i++){
+        int parsed_size;
+        config_str parsed = yon_char_parse(kernels[i],&parsed_size,";");
+        char *name = parsed[0];
+        char *modules = yon_char_new(parsed[1]);
+        char *tags = NULL;
+        char *package = parsed[2];
+        
+        char *description = parsed[3];
+        kernel_row *row = yon_kernel_row_new();
+        gtk_list_box_insert(GTK_LIST_BOX(widgets->KernelAddonListBox),row->row,-1);
+        gtk_size_group_add_widget(widgets->KernelSizeGroup,row->TagsBox);
+        gtk_widget_destroy(row->TagsBox);
+        gtk_widget_destroy(row->TagsSeparator);
+        gtk_widget_destroy(row->EnableRadio);
+        gtk_widget_destroy(row->EnableSeparator);
+
+        yon_kernel_row_setup(row,name,modules,package,tags,description);
+
+        if (yon_char_parsed_check_exist(modules_parsed,modules_size,parsed[1])>-1){
+            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(row->InstallCheck),1);
+        } else {
+            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(row->InstallCheck),0);
+        }
+        yon_char_parsed_free(parsed,parsed_size);
+    }
+    yon_kernel_addon_resize(widgets);
+
+    yon_char_parsed_free(kernels,size);
+
+
+}

source/ubinstall-gtk-keyboard.c

@@ -0,0 +1,335 @@
+#include "ubinstall-gtk.h"
+
+void on_layout_toggle_button_switch(GtkWidget *self, main_window *widgets){
+    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self))){
+        gtk_widget_set_sensitive(widgets->DefaultLayoutRadio,1);
+        gtk_widget_set_sensitive(widgets->ManualLayoutRadio,1);
+        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->ManualLayoutRadio))){
+            gtk_widget_set_sensitive(widgets->LayoutTree,1);
+            gtk_widget_set_sensitive(widgets->AddButton,1);
+            gtk_widget_set_sensitive(widgets->RemoveButton,1);
+        } else {
+            gtk_widget_set_sensitive(widgets->LayoutTree,0);
+            gtk_widget_set_sensitive(widgets->AddButton,0);
+            gtk_widget_set_sensitive(widgets->RemoveButton,0);
+        }
+    } else {
+        gtk_widget_set_sensitive(widgets->DefaultLayoutRadio,0);
+        gtk_widget_set_sensitive(widgets->ManualLayoutRadio,0);
+        gtk_widget_set_sensitive(widgets->LayoutTree,0);
+        gtk_widget_set_sensitive(widgets->AddButton,0);
+        gtk_widget_set_sensitive(widgets->RemoveButton,0);
+
+    }
+}
+
+int yon_keyboard_save(main_window *widgets){
+    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->ManualLayoutRadio))){
+        GtkTreeIter iter;
+        if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(widgets->LayoutList),&iter)){
+            yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),LAYOUTS_CHOSEN_BUT_EMPTY_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+            yon_ubl_status_highlight_incorrect(widgets->ManualLayoutRadio);
+            yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(widgets->LayoutTree));
+            return 0;
+        }
+    }
+    char *layouts_list="";
+    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->ManualLayoutRadio))&&gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->LayoutSensitiveCheck))){
+        GtkTreeModel *layouts_model=GTK_TREE_MODEL(widgets->LayoutList);
+        GtkTreeIter iter;
+        char *cur_layout=NULL;
+        for_iter(layouts_model,&iter){
+            int chosen=0;
+            gtk_tree_model_get(layouts_model,&iter,0,&cur_layout,3,&chosen,-1);
+            if (chosen)
+                layouts_list = yon_char_unite(layouts_list,yon_char_is_empty(layouts_list)?"":",",cur_layout,NULL);
+        }
+    }
+
+    if (yon_char_is_empty(layouts_list)&&gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->LayoutSensitiveCheck)))
+        yon_config_register(xkblayout_parameter,xkblayout_parameter_command,layouts_list);
+    else
+        yon_config_remove_by_key(xkblayout_parameter);
+
+    if (gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->KeyboardModelCombo))&&gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->KeyboardModelSensitiveCheck))){
+        char *model = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(widgets->KeyboardModelCombo));
+        if (!yon_char_is_empty(model))
+            yon_config_register(xkbmodel_parameter,xkbmodel_parameter_command,model);
+    } else{
+        yon_config_remove_by_key(xkbmodel_parameter);
+    }
+    
+    if (gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->LayoutBindingCombo))&&gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->OptionsSensitiveCheck))){
+        char *options = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(widgets->LayoutBindingCombo));
+        if (options){};
+        yon_config_register(xkboptions_parameter,xkboptions_parameter_command,options);
+    } else {
+        yon_config_remove_by_key(xkboptions_parameter);
+    }
+    return 1;
+}
+
+ubinstall_keyboard_window *yon_ubinstall_keyboard_new(){
+void on_additional_software_toggled();
+	ubinstall_keyboard_window *window = malloc(sizeof(ubinstall_keyboard_window));
+	GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_ubinstall_keyboard);
+	window->MainWindow=yon_gtk_builder_get_widget(builder,"MainWindow");
+	window->StatusBox=yon_gtk_builder_get_widget(builder,"StatusBox");
+	window->headerBar=yon_gtk_builder_get_widget(builder,"headerBar");
+	window->CancelButton=yon_gtk_builder_get_widget(builder,"CancelButton");
+	window->SaveButton=yon_gtk_builder_get_widget(builder,"SaveButton");
+	window->LayoutsTree=yon_gtk_builder_get_widget(builder,"LayoutsTree");
+    window->ActiveToggle = GTK_CELL_RENDERER(gtk_builder_get_object(builder,"ActiveToggle"));
+
+    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
+
+return window;
+}
+
+void on_keyboard_removed(GtkWidget *, main_window *widgets){
+    GtkTreeModel *model;
+    GtkTreeIter iter, childiter;
+    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->LayoutTree)),&model,&iter)){
+        gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(widgets->LayoutsFilter),&childiter,&iter);
+        gtk_tree_store_set(widgets->LayoutList,&childiter,3,0,-1);
+    }
+}
+
+void yon_language_selection_changed(GtkCellRenderer *, char *path, ubinstall_language_window *window){
+    GtkTreeIter iter;
+    int state;
+
+    if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->liststore1),&iter,path)){
+        gtk_tree_model_get(GTK_TREE_MODEL(window->liststore1),&iter,0,&state,-1);
+        gtk_list_store_set(window->liststore1,&iter,0,!state,-1);
+    }
+}
+
+void on_language_window_accept(GtkWidget *,dictionary *dict){
+    main_window *widgets= yon_dictionary_get_data(dict->first,main_window*);
+    ubinstall_language_window *window = yon_dictionary_get_data(dict->first->next,ubinstall_language_window*);
+    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->DefaultCheck))){
+        gtk_entry_set_text(GTK_ENTRY(widgets->AvailableLanguagesEntry),"");
+        GtkTreeIter iter;
+        int size;
+        config_str lang_parsed = default_langs(&size);
+
+        char *final = "";
+        for_iter(widgets->LanguagesList,&iter){
+            char *code, *labl;
+            gtk_tree_model_get(GTK_TREE_MODEL(widgets->LanguagesList),&iter,1,&labl,2,&code,-1);
+            if (yon_char_parsed_check_exist(lang_parsed,size,code)!=-1){
+                gtk_list_store_set(widgets->LanguagesList,&iter,0,1,-1);
+                char *tmp = yon_char_unite(final,!yon_char_is_empty(final)?";":"",labl,NULL);
+                if (!yon_char_is_empty(final)) free(final);
+                final = tmp;
+            } else
+                gtk_list_store_set(widgets->LanguagesList,&iter,0,0,-1);
+        }
+        if (!yon_char_is_empty(final)){
+            gtk_entry_set_text(GTK_ENTRY(widgets->AvailableLanguagesEntry),final);
+        }
+        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->LanguagesCombo),-1);
+        gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(widgets->LanguagesFilter));
+    } else {
+        yon_gtk_list_store_copy_full(widgets->LanguagesList,window->liststore1);
+        gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(widgets->LanguagesFilter));
+        config_str parsed = NULL;
+        int size;
+        GtkTreeIter iter;
+        for_iter(GTK_TREE_MODEL(window->liststore1),&iter){
+            char *current;
+            int status;
+            gtk_tree_model_get(GTK_TREE_MODEL(window->liststore1),&iter,0,&status,1,&current,-1);
+            if (status)
+                yon_char_parsed_add_or_create_if_exists(parsed,&size,current);
+        }
+        if (parsed){
+            char *final = yon_char_parsed_to_string(parsed,size,"; ");
+            gtk_entry_set_text(GTK_ENTRY(widgets->AvailableLanguagesEntry),!yon_char_is_empty(final)?final:"");
+            if (yon_char_is_empty(final)) {
+                gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->LanguagesCombo),-1);
+            }
+            if (final) free(final);
+            yon_char_parsed_free(parsed,size);
+        } else 
+            gtk_entry_set_text(GTK_ENTRY(widgets->AvailableLanguagesEntry),"");
+
+    }
+    on_subwindow_close(window->MainWindow);
+    free(window);
+}
+
+ubinstall_language_window *yon_ubinstall_language_new(){
+	ubinstall_language_window *window = malloc(sizeof(ubinstall_language_window));
+	GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_ubinstall_language);
+	window->liststore1=GTK_LIST_STORE(gtk_builder_get_object(builder,"liststore1"));
+	window->MainWindow=yon_gtk_builder_get_widget(builder,"MainWindow");
+	window->StatusBox=yon_gtk_builder_get_widget(builder,"StatusBox");
+	window->DefaultCheck=yon_gtk_builder_get_widget(builder,"DefaultCheck");
+	window->LanguagesTree=yon_gtk_builder_get_widget(builder,"LanguagesTree");
+	window->headerBar=yon_gtk_builder_get_widget(builder,"headerBar");
+	window->CancelButton=yon_gtk_builder_get_widget(builder,"CancelButton");
+	window->SaveButton=yon_gtk_builder_get_widget(builder,"SaveButton");
+	window->ToggleRenderer=GTK_CELL_RENDERER(gtk_builder_get_object(builder,"ToggleRenderer"));
+
+    g_signal_connect(G_OBJECT(window->DefaultCheck),"toggled",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button_inversed),window->LanguagesTree);
+    g_signal_connect(G_OBJECT(window->ToggleRenderer),"toggled",G_CALLBACK(yon_language_selection_changed),window);
+    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
+return window;
+}
+
+void on_language_clicked(GtkWidget *, main_window *widgets){
+    ubinstall_language_window *window = yon_ubinstall_language_new();
+    g_object_ref(G_OBJECT(window->liststore1));
+    gtk_tree_view_set_model(GTK_TREE_VIEW(window->LanguagesTree),NULL);
+    yon_gtk_list_store_copy_full(window->liststore1,widgets->LanguagesList);
+    gtk_tree_view_set_model(GTK_TREE_VIEW(window->LanguagesTree),GTK_TREE_MODEL(window->liststore1));
+    yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->MainWindow),TITLE_LABEL,icon_path,"language-chooser-window");
+
+    if (yon_char_is_empty(gtk_entry_get_text(GTK_ENTRY(widgets->AvailableLanguagesEntry)))){
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->DefaultCheck),1);
+    }
+
+    int size;
+    int found=0;
+    int statusfound=0;
+    config_str langs = default_langs(&size);
+    GtkTreeIter iter;
+    for_iter(widgets->LanguagesList,&iter){
+        char *cur;
+        int status;
+        gtk_tree_model_get(GTK_TREE_MODEL(widgets->LanguagesList),&iter,0,&status,2,&cur,-1);
+        if (status){
+            statusfound++;
+            if (yon_char_parsed_check_exist(langs,size,cur)>-1) 
+                found++;
+        }
+    }
+    if ((found==size)&&statusfound==size){
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->DefaultCheck),1);
+    }
+
+    dictionary *dict=NULL;
+    yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
+    yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
+    g_signal_connect(G_OBJECT(window->SaveButton),"clicked",G_CALLBACK(on_language_window_accept),dict);
+    gtk_widget_show(window->MainWindow);
+    
+}
+ 
+ 
+void on_layout_toggle(GtkCellRendererToggle*,  gchar* path, ubinstall_keyboard_window *window){
+    GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(window->LayoutsTree));
+    GtkTreeIter iter;
+    if (gtk_tree_model_get_iter_from_string(model,&iter,path)){
+        int status=0;
+        gtk_tree_model_get(model,&iter,3,&status,-1);
+        gtk_tree_store_set(GTK_TREE_STORE(model),&iter,3,!status,-1);
+    }
+}
+
+
+void on_keyboard_accept(GtkWidget *self,main_window *widgets){
+    gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(widgets->LayoutsFilter));
+    on_subwindow_close(self);
+}
+
+
+void on_keyboard_clicked (GtkWidget *, main_window *widgets){
+    ubinstall_keyboard_window *window = yon_ubinstall_keyboard_new();
+    yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->MainWindow),KEYBOARD_TITLE_LABEL,icon_path,"keyboard-window");
+    gtk_tree_view_set_model(GTK_TREE_VIEW(window->LayoutsTree),GTK_TREE_MODEL(widgets->LayoutList));
+
+    g_signal_connect(G_OBJECT(window->ActiveToggle),"toggled",G_CALLBACK(on_layout_toggle),window);
+    g_signal_connect(G_OBJECT(window->SaveButton),"clicked",G_CALLBACK(on_keyboard_accept),widgets);
+    gtk_widget_show(window->MainWindow);
+}
+
+void yon_layout_build(char *key, GHashTable *value, main_window *widgets){
+    GtkTreeIter parent;
+    GtkTreeIter iter;
+    gtk_tree_store_append(widgets->LayoutList,&parent,NULL);
+    gtk_tree_store_set(widgets->LayoutList,&parent,0,key,1,_((char*)g_hash_table_lookup(value,"")),2,1,3,0,-1);
+
+    GList *list = g_hash_table_get_keys(value);
+    GList *iterator = NULL;
+    for (iterator=list;iterator;iterator=iterator->next){
+        if (!yon_char_is_empty((char*)iterator->data)){
+            gtk_tree_store_append(widgets->LayoutList,&iter,&parent);
+            gtk_tree_store_set(widgets->LayoutList,&iter,0,(char*)iterator->data,1,_((char*)g_hash_table_lookup(value,iterator->data)),2,1,3,0,-1);
+        }
+    }
+}
+
+void yon_keyboard_init(main_window *widgets){
+    int size;
+    config_str parsed = NULL;
+    parsed = yon_config_load(yon_debug_output("%s\n",get_layouts_command),&size);
+    GHashTable *table = g_hash_table_new(g_str_hash,g_str_equal);
+    for (int i=0;i<size;i++){
+        yon_char_remove_last_symbol(parsed[i],'\n');
+        int layout_size;
+        config_str layout = yon_char_parse(parsed[i],&layout_size,"|");
+        if (layout_size){
+            
+            if (g_hash_table_contains(table,layout[0])){
+                GHashTable *child_table = g_hash_table_lookup(table,layout[0]);
+                g_hash_table_insert(child_table,yon_char_new(layout[1]),yon_char_new(layout[2]));
+            }else {
+                GHashTable *child_table = g_hash_table_new(g_str_hash,g_str_equal);
+                g_hash_table_insert(table,yon_char_new(layout[0]),child_table);
+                g_hash_table_insert(child_table,yon_char_new(layout[1]),yon_char_new(layout[2]));
+            }
+        }
+    }
+
+    g_hash_table_foreach(table,(GHFunc)yon_layout_build,widgets);
+    yon_char_parsed_free(parsed,size);
+    config_str models = yon_config_load(yon_debug_output("%s\n",get_models_command),&size);
+    for (int i=0;i<size;i+=2){
+        models[i] = yon_char_divide_search(models[i],"\n",-1);
+        models[i+1] = yon_char_divide_search(models[i+1],"\n",-1);
+        gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets->KeyboardModelCombo),models[i],_(models[i+1]));
+    }
+    if (size) yon_char_parsed_free(models,size);
+
+    char *keyboard = config(xkbmodel_parameter);
+    char *option_parameter = config(xkboptions_parameter);
+    char *layouts = config(xkblayout_parameter);
+
+    if (!yon_char_is_empty(keyboard)){
+        gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->KeyboardModelCombo),keyboard);
+    } else {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->KeyboardModelCombo),0);
+    }
+
+    if (!yon_char_is_empty(option_parameter)){
+        gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->LayoutBindingCombo),option_parameter);
+    } else{
+        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->LayoutBindingCombo),0);
+    }
+
+    if (!yon_char_is_empty(layouts)){
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->LayoutSensitiveCheck),1);
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->ManualLayoutRadio),1);
+        int parsed_size;
+        config_str parsed = yon_char_parse(layouts,&parsed_size,",");
+
+        GtkTreeIter iter;
+        GtkTreeModel *model = GTK_TREE_MODEL(widgets->LayoutList);
+        for_iter(model,&iter){
+            char *target;
+            gtk_tree_model_get(model,&iter,0,&target,-1);
+            if (yon_char_parsed_check_exist(parsed,parsed_size,target)>-1){
+                gtk_tree_store_set(widgets->LayoutList,&iter,2,1,3,1,-1);
+            } else {
+                gtk_tree_store_set(widgets->LayoutList,&iter,3,0,-1);
+            }
+        }
+    } else {
+
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->LayoutSensitiveCheck),0);
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->DefaultLayoutRadio),1);
+    }
+}

source/ubinstall-gtk-log.c

@@ -0,0 +1,118 @@
+#include "ubinstall-gtk.h"
+
+
+void on_log_closed(GtkWidget *, log_window *window){
+    main_window *widgets = g_object_get_data(G_OBJECT(window->Window),"widgets");
+
+    gtk_widget_set_sensitive(widgets->ReadFullLogButton,1);
+    gtk_widget_set_sensitive(widgets->ReadShortLogButton,1);
+
+    free(window->command);
+    window->Window=NULL;
+}
+
+log_window *yon_log_window_new(){
+    log_window *window = malloc(sizeof(log_window));
+    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_log_view);
+    window->Window = yon_gtk_builder_get_widget(builder,"MainWindow");
+    window->ScrollWindow = yon_gtk_builder_get_widget(builder,"ScrollWindow");
+    window->HeadLabel = yon_gtk_builder_get_widget(builder,"headerTopic");
+    window->LogLabel = yon_gtk_builder_get_widget(builder,"LogLabel");
+    window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
+    window->ScrollToEndCheck = yon_gtk_builder_get_widget(builder,"ScrollToEndCheck");
+    window->monitor = NULL;
+    gtk_widget_show(window->Window);
+    return window;
+}
+
+void yon_read_log(GFileMonitor *,GFile *,GFile *,GFileMonitorEvent ,log_window *window){
+        if (window->Window){
+            int size;
+            g_mutex_lock(&main_config.progress_mutex);
+            config_str parsed = yon_file_open(window->command,&size);
+            g_mutex_unlock(&main_config.progress_mutex);
+            if (size){
+                char *final = yon_char_parsed_to_string(parsed,size,"");
+                gtk_label_set_text(GTK_LABEL(window->LogLabel),final);
+                if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->ScrollToEndCheck))){
+                    gtk_adjustment_set_value(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(window->ScrollWindow)),gtk_adjustment_get_upper(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(window->ScrollWindow))));
+                }
+                free(final);
+                yon_char_parsed_free(parsed,size);
+            }
+            g_mutex_lock(&main_config.install_mutex);
+            if (!main_config.install_complete){
+                g_mutex_unlock(&main_config.install_mutex);
+                return;
+            } else {
+                g_mutex_unlock(&main_config.install_mutex);
+                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->ScrollToEndCheck),0);
+                gtk_widget_set_sensitive(window->ScrollToEndCheck,0);
+            }
+        }
+    return ;
+}
+
+void on_process_log_view(GtkWidget *,main_window *widgets){
+    log_window *window = yon_log_window_new();
+    g_object_set_data(G_OBJECT(window->Window),"widgets",widgets);
+    g_signal_connect(G_OBJECT(window->Window),"destroy",G_CALLBACK(on_log_closed),window);
+    gtk_widget_set_sensitive(widgets->ReadFullLogButton,0);
+    gtk_widget_set_sensitive(widgets->ReadShortLogButton,0);
+    yon_gtk_window_setup(GTK_WINDOW(window->Window),NULL,INSTALL_LOG_LABEL,icon_path,"log_viewer");
+    window->command = yon_char_new(short_log_path);
+    GFile *file = g_file_new_for_path(window->command);
+    window->monitor = g_file_monitor_file(file,G_FILE_MONITOR_NONE,NULL,NULL);
+    g_signal_connect(G_OBJECT(window->monitor),"changed",G_CALLBACK(yon_read_log),window);
+    g_object_unref(file);
+    yon_read_log(NULL,NULL,NULL,G_FILE_MONITOR_EVENT_CHANGED,window);
+}
+
+void on_summary_log_view(GtkWidget *,main_window *widgets){
+    log_window *window = yon_log_window_new();
+    g_object_set_data(G_OBJECT(window->Window),"widgets",widgets);
+    g_signal_connect(G_OBJECT(window->Window),"destroy",G_CALLBACK(on_log_closed),window);
+    gtk_widget_set_sensitive(widgets->ReadFullLogButton,0);
+    gtk_widget_set_sensitive(widgets->ReadShortLogButton,0);
+    yon_gtk_window_setup(GTK_WINDOW(window->Window),NULL,PROGRESS_LOG_LABEL,icon_path,"log_viewer");
+    window->command = yon_char_new(full_log_path);
+    GFile *file = g_file_new_for_path(window->command);
+    window->monitor = g_file_monitor_file(file,G_FILE_MONITOR_NONE,NULL,NULL);
+    g_signal_connect(G_OBJECT(window->monitor),"changed",G_CALLBACK(yon_read_log),window);
+    g_object_unref(file);
+    yon_read_log(NULL,NULL,NULL,G_FILE_MONITOR_EVENT_CHANGED,window);
+}
+
+void yon_installation_progress_update(GFileMonitor *,GFile *,GFile *,GFileMonitorEvent ,main_window *widgets) {
+    int size;
+
+    g_mutex_lock(&main_config.progress_mutex);
+    config_str text = yon_file_open(progress_path, &size);
+    g_mutex_unlock(&main_config.progress_mutex);
+
+    if (size) {
+        if (!yon_char_is_empty(text[size-1]) && text[size-1][0] == '(') {
+            char *current_copy = yon_char_new(text[size-1]);
+            char *percentage = yon_char_divide_search(current_copy, ")", -1);
+
+            if (!strstr(percentage, "#pb")) {
+                double fraction = atof(percentage+1);
+                gtk_label_set_text(GTK_LABEL(widgets->InstallationLabel), current_copy);
+                gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(widgets->InstallationProgress), fraction / 100);
+                gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(widgets->PackageInstallationProgress), 0);
+                gtk_label_set_text(GTK_LABEL(widgets->PackageInstallationLabel), "");
+            } else {
+                gtk_widget_show(gtk_widget_get_parent(widgets->PackageInstallationProgress));
+
+                config_str parsed = yon_char_parse(current_copy, &size, " ");
+                if (size >= 3) {
+                    double fraction = atof(parsed[2]) / 100;
+                    gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(widgets->PackageInstallationProgress), fraction);
+                    gtk_label_set_text(GTK_LABEL(widgets->PackageInstallationLabel), yon_char_parsed_to_string(parsed, size, " "));
+                }
+            }
+
+        }
+        yon_char_parsed_free(text, size);
+    }
+}

source/ubinstall-gtk-network.c

@@ -0,0 +1,331 @@
+#include "ubinstall-gtk.h"
+
+void on_autohostname_check(GtkWidget *, main_window *widgets){
+    gtk_switch_set_active(GTK_SWITCH(widgets->HostnameSensitiveSwitch),1);
+    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->AutoHostnameCheck))){
+        gtk_widget_set_sensitive(widgets->HotnameEntry,0);
+        gtk_entry_set_placeholder_text(GTK_ENTRY(widgets->HotnameEntry),"auto");
+    }else{
+        gtk_widget_set_sensitive(widgets->HotnameEntry,1);
+        gtk_entry_set_placeholder_text(GTK_ENTRY(widgets->HotnameEntry),"ublinux-install");
+    }
+}
+
+void on_autohostname_sensitiveness_check(GtkWidget *, int status, main_window *widgets){
+    if (status){
+        gtk_widget_set_sensitive(widgets->AutoHostnameCheck,1);
+        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->AutoHostnameCheck))){
+            gtk_widget_set_sensitive(widgets->HotnameEntry,0);
+        } else 
+            gtk_widget_set_sensitive(widgets->HotnameEntry,1);
+    } else {
+            gtk_widget_set_sensitive(widgets->HotnameEntry,0);
+            gtk_widget_set_sensitive(widgets->AutoHostnameCheck,0);
+    }
+}
+
+void on_hostname_entry_changed (GtkWidget *, main_window *widgets){
+    gtk_switch_set_active(GTK_SWITCH(widgets->HostnameSensitiveSwitch),1);
+    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->AutoHostnameCheck),0);
+} 
+
+void on_type_changed(GtkComboBox *self,network_info *info){
+    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(info->ConnectionCombo));
+    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(info->ConnectionCombo),DEFAULT_LABEL);
+    const char *id = gtk_combo_box_get_active_id(self);
+    GHashTable *table = g_hash_table_lookup(main_config.network_types,id);
+    if (table){
+        GList *list = g_hash_table_get_keys(table);
+        GList *iter;
+        for (iter=list;iter;iter=iter->next){
+            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(info->ConnectionCombo),iter->data,iter->data);
+        }
+        g_list_free(list);
+    }
+}
+
+network_info *yon_network_info_new(){
+    network_info *info = new(network_info);
+    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_network_info);
+    info->MainBox = yon_gtk_builder_get_widget(builder,"MainBox");
+    info->TypeCombo = yon_gtk_builder_get_widget(builder,"TypeCombo");
+    info->ConnectionCombo = yon_gtk_builder_get_widget(builder,"ConnectionCombo");
+    info->ConnectionEntry = yon_gtk_builder_get_widget(builder,"ConnectionEntry");
+    info->EnabledSwitch = yon_gtk_builder_get_widget(builder,"EnabledSwitch");
+    info->RemoveButton = yon_gtk_builder_get_widget(builder,"RemoveButton");
+    info->AutoGetIPSwitch = yon_gtk_builder_get_widget(builder,"AutoGetIPSwitch");
+    info->IpRevealer = yon_gtk_builder_get_widget(builder,"IpRevealer");
+    info->IpAdressEntry = yon_gtk_builder_get_widget(builder,"IpAdressEntry");
+    info->GatewayEntry = yon_gtk_builder_get_widget(builder,"GatewayEntry");
+    info->MaskEntry = yon_gtk_builder_get_widget(builder,"MaskEntry");
+    info->DNSEntry = yon_gtk_builder_get_widget(builder,"DNSEntry");
+
+    g_object_set_data(G_OBJECT(info->RemoveButton),"network_info",info);
+    g_object_set_data(G_OBJECT(info->MainBox),"network_info",info);
+
+    yon_on_entry_set_allowed_symbols(GTK_ENTRY(info->IpAdressEntry),"01234567890.");
+    yon_on_entry_set_allowed_symbols(GTK_ENTRY(info->MaskEntry),"01234567890.");
+    yon_on_entry_set_allowed_symbols(GTK_ENTRY(info->GatewayEntry),"01234567890.");
+    yon_on_entry_set_allowed_symbols(GTK_ENTRY(info->DNSEntry),"01234567890.");
+
+    yon_entry_set_pattern(GTK_ENTRY(info->IpAdressEntry),"^(\\d{0,3})(\\.(\\d{0,3}))?(\\.(\\d{0,3}))?(\\.(\\d{0,3}))?$");
+    yon_entry_set_pattern(GTK_ENTRY(info->MaskEntry),"^(\\d{0,3})(\\.(\\d{0,3}))?(\\.(\\d{0,3}))?(\\.(\\d{0,3}))?$");
+    yon_entry_set_pattern(GTK_ENTRY(info->GatewayEntry),"^(\\d{0,3})(\\.(\\d{0,3}))?(\\.(\\d{0,3}))?(\\.(\\d{0,3}))?$");
+    yon_entry_set_pattern(GTK_ENTRY(info->DNSEntry),"^(\\d{0,3})(\\.(\\d{0,3}))?(\\.(\\d{0,3}))?(\\.(\\d{0,3}))?$");
+    
+    g_signal_connect(G_OBJECT(info->AutoGetIPSwitch),"state-set",G_CALLBACK(yon_gtk_widget_set_sensitive_from_switch_inversed),info->IpAdressEntry);
+    g_signal_connect(G_OBJECT(info->AutoGetIPSwitch),"state-set",G_CALLBACK(yon_gtk_widget_set_sensitive_from_switch_inversed),info->GatewayEntry);
+    g_signal_connect(G_OBJECT(info->AutoGetIPSwitch),"state-set",G_CALLBACK(yon_gtk_widget_set_sensitive_from_switch_inversed),info->MaskEntry);
+    g_signal_connect(G_OBJECT(info->AutoGetIPSwitch),"state-set",G_CALLBACK(yon_gtk_widget_set_sensitive_from_switch_inversed),info->DNSEntry);
+    g_signal_connect(G_OBJECT(info->TypeCombo),"changed",G_CALLBACK(on_type_changed),info);
+    
+    yon_gtk_revealer_set_from_switch_inversed(GTK_REVEALER(info->IpRevealer),GTK_SWITCH(info->AutoGetIPSwitch));
+
+    GList *list = g_hash_table_get_keys(main_config.network_types);
+    GList *iter;
+    for (iter=list;iter;iter=iter->next){
+        gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(info->TypeCombo),iter->data,iter->data);
+    }
+    g_list_free(list);
+
+    gtk_widget_show(info->MainBox);
+    return info;
+}
+
+void on_ntp_sync(GtkWidget *, main_window *widgets){
+    int mode = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->NetworkNTPCombo));
+            gtk_widget_set_sensitive(widgets->NetworkNTPEntry,0);
+    switch(mode){
+        case 0:
+                gtk_entry_set_text(GTK_ENTRY(widgets->NetworkNTPEntry),"");
+                gtk_entry_set_placeholder_text(GTK_ENTRY(widgets->NetworkNTPEntry),"");
+            break;
+        case 2:{
+                int size;
+                config_str parsed = yon_config_load(get_ntp_default_command,&size);
+                if (size&&!yon_char_is_empty(parsed[0])&&strcmp(parsed[0],"(null)\n")){
+                    free(yon_char_divide_search(parsed[0],"=",-1));
+                    yon_char_remove_last_symbol(parsed[0],'\n');
+                    yon_char_remove_brackets(parsed[0]);
+                    gtk_entry_set_placeholder_text(GTK_ENTRY(widgets->NetworkNTPEntry),parsed[0]);
+                    yon_char_parsed_free(parsed,size);
+                    gtk_entry_set_text(GTK_ENTRY(widgets->NetworkNTPEntry),"");
+                }
+            }
+            break;
+        case 3:{
+                int size;
+                config_str parsed = yon_config_load(get_ntp_ru_command,&size);
+                if (size&&!yon_char_is_empty(parsed[0])&&strcmp(parsed[0],"(null)\n")){
+                    free(yon_char_divide_search(parsed[0],"=",-1));
+                    yon_char_remove_last_symbol(parsed[0],'\n');
+                    yon_char_remove_brackets(parsed[0]);
+                    gtk_entry_set_placeholder_text(GTK_ENTRY(widgets->NetworkNTPEntry),parsed[0]);
+                    yon_char_parsed_free(parsed,size);
+                    gtk_entry_set_text(GTK_ENTRY(widgets->NetworkNTPEntry),"");
+                }
+            }
+            break;
+        case 1:
+                gtk_entry_set_placeholder_text(GTK_ENTRY(widgets->NetworkNTPEntry),"DHCP");
+                gtk_entry_set_text(GTK_ENTRY(widgets->NetworkNTPEntry),"");
+            break;
+        case 5:
+                gtk_entry_set_placeholder_text(GTK_ENTRY(widgets->NetworkNTPEntry),"");
+                gtk_entry_set_text(GTK_ENTRY(widgets->NetworkNTPEntry),"");
+            break;
+        case 4:
+            gtk_widget_set_sensitive(widgets->NetworkNTPEntry,1);
+                gtk_entry_set_placeholder_text(GTK_ENTRY(widgets->NetworkNTPEntry),"");
+                gtk_entry_set_text(GTK_ENTRY(widgets->NetworkNTPEntry),"");
+            break;
+    }
+}
+
+void on_connection_add(GtkWidget *,main_window *widgets){
+    network_info *info = yon_network_info_new();
+    gtk_box_pack_start(GTK_BOX(widgets->NetworkConnectionsBox),info->MainBox,0,0,0);
+    gtk_widget_show(info->MainBox);
+}
+
+int yon_network_save(main_window *widgets){
+    if (gtk_switch_get_active(GTK_SWITCH(widgets->NetworkDomainSwitch))){
+        const char *domain_name = gtk_entry_get_text(GTK_ENTRY(widgets->NetworkDomainNameEntry));
+        if (yon_char_is_empty(domain_name)){
+            yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+            yon_ubl_status_highlight_incorrect(widgets->NetworkDomainNameEntry);
+            return 0;
+        }
+        const char *domain_admin = gtk_entry_get_text(GTK_ENTRY(widgets->NetworkDomainAdminEntry));
+        const char *domain_password = gtk_entry_get_text(GTK_ENTRY(widgets->NetworkDomainPasswordEntry));
+        if (!yon_char_is_empty(domain_name)) yon_config_register(DOMAIN_parameter,DOMAIN_parameter_command,(char*)domain_name);
+        else yon_config_remove_by_key(DOMAIN_parameter);
+        if ((!yon_char_is_empty(domain_admin)&&yon_char_is_empty(domain_password))||(yon_char_is_empty(domain_admin)&&!yon_char_is_empty(domain_password))){
+            yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+            yon_ubl_status_highlight_incorrect(widgets->NetworkDomainAdminEntry);
+            yon_ubl_status_highlight_incorrect(widgets->NetworkDomainPasswordEntry);
+            return 0;
+        }
+        if (!yon_char_is_empty(domain_admin)&&!yon_char_is_empty(domain_password)){
+            int size;
+            config_str encrypted_password = yon_config_load(encrypt_domain_password_command(domain_password),&size);
+            if (!size){
+                yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),ENCRYPT_ERROR_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+                yon_ubl_status_highlight_incorrect(widgets->NetworkDomainPasswordEntry);
+                return 0;
+            }
+            char *admin_string_full = yon_char_unite(domain_admin,":",encrypted_password[0],NULL);
+            yon_config_register(DOMAIN_admanger_parameter,DOMAIN_parameter_command,admin_string_full);
+        } else {
+            yon_config_remove_by_key(DOMAIN_admanger_parameter);
+        }
+    }
+    if (gtk_switch_get_active(GTK_SWITCH(widgets->NetworkNTPServerSwitch))){
+        
+        int mode = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->NetworkNTPCombo));
+        switch(mode){
+            case 0:yon_config_remove_by_key(NTPSERVERS_parameter);
+                break;
+            case 1:yon_config_register(NTPSERVERS_parameter,NTPSERVERS_parameter_command,"dhcp");
+                break;
+            case 2:yon_config_register(NTPSERVERS_parameter,NTPSERVERS_parameter_command,"default");
+                break;
+            case 3:yon_config_register(NTPSERVERS_parameter,NTPSERVERS_parameter_command,"ntp-ru");
+                break;
+            case 5:yon_config_register(NTPSERVERS_parameter,NTPSERVERS_parameter_command,"disable");
+                break;
+            case 6:yon_config_register(NTPSERVERS_parameter,NTPSERVERS_parameter_command,"stop");
+                break;
+            case 4:
+                char *value = (char*)gtk_entry_get_text(GTK_ENTRY(widgets->NetworkNTPEntry));
+                if (yon_char_is_empty(value)) {
+                    yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+                    yon_ubl_status_highlight_incorrect(widgets->NetworkNTPEntry);
+                    return 0;
+                }
+                yon_config_register(NTPSERVERS_parameter,NTPSERVERS_parameter_command,value);
+                break;
+        }
+    } else {
+        yon_config_remove_by_key(NTPSERVERS_parameter);
+    }
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->NetworkConnectionsBox));
+    GList *iter;
+    for (iter=list;iter;iter=iter->next){
+        network_info *info = g_object_get_data(G_OBJECT(iter->data),"network_info");
+        // char *type = gtk_combo_box_get_active_id(GTK_COMBO_BOX(info->TypeCombo));
+        char *connection = (char*)gtk_entry_get_text(GTK_ENTRY(info->ConnectionEntry));
+        int active = gtk_switch_get_active(GTK_SWITCH(info->EnabledSwitch));
+        int parameters_size=0;
+        config_str parameters = NULL;
+        if (!gtk_switch_get_active(GTK_SWITCH(info->AutoGetIPSwitch))){
+            char *ip = (char*)gtk_entry_get_text(GTK_ENTRY(info->IpAdressEntry));
+            char *mask = (char*)gtk_entry_get_text(GTK_ENTRY(info->MaskEntry));
+            char *gateway = (char*)gtk_entry_get_text(GTK_ENTRY(info->GatewayEntry));
+            char *dns = (char*)gtk_entry_get_text(GTK_ENTRY(info->DNSEntry));
+
+            yon_char_parsed_add_or_create_if_exists(parameters,&parameters_size,"ipv4.method manual");
+            if (!yon_ip_check(ip)){
+                yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),WRONG_IP_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+                yon_ubl_status_highlight_incorrect(info->IpAdressEntry);
+                return 0;
+            }
+            if (!yon_ip_check(mask)){
+                yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),WRONG_IP_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+                yon_ubl_status_highlight_incorrect(info->MaskEntry);
+                return 0;
+            } else {
+                int bitmask = yon_ip_mask_get_bits(mask);
+                mask = yon_char_from_int(bitmask);
+                char *ip_param = yon_char_unite("ipv4.addr", ip,"/",mask,NULL);
+                yon_char_parsed_add_or_create_if_exists(parameters,&parameters_size,ip_param);
+                free(ip_param);
+
+            }
+            if (yon_ip_check(gateway)){
+                char *ip_param = yon_char_append("ipv4.gateway", gateway);
+                yon_char_parsed_add_or_create_if_exists(parameters,&parameters_size,ip_param);
+                free(ip_param);
+            }
+            if (yon_ip_check(dns)){
+                char *ip_param = yon_char_append("ipv4.dns", dns);
+                yon_char_parsed_add_or_create_if_exists(parameters,&parameters_size,ip_param);
+                free(ip_param);
+            }
+            if (!active){
+                yon_char_parsed_add_or_create_if_exists(parameters,&parameters_size,"");
+            }
+
+            char *value = yon_char_parsed_to_string(parameters,parameters_size,"yes");
+            yon_config_register(NETWORK_devdown_parameter(connection),NETWORK_devdown_parameter_command(connection),value);
+        } else {
+            yon_config_register(NETWORK_parameter(connection),NETWORK_parameter_command(connection),network_value_auto);
+
+        }
+    }
+    return 1;
+}
+
+void yon_network_init(main_window *widgets){
+    int size;
+    config_str network_types = yon_resource_open_file(network_path,&size);
+    for (int i=1;i<size;i++){
+        yon_char_remove_last_symbol(network_types[i],'\n');
+        int parsed_size;
+        config_str parsed = yon_char_parse(network_types[i],&parsed_size,";");
+        if (!g_hash_table_contains(main_config.network_types,parsed[0])){
+            GHashTable *table = g_hash_table_new(g_str_hash,g_str_equal);
+            g_hash_table_insert(main_config.network_types,yon_char_new(parsed[0]),table);
+
+        }
+        g_hash_table_add(g_hash_table_lookup(main_config.network_types,parsed[0]),yon_char_new(parsed[1]));
+        yon_char_parsed_free(parsed,parsed_size);
+    }
+    yon_char_parsed_free(network_types,size);
+
+    config_str parameters = yon_config_get_all_by_key(NETWORK_parameter_search,&size);
+    for (int i=0;i<size;i++){
+        char *parameter = yon_char_new(parameters[i]);
+        char *parameter_name = yon_char_divide_search(parameter,"=",-1);
+        char *key = yon_config_parameter_get_key(parameter_name);
+        char *key_type = yon_char_divide_search(key,"@",-1);
+
+        if (!strcmp(key_type,"connmod")){
+            network_info *info = yon_network_info_new();
+            gtk_box_pack_start(GTK_BOX(widgets->NetworkConnectionsBox),info->MainBox,0,0,0);
+            gtk_widget_show(info->MainBox);
+
+            int connection_size;
+            config_str connection = yon_char_parse(parameter,&connection_size," ");
+            for (int k=0;k<connection_size;k++){
+                if (!strcmp(connection[k],"ipv4.method")){
+                    gtk_switch_set_active(GTK_SWITCH(info->AutoGetIPSwitch),0);
+                } else if (!strcmp(connection[k],"ipv4.addr")){
+                    char *mask = yon_char_new(connection[++k]);
+                    char *ip = yon_char_divide_search(mask,"/",-1);
+                    gtk_entry_set_text(GTK_ENTRY(info->MaskEntry),mask);
+                    gtk_entry_set_text(GTK_ENTRY(info->IpAdressEntry),ip);
+                    free(mask);
+                    free(ip);
+
+                } else if (!strcmp(connection[k],"ipv4.gateway")){
+                    gtk_entry_set_text(GTK_ENTRY(info->GatewayEntry),connection[++k]);
+
+                } else if (!strcmp(connection[k],"ipv4.dns")){
+                    gtk_entry_set_text(GTK_ENTRY(info->DNSEntry),connection[++k]);
+
+                }
+            }
+
+            GList *list = g_hash_table_get_keys(main_config.network_types);
+            GList *iter;
+            for (iter=list;iter;iter=iter->next){
+                if (g_hash_table_contains(g_hash_table_lookup(main_config.network_types,(char*)iter->data),key)){
+                    gtk_combo_box_set_active_id(GTK_COMBO_BOX(info->TypeCombo),(char*)iter->data);
+                    gtk_combo_box_set_active_id(GTK_COMBO_BOX(info->ConnectionCombo),key);
+                    break;
+                }
+            }
+        }
+    }
+}

source/ubinstall-gtk-page-switch.c

@@ -0,0 +1,384 @@
+#include "ubinstall-gtk.h"
+
+enum YON_PAGES yon_page_get_next(main_window *widgets, enum YON_PAGES page){
+    if (!yon_page_save(widgets,page)){
+        return -1;
+    }
+    switch (page){
+        case YON_PAGE_WELCOME: return YON_PAGE_LICENCE; break;
+        case YON_PAGE_LICENCE: return YON_PAGE_SECTIONS; break;
+        case YON_PAGE_SECTIONS: return yon_sections_get_next_page(widgets); break;
+        case YON_PAGE_OS_COMPONENTS: return main_config.configure_mode? YON_PAGE_KERNEL : YON_PAGE_INSTALLATION_BEGIN; break;
+        case YON_PAGE_INSTALLATION_BEGIN: return YON_PAGE_KERNEL; break;
+        case YON_PAGE_KERNEL: return YON_PAGE_KERNEL_ADDON; break;
+        case YON_PAGE_KERNEL_ADDON: return YON_PAGE_PACMAN_SOFTWARE; break;
+        case YON_PAGE_PACMAN_SOFTWARE: return YON_PAGE_REGION;
+        case YON_PAGE_SOFTWARE: return YON_PAGE_PACMAN_SOFTWARE; break;
+        case YON_PAGE_REGION: return YON_PAGE_KEYBOARD; break;
+        case YON_PAGE_KEYBOARD: return YON_PAGE_USERS; break;
+        case YON_PAGE_USERS: return YON_PAGE_STARTUP; break;
+        case YON_PAGE_STARTUP: return YON_PAGE_BOOTLOADER; break;
+        case YON_PAGE_BOOTLOADER: return YON_PAGE_NETWORK; break;
+        case YON_PAGE_NETWORK: return main_config.configure_mode? YON_PAGE_CONFIGURE_END : YON_PAGE_INSTALLATION; break;
+        case YON_PAGE_INSTALL_COMMON: return main_config.configure_mode?YON_PAGE_KERNEL:YON_PAGE_OS_COMPONENTS; break;
+        case YON_PAGE_INSTALL_SEPARATE: return main_config.configure_mode?YON_PAGE_KERNEL:YON_PAGE_OS_COMPONENTS; break;
+        case YON_PAGE_INSTALL_SAME_PARTITION: return main_config.configure_mode?YON_PAGE_KERNEL:YON_PAGE_OS_COMPONENTS; break;
+        case YON_PAGE_INSTALL_ADVANCED: return main_config.configure_mode?YON_PAGE_KERNEL:YON_PAGE_OS_COMPONENTS; break;
+        case YON_PAGE_INSTALL_RECOVERY: return yon_recovery_get_next(widgets); break;
+        case YON_PAGE_RECOVERY_GRUB_INSTALL: return main_config.configure_mode?YON_PAGE_INSTALLATION:YON_PAGE_INSTALLATION_BEGIN; break;
+        case YON_PAGE_RECOVERY_GRUB_UPDATE: return main_config.configure_mode?YON_PAGE_INSTALLATION:YON_PAGE_INSTALLATION_BEGIN; break;
+        case YON_PAGE_RECOVERY_OS_ONLY: return main_config.configure_mode?YON_PAGE_INSTALLATION:YON_PAGE_INSTALLATION_BEGIN; break;
+        case YON_PAGE_RECOVERY_USRDATA_ONLY: return main_config.configure_mode?YON_PAGE_INSTALLATION:YON_PAGE_INSTALLATION_BEGIN; break;
+        default:return YON_PAGE_WELCOME;
+    }   
+    return YON_PAGE_WELCOME;
+}
+
+enum YON_PAGES yon_page_get_prev(enum YON_PAGES page){
+    switch (page){
+        case YON_PAGE_WELCOME: return YON_PAGE_WELCOME; break;
+        case YON_PAGE_LICENCE: return YON_PAGE_WELCOME; break;
+        case YON_PAGE_SECTIONS: return YON_PAGE_LICENCE; break;
+        case YON_PAGE_OS_COMPONENTS: return YON_PAGE_SECTIONS; break;
+        case YON_PAGE_INSTALLATION_BEGIN: return YON_PAGE_SECTIONS; break;
+        case YON_PAGE_KERNEL: return YON_PAGE_SECTIONS; break;
+        case YON_PAGE_KERNEL_ADDON: return YON_PAGE_KERNEL; break;
+        case YON_PAGE_PACMAN_SOFTWARE: return YON_PAGE_KERNEL_ADDON; break;
+        case YON_PAGE_SOFTWARE: return YON_PAGE_PACMAN_SOFTWARE; break;
+        case YON_PAGE_REGION: return YON_PAGE_SOFTWARE; break;
+        case YON_PAGE_KEYBOARD: return YON_PAGE_REGION; break;
+        case YON_PAGE_USERS: return YON_PAGE_KEYBOARD; break;
+        case YON_PAGE_STARTUP: return YON_PAGE_USERS; break;
+        case YON_PAGE_BOOTLOADER: return YON_PAGE_STARTUP; break;
+        case YON_PAGE_NETWORK: return YON_PAGE_BOOTLOADER; break;
+        case YON_PAGE_INSTALLATION: return YON_PAGE_INSTALLATION; break;
+        case YON_PAGE_CONFIGURE_END: return YON_PAGE_CONFIGURE_END; break;
+        case YON_PAGE_INSTALL_COMMON: return YON_PAGE_SECTIONS; break;
+        case YON_PAGE_INSTALL_SEPARATE: return YON_PAGE_SECTIONS; break;
+        case YON_PAGE_INSTALL_SAME_PARTITION: return YON_PAGE_SECTIONS; break;
+        case YON_PAGE_INSTALL_ADVANCED: return YON_PAGE_SECTIONS; break;
+        case YON_PAGE_INSTALL_RECOVERY: return YON_PAGE_SECTIONS; break;
+        case YON_PAGE_RECOVERY_GRUB_INSTALL: return YON_PAGE_INSTALL_RECOVERY; break;
+        case YON_PAGE_RECOVERY_GRUB_UPDATE: return YON_PAGE_INSTALL_RECOVERY; break;
+        case YON_PAGE_RECOVERY_OS_ONLY: return YON_PAGE_INSTALL_RECOVERY; break;
+        case YON_PAGE_RECOVERY_USRDATA_ONLY: return YON_PAGE_INSTALL_RECOVERY; break;
+        default:return YON_PAGE_WELCOME;
+    }
+    return YON_PAGE_WELCOME;
+}
+
+enum YON_PAGES yon_page_get_current(GtkNotebook *target){
+    enum YON_PAGES page = gtk_notebook_get_current_page(target);
+    return page;
+}
+
+void yon_navigation_buttons_set_sensetiveness(main_window *widgets){
+    enum YON_PAGES page = yon_page_get_current(GTK_NOTEBOOK(widgets->Notebook));
+
+    switch(page){
+        case YON_PAGE_WELCOME:
+            gtk_widget_hide(widgets->BackButton);
+            gtk_widget_set_sensitive(widgets->NextButton,1);
+        break;
+        case YON_PAGE_LICENCE:
+            gtk_widget_show(widgets->BackButton);
+            gtk_widget_set_sensitive(widgets->BackButton,1);
+            gtk_widget_set_sensitive(widgets->NextButton,1);
+            gtk_widget_set_sensitive(widgets->CancelInstallButton,1);
+        break;
+        case YON_PAGE_INSTALLATION:
+            gtk_widget_set_sensitive(widgets->NextButton,0);
+            gtk_widget_set_sensitive(widgets->BackButton,0);
+        break;
+        case YON_PAGE_KERNEL:
+            gtk_widget_set_sensitive(widgets->BackButton,0);
+        break;
+        case YON_PAGE_COMPLETED:
+        case YON_PAGE_INSTALL_ERROR:
+        case YON_PAGE_CONFIGURE_SAVE:
+        case YON_PAGE_CONFIGURE_END:
+        case YON_PAGE_COMPLETION:
+            gtk_button_set_label(GTK_BUTTON(widgets->NextButton),RESTART_LABEL);
+            gtk_widget_set_sensitive(widgets->BackButton,0);
+        break;
+        default:
+            gtk_widget_set_sensitive(widgets->BackButton,1);
+            gtk_widget_set_sensitive(widgets->NextButton,1);
+            gtk_widget_set_sensitive(widgets->CancelInstallButton,1);
+        break;
+    }
+}
+
+int yon_page_save(main_window *widgets, enum YON_PAGES page){
+    switch (page){
+        case YON_PAGE_OS_COMPONENTS: 
+            return yon_os_components_save(widgets);
+        break;
+        case YON_PAGE_KERNEL: 
+            return yon_kernel_save(widgets);
+        break;
+        case YON_PAGE_KERNEL_ADDON: 
+            return yon_kernel_addon_save(widgets);
+        break;
+        case YON_PAGE_SOFTWARE: 
+            return yon_software_save(widgets);
+        break;
+        case YON_PAGE_PACMAN_SOFTWARE: 
+            return yon_pacman_software_save(widgets);
+        break;
+        case YON_PAGE_REGION: 
+            return yon_region_save(widgets);
+        break;
+        case YON_PAGE_KEYBOARD: 
+            return yon_keyboard_save(widgets);
+        break;
+        case YON_PAGE_USERS: 
+            return yon_users_save(widgets);
+        break;
+        case YON_PAGE_STARTUP: 
+            return yon_startup_save(widgets);
+        break;
+        case YON_PAGE_BOOTLOADER: 
+            return yon_bootloader_save(widgets);
+        break;
+        case YON_PAGE_NETWORK: 
+            return yon_network_save(widgets);
+        break;
+        case YON_PAGE_INSTALL_COMMON: 
+            return yon_install_common_save(widgets);
+        break;
+        case YON_PAGE_INSTALL_SEPARATE: 
+            return yon_install_separate_save(widgets);
+        break;
+        case YON_PAGE_INSTALL_SAME_PARTITION: 
+            return yon_install_same_partition_save(widgets);
+        break;
+        case YON_PAGE_INSTALL_ADVANCED: 
+            return yon_install_advanced_save(widgets);
+        break;
+        case YON_PAGE_RECOVERY_GRUB_INSTALL: 
+            return yon_grub_install_save(widgets);
+        break;
+        case YON_PAGE_RECOVERY_GRUB_UPDATE: 
+            return yon_grub_update_save(widgets);
+        break;
+        case YON_PAGE_RECOVERY_OS_ONLY: 
+            return yon_install_options_save(widgets->OSDevicesTree,widgets->OSSysSectionTree,"system_only",widgets);
+        break;
+        case YON_PAGE_RECOVERY_USRDATA_ONLY: 
+            return yon_install_options_save(widgets->UserdataDevicesTree,widgets->UserdataSysSectionTree,"data_only",widgets);
+        break;
+        case YON_PAGE_INSTALLATION_BEGIN:
+            return yon_installation_start(widgets);
+        break;
+        default:return 1;
+    }
+    return 1;
+}
+
+void yon_switch_page_render(main_window *widgets){
+    enum YON_PAGES page = yon_page_get_current(GTK_NOTEBOOK(widgets->Notebook));
+    switch(page){
+        case YON_PAGE_WELCOME:
+            page = 0;
+            break;
+        case YON_PAGE_LICENCE:
+            page = 1;
+            break;
+        case YON_PAGE_SECTIONS:
+        case YON_PAGE_OS_COMPONENTS:
+        case YON_PAGE_INSTALL_COMMON:
+        case YON_PAGE_INSTALL_SAME_PARTITION:
+        case YON_PAGE_INSTALL_SEPARATE:
+        case YON_PAGE_INSTALL_ADVANCED:
+        case YON_PAGE_INSTALL_RECOVERY:
+        case YON_PAGE_INSTALLATION_BEGIN:
+        case YON_PAGE_KERNEL:
+        case YON_PAGE_KERNEL_ADDON:
+        case YON_PAGE_SOFTWARE:
+        case YON_PAGE_PACMAN_SOFTWARE:
+        case YON_PAGE_RECOVERY_GRUB_INSTALL:
+        case YON_PAGE_RECOVERY_GRUB_UPDATE:
+        case YON_PAGE_RECOVERY_OS_ONLY:
+        case YON_PAGE_RECOVERY_USRDATA_ONLY:
+            page = 2;
+            break;
+        case YON_PAGE_REGION:
+            page = 3;
+            break;
+        case YON_PAGE_KEYBOARD:
+            page = 4;
+            break;
+        case YON_PAGE_USERS:
+            page = 5;
+            break;
+        case YON_PAGE_BOOTLOADER:
+        case YON_PAGE_STARTUP:
+        case YON_PAGE_NETWORK:
+            page = 6;
+            break;
+        case YON_PAGE_INSTALLATION:
+            page = 7;
+            break;
+        case YON_PAGE_COMPLETED:
+        case YON_PAGE_COMPLETION:
+        case YON_PAGE_INSTALL_ERROR:
+        case YON_PAGE_CONFIGURE_END:
+        case YON_PAGE_CONFIGURE_SAVE:
+            page=8;
+            break;
+    }
+
+    if (widgets){};
+    GtkContainer *parent = GTK_CONTAINER(gtk_widget_get_parent(widgets->UsersToggle));
+    GList *list = gtk_container_get_children(parent);
+    for (guint i=0;i<g_list_length(list);i++){
+        if (i!=(guint)page){
+                    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_list_nth_data(list,i)),0);
+                } else { 
+                    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_list_nth_data(list,i)),1);
+
+        }
+    }
+    g_list_free(list);
+}
+
+
+void yon_configuration_mode_check(main_window *widgets){
+    enum YON_PAGES page = gtk_notebook_get_current_page(GTK_NOTEBOOK(widgets->Notebook)); 
+    if (page==YON_PAGE_WELCOME){
+        gtk_widget_set_sensitive(widgets->ConfigurationModeMenuItem,1);
+    } else {
+        gtk_widget_set_sensitive(widgets->ConfigurationModeMenuItem,0);
+    }
+    if (page == YON_PAGE_CONFIGURE_END){
+        gtk_widget_show(widgets->SaveButton);
+    } else {
+        gtk_widget_hide(widgets->SaveButton);
+    }
+}
+
+void yon_page_update(main_window *widgets){
+    yon_navigation_buttons_set_sensetiveness(widgets);
+    yon_switch_page_render(widgets);
+    yon_configuration_mode_check(widgets);
+}
+
+enum YON_PAGES yon_sections_get_next_page(main_window *widgets){
+    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->InstallationRadio)))
+        return YON_PAGE_INSTALL_COMMON;
+    else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->InstallationNearRadio)))
+        return YON_PAGE_INSTALL_SEPARATE;
+    else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->InstallationLinuxRadio)))
+        return YON_PAGE_INSTALL_SAME_PARTITION;
+    else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->InstallationWindowsRadio)))
+        return YON_PAGE_INSTALL_ADVANCED;
+    else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->InstallationOptionsRadio)))
+        return YON_PAGE_INSTALL_RECOVERY;
+    return YON_PAGE_SECTIONS;
+}
+
+enum YON_PAGES yon_recovery_get_next(main_window *widgets){
+    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->GrubInstallRadio)))
+        return YON_PAGE_RECOVERY_GRUB_INSTALL;
+    else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->GrubUpdateRadio)))
+        return YON_PAGE_RECOVERY_GRUB_UPDATE;
+    else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->OSRadio)))
+        return YON_PAGE_RECOVERY_OS_ONLY;
+    else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->UserDataOnlyRadio)))
+        return YON_PAGE_RECOVERY_USRDATA_ONLY;
+    return YON_PAGE_SECTIONS;
+}
+
+void yon_page_init(main_window *widgets, enum YON_PAGES page){
+    switch(page){
+        case YON_PAGE_OS_COMPONENTS: 
+            yon_os_components_init(widgets);
+            break;
+        case YON_PAGE_KERNEL: 
+            yon_kernel_setup(widgets);
+            break;
+        case YON_PAGE_KERNEL_ADDON: 
+            yon_kernel_addon_setup(widgets);
+            break;
+        case YON_PAGE_SOFTWARE: 
+            yon_software_init(widgets);
+            break;
+        case YON_PAGE_PACMAN_SOFTWARE: 
+            yon_pacman_init(widgets);
+            break;
+        case YON_PAGE_REGION: 
+            yon_region_init(widgets);
+            break;
+        case YON_PAGE_KEYBOARD: 
+            yon_keyboard_init(widgets);
+            break;
+        case YON_PAGE_USERS: 
+            yon_user_init(widgets);
+            break;
+        case YON_PAGE_STARTUP: 
+            yon_startup_services_setup(widgets);
+            break;
+        case YON_PAGE_BOOTLOADER: 
+            yon_bootloader_init(widgets);
+        break;
+        case YON_PAGE_NETWORK: 
+            yon_network_init(widgets);
+        break;
+        case YON_PAGE_INSTALL_COMMON: 
+        case YON_PAGE_INSTALL_SEPARATE: 
+        case YON_PAGE_INSTALL_SAME_PARTITION: 
+        case YON_PAGE_INSTALL_ADVANCED: 
+        case YON_PAGE_RECOVERY_GRUB_INSTALL: 
+        case YON_PAGE_RECOVERY_GRUB_UPDATE: 
+        case YON_PAGE_RECOVERY_OS_ONLY: 
+        case YON_PAGE_RECOVERY_USRDATA_ONLY: 
+        case YON_PAGE_INSTALLATION_BEGIN:
+            yon_install_init(widgets,page);
+        break;
+        case YON_PAGE_INSTALLATION:
+            main_config.save_configured=1;
+            g_mutex_lock(&main_config.install_mutex);
+            if (main_config.install_complete){
+                g_mutex_unlock(&main_config.install_mutex);
+                g_thread_new("install_thread",(GThreadFunc)on_setup_system_configuration,widgets);
+                on_page_next_clicked(NULL,widgets);
+            } else {
+                g_mutex_unlock(&main_config.install_mutex);
+            }
+        break;
+        default: break;
+    }
+}
+
+void on_page_next_clicked(GtkWidget *, main_window *widgets){
+    enum YON_PAGES page = gtk_notebook_get_current_page(GTK_NOTEBOOK(widgets->Notebook));
+    page = yon_page_get_next(widgets,page);
+    if ((int)page!=-1){
+        gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets->Notebook),page);
+        yon_page_init(widgets,page);
+    }
+    yon_page_update(widgets);
+}
+
+void on_page_prev_clicked(GtkWidget *, main_window *widgets){
+    enum YON_PAGES page = gtk_notebook_get_current_page(GTK_NOTEBOOK(widgets->Notebook));
+    page = yon_page_get_prev(page);
+    if ((int)page!=-1){
+        gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets->Notebook),page);
+    }
+    yon_page_update(widgets);
+}
+
+void on_page_cancel_clicked(GtkWidget *, main_window *widgets){
+    gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets->Notebook),YON_PAGE_WELCOME);
+    gtk_widget_hide(widgets->BackButton);
+    gtk_widget_hide(widgets->SourceButton);
+    gtk_widget_hide(widgets->SkipInstallationButton);
+    gtk_widget_show(widgets->NextButton);
+    gtk_widget_show(widgets->StartScenarioButton);
+    gtk_widget_set_sensitive(widgets->CancelInstallButton,0);
+    gtk_widget_set_sensitive(widgets->BackButton,1);
+    gtk_widget_set_sensitive(widgets->NextButton,1);
+    
+}

source/ubinstall-gtk-password.c

@@ -0,0 +1 @@
+#include "ubinstall-gtk.h"

source/ubinstall-gtk-region.c

@@ -0,0 +1,149 @@
+#include "ubinstall-gtk.h"
+
+// void on_region_resized(GtkWidget *,main_window *widgets){
+//             yon_image_resize_from_container(GTK_IMAGE(widgets->SlidesImage), (GdkPixbuf*)g_list_nth_data(widgets->slides_original,cur_slide));
+//             yon_image_resize_from_container(GTK_IMAGE(widgets->RegionImage), widgets->regions_original);
+//             yon_image_resize_from_container(GTK_IMAGE(widgets->KeyboardImage), widgets->keyboard_original);
+// }
+
+int yon_region_save(main_window *widgets){
+    if (gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->RegionCombo))==-1){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),REGION_EMPTY_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(widgets->RegionCombo);
+        return 0;
+    } else if (gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->ZoneCombo))==-1){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),ZONE_EMPTY_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(widgets->ZoneCombo);
+        return 0;
+    } 
+    char *languages = "";
+    GtkTreeIter iter;
+    GtkTreeModel *model = GTK_TREE_MODEL(widgets->LanguagesFilter);
+    char *lang_code=NULL;
+    for_iter(model,&iter){
+        gtk_tree_model_get(model,&iter,2,&lang_code,-1);
+        languages = yon_char_unite(languages,!yon_char_is_empty(languages)?",":"",lang_code,NULL);
+    }
+    if (yon_char_is_empty(languages)||!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->MainLanguageSensitiveCheck))){
+        yon_config_remove_by_key(locale_parameter);
+    } else {
+        yon_config_register(locale_parameter,locale_parameter_command,languages);
+        free(languages);
+    }
+    if (gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->LanguagesCombo))==-1||!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->LanguagesSensitiveCheck))){
+        yon_config_remove_by_key(lang_parameter);
+    } else {
+        char *language = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(widgets->LanguagesCombo));
+        yon_config_register(lang_parameter,lang_parameter_command,language);
+    }
+    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->RegionSensitiveCheck))){
+        char *region = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(widgets->RegionCombo));
+        char *zone = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(widgets->ZoneCombo));
+        yon_debug_output("%s",region);
+        yon_debug_output("/%s\n\n",zone);
+        yon_config_register(zone_parameter,zone_parameter_command,yon_char_unite(region,"/",zone,NULL));
+    } else {
+        yon_config_remove_by_key(zone_parameter);
+    }
+    return 1;
+}
+
+void on_region_changed(GtkComboBox *self, main_window *widgets){
+    char *active = (char*)gtk_combo_box_get_active_id(self);
+    active = yon_char_append("/usr/share/zoneinfo/",active);
+    int size;
+    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->ZoneCombo));
+    if (yon_file_is_directory(active)){
+        config_str parsed = yon_file_ls(active,&size);
+        for (int i=0;i<size;i++){
+            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets->ZoneCombo),parsed[i],_(parsed[i]));
+        }
+        if (size) yon_char_parsed_free(parsed,size);
+        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->ZoneCombo),0);
+    }
+    free(active);
+}
+
+void yon_region_init(main_window *widgets){
+    int size;
+    config_str parsed = NULL;
+    int langsize;
+    config_str lang = default_langs(&langsize);
+
+    GtkTreeIter iter;
+    gtk_list_store_clear(widgets->LanguagesList);
+    parsed = yon_file_open(languages_path,&size);
+    for (int i=0;i<size;i++){
+        int cur_size;
+        yon_char_remove_last_symbol(parsed[i],'\n')
+        config_str cur = yon_char_parse(parsed[i],&cur_size,";");
+        if (cur_size){
+            gtk_list_store_append(widgets->LanguagesList,&iter);
+            gtk_list_store_set(widgets->LanguagesList,&iter,0,0,1,_(cur[1]),2,cur[0],-1);
+        }
+        yon_char_parsed_free(cur,cur_size);
+    }
+    yon_char_parsed_free(parsed,size);
+    if (lang)
+        yon_char_parsed_free(lang,langsize);
+
+    parsed = yon_dir_get_contents(zone_path,&size);
+    for (int i=0;i<size;i++){
+        if (!strstr(parsed[i],".")&&strcmp(parsed[i],"posix")&&strcmp(parsed[i],"right")){
+            char *path = yon_char_append(zone_path,parsed[i]);
+            if (yon_file_is_directory(path)){
+                gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets->RegionCombo),parsed[i],_(parsed[i]));
+            }
+            free(path);
+        }
+    }
+        while(gtk_events_pending()) gtk_main_iteration();
+    gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->RegionCombo),0);
+    yon_char_parsed_free(parsed,size);
+
+    gtk_tree_model_filter_set_visible_column(GTK_TREE_MODEL_FILTER(widgets->LanguagesFilter),0);
+    gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(widgets->LanguagesFilter));
+    
+    char *zone = yon_char_new(config(zone_parameter));
+    char *locale = config(locale_parameter);
+    char *lang_param = config(lang_parameter);
+
+    if (!yon_char_is_empty(zone)){
+        char *timezone = yon_char_divide_search(zone,"/",-1);
+        gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->RegionCombo),timezone);
+        while(gtk_events_pending()) gtk_main_iteration();
+        gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->ZoneCombo),zone);
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->RegionSensitiveCheck),1);
+        free(timezone);
+    } else {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->RegionCombo),0);
+        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->ZoneCombo),0);
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->RegionSensitiveCheck),0);
+    }
+
+    if (!yon_char_is_empty(locale)){
+        char *parameters_list = "";
+        config_str parsed = yon_char_parse(locale,&size,",");
+        GtkTreeModel *model = GTK_TREE_MODEL(widgets->LanguagesList);
+        for_iter(model,&iter){
+            char *target, *id;
+            gtk_tree_model_get(model,&iter,1,&target,2,&id,-1);
+            if (yon_char_parsed_check_exist(parsed,size,id)>-1){
+                gtk_list_store_set(widgets->LanguagesList,&iter,0,1,-1);
+                char *temp = yon_char_unite(parameters_list,!yon_char_is_empty(parameters_list)?",":"",target,NULL);
+                if (!yon_char_is_empty(parameters_list)) free(parameters_list);
+                parameters_list=temp;
+            } else {
+                gtk_list_store_set(widgets->LanguagesList,&iter,0,0,-1);
+            }
+        }
+        gtk_entry_set_text(GTK_ENTRY(widgets->AvailableLanguagesEntry),parameters_list);
+        if(!yon_char_is_empty(parameters_list)) free(parameters_list);
+
+    }
+
+    if (!yon_char_is_empty(lang_param)){
+        gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->LanguagesCombo),lang_param);
+    }
+
+}

source/ubinstall-gtk-saving.c

@@ -0,0 +1,649 @@
+#include "ubinstall-gtk.h"
+
+
+
+// void _yon_saving_threaded(char *final_command){
+//     FILE *file = popen(final_command,"r");
+//     int file_save;
+//     config_str file_return = yon_config_load_file(file,&file_save);
+//     pclose(file);
+//     file_return = yon_char_parsed_append(file_return,&file_save,final_command);
+//     char *result = yon_char_parsed_to_string(file_return,file_save,"");
+//     yon_debug_output("%s\n",result);
+//     yon_char_parsed_free(file_return,file_save);
+//     free(result);
+// }
+
+// void yon_save_proceed(char *path, YON_CONFIG_TYPE type){
+//         yon_debug_output("%s\n",yon_config_save_simple(type,path));
+// }
+ 
+void yon_load_proceed(YON_CONFIG_TYPE type){ 
+	if (type!=YON_CONFIG_CUSTOM){
+		yon_config_clean();
+        if (!yon_char_is_empty(config_get_default_command))
+            yon_config_load_config(YON_CONFIG_DEFAULT,config_get_default_command,NULL);
+	}
+    if (type==YON_CONFIG_GLOBAL){
+		yon_config_load_config(type,yon_config_get_command("global"),NULL);
+	} else if (type==YON_CONFIG_LOCAL){
+		yon_config_load_config(type,yon_config_get_command("system"),NULL);
+    } else if (type==YON_CONFIG_CUSTOM){
+        textdomain(template_ui_LocaleName);
+		GtkWidget *dialog = gtk_file_chooser_dialog_new(template_app_information.app_title,NULL,GTK_FILE_CHOOSER_ACTION_SAVE,CANCEL_LABEL,GTK_RESPONSE_CANCEL,OPEN_LABEL,GTK_RESPONSE_ACCEPT,NULL);
+        textdomain(LocaleName);
+        gtk_window_set_icon_name(GTK_WINDOW(dialog),"com.ublinux.ubl-settings-services");
+        gtk_window_set_title(GTK_WINDOW(dialog),TITLE_LABEL);
+        GtkFileFilter *filter = gtk_file_filter_new();
+		gtk_file_filter_add_pattern(filter,"*.ini");
+        gtk_file_filter_set_name(filter, "*.ini");
+		gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),filter);
+		gtk_widget_show(dialog);
+		int response = gtk_dialog_run(GTK_DIALOG(dialog));
+		if (response == GTK_RESPONSE_ACCEPT){
+			char *file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
+			if (!yon_char_is_empty(file)){
+				main_config.config_load_path=yon_char_new(file);
+                yon_config_clean();
+                if (!yon_char_is_empty(config_get_default_command))
+                    yon_config_load_config(YON_CONFIG_DEFAULT,config_get_default_command,NULL);
+                char *command = yon_config_get_command(main_config.config_load_path);
+                yon_config_load_config(type,command,NULL);
+			}
+			gtk_widget_destroy(dialog);
+		} else {
+			gtk_widget_destroy(dialog);
+		}
+	}
+}
+
+
+void on_config_local_load(GtkWidget *,main_window *widgets){
+    yon_load_proceed(YON_CONFIG_LOCAL);
+    yon_page_init(widgets,gtk_notebook_get_current_page(GTK_NOTEBOOK(widgets->Notebook)));
+    main_config.load_mode=YON_CONFIG_LOCAL;
+}
+
+void on_config_global_load(GtkWidget *,main_window *widgets){
+    yon_load_proceed(YON_CONFIG_GLOBAL);
+    yon_page_init(widgets,gtk_notebook_get_current_page(GTK_NOTEBOOK(widgets->Notebook)));
+    main_config.load_mode=YON_CONFIG_GLOBAL;
+}
+
+void on_config_custom_load(GtkWidget *,main_window *widgets){
+	yon_load_proceed(YON_CONFIG_CUSTOM);
+    yon_page_init(widgets,gtk_notebook_get_current_page(GTK_NOTEBOOK(widgets->Notebook)));
+	main_config.load_mode=YON_CONFIG_CUSTOM;
+}
+
+// void on_config_global_local_save(GtkWidget *,main_window *widgets){
+//     yon_save_proceed(NULL,YON_CONFIG_BOTH);
+//     gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets->Notebook),YON_PAGE_COMPLETED);
+// }
+
+// void on_config_local_save(GtkWidget *,main_window *widgets){
+//     yon_save_proceed("system",YON_CONFIG_LOCAL);
+//     gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets->Notebook),YON_PAGE_COMPLETED);
+//
+// }
+
+// void on_config_global_save(GtkWidget *,main_window *widgets){
+//     yon_save_proceed("global",YON_CONFIG_GLOBAL);
+//     gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets->Notebook),YON_PAGE_COMPLETED);
+//
+// }
+
+// void on_config_custom_save(GtkWidget *, main_window *widgets){
+//     char *path = NULL;
+//             GtkWidget *dialog = gtk_file_chooser_dialog_new(TITLE_LABEL,NULL,GTK_FILE_CHOOSER_ACTION_SAVE,CANCEL_LABEL,GTK_RESPONSE_CANCEL,SAVE_LABEL,GTK_RESPONSE_ACCEPT,NULL);
+//             textdomain(TITLE_LABEL);
+//             GtkFileFilter *filter = gtk_file_filter_new();
+//             gtk_window_set_icon_name(GTK_WINDOW(dialog),yon_char_append("com.ublinux.",LocaleName));
+//             gtk_file_filter_add_pattern(filter,"*.ini");
+//             gtk_file_filter_set_name(filter, "*.ini");
+//             gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),filter);
+//             int response = gtk_dialog_run(GTK_DIALOG(dialog));
+//             if (response == GTK_RESPONSE_ACCEPT){
+//                 char *file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
+//                 if (!yon_char_is_empty(file)){
+//                     if (!strstr(file,".ini")) file = yon_char_append(file,".ini");
+//                     if (access(file,0)!=F_OK){
+//                         char *command_creation = ubconfig_file_create(file);
+//                         int a = system(yon_debug_output("%s\n",command_creation));
+//                         if (access(file,0)!=F_OK||a){
+//                             yon_ubl_status_box_render(CUSTOM_CONFIG_CREATION_ERROR_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
+//                             return;
+//                         }
+//                     }
+//                 }
+//                 path = yon_char_unite("'",file,"'",NULL);
+//                 free(file);
+//                 gtk_widget_destroy(dialog);
+//             } else {
+//                 gtk_widget_destroy(dialog);
+//                 return;
+//             }
+// 	yon_save_proceed(path,YON_CONFIG_CUSTOM);
+//     if (path) free(path);
+//     gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets->Notebook),YON_PAGE_COMPLETED);
+// }
+//
+// void yon_open_browser(GtkWidget *, char *link);
+// void yon_open_browser(GtkWidget *, char *link){
+//     GtkWidget *window = yon_ubl_browser_window_open(link,TITLE_LABEL);
+//     if (window)
+//     gtk_window_set_icon_name(GTK_WINDOW(window),yon_char_append("com.ublinux.",LocaleName));
+// }
+
+// void yon_interface_update(main_window *widgets){
+//     if (widgets){};
+//     enum YON_PAGES page=YON_PAGE_COMPLETED;
+//     char *type = config(AUTOINSTALL_TYPE_INSTALL);
+//     if (!yon_char_is_empty(type)){
+//         if (!strcmp(type,"fast")){
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->InstallationRadio),1);
+//             page = YON_PAGE_INSTALL_COMMON;
+//         } else if (!strcmp(type,"next")){
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->InstallationNearRadio),1);
+//             page = YON_PAGE_INSTALL_SEPARATE;
+//         } else if (!strcmp(type,"part")){
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->InstallationLinuxRadio),1);
+//             page = YON_PAGE_INSTALL_SAME_PARTITION;
+//         } else if (!strcmp(type,"grub_install")){
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->InstallationWindowsRadio),1);
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->GrubInstallRadio),1);
+//             page = YON_PAGE_OPTIONS_GRUB_INSTALL;
+//         } else if (!strcmp(type,"grub_update")){
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->InstallationWindowsRadio),1);
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->GrubUpdateRadio),1);
+//             page = YON_PAGE_OPTIONS_GRUB_UPDATE;
+//         } else if (!strcmp(type,"system_only")){
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->InstallationWindowsRadio),1);
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->OSRadio),1);
+//             page = YON_PAGE_OPTIONS_OS_ONLY;
+//         } else if (!strcmp(type,"data_only")){
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->InstallationWindowsRadio),1);
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->UserDataOnlyRadio),1);
+//             page = YON_PAGE_OPTIONS_USRDATA_ONLY;
+//         } else if (!strcmp(type,"custom")){
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->InstallationWindowsRadio),1);
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->SeparateRadio),1);
+//             page = YON_PAGE_OPTIONS_SEPARATE;
+//         }
+//     }
+//     char *device = config(AUTOINSTALL_DEVICE);
+//     char *part = NULL;
+//     if (page!=YON_PAGE_INSTALL_COMMON)
+//     part = config(part_parameter);
+//     char *fs_type = config(part_fs_type_parameter);
+//     char *device_label = config(device_label_parameter);
+//     char *format = config(part_format_parameter);
+//     char *part_size = config(part_size_parameter);
+//     GtkListStore *device_list = widgets->DevicesList;
+//     GtkListStore *part_list=widgets->PartitionsList;
+//     GtkWidget *device_tree=NULL;
+//     GtkWidget *part_tree=NULL;
+//     switch (page){
+//         case YON_PAGE_INSTALL_COMMON:{
+//             device_tree = widgets->CommonInstallationDevicesTree;
+//         } break;
+//
+//         case YON_PAGE_INSTALL_SEPARATE:{
+//             device_tree = widgets->NextInstallationSysDevicesTree;
+//             part_tree = widgets->NextInstallationSysSectionTree;
+//             if (!yon_char_is_empty(part_size)){
+//                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->NextInstallationSizeSpin),atof(part_size));
+//                 if (part_size[strlen(part_size)-1]=='M') gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->NextInstallationSizeTypeSpin),0);
+//                 if (part_size[strlen(part_size)-1]=='G') gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->NextInstallationSizeTypeSpin),1);
+//                 if (part_size[strlen(part_size)-1]=='T') gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->NextInstallationSizeTypeSpin),2);
+//             }
+//             if (format&&!strcmp(format,"yes")) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->NextInstallationFormatCheck),1);
+//             else  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->NextInstallationFormatCheck),main_config.format_default);
+//             if (!yon_char_is_empty(fs_type))
+//             gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->NextInstallationFilesystemTypeCombo),fs_type);
+//             if (device_label)
+//             gtk_entry_set_text(GTK_ENTRY(widgets->NextInstallationSectionNameEntry),device_label);
+//             else 
+//             gtk_entry_set_text(GTK_ENTRY(widgets->NextInstallationSectionNameEntry),"");
+//
+//         } break;
+//
+//         case YON_PAGE_INSTALL_SAME_PARTITION:{
+//             device_tree = widgets->SamePlaceDeviceTree;
+//             part_tree = widgets->SamePlacePartTree;
+//             if (!yon_char_is_empty(fs_type))
+//                 gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->SameInstallationFilesystemTypeCombo),fs_type);
+//             if (format&&!strcmp(format,"yes")) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->SameInstallationFormatCheck),1);
+//             else  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->SameInstallationFormatCheck),main_config.format_default);
+//             if (device_label)
+//                 gtk_entry_set_text(GTK_ENTRY(widgets->SameInstallationSectionNameEntry),device_label);
+//                 else 
+//                 gtk_entry_set_text(GTK_ENTRY(widgets->SameInstallationSectionNameEntry),"");
+//
+//         } break;
+//         case YON_PAGE_OPTIONS_GRUB_INSTALL:{
+//             device_tree = widgets->GrubInstallDevicesTree;
+//         } break;
+//
+//         case YON_PAGE_OPTIONS_GRUB_UPDATE:{
+//             device_tree = widgets->GrubUpdateDevicesTree;
+//         } break;
+//
+//         case YON_PAGE_OPTIONS_SEPARATE:{
+//             GtkTreeIter iter;
+//             device_tree = widgets->SeparateDevicesTree;
+//             part_tree = widgets->SeparateSysSectionTree;
+//             for_iter(GTK_TREE_MODEL(device_list),&iter){
+//                 char *cur_device;
+//                 gtk_tree_model_get(GTK_TREE_MODEL(device_list),&iter, 0,&cur_device,-1);
+//                 if (!strcmp(cur_device,device)){
+//                     gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(device_tree)),&iter);
+//                     break;
+//                 }
+//             }
+//             on_near_installation_device_changed(device_tree,widgets);
+//             for_iter(GTK_TREE_MODEL(part_list),&iter){
+//                 char *cur_part;
+//                 gtk_tree_model_get(GTK_TREE_MODEL(device_list),&iter, 0,&cur_part,-1);
+//                 if (!strcmp(cur_part,part)){
+//                     gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(part_tree)),&iter);
+//                 }
+//             }
+//         } break;
+//
+//         case YON_PAGE_OPTIONS_OS_ONLY:{
+//             device_tree = widgets->OSDevicesTree;
+//             part_tree = widgets->OSSysSectionTree;
+//         } break;
+//
+//         case YON_PAGE_OPTIONS_USRDATA_ONLY:{
+//             device_tree = widgets->UserdataDevicesTree;
+//             part_tree = widgets->UserdataSysSectionTree;
+//         } break;
+//
+//         default:{}break;
+//     }
+//     GtkTreeIter iter;
+//     char *cur_device="";
+//     if (page!=YON_PAGE_OPTIONS_SEPARATE && !yon_char_is_empty(device)){
+//         for_iter (widgets->DevicesList,&iter){
+//             gtk_tree_model_get(GTK_TREE_MODEL(widgets->DevicesList),&iter,0,&cur_device,-1);
+//             if (!strcmp(device,cur_device)){
+//                 gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(device_tree)),&iter);
+//                 break;
+//             }
+//         }
+//         on_near_installation_device_changed(device_tree,widgets);
+//         if (!yon_char_is_empty(part)){
+//             for_iter (widgets->PartitionsList,&iter){
+//                 gtk_tree_model_get(GTK_TREE_MODEL(widgets->PartitionsList),&iter,0,&part,-1);
+//                 if (!strcmp(device,cur_device)){
+//                     gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(part_tree)),&iter);
+//                     break;
+//                 }
+//             }
+//         }
+//     }
+//     char *system_locale = config(locale_parameter);
+//     if (!yon_char_is_empty(system_locale)){
+//         char *chosen_langs = "";
+//         for_iter(widgets->LanguagesList,&iter){
+//             char *cur=NULL, *render = NULL;
+//             gtk_tree_model_get(GTK_TREE_MODEL(widgets->LanguagesList),&iter,1,&render,2,&cur,-1);
+//             if (strstr(system_locale,cur)){
+//                 gtk_list_store_set((widgets->LanguagesList),&iter,0,1,-1);
+//                 chosen_langs = yon_char_unite(chosen_langs,!yon_char_is_empty(chosen_langs)?";":"",render,NULL);
+//             } else {
+//                 gtk_list_store_set((widgets->LanguagesList),&iter,0,0,-1);
+//             }
+//         }
+//         if (!yon_char_is_empty(chosen_langs)){
+//             gtk_entry_set_text(GTK_ENTRY(widgets->AvailableLanguagesEntry),chosen_langs);
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->LanguagesSensitiveCheck),1);
+//             free(chosen_langs);
+//         } else {
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->LanguagesSensitiveCheck),0);
+//             gtk_entry_set_text(GTK_ENTRY(widgets->AvailableLanguagesEntry),"");
+//         }
+//     } else {
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->LanguagesSensitiveCheck),0);
+//         gtk_entry_set_text(GTK_ENTRY(widgets->AvailableLanguagesEntry),"");
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->LanguagesSensitiveCheck),0);
+//         int langsize;
+//         config_str lang = default_langs(&langsize);
+//         for_iter(widgets->LanguagesList,&iter){
+//             char *cur=NULL;
+//             gtk_tree_model_get(GTK_TREE_MODEL(widgets->LanguagesList),&iter,2,&cur,-1);
+//                 if (lang&&yon_char_parsed_check_exist(lang,langsize,cur)>-1){
+//                     gtk_list_store_set(widgets->LanguagesList,&iter,0,1,-1);
+//                 } else {
+//                     gtk_list_store_set(widgets->LanguagesList,&iter,0,0,-1);
+//                 }
+//                 if (cur) free(cur);
+//         }
+//         if (langsize) yon_char_parsed_free(lang,langsize);
+//     }
+//     char *zone = config(zone_parameter);
+//     char *region = NULL;
+//
+//     if (!yon_char_is_empty(zone)) region = yon_char_divide_search(zone,"/",-1); else {gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->RegionSensitiveCheck),0);}
+//     if (!yon_char_is_empty(region)){
+//         gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->RegionCombo),region);
+//     } else {
+//         gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->RegionCombo),"Europe");
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->RegionSensitiveCheck),0);
+//     }
+//     if (!yon_char_is_empty(zone)){
+//         gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->ZoneCombo),zone);
+//     } else {
+//         gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->ZoneCombo),"Moscow");
+//     }
+//     char *language = config(lang_parameter);
+//     if (!yon_char_is_empty(language)){
+//         gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->LanguageCombo),language);
+//     } else {
+//         gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->LanguageCombo),0);
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->MainLanguageSensitiveCheck),0);
+//     }
+//     char *kbmodel = config (xkbmodel_parameter);
+//     char *optinos = config(xkboptions_parameter);
+//     char *layout = config(xkblayout_parameter);
+//     if (!yon_char_is_empty(kbmodel)){
+//         gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->KeyboardModelCombo),kbmodel);
+//     } else {
+//         gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->KeyboardModelCombo),0);
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->KeyboardModelSensitiveCheck),0);
+//
+//     }
+//     if (!yon_char_is_empty(optinos)){
+//         gtk_combo_box_set_active_id(GTK_COMBO_BOX(widgets->LayoutBindingCombo),optinos);
+//     } else {
+//         gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->LayoutBindingCombo),0);
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->OptionsSensitiveCheck),0);
+//     }
+//     if (!yon_char_is_empty(layout)){
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->ManualLayoutRadio),1);
+//         for_iter(widgets->LayoutList,&iter){
+//             char *cur=NULL;
+//             gtk_tree_model_get(GTK_TREE_MODEL(widgets->LayoutList),&iter,0,&cur,-1);
+//             if (strstr(layout,cur)){
+//                 gtk_tree_store_set(widgets->LayoutList,&iter,3,1,-1);
+//             } else {
+//                 gtk_tree_store_set(widgets->LayoutList,&iter,3,0,-1);
+//             }
+//         }
+//     } else {
+//         for_iter(widgets->LayoutList,&iter){
+//             char *id;
+//             gtk_tree_model_get(GTK_TREE_MODEL(widgets->LayoutList),&iter,0,&id,-1);
+//             if (!strcmp(id,"ru")||!strcmp(id,"us")){
+//                 gtk_tree_store_set(widgets->LayoutList,&iter,3,1,-1);
+//             } else {
+//                 gtk_tree_store_set((widgets->LayoutList),&iter,3,0,-1);
+//             }
+//         }
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->LayoutSensitiveCheck),0);
+//     }
+//     char *user_name = config(user_name_parameter);
+//     char *user_gecos = config(user_gecos_parameter);
+//     char *user_password = config(user_password_parameter);
+//     char *root_password = config(root_password_parameter);
+//     char *autologin = config(autologin_parameter);
+//     char *hostname = config(hostname_parameter);
+//     if (!yon_char_is_empty(user_name)){
+//         if (!strcmp(user_name,"root")){
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->UserRootOnlyCheck),1);
+//         } else {
+//             gtk_entry_set_text(GTK_ENTRY(widgets->UserRootLoginEntry),user_name);
+//         }
+//     } else {
+//         gtk_entry_set_text(GTK_ENTRY(widgets->UserRootLoginEntry),"");
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->LoginSensitiveCheck),0);
+//     }
+//     if (!yon_char_is_empty(user_gecos)){
+//         gtk_entry_set_text(GTK_ENTRY(widgets->UserRootNameEntry),_(user_gecos));
+//     } else {
+//         gtk_entry_set_text(GTK_ENTRY(widgets->UserRootNameEntry),"");
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->UsernameSensitiveCheck),0);
+//     }
+//     int def_size=0;
+//     config_str default_password = NULL;
+//     if (!getuid()){
+//         default_password = yon_config_load(yon_debug_output("%s\n",get_default_password_command), &def_size);
+//         if (def_size>0&&default_password){
+//             yon_char_remove_last_symbol(default_password[0],'\n');
+//         }
+//     }
+//     if ((def_size>0&&!strcmp(default_password[0],user_password))||yon_char_is_empty(user_password)){
+//         gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->UserRootPasswordCombo),0);
+//         gtk_entry_set_text(GTK_ENTRY(widgets->UserRootPasswordEntry),"");
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->PasswordSensitiveCheck),0);
+//
+//     } else if (!yon_char_is_empty(user_password)){
+//         gtk_entry_set_text(GTK_ENTRY(widgets->UserRootPasswordEntry),user_password);
+//         gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->UserRootPasswordCombo),1);
+//     }
+//     if ((def_size>0&&!strcmp(default_password[0],user_password))||yon_char_is_empty(user_password)){
+//         gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->AdminPasswordCombo),0);
+//         gtk_entry_set_text(GTK_ENTRY(widgets->AdminPasswordEntry),"");
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->RootPasswordSensitiveCheck),0);
+//
+//     } else if (!yon_char_is_empty(root_password)){
+//         gtk_entry_set_text(GTK_ENTRY(widgets->AdminPasswordEntry),root_password);
+//         gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->AdminPasswordCombo),1);
+//     }
+//     if (!yon_char_is_empty(autologin)){
+//         if (!strcmp(autologin,"yes"))
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->UserAutologinSwitch),1);
+//         else 
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->UserAutologinSwitch),0);
+//     } else {
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->UserAutologinSwitch),main_config.autologin_default);
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->AutologinSensitiveCheck),0);
+//     }
+//     if (!yon_char_is_empty(hostname)){
+//         if (strcmp(hostname,"auto")){
+//             gtk_entry_set_text(GTK_ENTRY(widgets->HotnameEntry),hostname);
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->AutoHostnameCheck),0);
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->HostnameSensitiveCheck),1);
+//         } else{
+//             gtk_entry_set_text(GTK_ENTRY(widgets->HotnameEntry),"");
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->AutoHostnameCheck),1);
+//         }
+//     } else {
+//         gtk_entry_set_text(GTK_ENTRY(widgets->HotnameEntry),"");
+//         g_signal_handlers_block_by_func(G_OBJECT(widgets->AutoHostnameCheck),on_autohostname_check,widgets);
+//         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->AutoHostnameCheck),1);
+//         g_signal_handlers_unblock_by_func(G_OBJECT(widgets->AutoHostnameCheck),on_autohostname_check,widgets);
+//             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->HostnameSensitiveCheck),0);
+//     }
+// }
+
+gboolean on_install_success(main_window *widgets){
+    gtk_label_set_text(GTK_LABEL(widgets->InstallationLabel),"");
+    gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets->Notebook),YON_PAGE_COMPLETION);
+    yon_page_update(widgets);
+
+    return 0;
+}
+
+gboolean on_install_error(main_window *widgets){
+    gtk_label_set_text(GTK_LABEL(widgets->InstallationLabel),"");
+    gtk_notebook_set_current_page(GTK_NOTEBOOK(widgets->Notebook),YON_PAGE_INSTALL_ERROR);
+    yon_page_update(widgets);
+
+    return 0;
+}
+
+enum INSTALL_TYPE{
+    INSTALL_COMMON,
+    INSTALL_PART,
+    INSTALL_NEXT,
+    INSTALL_ADVANCED,
+    INSTALL_GRUB_INSTALL,
+    INSTALL_GRUB_UPDATE,
+    INSTALL_SYSTEM_ONLY,
+    INSTALL_USER_ONLY,
+    INSTALL_ERROR
+};
+
+/**Функция получения текущего режима установки
+ * 
+ */
+enum INSTALL_TYPE yon_ubl_get_install_mode(){
+    char *value = config(AUTOINSTALL_TYPE_INSTALL);
+    if (!strcmp(value,"fast")){
+        return INSTALL_COMMON;
+    } else if (!strcmp(value,"part")){
+        return INSTALL_PART;
+    } else if (!strcmp(value,"next")){
+        return INSTALL_NEXT;
+    } else if (!strcmp(value,"advanced")){
+        return INSTALL_ADVANCED;
+    } else if (!strcmp(value,"grub_install")){
+        return INSTALL_GRUB_INSTALL;
+    } else if (!strcmp(value,"grub_update")){
+        return INSTALL_GRUB_UPDATE;
+    } else if (!strcmp(value,"system_only")){
+        return INSTALL_SYSTEM_ONLY;
+    } else if (!strcmp(value,"data_only")){
+        return INSTALL_USER_ONLY;
+    }
+    return INSTALL_ERROR;
+}
+
+void *on_config_save(void *data){
+    main_window *widgets = (main_window*)data;
+
+        int size=0;
+        config_str parameters = NULL;
+        enum INSTALL_TYPE install_mode = yon_ubl_get_install_mode();
+        switch(install_mode){
+            case INSTALL_COMMON:
+                parameters = yon_config_get_selection_by_key_no_ignored(&size,install_common_parameters,NULL);
+            break;
+            case INSTALL_PART:
+                parameters = yon_config_get_selection_by_key_no_ignored(&size,install_part_parameters,NULL);
+            break;
+            case INSTALL_NEXT:
+                parameters = yon_config_get_selection_by_key_no_ignored(&size,install_next_parameters,NULL);
+            break;
+            case INSTALL_ADVANCED:
+                parameters = yon_config_get_selection_by_key_no_ignored(&size,install_advanced_parameters,NULL);
+            break;
+            case INSTALL_GRUB_INSTALL:
+            case INSTALL_GRUB_UPDATE:
+                parameters = yon_config_get_selection_by_key_no_ignored(&size,install_grub_install_update_parameters,NULL);
+            break;
+            case INSTALL_SYSTEM_ONLY:
+                parameters = yon_config_get_selection_by_key_no_ignored(&size,install_system_only_parameters,NULL);
+            break;
+            case INSTALL_USER_ONLY:
+                parameters = yon_config_get_selection_by_key_no_ignored(&size,install_userdata_only_parameters,NULL);
+            break;
+            default:
+                yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),ERROR_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE); 
+                return 0;
+        }
+        FILE *file = fopen(progress_path,"w");
+        if (file){
+            fclose(file);
+        }
+            GFile *file_desc = g_file_new_for_path(progress_path);
+            widgets->install_info_monitor = g_file_monitor_file(file_desc,G_FILE_MONITOR_NONE,NULL,NULL);
+            g_signal_connect(G_OBJECT(widgets->install_info_monitor),"changed",G_CALLBACK(yon_installation_progress_update),widgets);
+            g_object_unref(file_desc);
+            gtk_widget_show(gtk_widget_get_parent(widgets->InstallationProgress));
+        char *command = yon_debug_output("%s\n",save_config_command(yon_char_parsed_to_string(parameters,size," ")));
+        yon_char_parsed_free(parameters,size);
+        yon_debug_output("%s\n","Entered installation");
+        if (system(yon_debug_output("%s\n",command))){
+
+            gdk_threads_add_idle((GSourceFunc)on_install_error,widgets);
+            free(command);
+            g_mutex_lock(&main_config.install_mutex);
+            main_config.install_complete=1;
+            g_mutex_unlock(&main_config.install_mutex);
+            return 0;
+        };
+        free(command);
+        g_mutex_lock(&main_config.install_mutex);
+        main_config.install_complete=1;
+        g_mutex_unlock(&main_config.install_mutex);
+        if ((!main_config.save_done)&&main_config.save_configured){
+            on_setup_system_configuration(widgets);
+            on_page_next_clicked(NULL,widgets);
+        }
+    return 0;
+}
+
+void *on_setup_system_configuration(void * data){
+    yon_debug_output("%s\n","Entered thread");
+    main_window *widgets = (main_window*)data;
+    if (widgets){};
+    int size;
+    config_str all_parameters = yon_config_get_selection_by_key(&size,
+    root_password_parameter,
+    autologin_parameter,
+    xkbmodel_parameter,
+    xkblayout_parameter,
+    xkbvariant_parameter,
+    xkboptions_parameter,
+    hostname_parameter,
+    zone_parameter,
+    lang_parameter,
+    locale_parameter,
+    SERVICES_ENABLE_parameter,
+    GRUB_DEFAULT_parameter,
+    GRUB_TIMEOUT_parameter,
+    AUTOLOGINUSER_parameter,
+    GRUB_SUPERUSERS_parameter,
+    DOMAIN_parameter,
+    DOMAIN_admanger_parameter,
+    NTPSERVERS_parameter,
+    modules_extra_parameter,
+    KERNEL_BOOT_parameter,
+    modules_parameter,
+    packages_parameter,
+    NULL);
+    int user_size=0;
+    config_str users = yon_config_get_all_by_key(USERADD_parameter_search,&user_size);
+    if (user_size){
+        int final_size;
+        config_str final = yon_char_parsed_merge(all_parameters,size,users,user_size,&final_size);
+        yon_char_parsed_free(users,user_size);
+        if (size) yon_char_parsed_free(all_parameters,size);
+        all_parameters = final;
+        size = final_size;
+    }
+    users = yon_config_get_all_by_key(GRUB_PASSWORD_parameter_search,&user_size);
+    if (users){
+        int final_size;
+        config_str final = yon_char_parsed_merge(all_parameters,size,users,user_size,&final_size);
+        yon_char_parsed_free(users,user_size);
+        if (size) yon_char_parsed_free(all_parameters,size);
+        all_parameters = final;
+        size = final_size;
+    }
+    int network_size;
+    config_str networks = yon_config_get_all_by_key(NETWORK_parameter_search,&network_size);
+    if (network_size){
+        int final_size;
+        config_str final = yon_char_parsed_merge(all_parameters,size,networks,network_size,&final_size);
+        yon_char_parsed_free(networks,network_size);
+        if (size) yon_char_parsed_free(all_parameters,size);
+        all_parameters = final;
+        size = final_size;
+    }
+
+    if (all_parameters){
+        char *parameter_string = yon_char_parsed_to_string(all_parameters,size," ");
+        char *command = set_user_config_command(parameter_string);
+        if (system(yon_debug_output("%s\n",command))){};
+        yon_char_parsed_free(all_parameters,size);
+        free(command);
+        if (parameter_string) free(parameter_string);
+    }
+    g_idle_add((GSourceFunc)on_install_success,widgets);
+    return NULL;
+}

source/ubinstall-gtk-separate.c

@@ -0,0 +1,26 @@
+#include "ubinstall-gtk.h"
+
+int yon_install_options_save(GtkWidget *device_tree, GtkWidget *part_tree,char *mode,main_window *widgets){
+    GtkTreeIter iter,itar;
+    GtkTreeModel *model,*model2;
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(device_tree)),&model,&iter)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(device_tree));
+        return 0;
+    }
+    if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(part_tree)),&model2,&itar)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(widgets->StatusBox),NO_DEVICE_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(gtk_widget_get_parent(part_tree));
+        return 0;
+    }
+    char *cur_device, *cur_section;
+    gtk_tree_model_get(model,&iter,0,&cur_device,-1);
+    gtk_tree_model_get(model2,&itar,0,&cur_section,-1);
+    yon_config_register(AUTOINSTALL_DEVICE,AUTOINSTALL_DEVICE_command,cur_device);
+    yon_config_register(AUTOINSTALL_TYPE_INSTALL,AUTOINSTALL_TYPE_INSTALL_command,mode);
+    yon_config_register(part_parameter,part_parameter_command,cur_section);
+
+    if(cur_section) free(cur_section); 
+    if(cur_device) free(cur_device); 
+    return 1;
+}

source/ubinstall-gtk-standard.c

@@ -0,0 +1,48 @@
+#include "ubinstall-gtk.h"
+
+
+// void on_open_documentation_confirmation(GtkWidget *self, char *link);
+// void on_open_documentation_confirmation(GtkWidget *self, char *link){
+//     if (main_config.always_open_documentation==0){
+//         GtkBuilder *builder = gtk_builder_new_from_resource(ui_glade_path_documentation);
+//         documentation_confirmation_window *window = malloc(sizeof(documentation_confirmation_window));
+//         window->Window = yon_gtk_builder_get_widget(builder,"helpConfirmationWindow");
+//         window->AcceptButton = yon_gtk_builder_get_widget(builder,"ReadHelpButton");
+//         window->CloseButton = yon_gtk_builder_get_widget(builder,"CancelHelpButton");
+//         window->HeaderLabel = yon_gtk_builder_get_widget(builder,"webHeaderNameLabel");
+//         window->AlwaysOpenCheck = yon_gtk_builder_get_widget(builder,"AlwaysOpenDocumentationCheckbox");
+//         gtk_label_set_text(GTK_LABEL(window->HeaderLabel),TITLE_LABEL);
+//         gtk_widget_show_all(window->Window);
+//         g_signal_connect(G_OBJECT(window->CloseButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
+//         g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(yon_open_browser),yon_char_new(link));
+//         g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
+//
+//      
+//     } else {
+//         yon_open_browser(self,link);
+//     }
+// }
+
+// void on_link(GtkWidget *self, char* uri);
+// void on_link(GtkWidget *self, char* uri){
+//     gtk_widget_destroy(self);
+//     on_open_documentation_confirmation(self,uri);
+// }
+
+// void on_about(GtkWidget *);
+// void on_about(GtkWidget *){
+//     GtkBuilder *builder=gtk_builder_new_from_resource(ui_glade_path_about);
+//     GtkWidget *window=yon_gtk_builder_get_widget(builder,"AboutWindow");
+//     GtkWidget *title=yon_gtk_builder_get_widget(builder,"headerAboutTopic");
+//     GtkWidget *hideButtonBox=yon_gtk_builder_get_widget(builder,"buttonBoxHide");
+//     gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(window),version_application);
+//     gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(window),TITLE_LABEL);
+//     gtk_about_dialog_set_logo_icon_name(GTK_ABOUT_DIALOG(window),yon_char_append("com.ublinux.",LocaleName));
+//     gtk_window_set_icon_name(GTK_WINDOW(window),yon_char_append("com.ublinux.",LocaleName));
+//     gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(window),LocaleName);
+//     gtk_label_set_text(GTK_LABEL(title),TITLE_LABEL);
+//     g_signal_connect(G_OBJECT(window),"activate-link",G_CALLBACK(on_link),WIKI_LINK);
+//     gtk_widget_set_visible(hideButtonBox,0);
+//     gtk_widget_destroy(hideButtonBox);
+//     gtk_widget_show(window);
+// }

source/ubinstall-gtk-startup-services.c

@@ -0,0 +1,164 @@
+#include "ubinstall-gtk.h"
+
+
+void on_srartup_services_toggled(GtkWidget *, char *path, main_window *widgets){
+    GtkTreeIter iter;
+    int status;
+    gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(widgets->StartupList),&iter,path);
+    gtk_tree_model_get(GTK_TREE_MODEL(widgets->StartupList),&iter,0,&status,-1);
+    gtk_list_store_set(widgets->StartupList,&iter,0,!status,-1);
+}
+
+void on_startup_services_selection_changed(GtkWidget *,main_window *widgets){
+    GtkTreeIter iter;
+    GtkTreeModel *model;
+    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->StartupServicesTree)),&model,&iter)){
+        int status;
+        gtk_tree_model_get(model,&iter,4,&status,-1);
+        if (status){
+            gtk_widget_set_sensitive(widgets->StartupServicesEditButton,1);
+            gtk_widget_set_sensitive(widgets->StartupServicesRemoveButton,1);
+            return;
+        }
+    }
+    gtk_widget_set_sensitive(widgets->StartupServicesEditButton,0);
+    gtk_widget_set_sensitive(widgets->StartupServicesRemoveButton,0);
+}
+
+void on_startup_services_remove(GtkWidget *self,main_window *widgets){
+    GtkTreeIter iter;
+    GtkTreeModel *model;
+    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->StartupServicesTree)),&model,&iter)){
+        char *unit;
+        int deletable;
+        gtk_tree_model_get(model,&iter,2,&unit,4,&deletable,-1);
+        if (!deletable) return;
+        dialog_confirmation_data *data = yon_confirmation_dialog_data_new();
+        data->action_text = SERVICE_REMOVE_CONFIRMATION_LABEL(unit);
+        data->title = SERVICE_REMOVE_TITLE_LABEL;
+        if (yon_confirmation_dialog_call(self,data) == GTK_RESPONSE_ACCEPT){
+            gtk_list_store_remove(widgets->StartupList,&iter);
+        }
+    }
+}
+
+void yon_startup_services_setup(main_window *widgets){
+    int size;
+    config_str services = yon_resource_open_file(services_list_path,&size);
+    for (int i=1;i<size;i++){
+        int parsed_size;
+        config_str parsed = yon_char_parse(services[i],&parsed_size,";");
+        if (parsed_size&&!yon_char_is_empty(parsed[0])){
+            GtkTreeIter iter;
+            gtk_list_store_append(widgets->StartupList,&iter);
+            gtk_list_store_set(widgets->StartupList,&iter,0,1,1,parsed[0],2,yon_char_return_if_exist(parsed[1],""),3,yon_char_return_if_exist(parsed[2],""),-1);
+        }
+    }
+}
+
+void on_startup_add_accept(GtkWidget *self, main_window *widgets){
+    startup_service_window *window = g_object_get_data(G_OBJECT(self),"startup_service_window");
+        const char *unit = gtk_entry_get_text(GTK_ENTRY(window->UnitEntry));
+        const char *service = gtk_entry_get_text(GTK_ENTRY(window->ServiceEntry));
+        const char *description = gtk_entry_get_text(GTK_ENTRY(window->DescriptionEntry));
+        if (yon_char_is_empty(service)){
+            yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),_EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+            yon_ubl_status_highlight_incorrect(window->ServiceEntry);
+            return;
+        }
+        GtkTreeIter iter;
+        gtk_list_store_append(widgets->StartupList,&iter);
+        gtk_list_store_set(widgets->StartupList,&iter,1,unit,2,service,3,description,4,1,-1);
+    on_subwindow_close(self);
+}
+
+void on_startup_edit_accept(GtkWidget *self, main_window *widgets){
+    GtkTreeIter iter;
+    GtkTreeModel *model;
+    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->StartupServicesTree)),&model,&iter)){
+        startup_service_window *window = g_object_get_data(G_OBJECT(self),"startup_service_window");
+        const char *unit = gtk_entry_get_text(GTK_ENTRY(window->UnitEntry));
+        const char *service = gtk_entry_get_text(GTK_ENTRY(window->ServiceEntry));
+        const char *description = gtk_entry_get_text(GTK_ENTRY(window->DescriptionEntry));
+        if (yon_char_is_empty(service)){
+            yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),_EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+            yon_ubl_status_highlight_incorrect(window->ServiceEntry);
+            return;
+        }
+        gtk_list_store_set(widgets->StartupList,&iter,1,unit,2,service,3,description,4,1,-1);
+    }
+    on_subwindow_close(self);
+}
+
+startup_service_window *yon_startup_service_window_new(){
+    startup_service_window *window = new(startup_service_window);
+
+    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_service);
+
+    window->Window = yon_gtk_builder_get_widget(builder,"MainWindow");
+    window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
+    window->AcceptButton = yon_gtk_builder_get_widget(builder,"AcceptButton");
+    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
+    window->UnitEntry = yon_gtk_builder_get_widget(builder,"UnitEntry");
+    window->ServiceEntry = yon_gtk_builder_get_widget(builder,"ServiceEntry");
+    window->DescriptionEntry = yon_gtk_builder_get_widget(builder,"DescriptionEntry");
+
+    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
+    g_object_set_data(G_OBJECT(window->AcceptButton),"startup_service_window",window);
+
+    return window;
+}
+
+void on_startup_service_add(GtkWidget *, main_window *widgets){
+    startup_service_window *window = yon_startup_service_window_new();
+    yon_gtk_window_setup(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->MainWindow),SERVICE_ADD_TITLE_LABEL,icon_path,"service_add_window");
+    g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_startup_add_accept),widgets);
+    gtk_widget_show(window->Window);
+}
+
+void on_startup_service_edit(GtkWidget *, main_window *widgets){
+    GtkTreeIter iter;
+    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->StartupServicesTree)),NULL,&iter)){
+        char *service, *unit, *description;
+        int status;
+        gtk_tree_model_get(GTK_TREE_MODEL(widgets->StartupList),&iter,1,&unit,2,&service,3,&description,4,&status,-1);
+        if (status){
+            startup_service_window *window = yon_startup_service_window_new();
+            yon_gtk_window_setup(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->MainWindow),SERVICE_EDIT_TITLE_LABEL,icon_path,"service_add_window");
+            g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_startup_edit_accept),widgets);
+            gtk_entry_set_text(GTK_ENTRY(window->UnitEntry),unit);
+            gtk_entry_set_text(GTK_ENTRY(window->ServiceEntry),service);
+            gtk_entry_set_text(GTK_ENTRY(window->DescriptionEntry),description);
+            gtk_widget_show(window->Window);
+        }
+    }
+}
+
+int yon_startup_save(main_window *widgets){
+    GtkTreeIter iter;
+    GtkTreeModel *model = GTK_TREE_MODEL(widgets->StartupList);
+    int size = 0;
+    int list_size=0;
+    config_str modules = NULL;
+    for_iter(model,&iter){
+        list_size++;
+        char *target;
+        int status;
+        gtk_tree_model_get(model,&iter,0,&status,2,&target,-1);
+        if (status){
+            yon_char_parsed_add_or_create_if_exists(modules,&size,target);
+        }
+    }
+    if (size){
+        if (list_size==size){
+            yon_config_register(SERVICES_ENABLE_parameter,SERVICES_ENABLE_parameter_command,"auto");
+        } else {
+            char *final = yon_char_parsed_to_string(modules,size,",");
+            yon_config_register(SERVICES_ENABLE_parameter,SERVICES_ENABLE_parameter_command,final);
+        }
+        yon_char_parsed_free(modules,size);
+    } else {
+        yon_config_remove_by_key(SERVICES_ENABLE_parameter);  
+    }
+    return 1;
+}

source/ubinstall-gtk-users.c

@@ -0,0 +1,157 @@
+#include "ubinstall-gtk.h"
+
+int yon_users_save(main_window *widgets){
+    if (gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->UserRootPasswordCombo))){
+        const char *root_password = gtk_entry_get_text(GTK_ENTRY(widgets->UserRootPasswordEntry));
+        if (yon_char_is_empty(root_password)){
+            yon_ubl_status_box_spawn(GTK_CONTAINER(main_config.status_box),_EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+            yon_ubl_status_highlight_incorrect(widgets->UserRootPasswordEntry);
+            return 0;
+        }
+        yon_config_register(root_password_parameter,root_password_parameter_command,(char*)root_password);
+    } else {
+        yon_config_remove_by_key(root_password_parameter);
+    }
+    int autologin = gtk_switch_get_active(GTK_SWITCH(widgets->UserAutologinSwitch));
+    if (autologin){
+        yon_config_register(autologin_parameter,autologin_parameter_command,"yes");
+    } else {
+        yon_config_register(autologin_parameter,autologin_parameter_command,"no");
+    }
+
+    GList *users = gtk_container_get_children(GTK_CONTAINER(widgets->UserAddBox));
+    GList *iter;
+    for (iter=users;iter;iter=iter->next){
+        yon_user_struct *user = g_object_get_data(G_OBJECT(iter->data),"yon_user_struct");
+        if (user){
+            if (!yon_user_save(user)){
+                yon_ubl_status_box_spawn(GTK_CONTAINER(main_config.status_box),_EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+
+                return 0;
+            }
+        }
+    }
+
+    yon_debug_output("%s\n",yon_config_get_all_info());
+    return 1;
+}
+
+int yon_user_save(yon_user_struct *user){
+    char *name = (char *)gtk_entry_get_text(GTK_ENTRY(user->UsernameEntry));
+    char *login = (char *)gtk_entry_get_text(GTK_ENTRY(user->LoginEntry));
+    char *password = NULL;
+    if (yon_char_is_empty(login)){
+        yon_ubl_status_box_spawn(GTK_CONTAINER(main_config.status_box),_EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
+        yon_ubl_status_highlight_incorrect(user->LoginEntry);
+        return 0;
+    }
+    if (gtk_combo_box_get_active(GTK_COMBO_BOX(user->PasswordCombo))){
+        password = (char *)gtk_entry_get_text(GTK_ENTRY(user->PasswordEntry));
+        if (yon_char_is_empty(password)){
+            yon_ubl_status_highlight_incorrect(user->PasswordEntry);
+            return 0;
+        }
+    }
+    char *parameter = yon_char_unite(yon_char_return_if_exist(name,""),":::::",yon_char_return_if_exist(password,""),NULL);
+    yon_config_register(USERADD_parameter(login),USERADD_parameter_command(login),parameter);
+    free(parameter);
+    return 1;
+}
+
+void on_user_add(GtkWidget *,main_window *widgets){
+    yon_user_struct *user = yon_user_struct_new();
+    gtk_box_pack_start(GTK_BOX(widgets->UserAddBox),user->MainBox,0,0,0);
+}
+
+void on_user_remove_clicked(GtkWidget *,yon_user_struct *user){
+    gtk_widget_destroy(user->MainBox);
+    free(user);
+}
+
+void yon_password_root_new(GtkWidget *, main_window *widgets){
+    yon_password_window *window = yon_password_open(GTK_ENTRY(widgets->UserRootPasswordEntry));
+    gtk_widget_hide(gtk_widget_get_parent(window->EncryptionCombo));
+    gtk_widget_show(window->Window);
+}
+
+void yon_password_new(GtkWidget *, yon_user_struct *user){
+    yon_password_window *window = yon_password_open(GTK_ENTRY(user->PasswordEntry));
+    gtk_widget_hide(gtk_widget_get_parent(window->EncryptionCombo));
+    gtk_widget_show(window->Window);
+}
+
+yon_user_struct *yon_user_struct_new(){
+    yon_user_struct *user = new(yon_user_struct);
+    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_user);
+
+    user->MainBox = yon_gtk_builder_get_widget(builder,"MainBox");
+    user->RemoveButton = yon_gtk_builder_get_widget(builder,"RemoveButton");
+    user->UsernameEntry = yon_gtk_builder_get_widget(builder,"UsernameEntry");
+    user->LoginEntry = yon_gtk_builder_get_widget(builder,"LoginEntry");
+    user->PasswordCombo = yon_gtk_builder_get_widget(builder,"PasswordCombo");
+    user->PasswordEntry = yon_gtk_builder_get_widget(builder,"PasswordEntry");
+    user->PasswordButton = yon_gtk_builder_get_widget(builder,"PasswordButton");
+
+    g_object_set_data(G_OBJECT(user->MainBox),"yon_user_struct",user);
+
+    yon_gtk_entry_set_password_visibility_icon(GTK_ENTRY(user->PasswordEntry));
+
+    g_signal_connect(G_OBJECT(user->PasswordCombo),"changed",G_CALLBACK(yon_gtk_widget_set_sensitive_from_combo_box),user->PasswordEntry);
+    g_signal_connect(G_OBJECT(user->PasswordCombo),"changed",G_CALLBACK(yon_gtk_widget_set_sensitive_from_combo_box),user->PasswordButton);
+    g_signal_connect(G_OBJECT(user->PasswordButton),"clicked",G_CALLBACK(yon_password_new),user);
+    g_signal_connect(G_OBJECT(user->RemoveButton),"clicked",G_CALLBACK(on_user_remove_clicked),user);
+    return user;
+}
+
+void yon_user_init(main_window *widgets){
+    yon_gtk_entry_set_password_visibility_icon(GTK_ENTRY(widgets->UserRootPasswordEntry));
+    char *root_password = config(root_password_parameter);
+    char *autologin = config(autologin_parameter);
+    if (!yon_char_is_empty(root_password)){
+        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->UserRootPasswordCombo),1);
+        gtk_entry_set_text(GTK_ENTRY(widgets->UserRootPasswordEntry),root_password);
+    } else {
+        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->UserRootPasswordCombo),0);
+        gtk_entry_set_text(GTK_ENTRY(widgets->UserRootPasswordEntry),"");
+    }
+    if (!yon_char_is_empty(autologin)&&(!strcmp(autologin,"yes")||!strcmp(autologin,"enable"))){
+        gtk_switch_set_active(GTK_SWITCH(widgets->UserAutologinSwitch),1);
+    } else {
+        gtk_switch_set_active(GTK_SWITCH(widgets->UserAutologinSwitch),0);
+    }
+
+    GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->UserAddBox));
+    GList *iter;
+    for (iter = list; iter; iter = iter->next){
+        yon_user_struct *user = g_object_get_data(G_OBJECT(iter->data),"yon_user_struct");
+        gtk_widget_destroy(user->MainBox);
+        free(user);
+    }
+    int users_size;
+    config_str users = yon_config_get_all_by_key(USERADD_parameter_search,&users_size);
+    if (!users_size){
+        yon_user_struct *user = yon_user_struct_new();
+        gtk_box_pack_start(GTK_BOX(widgets->UserAddBox),user->MainBox,0,0,0);
+        gtk_entry_set_text(GTK_ENTRY(user->UsernameEntry),ADMINISTRATOR_LABEL);
+        gtk_entry_set_text(GTK_ENTRY(user->LoginEntry),"superadmin");
+    }
+    for (int i=0;i<users_size;i++){
+        yon_user_struct *user = yon_user_struct_new();
+        gtk_box_pack_start(GTK_BOX(widgets->UserAddBox),user->MainBox,0,0,0);
+
+        int parsed_size;
+        char *parameter = yon_char_new(users[i]);
+        char *parameter_name = yon_char_divide_search(parameter,"=",-1);
+        char *key = yon_config_parameter_get_key(parameter_name);
+        config_str parsed = yon_char_parse(parameter,&parsed_size,":");
+
+        gtk_entry_set_text(GTK_ENTRY(user->LoginEntry),key);
+        if (parsed_size>0)
+            gtk_entry_set_text(GTK_ENTRY(user->UsernameEntry),parsed[0]);
+        if (parsed_size>5){
+            gtk_entry_set_text(GTK_ENTRY(user->PasswordEntry),parsed[5]);
+            gtk_combo_box_set_active(GTK_COMBO_BOX(user->PasswordCombo),1);
+        }
+        gtk_widget_show(user->MainBox);
+    }
+}

source/ubl-strings.h

@@ -1,5 +1,3 @@
-#define VERSION_LABEL yon_char_unite(_("Version:")," ",!yon_char_is_empty(version_application)?version_application:"","\n",NULL)
-#define HELP_LABEL(rest) yon_char_unite(LocaleName,_(" version:")," ", !yon_char_is_empty(version_application)?version_application:"","\n",TITLE_LABEL,"\n",_("Usage:"), " ",LocaleName," ",_("[OPTIONS]"),"\n",_("Options:"),"\n\t--help, -h\t\t\t",_("Show this help"),"\n\t--version, -V\t\t\t",_("Show package version"),"\n\t--lock-help\t\t\t",_("Lock this help menu"),"\n\t--lock-save\t\t\t",_("Lock configuration saving"),"\n\t--lock-save-local\t\t",_("Lock local configration saving"),"\n\t--lock-save-global\t\t",_("Lock global configration saving"),"\n\t--lock-load-global\t\t",_("Lock global configration loading"),"\n\t--clear-config\t\t\t",_("Reset application settings"),"\n",!yon_char_is_empty(rest)?rest:NULL,NULL)
 
 #define TITLE_LABEL _("UBLinux installation")
 
@@ -102,12 +100,11 @@
 #define PASSWORD_SHORT_LABEL(min_size_char) yon_char_unite(_("Password must be at least")," ", min_size_char," ",_("characters"))
 
 #define RESTART_LABEL _("Restart PC")
-#define EXIT_LABEL _("Exit")
 #define CHOOSE_LABEL _("Choose file system type for the section:")
 #define SECTION_NAME_LABEL _("Section name:")
 #define FORMAT_LABEL _("Format")
 
-#define SUCCESS_LABEL _("You have UBLinux installed on your computer.\nYou can reboot and use your new system\nor continue working in the UBLinux Live environment.")
+#define INSTALL_SUCCESS_LABEL _("You have UBLinux installed on your computer.\nYou can reboot and use your new system\nor continue working in the UBLinux Live environment.")
 
 #define LANGUAGES_TITLE_LABEL _("Available languages in the system")
 #define LAYOUTS_TITLE_LABEL _("Keyboard layout language")
@@ -186,3 +183,27 @@
 
 #define WARNING_TEXT_LABEL _("Are you sure want to exit and\ninterrupt installation process?")
 #define WARNING_REBOOT_TEXT_LABEL _("Are you sure want to reboot system?")
+
+#define DEFAULT_BOOTLOAD_MENU_ITEM_LABEL _("Default (Use last succeeded)")
+#define ENCRYPT_ERROR_LABEL _("Password encryption error")
+
+#define DEFAULT_MENU_ITEM_LABEL _("Default (Use last succeeded)")
+
+#define LAUNCH_LABEL _("Launch")
+#define LTS_TAG _("LTS")
+#define REACTIVE_TAG _("Reactive")
+#define RECOMENDED_TAG _("Recomended")
+#define HARDENED_TAG _("Hardened")
+#define REALTIME_TAG _("RealTime")
+#define STABLE_TAG _("Stable")
+
+#define SERVICE_REMOVE_CONFIRMATION_LABEL(target) yon_char_unite(_("Are you sure want to remove service")," <b>",target,"</b> ",_("from the list"),"?",NULL)
+#define SERVICE_ADD_TITLE_LABEL _("Add service")
+#define SERVICE_EDIT_TITLE_LABEL _("Edit service")
+#define SERVICE_REMOVE_TITLE_LABEL _("Remove service")
+#define BOOTLOADER_USER_EXIST_LABEL(target) yon_char_unite(_("User")," <b>", target,"</b> ", _("is already exists. Do you really want to save user")," <b>",target,"</b>?",NULL)
+#define GRUB_PASSWORD(target) yon_char_unite("GRUB_PASSWORD[",target,"]",NULL)
+
+#define WRONG_IP_LABEL _("Ip adress is incorrect")
+
+#define ENABLED_KERNEL_MISSING_LABEL _("No kernel was enabled")

ubinstall-gtk-advanced-box.glade

@@ -0,0 +1,415 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.38.2 -->
+<interface domain="ubinstall-gtk">
+  <requires lib="gtk+" version="3.24"/>
+  <!-- interface-css-provider-path ubinstall-gtk.css -->
+  <object class="GtkImage" id="image1">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="icon-name">com.ublinux.libublsettingsui-gtk3.trash-symbolic</property>
+  </object>
+  <object class="GtkImage" id="image2">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="stock">gtk-missing-image</property>
+  </object>
+  <object class="GtkImage" id="image3">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="stock">gtk-missing-image</property>
+  </object>
+  <object class="GtkImage" id="image4">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="icon-name">com.ublinux.libublsettingsui-gtk3.edit-symbolic</property>
+  </object>
+  <object class="GtkBox" id="MainBox">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="orientation">vertical</property>
+    <child>
+      <object class="GtkBox">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <property name="margin-start">5</property>
+        <property name="margin-end">5</property>
+        <property name="margin-top">5</property>
+        <property name="margin-bottom">5</property>
+        <property name="orientation">vertical</property>
+        <property name="spacing">5</property>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="spacing">5</property>
+            <child>
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">New section at</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel" id="SectionLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">/dev/sdb</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="RemoveButton">
+                <property name="visible">True</property>
+                <property name="can-focus">True</property>
+                <property name="receives-default">True</property>
+                <property name="image">image1</property>
+                <style>
+                  <class name="thin"/>
+                </style>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="pack-type">end</property>
+                <property name="position">2</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkToggleButton" id="UserDataSectionToggle">
+                <property name="label" translatable="yes">"/ublinux-data/" user data section</property>
+                <property name="visible">True</property>
+                <property name="can-focus">True</property>
+                <property name="receives-default">True</property>
+                <property name="image">image2</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="pack-type">end</property>
+                <property name="position">3</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkToggleButton" id="SystemSectionToggle">
+                <property name="label" translatable="yes">"/ublinux/" system section</property>
+                <property name="visible">True</property>
+                <property name="can-focus">True</property>
+                <property name="receives-default">True</property>
+                <property name="image">image3</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="pack-type">end</property>
+                <property name="position">5</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="spacing">5</property>
+            <child>
+              <object class="GtkSwitch" id="FormatSwitch">
+                <property name="visible">True</property>
+                <property name="can-focus">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">Format</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkRevealer" id="FormatRevealer">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="orientation">vertical</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkSeparator">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="spacing">5</property>
+                    <child>
+                      <object class="GtkLabel" id="label1">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">Size:</property>
+                        <property name="xalign">0</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkSpinButton" id="SizeSpin">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkComboBoxText" id="SizeCombo">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <items>
+                          <item id="M" translatable="yes">Mb</item>
+                          <item id="G" translatable="yes">Gb</item>
+                          <item id="T" translatable="yes">Tb</item>
+                        </items>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">2</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkLabel" id="label3">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">Part label:</property>
+                        <property name="xalign">0</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">3</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="SectionMarkEntry">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">4</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">File system type:</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">5</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkComboBoxText" id="FileSystemTypeCombo">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <items>
+                          <item translatable="yes">Default</item>
+                        </items>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">6</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="spacing">5</property>
+                    <child>
+                      <object class="GtkLabel" id="label2">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">File system label:</property>
+                        <property name="xalign">0</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="FileSystemMarkentry">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkLabel" id="label4">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">Encryption:</property>
+                        <property name="xalign">0</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">2</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkComboBoxText" id="EncryptionCombo">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <items>
+                          <item translatable="yes">Off</item>
+                        </items>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">3</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">Encryption password:</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">4</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="EncryptionEntry">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">5</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkButton" id="EncryptionButton">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="receives-default">True</property>
+                        <property name="image">image4</property>
+                        <style>
+                          <class name="thin"/>
+                        </style>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">6</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
+              </object>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">2</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">True</property>
+        <property name="fill">True</property>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <style>
+      <class name="bggrey"/>
+    </style>
+  </object>
+  <object class="GtkSizeGroup">
+    <widgets>
+      <widget name="label1"/>
+      <widget name="label2"/>
+    </widgets>
+  </object>
+  <object class="GtkSizeGroup">
+    <widgets>
+      <widget name="label3"/>
+      <widget name="label4"/>
+    </widgets>
+  </object>
+</interface>

ubinstall-gtk-bootloader-user.glade

@@ -0,0 +1,222 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.38.2 -->
+<interface domain="ubinstall-gtk">
+  <requires lib="gtk+" version="3.24"/>
+  <!-- interface-css-provider-path ubinstall-gtk.css -->
+  <object class="GtkImage" id="image1">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="icon-name">com.ublinux.libublsettingsui-gtk3.edit-symbolic</property>
+  </object>
+  <object class="GtkImage" id="image4">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="icon-name">com.ublinux.libublsettingsui-gtk3.cancel-symbolic</property>
+  </object>
+  <object class="GtkImage" id="image5">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="icon-name">com.ublinux.libublsettingsui-gtk3.accept-symbolic</property>
+  </object>
+  <object class="GtkWindow" id="MainWindow">
+    <property name="width-request">450</property>
+    <property name="height-request">250</property>
+    <property name="can-focus">False</property>
+    <property name="resizable">False</property>
+    <property name="modal">True</property>
+    <property name="default-width">450</property>
+    <property name="icon-name">com.ublinux.ubl-settings-usergroups</property>
+    <child>
+      <object class="GtkBox">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <property name="margin-bottom">5</property>
+        <property name="orientation">vertical</property>
+        <property name="spacing">5</property>
+        <child>
+          <object class="GtkBox" id="StatusBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="orientation">vertical</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="margin-start">5</property>
+            <property name="margin-end">5</property>
+            <property name="orientation">vertical</property>
+            <property name="spacing">5</property>
+            <child>
+              <object class="GtkCheckButton" id="AdminCheck">
+                <property name="label" translatable="yes">Administrator</property>
+                <property name="visible">True</property>
+                <property name="can-focus">True</property>
+                <property name="receives-default">False</property>
+                <property name="draw-indicator">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkLabel" id="label1">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="label" translatable="yes">User name:</property>
+                    <property name="xalign">0</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkEntry" id="UsernameEntry">
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkLabel" id="label2">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="label" translatable="yes">User password:</property>
+                    <property name="xalign">0</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkEntry" id="PasswordEntry">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="visibility">False</property>
+                    <property name="invisible-char">*</property>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="PasswordButton">
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">True</property>
+                    <property name="image">image1</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">2</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <child type="titlebar">
+      <object class="GtkHeaderBar">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <child type="title">
+          <object class="GtkLabel" id="TitleLabel">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="label" translatable="yes">Add user</property>
+            <attributes>
+              <attribute name="weight" value="bold"/>
+            </attributes>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="CancelButton">
+            <property name="label" translatable="yes">Cancel</property>
+            <property name="visible">True</property>
+            <property name="can-focus">True</property>
+            <property name="receives-default">True</property>
+            <property name="image">image4</property>
+            <style>
+              <class name="button"/>
+              <class name="marginright"/>
+            </style>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="AcceptButton">
+            <property name="label" translatable="yes">Accept</property>
+            <property name="visible">True</property>
+            <property name="can-focus">True</property>
+            <property name="receives-default">True</property>
+            <property name="image">image5</property>
+            <style>
+              <class name="button"/>
+              <class name="marginright"/>
+            </style>
+          </object>
+          <packing>
+            <property name="pack-type">end</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+  </object>
+  <object class="GtkSizeGroup">
+    <widgets>
+      <widget name="label1"/>
+      <widget name="label2"/>
+    </widgets>
+  </object>
+</interface>

ubinstall-gtk-kernel-row.glade

@@ -0,0 +1,185 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.38.2 -->
+<interface domain="ubinstall-gtk">
+  <requires lib="gtk+" version="3.24"/>
+  <!-- interface-css-provider-path ubinstall-gtk.css -->
+  <object class="GtkBox" id="TableRow">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="margin-top">1</property>
+    <property name="orientation">vertical</property>
+    <child>
+      <object class="GtkBox">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <property name="margin-bottom">5</property>
+        <property name="spacing">7</property>
+        <child>
+          <object class="GtkCheckButton" id="InstallCheck">
+            <property name="visible">True</property>
+            <property name="can-focus">True</property>
+            <property name="receives-default">False</property>
+            <property name="margin-top">5</property>
+            <property name="draw-indicator">True</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkSeparator">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkRadioButton" id="EnableRadio">
+            <property name="visible">True</property>
+            <property name="sensitive">False</property>
+            <property name="can-focus">True</property>
+            <property name="receives-default">False</property>
+            <property name="halign">center</property>
+            <property name="margin-top">5</property>
+            <property name="draw-indicator">True</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">2</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkSeparator" id="EnableSeparator">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">3</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLabel" id="NameLabel">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="label" translatable="yes">Name</property>
+            <property name="use-markup">True</property>
+            <property name="track-visited-links">False</property>
+            <property name="xalign">0</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">4</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkSeparator">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">5</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox" id="TagsBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="valign">start</property>
+            <property name="margin-top">5</property>
+            <property name="margin-bottom">5</property>
+            <property name="orientation">vertical</property>
+            <property name="spacing">2</property>
+            <property name="homogeneous">True</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">6</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkSeparator" id="TagsSeparator">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">7</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLabel" id="ModulesLabel">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="margin-top">5</property>
+            <property name="label" translatable="yes">label</property>
+            <property name="xalign">0</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">8</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLabel" id="DescriptionLabel">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="margin-top">5</property>
+            <property name="xalign">0</property>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="pack-type">end</property>
+            <property name="position">9</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkSeparator">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">10</property>
+          </packing>
+        </child>
+        <style>
+          <class name="selection"/>
+        </style>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="fill">True</property>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <style>
+      <class name="tableborderbottom"/>
+    </style>
+  </object>
+</interface>

ubinstall-gtk-menu-item.glade

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.38.2 -->
+<interface domain="ubl-settings-bootloader">
+  <requires lib="gtk+" version="3.24"/>
+  <!-- interface-css-provider-path ubl-settings-bootloader.css -->
+  <object class="GtkBox" id="MenuItemBox">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <child>
+      <object class="GtkButton" id="MenuButton">
+        <property name="visible">True</property>
+        <property name="can-focus">True</property>
+        <property name="receives-default">True</property>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="spacing">5</property>
+            <child>
+              <object class="GtkLabel" id="MenuTextLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">label</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkMenuButton" id="NextIconButton">
+                <property name="visible">True</property>
+                <property name="can-focus">True</property>
+                <property name="focus-on-click">False</property>
+                <property name="receives-default">True</property>
+                <property name="popup">menu1</property>
+                <property name="direction">right</property>
+                <child>
+                  <placeholder/>
+                </child>
+                <style>
+                  <class name="thin"/>
+                  <class name="noborder"/>
+                  <class name="nobackground"/>
+                </style>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="pack-type">end</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+        </child>
+        <style>
+          <class name="noborder"/>
+          <class name="menunoborder"/>
+        </style>
+      </object>
+      <packing>
+        <property name="expand">True</property>
+        <property name="fill">True</property>
+        <property name="position">0</property>
+      </packing>
+    </child>
+  </object>
+  <object class="GtkMenu" id="menu1">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+  </object>
+</interface>

ubinstall-gtk-menu.glade

@@ -0,0 +1,203 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.38.2 -->
+<interface domain="ubl-settings-bootloader">
+  <requires lib="gtk+" version="3.24"/>
+  <!-- interface-css-provider-path ubl-settings-bootloader.css -->
+  <object class="GtkWindow" id="MainWindow">
+    <property name="width-request">450</property>
+    <property name="height-request">250</property>
+    <property name="can-focus">False</property>
+    <property name="resizable">False</property>
+    <property name="modal">True</property>
+    <property name="default-width">450</property>
+    <property name="icon-name">com.ublinux.ubl-settings-bootloader</property>
+    <property name="skip-taskbar-hint">True</property>
+    <property name="skip-pager-hint">True</property>
+    <property name="decorated">False</property>
+    <child>
+      <object class="GtkFrame">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <property name="label-xalign">0</property>
+        <property name="shadow-type">in</property>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="margin-start">5</property>
+            <property name="margin-end">5</property>
+            <property name="margin-top">5</property>
+            <property name="margin-bottom">5</property>
+            <child>
+              <object class="GtkRevealer" id="ItemsRevealer">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="transition-type">none</property>
+                <property name="reveal-child">True</property>
+                <child>
+                  <object class="GtkScrolledWindow">
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="hscrollbar-policy">never</property>
+                    <property name="min-content-height">50</property>
+                    <property name="max-content-height">200</property>
+                    <child>
+                      <object class="GtkViewport">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <child>
+                          <object class="GtkListBox" id="ItemsListBox">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="selection-mode">none</property>
+                            <child type="placeholder">
+                              <object class="GtkLabel">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="label" translatable="yes">OS options were not found</property>
+                                <style>
+                                  <class name="workingbg"/>
+                                </style>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+                <style>
+                  <class name="workingbg"/>
+                </style>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkRevealer" id="ChildrenRevealer">
+                <property name="can-focus">False</property>
+                <property name="transition-type">none</property>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="orientation">vertical</property>
+                    <property name="spacing">5</property>
+                    <child>
+                      <object class="GtkButton" id="BackButton">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="receives-default">True</property>
+                        <child>
+                          <object class="GtkBox">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="spacing">5</property>
+                            <child>
+                              <object class="GtkMenuButton" id="NextIconButton">
+                                <property name="visible">True</property>
+                                <property name="can-focus">True</property>
+                                <property name="focus-on-click">False</property>
+                                <property name="receives-default">True</property>
+                                <property name="direction">left</property>
+                                <child>
+                                  <placeholder/>
+                                </child>
+                                <style>
+                                  <class name="thin"/>
+                                  <class name="noborder"/>
+                                  <class name="nobackground"/>
+                                </style>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkLabel" id="MenuTextLabel">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="label" translatable="yes">Back</property>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                          </object>
+                        </child>
+                        <style>
+                          <class name="noborder"/>
+                          <class name="menunoborder"/>
+                        </style>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkScrolledWindow">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="hscrollbar-policy">never</property>
+                        <property name="min-content-height">50</property>
+                        <property name="max-content-height">175</property>
+                        <child>
+                          <object class="GtkViewport">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <child>
+                              <object class="GtkListBox" id="ChildrenListBox">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="selection-mode">none</property>
+                                <child type="placeholder">
+                                  <object class="GtkLabel">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="label" translatable="yes">Children options were not found</property>
+                                  </object>
+                                </child>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">True</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                  </object>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <style>
+              <class name="workingbg"/>
+            </style>
+          </object>
+        </child>
+        <child type="label_item">
+          <placeholder/>
+        </child>
+      </object>
+    </child>
+    <style>
+      <class name="workingbg"/>
+    </style>
+  </object>
+</interface>

ubinstall-gtk-network-box.glade

@@ -0,0 +1,347 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.40.0 -->
+<interface domain="ubinstall-gtk">
+  <requires lib="gtk+" version="3.24"/>
+  <!-- interface-css-provider-path ubinstall-gtk.css -->
+  <object class="GtkImage" id="image1">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="icon-name">com.ublinux.libublsettingsui-gtk3.trash-symbolic</property>
+  </object>
+  <object class="GtkBox" id="MainBox">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="orientation">vertical</property>
+    <child>
+      <object class="GtkBox">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <property name="margin-start">5</property>
+        <property name="margin-end">5</property>
+        <property name="margin-top">5</property>
+        <property name="margin-bottom">5</property>
+        <property name="orientation">vertical</property>
+        <property name="spacing">5</property>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="spacing">5</property>
+            <child>
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">Connection type:</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkComboBoxText" id="TypeCombo">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="active">0</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkComboBoxText" id="ConnectionCombo">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="active">0</property>
+                <property name="has-entry">True</property>
+                <items>
+                  <item translatable="yes">Default</item>
+                </items>
+                <child internal-child="entry">
+                  <object class="GtkEntry" id="ConnectionEntry">
+                    <property name="can-focus">True</property>
+                    <property name="text" translatable="yes">Default</property>
+                  </object>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">2</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">Enabled:</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">3</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkSwitch" id="EnabledSwitch">
+                <property name="visible">True</property>
+                <property name="can-focus">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">4</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="RemoveButton">
+                <property name="visible">True</property>
+                <property name="can-focus">True</property>
+                <property name="receives-default">True</property>
+                <property name="image">image1</property>
+                <style>
+                  <class name="thin"/>
+                </style>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="pack-type">end</property>
+                <property name="position">5</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="spacing">5</property>
+            <child>
+              <object class="GtkSwitch" id="AutoGetIPSwitch">
+                <property name="visible">True</property>
+                <property name="can-focus">True</property>
+                <property name="active">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">Automatically get IP adress with DHCP</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkSeparator">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">2</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkRevealer" id="IpRevealer">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="orientation">vertical</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkSeparator">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="spacing">5</property>
+                    <child>
+                      <object class="GtkLabel" id="label1">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">IP adress:</property>
+                        <property name="xalign">0</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="IpAdressEntry">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="placeholder-text" translatable="yes">192.168.0.1</property>
+                      </object>
+                      <packing>
+                        <property name="expand">True</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkLabel" id="label3">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">Gateway:</property>
+                        <property name="xalign">0</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">2</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="GatewayEntry">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="placeholder-text" translatable="yes">192.168.0.254</property>
+                      </object>
+                      <packing>
+                        <property name="expand">True</property>
+                        <property name="fill">True</property>
+                        <property name="position">3</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="spacing">5</property>
+                    <child>
+                      <object class="GtkLabel" id="label2">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">Mask:</property>
+                        <property name="xalign">0</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="MaskEntry">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="placeholder-text" translatable="yes">24</property>
+                      </object>
+                      <packing>
+                        <property name="expand">True</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkLabel" id="label4">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">DNS-server:</property>
+                        <property name="xalign">0</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">2</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="DNSEntry">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="placeholder-text" translatable="yes">192.168.0.254</property>
+                      </object>
+                      <packing>
+                        <property name="expand">True</property>
+                        <property name="fill">True</property>
+                        <property name="position">3</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
+              </object>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">3</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">True</property>
+        <property name="fill">True</property>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <style>
+      <class name="bggrey"/>
+    </style>
+  </object>
+  <object class="GtkSizeGroup">
+    <widgets>
+      <widget name="label1"/>
+      <widget name="label2"/>
+    </widgets>
+  </object>
+  <object class="GtkSizeGroup">
+    <widgets>
+      <widget name="label3"/>
+      <widget name="label4"/>
+    </widgets>
+  </object>
+</interface>

ubinstall-gtk-os-row.glade

@@ -0,0 +1,135 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.38.2 -->
+<interface domain="ubinstall-gtk">
+  <requires lib="gtk+" version="3.24"/>
+  <!-- interface-css-provider-path ubinstall-gtk.css -->
+  <object class="GtkBox" id="TableRow">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="spacing">11</property>
+    <child>
+      <object class="GtkCheckButton" id="InstallCheck">
+        <property name="visible">True</property>
+        <property name="can-focus">True</property>
+        <property name="receives-default">False</property>
+        <property name="draw-indicator">True</property>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="fill">True</property>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkBox">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <property name="margin-top">1</property>
+        <property name="orientation">vertical</property>
+        <property name="spacing">1</property>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="spacing">7</property>
+            <child>
+              <object class="GtkLabel" id="NameLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">Name</property>
+                <property name="width-chars">0</property>
+                <property name="track-visited-links">False</property>
+                <property name="xalign">0</property>
+                <attributes>
+                  <attribute name="weight" value="bold"/>
+                </attributes>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel" id="VersionLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">Version</property>
+                <property name="use-markup">True</property>
+                <property name="width-chars">15</property>
+                <property name="track-visited-links">False</property>
+                <property name="xalign">0</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox" id="TagsBox">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="valign">start</property>
+                <property name="margin-top">3</property>
+                <property name="margin-bottom">5</property>
+                <property name="spacing">2</property>
+                <child>
+                  <placeholder/>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">6</property>
+              </packing>
+            </child>
+            <style>
+              <class name="selection"/>
+            </style>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLabel" id="DescriptionLabel">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="margin-bottom">2</property>
+            <property name="label" translatable="yes">Description</property>
+            <property name="xalign">0</property>
+            <property name="yalign">0</property>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="pack-type">end</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkSeparator">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">2</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">True</property>
+        <property name="fill">True</property>
+        <property name="position">1</property>
+      </packing>
+    </child>
+    <style>
+      <class name="tableborderbottom"/>
+    </style>
+  </object>
+</interface>

ubinstall-gtk-service-window.glade

@@ -0,0 +1,219 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.38.2 -->
+<interface domain="ubinstall-gtk">
+  <requires lib="gtk+" version="3.24"/>
+  <!-- interface-css-provider-path ubinstall-gtk.css -->
+  <object class="GtkImage" id="image1">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="icon-name">com.ublinux.libublsettingsui-gtk3.cancel-symbolic</property>
+  </object>
+  <object class="GtkImage" id="image2">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="icon-name">com.ublinux.libublsettingsui-gtk3.accept-symbolic</property>
+  </object>
+  <object class="GtkWindow" id="MainWindow">
+    <property name="width-request">500</property>
+    <property name="height-request">250</property>
+    <property name="can-focus">False</property>
+    <property name="modal">True</property>
+    <child>
+      <object class="GtkBox">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkBox" id="StatusBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="orientation">vertical</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="margin-start">5</property>
+            <property name="margin-end">5</property>
+            <property name="margin-top">5</property>
+            <property name="margin-bottom">5</property>
+            <property name="orientation">vertical</property>
+            <property name="spacing">5</property>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkLabel" id="label3">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="label" translatable="yes">Unit:</property>
+                    <property name="xalign">0</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkEntry" id="UnitEntry">
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkLabel" id="label2">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="label" translatable="yes">Service:</property>
+                    <property name="xalign">0</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkEntry" id="ServiceEntry">
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkLabel" id="label1">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="label" translatable="yes">Description:</property>
+                    <property name="xalign">0</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkEntry" id="DescriptionEntry">
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">2</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <child type="titlebar">
+      <object class="GtkHeaderBar">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <child type="title">
+          <object class="GtkLabel" id="headerTopic">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="margin-left">5</property>
+            <property name="margin-right">5</property>
+            <property name="margin-start">5</property>
+            <property name="margin-end">5</property>
+            <property name="margin-bottom">2</property>
+            <property name="label" translatable="yes">UBLinux installation</property>
+            <attributes>
+              <attribute name="weight" value="bold"/>
+            </attributes>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="CancelButton">
+            <property name="label" translatable="yes">Cancel</property>
+            <property name="visible">True</property>
+            <property name="can-focus">True</property>
+            <property name="receives-default">True</property>
+            <property name="image">image1</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="AcceptButton">
+            <property name="label" translatable="yes">Accept</property>
+            <property name="visible">True</property>
+            <property name="can-focus">True</property>
+            <property name="receives-default">True</property>
+            <property name="image">image2</property>
+          </object>
+          <packing>
+            <property name="pack-type">end</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+  </object>
+  <object class="GtkSizeGroup">
+    <widgets>
+      <widget name="label1"/>
+      <widget name="label2"/>
+      <widget name="label3"/>
+    </widgets>
+  </object>
+</interface>

ubinstall-gtk-user.glade

@@ -0,0 +1,219 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.40.0 -->
+<interface domain="ubinstall-gtk">
+  <requires lib="gtk+" version="3.24"/>
+  <!-- interface-css-provider-path ubinstall-gtk.css -->
+  <object class="GtkImage" id="image1">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="icon-name">com.ublinux.libublsettingsui-gtk3.trash-symbolic</property>
+  </object>
+  <object class="GtkImage" id="image22">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="icon-name">com.ublinux.libublsettingsui-gtk3.edit-symbolic</property>
+  </object>
+  <object class="GtkBox" id="MainBox">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="orientation">vertical</property>
+    <child>
+      <object class="GtkBox">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <property name="margin-left">5</property>
+        <property name="margin-right">5</property>
+        <property name="margin-start">5</property>
+        <property name="margin-end">5</property>
+        <property name="margin-top">5</property>
+        <property name="margin-bottom">5</property>
+        <property name="orientation">vertical</property>
+        <property name="spacing">5</property>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="orientation">vertical</property>
+            <property name="spacing">5</property>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="label" translatable="yes">Account name:</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkEntry" id="UsernameEntry">
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="placeholder-text" translatable="yes">Administrator</property>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="RemoveButton">
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">True</property>
+                    <property name="image">image1</property>
+                    <style>
+                      <class name="thin"/>
+                    </style>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">3</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="label" translatable="yes">Login:</property>
+                    <property name="xalign">0</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkEntry" id="LoginEntry">
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="placeholder-text" translatable="yes">superadmin</property>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="label" translatable="yes">Password:</property>
+                    <property name="xalign">0</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkComboBoxText" id="PasswordCombo">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="active">0</property>
+                    <items>
+                      <item translatable="yes">Default</item>
+                      <item translatable="yes">Set a password</item>
+                    </items>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkEntry" id="PasswordEntry">
+                    <property name="visible">True</property>
+                    <property name="sensitive">False</property>
+                    <property name="can-focus">False</property>
+                    <property name="visibility">False</property>
+                    <property name="invisible-char">●</property>
+                    <property name="placeholder-text" translatable="yes">ublinux</property>
+                    <property name="input-purpose">password</property>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="PasswordButton">
+                    <property name="visible">True</property>
+                    <property name="sensitive">False</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">True</property>
+                    <property name="image">image22</property>
+                    <style>
+                      <class name="thin"/>
+                    </style>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">3</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">2</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="fill">True</property>
+        <property name="position">2</property>
+      </packing>
+    </child>
+    <style>
+      <class name="bggrey"/>
+    </style>
+  </object>
+</interface>

ubinstall-gtk.css

@@ -5,6 +5,11 @@
 .noborder {
 	border:none;
 }
+.borders *{
+	border-width:0.5px;
+	border-style: solid;
+	
+}
 .nobackground {
 background:transparent;
 }
@@ -16,6 +21,14 @@ background:transparent;
 	color: @theme_text_color;
 }
 
+.bggrey{
+	border-radius:5px;
+	border-color:@theme_text_color;
+	border-style:solid;
+	border-width:0.3px;
+	box-shadow: 1px 1px 2px rgba(0, 0, 0, 0.15);
+}
+
 .inherited>* {
 	border:none;
 	background:inherit;
@@ -218,3 +231,87 @@ treeview row:nth-child(even) { background-color: #ffffff; }
 .menubox *{
 	color:@theme_base_color;
 }
+.bggrey{
+	border-radius:5px;
+	border-color:@theme_text_color;
+	border-style:solid;
+	border-width:0.3px;
+	box-shadow: 1px 1px 2px rgba(0, 0, 0, 0.15);
+}
+
+.tag_red{
+	border-radius: 2px;
+	border-width: 0.5px;
+	border-style: solid;
+	padding:2px 5px;
+	color:#660000;
+	border-color: #cf2a27;
+
+	background-color:#ea9999
+}
+.tag_blue{
+	border-radius: 2px;
+	border-width: 0.5px;
+	border-style: solid;
+	padding:2px 5px;
+	color:#073763;
+	border-color: #2b78e4;
+
+	background-color:#9fc5f8
+}
+.tag_purple{
+	border-radius: 2px;
+	border-width: 0.5px;
+	border-style: solid;
+	padding:2px 5px;
+	color:#073763;
+	border-color: #9900ff;
+
+	background-color:#b4a7d6
+}
+.tag_orange{
+	border-radius: 2px;
+	border-width: 0.5px;
+	border-style: solid;
+	padding:2px 5px;
+	color:#783f04;
+	border-color: #ff9900;
+
+	background-color:#f9cb9c
+}
+.tag_yellow{
+	border-radius: 2px;
+	border-width: 0.5px;
+	border-style: solid;
+	padding:2px 5px;
+	color:#7f6000;
+	border-color: #bf9000;
+
+	background-color:#ffe599
+}
+.tag_green{
+	border-radius: 2px;
+	border-width: 0.5px;
+	border-style: solid;
+	padding:2px 5px;
+	border-color: #009e0f;
+	background-color:#b6d7a8;
+	color:#274e13;
+}
+.tag_grey{
+	border-radius: 2px;
+	border-width: 0.5px;
+	border-style: solid;
+	padding:2px 5px;
+	color:#5f5f5f;
+	border-color: #777777;
+
+	background-color:#999999
+}
+
+.tableborderbottom {
+	border-bottom:0.5px;
+	border-style: solid;
+	border-color: @theme_fg_color;
+
+}