#include "ubl-settings-repomanager.h"

config main_config;

void on_repo_signed(){

}

void on_repo_removed(GtkWidget *self,storage_config_window *window){
    GList *list = gtk_container_get_children(GTK_CONTAINER(gtk_widget_get_parent(self)));
    char *repo = (char*)gtk_entry_get_text(GTK_ENTRY(g_list_nth_data(list,0)));
    GtkTreeIter iter, itar;
    char *storage;
    char *id = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
    if (!yon_char_is_empty(id)){
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&iter,id);
        int valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(window->storages_copy),&itar,&iter);
        for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->storages_copy),&itar)){
            char *target;
            gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&itar,2,&target,-1);
            if (!strcmp(target,repo)){
                gtk_tree_store_remove(window->storages_copy,&itar);
                break;
            }
        }
    }
    yon_storage_config_update(window);
}

void on_repo_sign_changed(GtkWidget *self, storage_config_window *window){
    GList *list = gtk_container_get_children(GTK_CONTAINER(gtk_widget_get_parent(self)));
    const char *sign = gtk_combo_box_get_active_id(GTK_COMBO_BOX(g_list_nth_data(list,2)));
    char *target_repo = (char*)gtk_entry_get_text(GTK_ENTRY(g_list_nth_data(list,0)));
    const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
    if (!yon_char_is_empty(id)){
        GtkTreeIter iter,itar;
        int size;
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&iter,id);
        char *storage_path;
        gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&iter,3,&storage_path,-1);
        config_str repos = yon_tree_store_get_all_at_level(window->storages_copy,&iter,&size,2,2);
        int found = yon_char_parsed_check_exist(repos,size,target_repo);
        if (found>-1){
            char *child_id = yon_char_unite((char*)id,":",yon_char_from_int(found),NULL);
            if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&itar,child_id)){
                if (!yon_char_is_empty(sign)){
                    gtk_tree_store_set(window->storages_copy,&itar,6,1,5,sign,-1);
                    if (system(yon_debug_output("%s\n",yon_sign_repo(storage_path,target_repo,sign)))){
                        gtk_combo_box_set_active(GTK_COMBO_BOX((GtkWidget*)g_list_nth_data(list,2)),0);
                        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),REPO_SIGN_ERROR_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
                    }
                }else
                    gtk_tree_store_set(window->storages_copy,&itar,6,-1,5,NULL,-1);
            }
        }
    }
}

void yon_storage_config_update(storage_config_window *window){  
    GList *children = gtk_container_get_children(GTK_CONTAINER(window->ReposBox));
    for (int i=0;i<g_list_length(children);i++){
        gtk_widget_destroy((GtkWidget*)g_list_nth_data(children,i));
    }
    GtkTreeIter iter,itar;
    const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StoragePathCombo));
    if (id){
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->storages_copy),&iter,id);
        if (gtk_tree_model_iter_children(GTK_TREE_MODEL(window->storages_copy),&itar,&iter)){
            int valid = 1;
            for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->storages_copy),&itar)){
                char *repo;
                gtk_tree_model_get(GTK_TREE_MODEL(window->storages_copy),&itar,2,&repo,-1);
                GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_repo_block);
                GtkWidget *box = yon_gtk_builder_get_widget(builder,"MainBox");
                gtk_box_pack_start(GTK_BOX(window->ReposBox),box,0,0,0);
                yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(gtk_builder_get_object(builder,"SignatureCombo")));
                gtk_combo_box_set_active(GTK_COMBO_BOX(gtk_builder_get_object(builder,"SignatureCombo")),0);
                g_signal_connect(gtk_builder_get_object(builder,"SignatureButton"),"clicked",G_CALLBACK(on_repo_signed),window);
                g_signal_connect(gtk_builder_get_object(builder,"RepoRemoveButton"),"clicked",G_CALLBACK(on_repo_removed),window);
                gtk_entry_set_text(GTK_ENTRY(gtk_builder_get_object(builder,"RepoNameEntry")),repo);
                char *storage = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->StoragePathCombo));
                int sign_size;
                char *command = yon_repo_get_signature(storage,repo);
                yon_debug_output("%s\n",command);
                config_str sign = yon_config_load(command,&sign_size);
                if (sign_size>0){
                    yon_char_remove_last_symbol(sign[2],'\n');
                    char *mail = strstr(sign[2],"\"");
                    if (!yon_char_is_empty(mail)){
                        char *email = yon_char_new(mail);
                        yon_char_remove_brackets(email);
                        gtk_combo_box_set_active_id(GTK_COMBO_BOX(gtk_builder_get_object(builder,"SignatureCombo")),email);
                        free(email);
                    }
                    yon_char_parsed_free(sign,sign_size);
                }
                g_signal_connect(gtk_builder_get_object(builder,"SignatureButton"),"clicked",G_CALLBACK(on_repo_sign_changed),window);
            }
        }
    }
}

// filechooser window section

void on_file_chooser_entry_changed(GtkEntry *self, file_chooser_window *window){
    const char *text = gtk_entry_get_text(self);
    GtkFileFilter *filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(window->FileChooserWidget));
    gtk_file_chooser_remove_filter(GTK_FILE_CHOOSER(window->FileChooserWidget),filter);
    filter = gtk_file_filter_new();
    char *pattern = !yon_char_is_empty(text)?yon_char_unite("*",text,"*.pkg.tar*[^.sig]",NULL) : "*.pkg.tar*[^.sig]";
    gtk_file_filter_add_pattern(filter,pattern);
    gtk_file_filter_set_name(filter,"*.pkg.tar*");
    gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(window->FileChooserWidget),filter);
    if (!yon_char_is_empty(text)) free(pattern);
}

void on_file_chooser_file_activate(GtkFileChooser *self, repo_add_window *window){
    GtkTreeIter iter;
    GSList *list = gtk_file_chooser_get_filenames(self);
    if (list){
        for (int i=0;i<g_slist_length(list);i++){
            char *path = g_slist_nth_data(list,i);
            char *filename = yon_char_new(path);
            free(yon_char_divide(filename,yon_char_find_last(filename,'/')));
            gtk_list_store_append(window->PackagesList,&iter);
            gtk_list_store_set(window->PackagesList,&iter,1,filename,2,path,-1);
            free(filename);
        }
        g_slist_free(list);
    }
    gtk_widget_destroy(gtk_widget_get_toplevel(GTK_WIDGET(self)));
}

file_chooser_window *yon_file_chooser_new(){
    file_chooser_window *window = malloc(sizeof(file_chooser_window));
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_filechooser);
    window->Window = yon_gtk_builder_get_widget(builder,"Window");
    window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
    window->HeadLabel = yon_gtk_builder_get_widget(builder,"webHeaderNameLabel2");
    window->ChooseButton = yon_gtk_builder_get_widget(builder,"ChooseButton");
    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
    window->NameEntry = yon_gtk_builder_get_widget(builder,"NameEntry");
    window->FileChooserWidget = yon_gtk_builder_get_widget(builder,"FileChooserWidget");
    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
    g_signal_connect(G_OBJECT(window->NameEntry),"changed",G_CALLBACK(on_file_chooser_entry_changed),window);

    return window;
}

