#include "ubl-settings-services.h"

config main_config;

//signal emmit handlers - no header initialization

/**on_close_subwindow(GtkWidget *self)
 * [EN]
 * Closes window in which [self] is contained.
 * [RU]
 * Закрывает окно, в котором расположен виджет [self].
*/
void on_close_subwindow(GtkWidget *self){
    gtk_widget_destroy(gtk_widget_get_toplevel(self));
}

/**yon_open_browser(GtkWidget *self, char *link)
 * [EN]
 * Opens browser with [link] link.
 * [RU]
 * Открывает браузер с [link] ссылкой.
*/
void yon_open_browser(GtkWidget *self, char *link){
    yon_ubl_browser_window_open(link,TITLE_LABEL);
}

/**on_open_documentation_confirmation(GtkWidget *self, char *link)
 * [EN]
 * Opens confirmation window for [link] link.
 * [RU]
 * Открывает окно подтверждение перехода по ссылке [link].
*/
void on_open_documentation_confirmation(GtkWidget *self, char *link){
    if (main_config.always_open_documentation==0){
        GtkBuilder *builder = gtk_builder_new_from_resource(glade_path);
        documentation_confirmation_window *widgets = malloc(sizeof(documentation_confirmation_window));
        widgets->Window = yon_gtk_builder_get_widget(builder,"helpConfirmationWindow");
        widgets->AcceptButton = yon_gtk_builder_get_widget(builder,"ReadHelpButton");
        widgets->CloseButton = yon_gtk_builder_get_widget(builder,"CancelHelpButton");
        widgets->HatText = yon_gtk_builder_get_widget(builder,"webHeaderNameLabel");
        widgets->HeaderText = yon_gtk_builder_get_widget(builder,"helpHeader");
        widgets->InfoText = yon_gtk_builder_get_widget(builder,"helpText");
        widgets->AlwaysOpenCheck = yon_gtk_builder_get_widget(builder,"AlwaysOpenDocumentationCheckbox");
        gtk_label_set_text(GTK_LABEL(widgets->HatText),TITLE_LABEL);
        gtk_label_set_text(GTK_LABEL(widgets->HeaderText),HELP_TITLE_LABEL);
        gtk_label_set_text(GTK_LABEL(widgets->InfoText),HELP_INFO_LABEL);
        gtk_button_set_label(GTK_BUTTON(widgets->AcceptButton),OPEN_HELP_LABEL);
        gtk_button_set_label(GTK_BUTTON(widgets->AlwaysOpenCheck),HELP_ALWAYS_OPEN_LABEL);
        gtk_button_set_label(GTK_BUTTON(widgets->CloseButton),CANCEL_LABEL);
        gtk_widget_show_all(widgets->Window);
        g_signal_connect(G_OBJECT(widgets->CloseButton),"clicked",G_CALLBACK(on_close_subwindow),NULL);
        g_signal_connect(G_OBJECT(widgets->AcceptButton),"clicked",G_CALLBACK(yon_open_browser),yon_char_new(link));
        g_signal_connect(G_OBJECT(widgets->AcceptButton),"clicked",G_CALLBACK(on_close_subwindow),NULL);
        
        
    } else {
        yon_open_browser(self,link);
    }
}

/**on_link(GtkWidget *self, char* uri, gpointer user_data)
 * [EN]
 * Signal for hadnling AboutDialog links.
 * Connect to "activate-link" signal.
 * [self] is AboutDialog window;
 * [uri] is activated link;
 * [user_data] is pointer for user data, hasn't used in standard handler;
 * [RU]
 * Функция для обработки сигнала нажатия на ссылку окна AboutDialog.
 * Присоединять к сигналу "activate-link".
 * [self] - окно AboutDialog;
 * [uri] - ссылка, по которой совершается переход;
 * [user_data] - указатель на любые другие данные, не используется в стандартном обработчике;
*/
void on_link(GtkWidget *self, char* uri, gpointer user_data){
    gtk_widget_destroy(self);
    on_open_documentation_confirmation(self,uri);
}

/**on_about()
 * [EN]
 * Function for setting up and showing AboutDialog.
 * Connect it to "activate" signal of Documentation MenuItem.
 * [RU]
 * Функиця для настройки и показа окна AboutDialog.
 * Присоединять к сигналу "activate" кнопки справки типа MenuItem.
*/
void on_about(){
    GtkBuilder *builder=gtk_builder_new_from_resource(glade_path);
    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_website_label(GTK_ABOUT_DIALOG(window),PROJECT_HOME_LABEL);
    gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(window),TITLE_LABEL);
    gtk_label_set_text(GTK_LABEL(title),TITLE_LABEL);
    g_signal_connect(G_OBJECT(window),"activate-link",G_CALLBACK(on_link),NULL);
    gtk_widget_set_visible(hideButtonBox,0);
    gtk_widget_destroy(hideButtonBox);
    gtk_widget_show(window);
}