// main window 
void on_add_clicked(GtkWidget *self, main_window *widgets){
    repo_add_window *window = yon_repo_add_window_new();
    yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->Window),ADD_PACKAGES_TITLE_LABEL,icon_path,"add-repo-window");
    gtk_label_set_text(GTK_LABEL(window->HeadLabel),ADD_PACKAGES_TITLE_LABEL);
    GtkTreeIter iter;
    for_iter (window->tree_copy,&iter){
        char *current;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&current,-1);
        if (!yon_char_is_empty(current)){
            char *path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&iter);
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->StorageCombo),path,current);
        }
    }
    

    yon_sign_list_update();
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->RepoSignCombo));
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->PackageSignCombo));

    gtk_combo_box_set_active(GTK_COMBO_BOX(window->RepoSignCombo),0);
    gtk_combo_box_set_active(GTK_COMBO_BOX(window->PackageSignCombo),0);

    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->StorageCombo),"changed",G_CALLBACK(on_add_target_repo_selection_changed),window);
    g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_add_target_arch_selection_changed),window);
    g_signal_connect(G_OBJECT(window->ArchitectureCombo),"changed",G_CALLBACK(on_arch_chosen),window);
    g_signal_connect(G_OBJECT(window->ArchitectureCombo),"changed",G_CALLBACK(on_add_target_package_selection_changed),window);
    g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_add_packages_accept),dict);
    g_signal_connect(G_OBJECT(window->AddPackageButton),"clicked",G_CALLBACK(on_add_package),window);
    g_signal_connect(G_OBJECT(window->RemoveButton),"clicked",G_CALLBACK(on_remove_package),window);
    g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_repo_sign_load),window);
    yon_add_window_set_selected(widgets,window);
    GtkTreeModel *model;
    GList *list = NULL;
    char *full_path;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),NULL,&iter)){
        gtk_tree_model_get(GTK_TREE_MODEL(widgets->RepoList),&iter,3,&full_path,-1);
        if (list = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoPackagesTree)),&model)){
            for (int i=0; i<g_list_length(list);i++){
                GtkTreeIter itar;
                char *path;
                gtk_tree_model_get_iter(model, &iter,g_list_nth_data(list,i));
                gtk_tree_model_get(model,&iter,1,&path,-1);
                gtk_list_store_append(window->PackagesList,&itar);
                char *temp = yon_char_unite(full_path,"/",path,NULL);
                free(full_path);
                full_path = temp;
                gtk_list_store_set(window->PackagesList,&itar,1,path,2,full_path,-1);
            }
        }
    }
    gtk_widget_show(window->MainWindow);
}

void on_folder_changed(GtkFileChooser *self, file_chooser_window *dialog){
    const char *current = gtk_file_chooser_get_current_folder(self);
    if (!strstr(current,dialog->root_path)){
        gtk_file_chooser_set_current_folder(self,dialog->root_path);
    }
}

void on_move_add_accept(GtkWidget *self, dictionary *dict){
    repo_add_window *window = yon_dictionary_get_data(dict->first,repo_add_window*);
    file_chooser_window *dialog = yon_dictionary_get_data(dict->first->next,file_chooser_window*);
    GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog->FileChooserWidget));
    for (int i=0;i<g_slist_length(list);i++){
        char *path = (char*)g_slist_nth_data(list,i);
        if (yon_file_is_directory(path)){
            int size;
            config_str files = yon_file_ls(path,&size);
            for (int k=0;k<size;k++){
                if (strstr(files[k],".pkg.tar")&&!strstr(files[k],".sig")){
                    GtkTreeIter iter;
                    int temp_size;
                    config_str name = yon_config_load(yon_get_package_name_from_filename(files[k]),&temp_size);
                    yon_char_remove_last_symbol(name[0],'\n');
                    gtk_list_store_append(window->PackagesList,&iter);
                    gtk_list_store_set(window->PackagesList,&iter,1,name[0],2,files[k],-1);
                }
            }
        } else {
            GtkTreeIter iter;
            int temp_size;
            config_str name = yon_config_load(yon_get_package_name_from_filename(path),&temp_size);
            if (temp_size<=0){
                yon_ubl_status_box_spawn(GTK_CONTAINER(dialog->StatusBox),PACKAGE_NAME_ERROR_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
                return;
            }
            yon_char_remove_last_symbol(name[0],'\n');
            if (!yon_gtk_tree_model_check_exist(GTK_TREE_MODEL(window->PackagesList),&iter,name[0],1)){
                gtk_list_store_append(window->PackagesList,&iter);
                gtk_list_store_set(window->PackagesList,&iter,1,name[0],2,path,-1);
            } else {
                yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),ALREADY_EXIST_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
            }

        }
    }
    gtk_widget_destroy(dialog->Window);
    free(dialog);
    GtkTreeIter iter;
    if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->tree_copy),&iter)){
        gtk_widget_set_sensitive(window->MoveSourceStorageEntry,0);
        gtk_widget_set_sensitive(window->MoveSourceRepoEntry,0);
        gtk_widget_set_sensitive(window->MoveSourceArchEntry,0);

        gtk_widget_set_sensitive(window->MoveTargetRepoEntry,0);
        gtk_widget_set_sensitive(window->MoveTargetArchEntry,0);

        if (window->StorageCombo&&window->RepositoryCombo&&window->ArchitectureCombo){
            gtk_widget_set_sensitive(window->StorageCombo,0);
            gtk_widget_set_sensitive(window->RepositoryCombo,0);
            gtk_widget_set_sensitive(window->ArchitectureCombo,0);
        }
    }
}

void on_move_add_package(GtkWidget *self, repo_add_window *window){
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->MoveTargetArchEntry))>-1&&gtk_combo_box_get_active(GTK_COMBO_BOX(window->MoveSourceStorageEntry))>-1){
        file_chooser_window *dialog = yon_file_chooser_new();
        yon_gtk_window_setup(GTK_WINDOW(dialog->Window),GTK_WINDOW(window->MainWindow),CHOSE_PACKAGES_TITLE_LABEL,icon_path,"ChooseMoveFileChooserWindow");
        gtk_label_set_text(GTK_LABEL(dialog->HeadLabel),CHOSE_PACKAGES_TITLE_LABEL);
        GtkFileFilter *filter = gtk_file_filter_new();
        gtk_file_filter_add_pattern(filter,"*.pkg.tar*[^.sig]");
        gtk_file_filter_set_name(filter,"*.pkg.tar.*");
        gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog->FileChooserWidget),filter);
        GtkTreeIter iter,itar;
        yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->MoveSourceArchEntry),GTK_TREE_MODEL(window->tree_copy),&iter);
        char *target;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&target,3,&dialog->root_path,-1);
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog->FileChooserWidget),target);

        dictionary *dict = NULL;
        yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
        yon_dictionary_add_or_create_if_exists_with_data(dict,"dialog",dialog);

        g_signal_connect(G_OBJECT(dialog->FileChooserWidget),"current-folder-changed",G_CALLBACK(on_folder_changed),dialog);
        g_signal_connect(G_OBJECT(dialog->ChooseButton),"clicked",G_CALLBACK(on_move_add_accept),dict);
    g_signal_connect(G_OBJECT(dialog->FileChooserWidget),"file-activated",G_CALLBACK(on_file_chooser_file_activate),window);
        gtk_widget_show(dialog->Window);
    }
}

void on_move_remove_package(GtkWidget *self, repo_add_window *window){
    GtkTreeIter iter;
    GtkTreeModel *model;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(window->PackagesTree)),&model,&iter)){
        gtk_list_store_remove(window->PackagesList,&iter);
    }
    if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->PackagesList),&iter)){

        gtk_widget_set_sensitive(window->MoveSourceStorageEntry,1);
        gtk_widget_set_sensitive(window->MoveSourceRepoEntry,1);
        gtk_widget_set_sensitive(window->MoveSourceArchEntry,1);

        gtk_widget_set_sensitive(window->MoveTargetRepoEntry,1);
        if (window->StorageCombo&&window->RepositoryCombo&&window->ArchitectureCombo){
            gtk_widget_set_sensitive(window->StorageCombo,1);
            gtk_widget_set_sensitive(window->RepositoryCombo,1);
            gtk_widget_set_sensitive(window->ArchitectureCombo,1);
        }
    }
}

void on_move_accept(GtkWidget *self, dictionary *dict){
    main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
    repo_add_window *window = yon_dictionary_get_data(dict->first->next,repo_add_window*);

    int size = 0;
    config_str packages = NULL;
    GtkTreeIter iter,itar;
    for_iter(GTK_TREE_MODEL(window->PackagesList),&iter){
        char *target=NULL;
        gtk_tree_model_get(GTK_TREE_MODEL(window->PackagesList),&iter,2,&target,-1);
        if (!yon_char_is_empty(target)){
            free(yon_char_divide(target,yon_char_find_last(target,'/')));
            yon_char_parsed_add_or_create_if_exists(packages,&size,target);
            free(target);
        }
    }
    if (size){
        char *arch = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->MoveSourceArchEntry));
        yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->MoveSourceRepoEntry),GTK_TREE_MODEL(window->tree_copy),&iter);
        yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->MoveTargetRepoEntry),GTK_TREE_MODEL(window->tree_copy),&itar);
        char *source_path, *source_repo, *target_path, *target_repo;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&source_repo,-1);
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itar,3,&target_repo,-1);
        source_path = yon_char_divide(source_repo,yon_char_find_last(source_repo,'/'));
        target_path = yon_char_divide(target_repo,yon_char_find_last(target_repo,'/'));
        char *command = yon_move_packages_command(source_path,arch,source_repo, target_repo, yon_char_parsed_to_string(packages,size," "));
        yon_debug_output("%s\n",command);
        if (!system(command)){
            yon_ubl_status_box_render(PACKAGES_MOVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
            gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),NULL);
                gtk_tree_store_clear(widgets->RepoList);
                yon_gtk_tree_store_copy_full(window->tree_copy,widgets->RepoList);
                gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),GTK_TREE_MODEL(widgets->RepoList));

                const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->ArchitectureCombo));
                if (!yon_char_is_empty(id)){
                    gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(widgets->RepoList),&iter,id);
                    gtk_tree_view_expand_to_path(GTK_TREE_VIEW(widgets->ReposTree),gtk_tree_path_new_from_string(id));
                    gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&iter);
                    on_main_tree_selection_changed(NULL,widgets);
                }
            yon_config_load_update(widgets);
            on_subwindow_close(window->MainWindow);
        }
    } else {
        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NOTHING_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
    }
}

repo_add_window *on_move_clicked(GtkWidget *self, main_window *widgets){
    repo_add_window *window = yon_repo_add_window_new();
    yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->Window),MOVE_PACKAGES_TITLE_LABEL,icon_path,"move-repo-window");
        gtk_label_set_text(GTK_LABEL(window->HeadLabel),MOVE_PACKAGES_TITLE_LABEL);
    gtk_button_set_label(GTK_BUTTON(window->AddButton),MOVE_LABEL);
    gtk_label_set_text(GTK_LABEL(window->PackagesToAddLabel),MOVE_PACKAGES_LABEL);
    gtk_widget_show(window->MoveSourceFrame);
    gtk_widget_show(window->MoveTargetFrame);
    gtk_widget_hide(gtk_widget_get_parent(window->PackageSignCombo));
    GtkTreeIter iter;
    for_iter (window->tree_copy,&iter){
        char *current;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&current,-1);
        if (!yon_char_is_empty(current)){
            char *path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&iter);
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->MoveSourceStorageEntry),path,current);
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->MoveTargetStorageEntry),path,current);
        }
    }

    yon_sign_list_update();
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->RepoSignCombo));
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->PackageSignCombo));
    gtk_combo_box_set_active(GTK_COMBO_BOX(window->RepoSignCombo),0);
    gtk_combo_box_set_active(GTK_COMBO_BOX(window->PackageSignCombo),0);

    gtk_widget_destroy(gtk_widget_get_parent(window->StorageCombo));
    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->MoveSourceStorageEntry),"changed",G_CALLBACK(on_move_storage_changed),window);
    g_signal_connect(G_OBJECT(window->MoveSourceRepoEntry),"changed",G_CALLBACK(on_move_repo_changed),window);
    g_signal_connect(G_OBJECT(window->MoveSourceArchEntry),"changed",G_CALLBACK(on_move_arch_changed),window);

    g_signal_connect(G_OBJECT(window->MoveTargetRepoEntry),"changed",G_CALLBACK(on_move_repo_changed),window);
    g_signal_connect(G_OBJECT(window->MoveTargetArchEntry),"changed",G_CALLBACK(on_move_arch_changed),window);

    g_signal_connect(G_OBJECT(window->AddPackageButton),"clicked",G_CALLBACK(on_move_add_package),window);
    g_signal_connect(G_OBJECT(window->RemoveButton),"clicked",G_CALLBACK(on_move_remove_package),window);
    g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_move_accept),dict);
    g_signal_connect(G_OBJECT(window->MoveSourceRepoEntry),"changed",G_CALLBACK(on_repo_sign_load),window);
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),NULL,&iter)){

        char *target = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(widgets->RepoList),&iter);
        int mod = yon_char_count(target,":")+1;
        char *arc=NULL;
        char *repo=NULL;
        char *stor=NULL;
        if (mod ==3){
            arc = yon_char_new(target);
            char *temp = yon_char_new(target);
            repo = yon_char_divide(temp,yon_char_find_last(temp,':'));
            free(temp);
            temp = yon_char_new(repo);
            stor = yon_char_divide(temp,yon_char_find_last(temp,':'));
            free(temp);
        } else if (mod>=2){
            repo = yon_char_new(target);
            char *temp = yon_char_new(target);
            stor = yon_char_divide(temp,yon_char_find_last(temp,':'));
            free(temp);
        } else if (mod>=1){
            stor = yon_char_new(target);
        }

        if (stor)
            gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->MoveSourceStorageEntry),stor);
        if (repo)
            gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->MoveSourceRepoEntry),repo);
        if (arc)
            gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->MoveSourceArchEntry),arc);
    }
    gtk_widget_show(window->MainWindow);
    return window;
}

void on_remove_add_package(GtkWidget *self, repo_add_window *window){
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->ArchitectureCombo))>-1){
        file_chooser_window *dialog = yon_file_chooser_new();
        yon_gtk_window_setup(GTK_WINDOW(dialog->Window),GTK_WINDOW(window->MainWindow),CHOSE_PACKAGES_TITLE_LABEL,icon_path,"ChooseMoveFileChooserWindow");
        gtk_label_set_text(GTK_LABEL(dialog->HeadLabel),CHOSE_PACKAGES_TITLE_LABEL);
        GtkFileFilter *filter = gtk_file_filter_new();
        gtk_file_filter_add_pattern(filter,"*.pkg.tar*[^.sig]");
        gtk_file_filter_set_name(filter,"*.pkg.tar.*");
        gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog->FileChooserWidget),filter);
        GtkTreeIter iter,itar;
        yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->ArchitectureCombo),GTK_TREE_MODEL(window->tree_copy),&iter);
        char *target;
        int temp_size=0;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&target,-1);
        yon_gtk_tree_iter_get_from_combo_box_id(GTK_COMBO_BOX(window->ArchitectureCombo),GTK_TREE_MODEL(window->tree_copy),&itar);
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&itar,3,&dialog->root_path,-1);
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog->FileChooserWidget),target);

        dictionary *dict = NULL;
        yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
        yon_dictionary_add_or_create_if_exists_with_data(dict,"dialog",dialog);

        g_signal_connect(G_OBJECT(dialog->FileChooserWidget),"current-folder-changed",G_CALLBACK(on_folder_changed),dialog);
        g_signal_connect(G_OBJECT(dialog->ChooseButton),"clicked",G_CALLBACK(on_move_add_accept),dict);
    g_signal_connect(G_OBJECT(dialog->FileChooserWidget),"file-activated",G_CALLBACK(on_file_chooser_file_activate),window);
        gtk_widget_show(dialog->Window);
    }
}