//functions

void on_activate(GtkTreeView *self, main_window *widgets){
    
    GtkTreeIter iter;
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);
    char *name=NULL;
    char *description=NULL;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->MainTree)),&model,&iter)){
        gtk_tree_model_get(GTK_TREE_MODEL(main_config.list),&iter,5,&name,6,&description,-1);
        gtk_label_set_text(GTK_LABEL(widgets->ChosenNameLabel),name);
        gtk_label_set_text(GTK_LABEL(widgets->ChosenDescriptionLabel),description);
        menu_obj *menu=widgets->menu;
        if (main_config.rmb_clicked){
            gboolean CAutostart,CAutostop,CBlock,SAutostart,SLaunched;
            gtk_tree_model_get(GTK_TREE_MODEL(main_config.list),&iter,0,&CAutostart,1,&CAutostop,2,&CBlock,3,&SAutostart,4,&SLaunched,-1);
            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(menu->MenuConfigAutostart)),0))),2)),CAutostart);
            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(menu->MenuConfigAutostop)),0))),2)),CAutostop);
            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(menu->MenuConfigBlock)),0))),2)),CBlock);
            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(menu->MenuSystemAutostart)),0))),2)),SAutostart);
            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(menu->MenuSystemLaunched)),0))),2)),SLaunched);
            gtk_menu_popup_at_pointer(GTK_MENU(menu->Menu),NULL);
        }
    }
    main_config.rmb_clicked=0;
}

void yon_config_load_proceed(char *command){
    yon_config_clean();
    // yon_config_main_clean();
    
    gtk_list_store_clear(main_config.list);
    int services_len=0;
    int sockets_len=0;
    int config_size=0;
    config_str services = yon_config_load(load_services_command,&services_len);
    config_str config = yon_config_load(command,&config_size);
    for (int i=0; i<services_len;i++){
        int current_size=0;
        gboolean syslaunched=0;
        gboolean conf_autolaunch=0;
        gboolean conf_autostop=0;
        gboolean conf_block=0;
        services[i]=yon_char_divide_search(services[i],"\n",-1);
        config_str current_service = yon_char_parse(services[i],&current_size,";");
        GtkTreeIter iter;
        if (strcmp(current_service[2],"active")==0) syslaunched=1;

        if (config){
            main_config.loaded_config = config;
            if (strstr(config[0],yon_char_append(current_service[0],","))) conf_autolaunch = 1;
            if (strstr(config[1],yon_char_append(current_service[0],","))) conf_autostop = 1;
            if (strstr(config[2],yon_char_append(current_service[0],","))) conf_block = 1;
        }
        gtk_list_store_append(main_config.list, &iter);

        gtk_list_store_set(main_config.list,&iter,4,syslaunched,5,current_service[0],6,current_service[4],-1);
    }
    
    if (config){
        main_config.loaded_config = config;
        yon_ubl_status_box_render(LOCAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    }else
        yon_ubl_status_box_render(LOAD_FAILED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}

void yon_config_load_local(GtkWidget *self, main_window *widgets){
    gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->MainTree),NULL);
    yon_config_load_proceed(load_config_local_command);
    gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->MainTree),GTK_TREE_MODEL(main_config.list));
    int size = 0;
    dictionary *dict=NULL;
    config_str config = yon_config_load(load_services_command,&size);
    printf("%s\n",config[0]);
    for (int i=0;i<size;i++){
        int servsize=0;
        config_str service = yon_char_parse(config[i],&servsize,";");
        service_info *info = new(service_info);
        info->name = yon_char_divide(service[0],strlen(service[0])-strlen(".service"));
        info->loaded=strcmp(service[1],"loaded")==0;
        info->active=strcmp(service[2],"active")==0;
        info->description=yon_char_divide_search(service[4],"\n",-1);
        yon_dictionary_add_or_create_if_exists_with_data(dict,info->name,info);
    }
    // if (main_config.loaded_config){
    //     for (int i=0;main_config.loaded_config[i];i++){
    //         dictionary *dct=NULL;
    //         for_dictionaries (dct,dict){
    //             if (strcmp(main_config.loaded_config[i],dict->key)==0){
    //                 service_info *serv = yon_dictionary_get_data(dct,service_info*);
    //                 GtkTreeIter iter;
    //                 gtk_list_store_append(main_config.list,&iter);
    //                 gtk_list_store_set(main_config.list,&iter,3,serv->loaded,4,serv->active,-1);
    //             }
    //         }
    //     } 
    // }

}