void on_remove_arch_selection_changed(GtkWidget *self, repo_add_window *window){
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->ArchitectureCombo))==-1){
        gtk_widget_set_sensitive(window->AddPackageButton,0);
    } else {
        gtk_widget_set_sensitive(window->AddPackageButton,1);
    }
}

void on_remove_accept(GtkWidget *self, dictionary *dict){
    main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
    repo_add_window *window = yon_dictionary_get_data(dict->first->next,repo_add_window*);
    GtkTreeModel *model;
    GtkTreeIter iter;
    const char *storage_id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->StorageCombo));
    char *storage_path;
    char *repo = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->RepositoryCombo));
    char *arch = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->ArchitectureCombo));

    if (!yon_char_is_empty(storage_id)){
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->tree_copy),&iter,storage_id);
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&storage_path,-1);
        int size=0;
        config_str packages=NULL;
        for_iter(GTK_TREE_MODEL(window->PackagesList),&iter){
            char *target;
            gtk_tree_model_get(GTK_TREE_MODEL(window->PackagesList),&iter,1,&target,-1);
            yon_char_parsed_add_or_create_if_exists(packages,&size,target);
        }
        if (size){
            char *sign = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->RepoSignCombo));
            char *command;
            if (yon_char_is_empty(sign)){
                command = yon_delete_packages_command(storage_path,arch,repo,yon_char_parsed_to_string(packages,size," "));
            } else {
                command = yon_delete_packages_sign_command(storage_path,arch,repo,sign,yon_char_parsed_to_string(packages,size," "));
            }
            yon_debug_output("%s\n",command);
            if (!system(command)){
                yon_ubl_status_box_render(PACKAGES_REMOVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
                gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),NULL);
                gtk_tree_store_clear(widgets->RepoList);
                yon_gtk_tree_store_copy_full(window->tree_copy,widgets->RepoList);
                gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->ReposTree),GTK_TREE_MODEL(widgets->RepoList));

                const char *id = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->ArchitectureCombo));
                if (!yon_char_is_empty(id)){
                    gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(widgets->RepoList),&iter,id);
                    gtk_tree_view_expand_to_path(GTK_TREE_VIEW(widgets->ReposTree),gtk_tree_path_new_from_string(id));
                    gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&iter);
                    on_main_tree_selection_changed(NULL,widgets);
                }
            }
            yon_config_load_update(widgets);
        } else {
            yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NOTHING_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE); 
            return;
        }
    }else {
        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NOTHING_CHOSEN_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
        return;
    }
    gtk_widget_destroy(window->MainWindow);
}

repo_add_window *on_remove_clicked(GtkWidget *self, main_window *widgets){
    repo_add_window *window = yon_repo_add_window_new();
    yon_gtk_window_setup(GTK_WINDOW(window->MainWindow),GTK_WINDOW(widgets->Window),REMOVE_PACKAGES_TITLE_LABEL,icon_path,"add-repo-window");
        gtk_label_set_text(GTK_LABEL(window->HeadLabel),REMOVE_PACKAGES_TITLE_LABEL);
    GtkTreeIter iter;
    for_iter (window->tree_copy,&iter){
        char *current;
        gtk_tree_model_get(GTK_TREE_MODEL(window->tree_copy),&iter,3,&current,-1);
        if (!yon_char_is_empty(current)){
            char *path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(window->tree_copy),&iter);
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->StorageCombo),path,current);
        }
    }
    gtk_label_set_text(GTK_LABEL(window->PackagesToAddLabel),REMOVE_PACKAGES_LABEL);
    yon_sign_list_update();
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->RepoSignCombo));
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->PackageSignCombo));
    gtk_combo_box_set_active(GTK_COMBO_BOX(window->RepoSignCombo),0);

    gtk_widget_hide(gtk_widget_get_parent(window->PackageSignCombo));

    gtk_button_set_label(GTK_BUTTON(window->AddButton),REMOVE_LABEL);
    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->ArchitectureCombo),"changed",G_CALLBACK(on_arch_chosen),window);
    g_signal_connect(G_OBJECT(window->StorageCombo),"changed",G_CALLBACK(on_add_target_repo_selection_changed),window);
    g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_add_target_arch_selection_changed),window);
    g_signal_connect(G_OBJECT(window->ArchitectureCombo),"changed",G_CALLBACK(on_remove_arch_selection_changed),window);
    g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_remove_accept),dict);
    g_signal_connect(G_OBJECT(window->AddPackageButton),"clicked",G_CALLBACK(on_remove_add_package),window);
    g_signal_connect(G_OBJECT(window->RemoveButton),"clicked",G_CALLBACK(on_move_remove_package),window);
    g_signal_connect(G_OBJECT(window->RepositoryCombo),"changed",G_CALLBACK(on_repo_sign_load),window);
    yon_add_window_set_selected(widgets,window);
    gtk_widget_show(window->MainWindow);
    return window;
}

    /*      setup functions     */
void config_init(){
    main_config.tree_store=NULL;
    main_config.always_open_documentation=0;
    main_config.socket_id=-1;
    main_config.save_socket_id=-1;
    main_config.load_socket_id=-1;
    main_config.lock_help=0;
    main_config.lock_help=0;
    main_config.lock_load_global=0;
    main_config.lock_save_global=0;
    main_config.lock_save_local=0;
    main_config.signs=NULL;
    main_config.signs_size=0;
    yon_sign_list_update();
    main_config.last_selection = NULL;
}

void yon_config_load_update(main_window *widgets){
    gtk_tree_store_clear(widgets->RepoList);
    gsize size=0;
    config_str storages = yon_window_config_get_section("storage_info",&size);
    GtkTreeIter iter,itar,childiter;
    for (int i=0;i<size;i++){
        char *name = yon_char_new(storages[i]);
        free(yon_char_divide(name,yon_char_find_last(name,'/')));
        gtk_tree_store_append(widgets->RepoList,&iter,NULL);
        gtk_tree_store_set(widgets->RepoList,&iter,0,folder_no_edits,2,name,3,storages[i],-1);
        free(name);
        yon_window_config_get_parameter("storage_info",storages[i],&name,YON_TYPE_STRING);
        if (!yon_char_is_empty(name)){
            int parsed_size;
            config_str name_parsed = yon_char_parse(name,&parsed_size,",");
            for (int j=0;j<parsed_size;j++){
                char *nm = yon_char_new(name_parsed[j]);
                free(yon_char_divide(nm,yon_char_find_last(nm,'/')));
                gtk_tree_store_append(widgets->RepoList,&itar,&iter);
                gtk_tree_store_set(widgets->RepoList,&itar,2,nm,3,name_parsed[j],-1);
                int size;
                config_str dirs = yon_file_list_dirs(name_parsed[j],&size);
                for (int k=0;k<size;k++){
                    if (strcmp(dirs[k],"pool")&&strcmp(dirs[k],nm)){
                        char *arch_path = yon_char_unite(name_parsed[j],"/",dirs[k],NULL);
                        int arch_status = system(yon_debug_output("%s\n",yon_repo_get_signature_status_arch(storages[i],nm,dirs[k])));
                        arch_status = WEXITSTATUS(arch_status);
                        int packages_status = system(yon_debug_output("%s\n",yon_repo_get_signature_status_packages(storages[i],nm,dirs[k])));
                        char *sign_status_image = "";
                        if (!arch_status&&!packages_status){
                            sign_status_image = key_icon_name;
                        } else if (!arch_status&&packages_status==2)
                            sign_status_image = warning_icon_name;
                        else if (arch_status==2&&packages_status==2)
                            sign_status_image = "";
                        else
                            sign_status_image = warning_icon_name;
                        gtk_tree_store_append(widgets->RepoList,&childiter,&itar);
                        gtk_tree_store_set(widgets->RepoList,&childiter,0,sign_status_image,2,dirs[k],3,arch_path,-1);
                    }
                }
                free(nm);
            }
            yon_char_parsed_free(name_parsed,parsed_size);
        }
        
    }
    if (size)
    yon_char_parsed_free(storages,size);
}

config_str yon_tree_store_storage_get_archs(GtkTreeStore *target, GtkTreeIter *storage, int *size){
    config_str final = NULL;
    GtkTreeIter iter,itar;
    int repos_valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(target),&iter,storage);
    for (;repos_valid;repos_valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(target),&iter)){
        int archs_valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(target),&itar,&iter);
        for (;archs_valid;archs_valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(target),&itar)){
            char *current;
            gtk_tree_model_get(GTK_TREE_MODEL(target),&itar,2,&current,-1);
            if (yon_char_parsed_check_exist(final,*size,current)==-1)
                yon_char_parsed_add_or_create_if_exists(final,size,current);
        }
    }
    return final;
}

config_str yon_tree_store_repo_get_archs(GtkTreeStore *target, GtkTreeIter *repo, int *size){
    config_str final = NULL;
    GtkTreeIter iter;
    int repos_valid = gtk_tree_model_iter_children(GTK_TREE_MODEL(target),&iter,repo);
    for (;repos_valid;repos_valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(target),&iter)){
        char *current;
        gtk_tree_model_get(GTK_TREE_MODEL(target),&iter,2,&current,-1);
        if (yon_char_parsed_check_exist(final,*size,current)==-1)
            yon_char_parsed_add_or_create_if_exists(final,size,current);
    }
    return final;
}

char *yon_signature_get(GtkTreeView *target, GtkTreeIter *iter){
    GtkTreeIter itar;
    GtkTreeModel *model = gtk_tree_view_get_model(target);
    char *full_path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(model),iter);
    int size;
    config_str parsed = yon_char_parse(full_path,&size,":");
    if (size==2){
        char *storage_path = parsed[0];
        char *repo_path = yon_char_unite(parsed[0],":",parsed[1],NULL);
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(model),&itar,storage_path);
        char *path;
        gtk_tree_model_get(GTK_TREE_MODEL(model),&itar,3,&path,-1);
        char *repo;
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(model),&itar,repo_path);
        gtk_tree_model_get(GTK_TREE_MODEL(model),&itar,2,&repo,-1);
        int status_size;
        config_str status = yon_config_load(yon_repo_get_signature(path,repo),&status_size);
        char *final_string = NULL;
        if (status_size>4){
            final_string = yon_char_unite(status[0],status[1],status[2],status[3],NULL);
        }
        free(full_path);
        free(path);
        free(repo);
        yon_char_parsed_free(parsed,size);
        yon_char_parsed_free(status,status_size);
        
        return final_string;
    }
    return NULL;
}

void on_main_tree_selection_changed(GtkWidget *self, main_window *widgets){
    gtk_label_set_text(GTK_LABEL(widgets->InformationLabel),"");
    gtk_list_store_clear(widgets->RepoFileList);
    gtk_list_store_clear(widgets->RepoPackagesList);
    GtkTreeIter iter,itar;
    GtkTreeModel *model=NULL;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model,&iter)){
        GtkTreePath *path = gtk_tree_model_get_path(model,&iter);
        int depth = gtk_tree_path_get_depth(path);
        char *target, *name;
        gtk_tree_model_get(model, &iter,2,&name,3,&target,-1);
        switch (depth){
            case 1:{
                int size, arch_size;
                config_str repos = yon_tree_store_get_all_at_level(widgets->RepoList,&iter,&size,2,2);
                config_str archs = yon_tree_store_storage_get_archs(widgets->RepoList,&iter,&arch_size);
                if (size>0&&arch_size>0){
                    char *repo_string = yon_char_parsed_to_string(repos,size,", ");
                    char *archs_string = yon_char_parsed_to_string(archs,arch_size,", ");
                    char *info = get_storage_info_label(target,repo_string,archs_string);
                    gtk_label_set_markup(GTK_LABEL(widgets->InformationLabel),info);
                    int lvlsize;
                    config_str level = yon_tree_store_get_all_at_level(widgets->RepoList,&iter,&lvlsize,2,2);
                    for (int i=0;i<lvlsize;i++){
                        gtk_list_store_append(widgets->RepoFileList,&itar);
                        gtk_list_store_set(widgets->RepoFileList,&itar,1,level[i],-1);
                    }
                    if (!yon_char_is_empty(repo_string))free(repo_string);
                    if (!yon_char_is_empty(archs_string)) free(archs_string);
                    if (!yon_char_is_empty(info))free(info);
                    yon_char_parsed_free(repos,size);
                    yon_char_parsed_free(archs,arch_size);
                }
            }
                break;
            case 2:{
                int size, arch_size;
                config_str archs = yon_tree_store_repo_get_archs(widgets->RepoList,&iter,&arch_size);
                char *archs_string = yon_char_parsed_to_string(archs,arch_size,", ");
                char *sign = yon_signature_get(GTK_TREE_VIEW(widgets->ReposTree),&iter);
                char *info = get_repo_info_label(name,archs_string,sign);
                gtk_label_set_markup(GTK_LABEL(widgets->InformationLabel),info);
                int lvlsize;
                config_str level = yon_tree_store_get_all_at_level(widgets->RepoList,&iter,&lvlsize,2,3);
                for (int i=0;i<lvlsize;i++){
                    gtk_list_store_append(widgets->RepoFileList,&itar);
                    gtk_list_store_set(widgets->RepoFileList,&itar,1,level[i],-1);
                }
                    if (!yon_char_is_empty(archs_string)) free(archs_string);
                    if (!yon_char_is_empty(info))free(info);
                yon_char_parsed_free(archs,arch_size);

            }
                break;
            case 3:{
                GtkTreeIter itor;
                gtk_tree_model_iter_parent(GTK_TREE_MODEL(widgets->RepoList),&itor,&iter);
                char *trg;
                gtk_tree_model_get(GTK_TREE_MODEL(widgets->RepoList),&itor,2,&trg,-1);
                char *info = get_arch_info_label(trg,name);
                gtk_label_set_markup(GTK_LABEL(widgets->InformationLabel),info);
                char *packages;
                int size;
                char *arch = yon_char_new(target);
                char *repo = yon_char_divide(arch,yon_char_find_last(arch,'/'));
                char *storage = yon_char_divide(repo,yon_char_find_last(repo,'/'));
                char *command = yon_get_packages_command(storage,repo,arch);
                yon_debug_output("%s\n",command);
                config_str parsed = yon_config_load(command,&size);
                    for (int i=0;i<size;i++){
                        int line_size;
                        yon_char_remove_last_symbol(parsed[i],'\n');
                        config_str line = yon_char_parse(parsed[i],&line_size," ");
                        if (line[0][0]!='-'&&line[0][1]!='\0'){
                            int load_size;
                            char *name = yon_char_unite(target,"/",line[1],NULL);
                            config_str load = yon_config_load(yon_get_package_name_from_filename(name),&load_size);
                            if (load_size>0){
                                yon_char_remove_last_symbol(load[0],'\n');
                                int package_status = system(yon_debug_output("%s\n",yon_repo_get_signature_status(storage,repo,arch,load[0])));
                                char *sign_status_icon = "";
                                if (!package_status)
                                    sign_status_icon = package_signature_icon_name;
                                else
                                    sign_status_icon = package_signature_error_icon_name;
                                gtk_list_store_append(widgets->RepoFileList,&itar);
                                gtk_list_store_set(widgets->RepoFileList,&itar,0,sign_status_icon,1,line[0],2,line[1],-1);
                                yon_char_parsed_free(load,load_size);
                            }
                        } else {
                            gtk_list_store_append(widgets->RepoPackagesList,&itar);
                                gtk_list_store_set(widgets->RepoPackagesList,&itar,0,package_signature_error_icon_name,1,line[1],-1);
                        }
                    }
                    if (!yon_char_is_empty(info))free(info);
                }
            break;
        }
        if (main_config.last_selection){
            if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(widgets->RepoFileList),&itar,main_config.last_selection))
                gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),&itar);
        }
    }
}