void yon_config_load_global(){
}

void on_config_autostart_switch(GtkMenuItem *self,main_window *widgets){
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);
    GtkTreeIter iter;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->MainTree)),&model,&iter)){
        gboolean autostart=0;
        gtk_tree_model_get(model,&iter,0,&autostart,-1);
        gtk_list_store_set(main_config.list,&iter,0,!autostart,-1);
    }

}

void on_config_autostop_switch(GtkMenuItem *self,main_window *widgets){
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);
    GtkTreeIter iter;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->MainTree)),&model,&iter)){
        gboolean autostop=0;
        gtk_tree_model_get(model,&iter,1,&autostop,-1);
        gtk_list_store_set(main_config.list,&iter,1,!autostop,-1);
    }


}

void on_config_block_switch(GtkMenuItem *self,main_window *widgets){
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);
    GtkTreeIter iter;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->MainTree)),&model,&iter)){
        gboolean block=0;
        gtk_tree_model_get(model,&iter,2,&block,-1);
        gtk_list_store_set(main_config.list,&iter,2,!block,-1);
    }


}

void on_system_autostart_switch(GtkMenuItem *self,main_window *widgets){
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);
    GtkTreeIter iter;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->MainTree)),&model,&iter)){
        gboolean autostart=0;
        gtk_tree_model_get(model,&iter,3,&autostart,-1);
        gtk_list_store_set(main_config.list,&iter,3,!autostart,-1);
    }


}

void on_system_launched(GtkMenuItem *self,main_window *widgets){
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);
    GtkTreeIter iter;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->MainTree)),&model,&iter)){
        gboolean launched=0;
        gtk_tree_model_get(model,&iter,4,&launched,-1);
        gtk_list_store_set(main_config.list,&iter,4,!launched,-1);
    }

    
}

void on_config_reload(GtkMenuItem *self,main_window *widgets){

}

void on_status_show(GtkMenuItem *self,main_window *widgets){
    GtkBuilder *builder = gtk_builder_new_from_resource(terminal_window_path);
    GtkWidget *Window = yon_gtk_builder_get_widget(builder,"TerminalWindow");
    GtkWidget *box = yon_gtk_builder_get_widget(builder,"TerminalHolder");
    GtkWidget *updateButton = yon_gtk_builder_get_widget(builder,"UpdateButton");
    GtkWidget *closeButton = yon_gtk_builder_get_widget(builder,"CancelButton");
    GtkTreeModel *model = GTK_TREE_MODEL(main_config.list);
    GtkTreeIter iter;
    char *name = NULL;
    gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->MainTree)),&model,&iter);
    gtk_tree_model_get(model,&iter,5,&name,-1);
    yon_terminal_integrated_launch(box,yon_char_append(status_command,name),NULL,NULL);
    g_signal_connect(G_OBJECT(closeButton),"clicked",G_CALLBACK(on_close_subwindow),NULL);
    gtk_widget_show_all(Window);
}

GtkWidget *yon_menu_button_create(char *icon_name, char *text) {
    GtkWidget *menu_item = gtk_menu_item_new();
    GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
    GtkWidget *icon;
    GtkWidget *check;
    if(icon_name){
        icon = gtk_image_new_from_icon_name(icon_name,GTK_ICON_SIZE_BUTTON);
        check = gtk_check_button_new();
        gtk_box_pack_start(GTK_BOX(box),icon,0,0,5);
        gtk_box_pack_end(GTK_BOX(box),check,0,0,5);
    }
    GtkWidget *label = gtk_label_new(text);
    gtk_box_pack_start(GTK_BOX(box),label,0,0,5);
    gtk_container_add(GTK_CONTAINER(menu_item),box);
    gtk_widget_show_all(menu_item);
    return menu_item;
}

GtkWidget *yon_menu_separator_create() {
    GtkWidget *menu_item = gtk_menu_item_new();
    GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
    GtkWidget *separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
    gtk_box_pack_start(GTK_BOX(box),separator,1,1,0);
    gtk_container_add(GTK_CONTAINER(menu_item),box);

    gtk_widget_show_all(menu_item);
    gtk_widget_set_sensitive(menu_item,0);
    return menu_item;
}