void on_package_selection_changed(GtkWidget *self, main_window *widgets){
    gtk_label_set_markup(GTK_LABEL(widgets->InformationLabel),"");
    GtkTreeIter iter,itar;
    GtkTreeModel *model, *model2;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),&model,&iter)){
        if (main_config.last_selection) free(main_config.last_selection);
        main_config.last_selection = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(widgets->RepoFileList),&iter);
        gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model2,&itar);
        switch (gtk_tree_store_iter_depth(widgets->RepoList,&itar)){
            case 0:
                break;
            case 1:
                break;
            case 2:
                char *path, *filename;
                gtk_tree_model_get(model,&iter,2,&filename,-1);
                gtk_tree_model_get(model2,&itar,3,&path,-1);
                int size;
                char *command = get_package_info_command(yon_char_unite(path,"/",filename,NULL));
                yon_debug_output("%s\n",command);
                config_str parsed = yon_config_load(command,&size);
                for (int i=0;i<size;i++){
                    if (!yon_char_is_empty(parsed[i])&&strcmp(parsed[i],"\n")&&strstr(parsed[i],":")){
                        char *title = yon_char_divide_search(parsed[i],":",-1);
                        char *temp = parsed[i];
                        if (strstr(temp,"@")||strstr(temp,"<")||strstr(temp,">")) temp = g_markup_escape_text(temp,strlen(temp));
                        temp = yon_char_replace(temp,">","&gt;");
                        temp = yon_char_replace(temp,"<","&lt;");
                        parsed[i] = yon_char_unite("<b>",title,":</b>",temp,NULL);
                        if (!yon_char_is_empty(temp)) free(temp);
                        if (!yon_char_is_empty(title)) free(title);
                    }
                }
                char *full = yon_char_parsed_to_string(parsed,size,"");
                gtk_label_set_markup(GTK_LABEL(widgets->InformationLabel),full);
                yon_char_parsed_free(parsed,size);
                if (!yon_char_is_empty(full)) free(full);
            break;
        }
    }
}

void yon_combo_box_text_set_signs(GtkComboBoxText *target){
    g_return_if_fail(GTK_IS_COMBO_BOX_TEXT(target));
    gtk_combo_box_text_remove_all(target);
    gtk_combo_box_text_append_text(target,DO_NOT_SIGN_LABEL);
    for (int i=0;i<main_config.signs_size;i++){
        char *temp = yon_char_new(main_config.signs[i]);
        if (strstr(temp,"<"))
        free(yon_char_divide_search(temp,"<",-1));
        if (strstr(temp,">"))
        yon_char_remove_last_symbol(temp,'>');
        gtk_combo_box_text_append(target,temp,main_config.signs[i]);
        free(temp);
    }
}

void yon_sign_list_update(){
    if (main_config.signs&&main_config.signs_size) yon_char_parsed_free(main_config.signs,main_config.signs_size);
    main_config.signs = yon_config_load(get_gpg_keys_command,&main_config.signs_size);
    for (int i=0;i<main_config.signs_size;i++){
        yon_char_remove_last_symbol(main_config.signs[i],'\n');
    }
}

void on_ubl_settings_update_launch(){
    yon_launch_app_with_arguments(ubl_settings_update_command,NULL);
}

void on_calendar_open(GtkWidget *self,key_creation_window *window){
    yon_calendar_popover_open(GTK_ENTRY(window->ExpireEntry),self);
}

void on_key_generate_accept(GtkWidget *self, key_creation_window* window){
    const char *name = gtk_entry_get_text(GTK_ENTRY(window->NameEntry));
    const char *type = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->EncryptionCombo));
    const char *email = gtk_entry_get_text(GTK_ENTRY(window->EmailEntry));
    char *strength = yon_char_from_long(gtk_spin_button_get_value(GTK_SPIN_BUTTON(window->KeyStrengthSpin)));
    const char *comment = gtk_entry_get_text(GTK_ENTRY(window->CommentsEntry));
    if (!yon_char_is_empty(name)&&strlen(name)<5){
        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),NAME_SHORT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
        yon_ubl_status_highlight_incorrect(window->NameEntry);
        return;
    }
    GtkWidget *highlight_target=NULL;
    if (yon_char_is_empty(name)){
        highlight_target=window->NameEntry;
    } else if (yon_char_is_empty(type)){
        highlight_target=window->EncryptionCombo;
    } else if (yon_char_is_empty(email)){
        highlight_target=window->EmailEntry;
    } else if (yon_char_is_empty(strength)){
        highlight_target=window->KeyStrengthSpin;
    }
    if (highlight_target){
        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
        yon_ubl_status_highlight_incorrect(highlight_target);
        return;
    }
    char *expire = NULL;
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->ExpireCombo))==1){
        GDateTime *datetime = g_date_time_new_from_unix_local(yon_calendar_get_last_date());
        expire = g_date_time_format(datetime,"%Y%m%dT000000");
        g_date_time_unref(datetime);

    }
    const char *password = gtk_entry_get_text(GTK_ENTRY(window->PasswordEntry));
    const char *password_confirm = gtk_entry_get_text(GTK_ENTRY(window->PasswordConfirmationEntry));
    int ex_status=0;
    if (yon_char_is_empty(password)&&yon_char_is_empty(password_confirm)){
        yon_debug_output("%s\n",yon_generate_key_no_password_command(type,name,email,strength,comment,expire,password));
        ex_status = system(yon_debug_output("%s\n",yon_generate_key_no_password_command(type,name,email,strength,comment,expire,password)));
    } else if (!strcmp(password,password_confirm)){
        yon_debug_output("%s\n",yon_generate_key_command(type,name,email,strength,comment,expire,password));
        ex_status = system(yon_debug_output("%s\n",yon_generate_key_command(type,name,email,strength,comment,expire,password)));
    } else {
        yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),PASSWORD_INCORRECT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
        yon_ubl_status_highlight_incorrect(window->PasswordConfirmationEntry);
        yon_ubl_status_highlight_incorrect(window->PasswordEntry);
        return;
    }
    if (!ex_status)
        yon_ubl_status_box_render(KEY_CREATION_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    else 
        yon_ubl_status_box_render(KEY_CREATION_FAILURE_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
    gtk_widget_destroy(window->Window);
    yon_sign_list_update();
}

key_creation_window *yon_key_creation_window_new(){
    key_creation_window *window = malloc(sizeof(key_creation_window));
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_key);
    window->Window = yon_gtk_builder_get_widget(builder,"MainWindow");
    window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
    window->HeadLabel = yon_gtk_builder_get_widget(builder,"HeadLabel");
    window->NameEntry = yon_gtk_builder_get_widget(builder,"NameEntry");
    window->EmailEntry = yon_gtk_builder_get_widget(builder,"EmailEntry");
    window->CommentsEntry = yon_gtk_builder_get_widget(builder,"CommentsEntry");
    window->EncryptionCombo = yon_gtk_builder_get_widget(builder,"EncryptionCombo");
    window->KeyStrengthSpin = yon_gtk_builder_get_widget(builder,"KeyStrengthSpin");
    window->ExpireCombo = yon_gtk_builder_get_widget(builder,"ExpireCombo");
    window->ExpireEntry = yon_gtk_builder_get_widget(builder,"ExpireEntry");
    window->ExpireButton = yon_gtk_builder_get_widget(builder,"ExpireButton");
    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
    window->AddButton = yon_gtk_builder_get_widget(builder,"AddButton");
    window->PasswordEntry = yon_gtk_builder_get_widget(builder,"PasswordEntry");
    window->PasswordConfirmationEntry = yon_gtk_builder_get_widget(builder,"PasswordConfirmationEntry");

    yon_gtk_entry_set_password_visibility_icon(GTK_ENTRY(window->PasswordConfirmationEntry));
    yon_gtk_entry_set_password_visibility_icon(GTK_ENTRY(window->PasswordEntry));

    g_signal_connect(G_OBJECT(window->ExpireCombo),"changed",G_CALLBACK(yon_gtk_widget_set_sensitive_from_combo_box),window->ExpireButton);
    g_signal_connect(G_OBJECT(window->ExpireCombo),"changed",G_CALLBACK(yon_gtk_widget_set_sensitive_from_combo_box),window->ExpireEntry);
    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
    g_signal_connect(G_OBJECT(window->ExpireButton),"clicked",G_CALLBACK(on_calendar_open),window);
    g_signal_connect(G_OBJECT(window->AddButton),"clicked",G_CALLBACK(on_key_generate_accept),window);

    int size;
    config_str encription_keys = yon_file_open(key_encription_path,&size);
    window->expire_time=0;

    for (int i=1;i<size;i++){
        yon_char_remove_last_symbol(encription_keys[i],'\n');
        int parsed_size;
        config_str parsed = yon_char_parse(encription_keys[i],&parsed_size,";");
        gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->EncryptionCombo),parsed[2],parsed[0]);
        yon_char_parsed_free(parsed,parsed_size);
    }
    gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->EncryptionCombo),"RSA");
    return window;
}

void on_key_clicked(GtkWidget *self, main_window *widgets){
    key_creation_window *window = yon_key_creation_window_new();
    yon_gtk_window_setup(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->Window),KEY_CREATION_TITLE_LABEL,icon_path,"key-create-window");
        gtk_label_set_text(GTK_LABEL(window->HeadLabel),KEY_CREATION_TITLE_LABEL);
    gtk_widget_show(window->Window);
}

void on_tree_view_activate(GtkWidget *self, GtkTreePath* path, GtkTreeViewColumn* column, main_window *widgets){
        gtk_tree_view_expand_to_path(GTK_TREE_VIEW(widgets->ReposTree),path);

}

void on_repo_item_activate(GtkWidget *self, GtkTreePath *path, GtkTreeViewColumn *column, main_window *widgets){
    GtkTreeModel *model;
    GtkTreeIter iter;
    GtkTreeSelection *tree_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree));
    gtk_tree_selection_get_selected(tree_selection,&model,&iter);
    if (gtk_tree_store_iter_depth(GTK_TREE_STORE(widgets->RepoList),&iter)<2){
        char *path_id = gtk_tree_model_get_string_from_iter(model,&iter);
        char *target_id = gtk_tree_path_to_string(path);
        char *selection = yon_char_unite(path_id,":",target_id,NULL);
        GtkTreePath *new_selection = gtk_tree_path_new_from_string(selection);
        gtk_tree_view_expand_to_path(GTK_TREE_VIEW(widgets->ReposTree),new_selection);
        gtk_tree_selection_select_path(tree_selection,new_selection);
        // on_package_selection_changed(NULL,widgets);
        g_signal_emit_by_name(G_OBJECT(widgets->ReposTree),"cursor-changed",widgets,G_TYPE_NONE,NULL);
    }
}

void on_update_clicked(GtkWidget *self, main_window *widgets){
    yon_config_load_update(widgets);
}

void on_sign_window_accept(GtkWidget *self, dictionary *dict){
    main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
    sign_window *window = yon_dictionary_get_data(dict->first->next,sign_window*);
    GtkTreeModel *model;
    GtkTreeIter iter;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model,&iter)){
        char *arch;
        char *repo;
        char *storage;
        char *signature = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->SignCombo));
        gtk_tree_model_get(GTK_TREE_MODEL(widgets->RepoList),&iter,3,&arch,-1);
        char *full_path = yon_char_new(arch);
        repo = yon_char_divide(arch,yon_char_find_last(arch,'/'));
        storage = yon_char_divide(repo,yon_char_find_last(repo,'/'));
        storage = yon_char_append(storage,"/");
        GList *list = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),NULL);
        char *targets = "";
        for (int i=0;i<g_list_length(list);i++){
            char *pack;
            gtk_tree_model_get_iter(GTK_TREE_MODEL(widgets->RepoFileList),&iter,(GtkTreePath*)g_list_nth_data(list,i));
            gtk_tree_model_get(GTK_TREE_MODEL(widgets->RepoFileList),&iter,2,&pack,-1);
            char *temp = yon_char_unite(targets, " ", full_path,"/",pack,NULL);
            if (!yon_char_is_empty(targets)) free(targets);
            targets=temp;
        }
        if (!system(yon_debug_output("%s\n",yon_sign_package(storage,repo,arch,targets,signature)))){
            yon_ubl_status_box_render(SIGN_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
        }
            on_subwindow_close(window->Window);
    }
}

sign_window *yon_sign_window_new(){
    sign_window *window = malloc(sizeof(sign_window));
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_sign);

    window->Window = yon_gtk_builder_get_widget(builder,"MainWindow");
    window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
    window->HeadLabel = yon_gtk_builder_get_widget(builder,"HeadLabel");
    window->SignCombo = yon_gtk_builder_get_widget(builder,"SignCombo");
    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
    window->SignButton = yon_gtk_builder_get_widget(builder,"SignButton");

    g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);

    return window;
}

void on_packages_sign(GtkWidget *self, main_window *widgets){
    sign_window *window = yon_sign_window_new();
    yon_gtk_window_setup(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->Window),SIGNATURE_TITLE_LABEL,icon_path,"sign-window");
    yon_combo_box_text_set_signs(GTK_COMBO_BOX_TEXT(window->SignCombo));
    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->SignButton),"clicked",G_CALLBACK(on_sign_window_accept),dict);
    gtk_widget_show(window->Window);
}

int yon_tree_is_selected(void *widget){
    main_window *widgets = (main_window*)widget;
    GtkTreeModel *model;
    GtkTreeIter iter, itar;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),&model,&iter)){
        gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),NULL,&itar);
        if (gtk_tree_store_iter_depth(widgets->RepoList,&itar)==2){
            return 1;
        }
    }
    return 0;
}

void on_rmb_move(GtkWidget *self, main_window *widgets){
    repo_add_window *window = on_move_clicked(NULL,widgets);
    GtkTreeModel *model;
    GtkTreeIter iter;
    char *path;
    gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model,&iter);
    gtk_tree_model_get(model,&iter,3,&path,-1);
    GList *list = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),&model);
    for (int i=0;i<g_list_length(list);i++){
        GtkTreeIter itar;
        char *filename, *name;
        gtk_tree_model_get_iter(model,&iter,g_list_nth_data(list,i));
        gtk_tree_model_get(model,&iter,1,&name,2,&filename,-1);
        char *full_path = yon_char_unite(path,"/",filename,NULL);
        gtk_list_store_append(window->PackagesList,&itar);
        gtk_list_store_set(window->PackagesList,&itar,1,name,2,full_path,-1);
        free(full_path);
        free(filename);
        free(name);
    }
}