gboolean on_context_menu_open(GtkWidget *self,GdkEventButton *event, main_window *widgets){
    if (event->button==3){
        main_config.rmb_clicked=1;
    menu_obj *menu_object = g_malloc0(sizeof(menu_obj));
    GtkWidget *menu = gtk_menu_new();
    gtk_menu_set_reserve_toggle_size(GTK_MENU(menu),0);
    GtkWidget *menu_item_configuration_in_config = yon_menu_button_create(NULL,CONFIG_CONFIGURATION_LABEL);
    gtk_widget_set_sensitive(menu_item_configuration_in_config,0);
    GtkWidget *menu_item_autostart_config = yon_menu_button_create("media-playback-start-symbolic",AUTOSTART_LABEL);
    GtkWidget *menu_item_autostop = yon_menu_button_create("media-playback-stop-symbolic",AUTOSTOP_LABEL);
    GtkWidget *menu_item_block = yon_menu_button_create("process-stop-symbolic",BLOCK_LABEL);
    GtkWidget *menu_item_separator1 = yon_menu_separator_create();
    GtkWidget *menu_item_configuration_in_system = yon_menu_button_create(NULL,SYSTEM_CONFIGURATION_LABEL);
    gtk_widget_set_sensitive(menu_item_configuration_in_system,0);
    GtkWidget *menu_item_autostart_system = yon_menu_button_create("media-playback-start-symbolic",AUTOSTART_LABEL);
    GtkWidget *menu_item_launched = yon_menu_button_create("emoji-flags-symbolic",LAUNCHED_LABEL);
    GtkWidget *menu_item_separator2 = yon_menu_separator_create();
    GtkWidget *menu_item_reload = yon_menu_button_create("emblem-synchronizing-symbolic",SERVICE_RELOAD_LABEL);
    GtkWidget *menu_item_status = yon_menu_button_create("dialog-information-symbolic",STATUS_LABEL);
    menu_object->Menu = menu;
    menu_object->MenuConfigAutostart = menu_item_autostart_config;
    menu_object->MenuConfigAutostop = menu_item_autostop;
    menu_object->MenuConfigBlock = menu_item_block;
    menu_object->MenuSystemAutostart = menu_item_autostart_system;
    menu_object->MenuSystemLaunched = menu_item_launched;
    menu_object->MenuReloadConfig = menu_item_reload;
    menu_object->MenuStatus = menu_item_status;
    g_signal_connect(G_OBJECT(menu_item_autostart_config),"activate",G_CALLBACK(on_config_autostart_switch),widgets);
    g_signal_connect(G_OBJECT(menu_item_autostop),"activate",G_CALLBACK(on_config_autostop_switch),widgets);
    g_signal_connect(G_OBJECT(menu_item_block),"activate",G_CALLBACK(on_config_block_switch),widgets);
    g_signal_connect(G_OBJECT(menu_item_autostart_system),"activate",G_CALLBACK(on_system_autostart_switch),widgets);
    g_signal_connect(G_OBJECT(menu_item_launched),"activate",G_CALLBACK(on_system_launched),widgets);
    g_signal_connect(G_OBJECT(menu_item_reload),"activate",G_CALLBACK(on_config_reload),widgets);
    g_signal_connect(G_OBJECT(menu_item_status),"activate",G_CALLBACK(on_status_show),widgets);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item_configuration_in_config);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item_autostart_config);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item_autostop);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item_block);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item_separator1);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item_configuration_in_system);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item_autostart_system);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item_launched);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item_separator2);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item_reload);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item_status);
    widgets->RMBMenu=menu;
    widgets->menu=menu_object;
    // gtk_menu_popup_at_pointer(GTK_MENU(menu),NULL);
    return 0;
    }
    return 0;
}


// standard functions

void config_init(){
    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.rmb_clicked=0;
    main_config.loaded_config=NULL;
}

void yon_config_main_clean(){
    if (main_config.loaded_config){
        for (char *str = main_config.loaded_config[0];str;str+=8)
            free(str);
    }
    main_config.loaded_config=NULL;

}

main_window *setup_window(){
    /* Widgets getting | Получение виджетов */
    main_window *widgets = malloc(sizeof(main_window));
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path);
    widgets->Window = yon_gtk_builder_get_widget(builder,"MainWindow");
    widgets->HatLabel = yon_gtk_builder_get_widget(builder,"headerTopic");
    widgets->PlugBox = yon_gtk_builder_get_widget(builder,"plugBox");

    widgets->HeadOverlay = yon_gtk_builder_get_widget(builder,"HeadOverlay");
    widgets->HeadImage = yon_gtk_builder_get_widget(builder,"HeadBackgroundImage");
    widgets->HeadBox = yon_gtk_builder_get_widget(builder,"HeaderBox");
    widgets->HeadTitleLabel = yon_gtk_builder_get_widget(builder,"HeaderTitleLabel");
    widgets->HeadInfoLabel = yon_gtk_builder_get_widget(builder,"HeaderInfoLabel");
    
    widgets->StatusBox = yon_gtk_builder_get_widget(builder,"mainStatusBox");
    widgets->StatusIcon = yon_gtk_builder_get_widget(builder,"mainStatusIcon");
    widgets->StatusLabel = yon_gtk_builder_get_widget(builder,"mainStatusLabel");

    widgets->SaveLabel = yon_gtk_builder_get_widget(builder,"headerSaveConfigLabel");
    widgets->SaveMenuItem = yon_gtk_builder_get_widget(builder,"SaveGlobalLocalConfigurationMenuItem");
    widgets->SaveGlobalMenuItem = yon_gtk_builder_get_widget(builder,"SaveGlobalConfigurationMenuItem");
    widgets->SaveLocalMenuItem = yon_gtk_builder_get_widget(builder,"SaveLocalConfigurationMenuItem");
    widgets->RightBox = yon_gtk_builder_get_widget(builder,"HeaderRightBox");

    widgets->ChosenNameLabel = yon_gtk_builder_get_widget(builder,"MainChosenNameLabel");
    widgets->ChosenDescriptionLabel = yon_gtk_builder_get_widget(builder,"MainChosenDescriptionLabel");

    widgets->LoadLabel = yon_gtk_builder_get_widget(builder,"headerLoadConfigLabel");
    widgets->LoadGlobalMenuItem = yon_gtk_builder_get_widget(builder,"LoadGlobalConfigurationMenuItem");
    widgets->LoadLocalMenuItem = yon_gtk_builder_get_widget(builder,"LoadLocalConfigurationMenuItem");
    widgets->LeftBox = yon_gtk_builder_get_widget(builder,"HeaderLeftBox");

    widgets->DocumentationMenuItem = yon_ubl_menu_item_documentation_new(DOCUMENTATION_LABEL); // yon_gtk_builder_get_widget(builder,"DocumentationMenuItem");
    widgets->AboutMenuItem = yon_ubl_menu_item_about_new(ABOUT_LABEL); // yon_gtk_builder_get_widget(builder,"AboutMenuItem");
    
    widgets->FirstRowNamesTree = yon_gtk_builder_get_widget(builder,"FirstRowNamesTree");
    widgets->MainTree = yon_gtk_builder_get_widget(builder,"MainTree");

    widgets->ActionsPopover = yon_gtk_builder_get_widget(builder,"ActionsPopover");

    widgets->ServiceTreeColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder,"ServiceTreeColumn"));

    widgets->RMBMenu = yon_gtk_builder_get_widget(builder,"RMBMenu");

    GtkWidget *menu = yon_gtk_builder_get_widget(builder,"menu2");

    main_config.list = GTK_LIST_STORE(gtk_builder_get_object(builder,"mainList"));
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),widgets->DocumentationMenuItem);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu),widgets->AboutMenuItem);

    gtk_menu_attach_to_widget(GTK_MENU(widgets->RMBMenu),widgets->MainTree,NULL);

    if (main_config.lock_load_global == 1){
        gtk_widget_set_sensitive(widgets->LoadGlobalMenuItem,0);
    }
    if (main_config.lock_save_global == 1){
        gtk_widget_set_sensitive(widgets->SaveGlobalMenuItem,0);
        gtk_widget_set_sensitive(widgets->SaveMenuItem,0);
    }
    if (main_config.lock_save_local == 1){
        gtk_widget_set_sensitive(widgets->SaveLocalMenuItem,0);
        gtk_widget_set_sensitive(widgets->SaveMenuItem,0);
    }

    /* Signal connection | Присоединение сигналов */
    g_signal_connect(G_OBJECT(widgets->Window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(widgets->MainTree),"button-press-event",G_CALLBACK(on_context_menu_open),widgets);
    g_signal_connect(G_OBJECT(widgets->DocumentationMenuItem),"activate",G_CALLBACK(on_open_documentation_confirmation),WIKI_LINK);
    g_signal_connect(G_OBJECT(widgets->AboutMenuItem),"activate",G_CALLBACK(on_about),NULL);
    g_signal_connect(G_OBJECT(widgets->MainTree),"cursor-changed",G_CALLBACK(on_activate),widgets);


    g_signal_connect(G_OBJECT(widgets->LoadGlobalMenuItem), "activate", G_CALLBACK(yon_config_load_global), widgets);
    g_signal_connect(G_OBJECT(widgets->LoadLocalMenuItem), "activate", G_CALLBACK(yon_config_load_local), widgets);

    // g_signal_connect(G_OBJECT(widgets->SaveMenuItem), "activate", G_CALLBACK(yon_config_save), widgets);
    // g_signal_connect(G_OBJECT(widgets->SaveGlobalMenuItem), "activate", G_CALLBACK(yon_config_save_global), widgets);
    // g_signal_connect(G_OBJECT(widgets->SaveLocalMenuItem), "activate", G_CALLBACK(yon_config_save_local), widgets);
    

    gtk_widget_show(widgets->Window);
    return widgets;
}