void on_rmb_remove(GtkWidget *self, main_window *widgets){

    repo_add_window *window = on_remove_clicked(NULL,widgets);
    GtkTreeModel *model;
    GtkTreeIter iter;
    char *path;
    gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->ReposTree)),&model,&iter);
    gtk_tree_model_get(model,&iter,3,&path,-1);
    GList *list = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->RepoFileTree)),&model);
    for (int i=0;i<g_list_length(list);i++){
        GtkTreeIter itar;
        char *filename, *name;
        gtk_tree_model_get_iter(model,&iter,g_list_nth_data(list,i));
        gtk_tree_model_get(model,&iter,1,&name,2,&filename,-1);
        char *full_path = yon_char_unite(path,"/",filename,NULL);
        gtk_list_store_append(window->PackagesList,&itar);
        gtk_list_store_set(window->PackagesList,&itar,1,name,2,full_path,-1);
        free(full_path);
        free(filename);
        free(name);
    }
}

main_window *yon_main_window_complete(main_window *widgets){ 
    widgets = yon_remalloc(widgets,sizeof(main_window)); 
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path); 
    gtk_box_pack_start(GTK_BOX(widgets->InterfaceBox),yon_gtk_builder_get_widget(builder,"BoxMain"),1,1,0); 
    // Custom widgets configuration 
    {
        widgets->UpdateButton = yon_gtk_builder_get_widget(builder,"UpdateButton");
        widgets->DBConfigurationButton = yon_gtk_builder_get_widget(builder,"DBConfigurationButton");
        widgets->AddButton = yon_gtk_builder_get_widget(builder,"AddButton");
        widgets->MoveButton = yon_gtk_builder_get_widget(builder,"MoveButton");
        widgets->RemoveButton = yon_gtk_builder_get_widget(builder,"RemoveButton");
        widgets->CloudButton = yon_gtk_builder_get_widget(builder,"CloudButton");

        widgets->ReposTree = yon_gtk_builder_get_widget(builder,"ReposTree");
        widgets->SearchEntry = yon_gtk_builder_get_widget(builder,"SearchEntry");
        widgets->RepoFileTree = yon_gtk_builder_get_widget(builder,"RepoFileTree");
        widgets->RepoPackagesTree = yon_gtk_builder_get_widget(builder,"RepoPackagesTree");
        widgets->InformationLabel = yon_gtk_builder_get_widget(builder,"InformationLabel");

        widgets->RepoList = GTK_TREE_STORE(gtk_builder_get_object(builder,"RepoStore"));
        widgets->RepoFileList = GTK_LIST_STORE(gtk_builder_get_object(builder,"RepoFileList"));
        widgets->RepoPackagesList = GTK_LIST_STORE(gtk_builder_get_object(builder,"RepoPackageList"));
        {
            widgets->KeyMenuItem = gtk_menu_item_new();
            gtk_menu_shell_prepend(GTK_MENU_SHELL(gtk_widget_get_parent(widgets->AboutMenuItem)),widgets->KeyMenuItem);
            GtkWidget *icon = gtk_image_new_from_icon_name(key_icon_name,GTK_ICON_SIZE_BUTTON);
            GtkWidget *label = gtk_label_new(KEY_LABEL);
            GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
            gtk_box_pack_start(GTK_BOX(box),icon,0,0,5);
            gtk_box_pack_start(GTK_BOX(box),label,0,0,5);
            gtk_container_add(GTK_CONTAINER(widgets->KeyMenuItem),box);
            gtk_widget_show_all(widgets->KeyMenuItem);
            gtk_style_context_add_class(gtk_widget_get_style_context(widgets->KeyMenuItem),"menuitemtop");
            gtk_style_context_remove_class(gtk_widget_get_style_context(widgets->DocumentationMenuItem),"menuitemtop");
            gtk_style_context_add_class(gtk_widget_get_style_context(widgets->DocumentationMenuItem),"menuitemmiddle");
            g_signal_connect(G_OBJECT(widgets->KeyMenuItem),"activate",G_CALLBACK(on_key_clicked),widgets);
        }
        main_config.tree_store = widgets->RepoList;

        rmb_menu_window *rmb = yon_rmb_menu_setup(widgets->RepoFileTree, yon_tree_is_selected,widgets,
        SIGN_LABEL,lib_key_icon_name,G_CALLBACK(on_packages_sign),widgets,
        MOVE_PACKAGES_TITLE_LABEL,move_icon,G_CALLBACK(on_rmb_move),widgets,
        REMOVE_PACKAGES_TITLE_LABEL,remove_icon,G_CALLBACK(on_rmb_remove),widgets,
        NULL);

        g_signal_connect(G_OBJECT(widgets->DBConfigurationButton),"clicked",G_CALLBACK(on_storage_configure_clicked),widgets);
        g_signal_connect(G_OBJECT(widgets->AddButton),"clicked",G_CALLBACK(on_add_clicked),widgets);
        g_signal_connect(G_OBJECT(widgets->MoveButton),"clicked",G_CALLBACK(on_move_clicked),widgets);
        g_signal_connect(G_OBJECT(widgets->RemoveButton),"clicked",G_CALLBACK(on_remove_clicked),widgets);
        g_signal_connect(G_OBJECT(widgets->ReposTree),"cursor-changed",G_CALLBACK(on_main_tree_selection_changed),widgets);
        g_signal_connect(G_OBJECT(widgets->CloudButton),"clicked",G_CALLBACK(on_ubl_settings_update_launch),widgets);
        g_signal_connect(G_OBJECT(widgets->RepoFileTree),"cursor-changed",G_CALLBACK(on_package_selection_changed),widgets);
        g_signal_connect(G_OBJECT(widgets->ReposTree),"row-activated",G_CALLBACK(on_tree_view_activate),widgets);
        g_signal_connect(G_OBJECT(widgets->RepoFileTree),"row-activated",G_CALLBACK(on_repo_item_activate),widgets);
        g_signal_connect(G_OBJECT(widgets->UpdateButton),"clicked",G_CALLBACK(on_update_clicked),widgets);
        yon_calendar_set_date_orientation(1);
        gtk_window_set_title(GTK_WINDOW(widgets->Window),TITLE_LABEL);

        gtk_tree_view_set_search_entry(GTK_TREE_VIEW(widgets->RepoFileTree),GTK_ENTRY(widgets->SearchEntry));

        /* Widget registration for config monitoring | Регистрация виджетов для мониторинга конфига */
        /* Localisation | Локализация */
        // gtk_widget_show(widgets->Window);
        return widgets;
    }
}

int main(int argc, char *argv[]){ 
    setlocale(LC_ALL, "");
    textdomain (LocaleName);
    config_init();
    
    yon_ubl_connect_config((_template_config*)&main_config); 
    yon_ubl_window_init(TITLE_LABEL,TITLE_INFO_LABEL,LocaleName,CssPath,LocaleName,version_application,WIKI_LINK);
	config_str unfound = NULL;
	int size=0;
	yon_ubl_setup_arguments(argc,argv,&unfound,&size,NULL);
    gtk_init(&argc,&argv);
    template_main_window *widgets = yon_ubl_window_setup(); 
    gtk_widget_hide(gtk_menu_get_attach_widget(GTK_MENU(gtk_widget_get_parent(widgets->SaveMenuItem))));
    gtk_widget_hide(gtk_menu_get_attach_widget(GTK_MENU(gtk_widget_get_parent(widgets->LoadGlobalMenuItem))));
    widgets = (template_main_window*)yon_main_window_complete((main_window*)widgets);
    char *path = yon_char_unite(yon_ubl_user_get_home_directory(),"/.config/",LocaleName,"/",LocaleName,".conf",NULL);
    yon_window_config_load(path);
    yon_config_load_update((main_window*)widgets);
        yon_ubl_status_box_render(DATA_LOADED_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    gtk_main();
    return 0;
}