int main(int argc, char *argv[]){
    local=setlocale(LC_ALL, "");
    textdomain (LocaleName);
    config_init();
    int option_index=0;
    int show_help=0;
    int debug_mode=0;
    {
        struct option long_options[] = {
                {"help", 0, 0, 'h'},
                {"version", 0, 0, 'V'},
                {"lock-help", 0,0, 1},
                {"lock-save", 0,0, 2},
                {"lock-save-local", 0,0, 3},
                {"lock-save-global", 0,0, 4},
                {"lock-load-global", 0,0, 5},
                {"socket-id", 1, 0, 's'},
                {"socket-ext-id", 1,0, 'e'},
                {"socket-trd-id", 1,0, 't'},
                {"debug", 0,0, 'd'},
                { NULL, 0, NULL, 0 }
        };
        for (int i=0;i<argc;i++){
            int argument=getopt_long(argc,argv,"hVvs:e:t:d",long_options,&option_index);
            switch(argument){
                case 'h':
                    show_help=1;
                    break;
                case 'v':
                case 'V':
                    printf("%s\n",VERSION_LABEL);
                    exit(0);
                    break;
                case 's':
                    if(optarg)
                        main_config.socket_id=atoi(optarg);
                    break;
                case 'e':
                    if(optarg)
                        main_config.load_socket_id=atoi(optarg);
                    break;
                case 't':
                    if(optarg)
                        main_config.save_socket_id=atoi(optarg);
                    break;
                case 1:
                    main_config.lock_help=1;
                    break;
                case 2:
                    main_config.lock_save_local=1;
                    main_config.lock_save_global=1;
                    break;
                case 3:
                    main_config.lock_save_local=1;
                    break;
                case 4:
                    main_config.lock_save_global=1;
                    break;
                case 5:
                    main_config.lock_load_global=1;
                    break;
            }
        }
        if (show_help==1&&main_config.lock_help!=1){
            printf("%s\n",HELP_LABEL);
            exit(0);
            }
    }

    if (getuid()!=0){
        main_config.lock_load_global=1;
        main_config.lock_save_global=1;
        main_config.lock_save_local=1;
    }
    gtk_init(&argc,&argv);
    

    main_window *widgets = setup_window();
    yon_ubl_header_setup_resource(widgets->HeadOverlay,widgets->HeadBox,widgets->HeadImage,banner_path);
    
    yon_ubl_status_box_setup(widgets->StatusIcon,widgets->StatusBox,widgets->StatusLabel);
    if (getuid()!=0)
        yon_ubl_status_box_render(ROOT_WARNING_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
    else
        yon_ubl_status_box_render(TITLE_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    yon_ubl_setup_sockets(widgets->PlugBox,widgets->LeftBox,widgets->RightBox,main_config.socket_id,main_config.load_socket_id,main_config.save_socket_id);
    yon_window_config_setup(GTK_WINDOW(widgets->Window));
    yon_window_config_load(config_path);
    yon_config_load_local(NULL,widgets);
    GtkCssProvider *css=gtk_css_provider_new();
    gtk_css_provider_load_from_resource(css,CssPath);
    gtk_style_context_add_provider_for_screen(gdk_screen_get_default(),
                            GTK_STYLE_PROVIDER(css),
                            -1);
    gtk_main();
}