#include "ubl-settings-keyboard.h"

config main_config;

void on_save_done(main_window *, config_str output, int size){
	char *final_output = yon_char_parsed_to_string(output,size,"");
	if (final_output){
		printf("%s\n",final_output);
		free(final_output);
	}
	yon_char_parsed_free(output,size);
	textdomain(template_ui_LocaleName);
	switch (main_config.save_config){
		case 0:
			yon_ubl_status_box_render(GLOBAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
			break;
		case 1:
			yon_ubl_status_box_render(LOCAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
			break;
		case 2:
			yon_ubl_status_box_render(GLOBAL_LOCAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
			break;
	}
	textdomain(LocaleName);
	
}

void on_config_global_local_save(GtkWidget *, main_window *){
    main_config.save_config=3;
    yon_save_proceed(NULL,YON_CONFIG_BOTH,config_get_global_command,NULL);
}

void on_config_local_save(GtkWidget *, main_window *){
    main_config.save_config=1;
    yon_save_proceed("system",YON_CONFIG_LOCAL,config_get_local_command,NULL);
    
}

void on_config_global_save(GtkWidget *, main_window *){
    main_config.save_config=0;
    yon_save_proceed("global",YON_CONFIG_GLOBAL,config_get_global_command,NULL);
    
}

void on_config_custom_save(GtkWidget *, main_window *){
    main_config.save_config=1;
	template_saving_window *window = yon_save_proceed(NULL,YON_CONFIG_CUSTOM,yon_config_get_custom_command("system"),NULL);
	if (window){};
}

void on_config_local_load(GtkWidget *,main_window *widgets){
        yon_load_proceed(YON_CONFIG_LOCAL);
        yon_interface_update(widgets);
        main_config.load_mode=1;
}

void on_config_global_load(GtkWidget *,main_window *widgets){
        yon_load_proceed(YON_CONFIG_GLOBAL);
        yon_interface_update(widgets);
        main_config.load_mode=0;
    
}

void on_config_custom_load(GtkWidget *,main_window *widgets){
	yon_load_proceed(YON_CONFIG_CUSTOM);
	textdomain(template_ui_LocaleName);
	yon_ubl_status_box_render(GLOBAL_LOAD_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
	textdomain(LocaleName);
	main_config.load_mode=3;
        yon_interface_update(widgets);
}

void yon_load_proceed(YON_CONFIG_TYPE type){
    yon_config_clean();
    if (!yon_char_is_empty(config_get_default_command))
        yon_config_load_config(YON_CONFIG_DEFAULT,config_get_default_command,NULL);
    if (type==YON_CONFIG_GLOBAL){
		yon_config_load_config(type,yon_debug_output("%s\n",config_get_global_command),NULL);
	} else if (type==YON_CONFIG_LOCAL){
		yon_config_load_config(type,config_get_local_command,NULL);
    } else if (type==YON_CONFIG_CUSTOM){
		char *path="";
        textdomain(template_ui_LocaleName);
		GtkWidget *dialog = gtk_file_chooser_dialog_new(template_app_information.app_title,NULL,GTK_FILE_CHOOSER_ACTION_SAVE,CANCEL_LABEL,GTK_RESPONSE_CANCEL,OPEN_LABEL,GTK_RESPONSE_ACCEPT,NULL);
        textdomain(LocaleName);
        gtk_window_set_icon_name(GTK_WINDOW(dialog),"com.ublinux.ubl-settings-services");
        gtk_window_set_title(GTK_WINDOW(dialog),TITLE_LABEL);
        GtkFileFilter *filter = gtk_file_filter_new();
		gtk_file_filter_add_pattern(filter,"*.ini");
        gtk_file_filter_set_name(filter, "*.ini");
		gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),filter);
		gtk_widget_show(dialog);
		int response = gtk_dialog_run(GTK_DIALOG(dialog));
		if (response == GTK_RESPONSE_ACCEPT){
			char *file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
			if (!yon_char_is_empty(file)){
				path=file;
			}
			gtk_widget_destroy(dialog);
		} else {
			gtk_widget_destroy(dialog);
		}
        char *command = yon_config_get_custom_command(path);
		yon_config_load_config(type,command,NULL);
	}
}

gboolean yon_interface_update(main_window *widgets){
    g_signal_handlers_block_by_func(G_OBJECT(widgets->ModelCombo),G_CALLBACK(on_model_changed),widgets);
    g_signal_handlers_block_by_func(G_OBJECT(widgets->MoveDownButton),G_CALLBACK(on_move_down),widgets);
    g_signal_handlers_block_by_func(G_OBJECT(widgets->MoveUpButton),G_CALLBACK(on_move_up),widgets);
    g_signal_handlers_block_by_func(G_OBJECT(widgets->OptionsButton),G_CALLBACK(on_options_open),widgets);
    g_signal_handlers_block_by_func(G_OBJECT(widgets->NumLockCombo),G_CALLBACK(on_num_lock_changed),widgets);
    gtk_list_store_clear(widgets->layoutsList);

    gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->ModelCombo),0);
    gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->NumLockCombo),0);
        GtkTreeIter iter;
    gtk_entry_set_text(GTK_ENTRY(widgets->OptionsEntry),DEFAULT_LABEL);
    {
        char *name = yon_config_get_by_key(model_parameter);
        char *id;
        if (name) {
            int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(widgets->modelsList),&iter);
            for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(widgets->modelsList),&iter)){
                gtk_tree_model_get(GTK_TREE_MODEL(widgets->modelsList),&iter,1,&id,-1);
                if (!strcmp(name,id)){
                    gtk_combo_box_set_active_iter(GTK_COMBO_BOX(widgets->ModelCombo),&iter);
                    break;
                }
            }
        } else gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->ModelCombo),0);
    }
    {
        char *name = yon_config_get_by_key(options_parameter);
        if (name) {
            char *id, *rname;
            gtk_entry_set_text(GTK_ENTRY(widgets->OptionsEntry),name);
            int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(main_config.options_list),&iter);
            for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(main_config.options_list),&iter)){
                gtk_tree_model_get(GTK_TREE_MODEL(main_config.options_list),&iter,0,&id,1,&rname,-1);
                if (!strcmp(id,name)){
                    gtk_list_store_set(main_config.options_list,&iter,2,1,-1);
                    gtk_entry_set_text(GTK_ENTRY(widgets->OptionsEntry),rname);
                    break;
                }
            }
        }
    }
    {
        if (main_config.layouts_list){
            for_iter(main_config.layouts_list,&iter){
                gtk_list_store_set(main_config.layouts_list,&iter,2,0,-1);
            }
        }
        char *name = yon_config_get_by_key(num_lock_boot_parameter);
        if (name) {
            if (!strcmp(name,"yes")) gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->NumLockCombo),1);
            else if (!strcmp(name,"no")) gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->NumLockCombo),2);
        }
        else gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->NumLockCombo),0);
        if (main_config.layouts_list){
            int size=0;
            name = yon_config_get_by_key(keyboard_layout_parameter);
            config_str layouts = yon_char_parse(name,&size,",");
            GtkTreeIter iter, itar;
            char *rid,*rname;
            gtk_list_store_clear(widgets->layoutsList);
            for (int i=0;i<size;i++){
                for_iter(main_config.layouts_list,&iter){
                    gtk_tree_model_get(GTK_TREE_MODEL(main_config.layouts_list),&iter,0,&rid,1,&rname,-1);
                    if (!strcmp(layouts[i],rid)){
                        gtk_list_store_append(widgets->layoutsList,&itar);
                        gtk_list_store_set(widgets->layoutsList,&itar,0,rname,1,rid,2,1,-1);
                    }
                }
            }
        }
    }

    g_signal_handlers_unblock_by_func(G_OBJECT(widgets->ModelCombo),G_CALLBACK(on_model_changed),widgets);
    g_signal_handlers_unblock_by_func(G_OBJECT(widgets->MoveDownButton),G_CALLBACK(on_move_down),widgets);
    g_signal_handlers_unblock_by_func(G_OBJECT(widgets->MoveUpButton),G_CALLBACK(on_move_up),widgets);
    g_signal_handlers_unblock_by_func(G_OBJECT(widgets->OptionsButton),G_CALLBACK(on_options_open),widgets);
    g_signal_handlers_unblock_by_func(G_OBJECT(widgets->NumLockCombo),G_CALLBACK(on_num_lock_changed),widgets);
    return G_SOURCE_REMOVE;
}

void on_num_lock_changed(GtkComboBox *self, main_window *){
    switch (gtk_combo_box_get_active(self)){
        case 0:
            yon_config_remove_by_key(num_lock_boot_parameter);
            break;
        case 1:  yon_config_register(num_lock_boot_parameter,num_lock_boot_parameter_command,"yes");
            break;
        case 2:yon_config_register(num_lock_boot_parameter,num_lock_boot_parameter_command,"no");
            break;
    }
}

void on_model_changed(GtkComboBoxText *self, main_window *widgets){
    switch (gtk_combo_box_get_active(GTK_COMBO_BOX(self))){
        case 0:
            yon_config_remove_by_key(model_parameter);
            break;
        default: 
            char *id;
            GtkTreeIter iter;
            gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widgets->ModelCombo),&iter);
            gtk_tree_model_get(GTK_TREE_MODEL(widgets->modelsList),&iter,1,&id,-1);
            yon_config_register(model_parameter,model_parameter_command,id);
            break;
    }

}

void on_options_accept(GtkWidget *self, dictionary *dict){
    main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
    layouts_window *window = yon_dictionary_get_data(dict->first->next,layouts_window*);
    GtkTreeModel *model = GTK_TREE_MODEL(window->list);
    GtkTreeIter iter;
    char *name, *id;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(window->MainTree)),&model,&iter)){
        gtk_tree_model_get(model,&iter,0,&id,1,&name,-1);
        gtk_entry_set_text(GTK_ENTRY(widgets->OptionsEntry),name);
        yon_config_register(options_parameter,options_parameter_command,id);
        
    }
    on_subwindow_close(self);
}

void yon_layouts_save(main_window *widgets){
    GtkTreeIter iter;
    GtkTreeIter child_iter;
    int size;
    config_str parsed = NULL;
    for_iter(widgets->layoutsFilter,&iter){
        char *name, *id;
        gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(widgets->layoutsFilter),&child_iter,&iter);
        gtk_tree_model_get(GTK_TREE_MODEL(widgets->layoutsList),&child_iter,0,&name,1,&id,-1);
        yon_char_parsed_add_or_create_if_exists(parsed,&size,id);
    }
    if (parsed&&size>0){
        yon_config_register(keyboard_layout_parameter,keyboard_layout_parameter_command,yon_char_parsed_to_string(parsed,size,","));
        yon_char_parsed_free(parsed,size);
    } else {
        yon_config_remove_by_key(keyboard_layout_parameter);
    }
}

void on_options_open(GtkWidget *, main_window *widgets){
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_layouts_path);
    layouts_window *window = malloc(sizeof(layouts_window));
    window->Window = yon_gtk_builder_get_widget(builder,"Window");
    window->AcceptButton = yon_gtk_builder_get_widget(builder,"AcceptButton");
    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
    window->MainTree = yon_gtk_builder_get_widget(builder,"LayoutsTree");
    window->list = main_config.options_list;
    gtk_tree_view_set_model(GTK_TREE_VIEW(window->MainTree),GTK_TREE_MODEL(window->list));
    dictionary *dict = NULL;
    gtk_tree_view_remove_column(GTK_TREE_VIEW(window->MainTree),gtk_tree_view_get_column(GTK_TREE_VIEW(window->MainTree),0));
    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->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
    g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_options_accept),dict);
}

GList *yon_get_all_selected(GtkTreeView *tree, int column){
    GtkTreeIter iter;
    GList *list = NULL; 
    GtkTreeModel *model = gtk_tree_view_get_model(tree);
    for_iter(model,&iter){
        int status;
        gtk_tree_model_get(model,&iter,column,&status,-1);
        if (status){
            GtkTreePath *path = gtk_tree_model_get_path(model,&iter);
            list = g_list_append(list,path);
        }
    }
    return list;
}

void on_layouts_accept(GtkWidget *self, dictionary *dict){
    main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
    layouts_window *window = yon_dictionary_get_data(dict->first->next,layouts_window*);
    gtk_list_store_clear(widgets->layoutsList);
    GtkTreeModel *model = GTK_TREE_MODEL(window->list);
    GList *list = yon_get_all_selected(GTK_TREE_VIEW(window->MainTree),2);
    char *name;
    char *id;
    GtkTreeIter iter, lwiter;
    GtkTreePath *pth;
    for (guint i=0;i<g_list_length(list);i++){
        pth = (GtkTreePath*)g_list_nth_data(list,i);
        gtk_tree_model_get_iter(model,&lwiter,pth);
        gtk_list_store_append(widgets->layoutsList,&iter);
        gtk_tree_model_get(model,&lwiter,0,&name,1,&id,-1);
        gtk_list_store_set(widgets->layoutsList,&iter,1,name,0,id,2,1,-1);
    }
    yon_layouts_save(widgets);
    on_subwindow_close(self);
}

void on_layouts_chosen(GtkCellRenderer *, gchar *path, layouts_window *window){
    GtkTreeIter iter;
    gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->list),&iter,path);
    int chosen;
    gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,2,&chosen,-1);
    gtk_list_store_set(window->list,&iter,2,!chosen,-1);
}

void on_layouts_add(GtkWidget *, main_window *widgets){
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_layouts_path);
    layouts_window *window = malloc(sizeof(layouts_window));
    window->Window = yon_gtk_builder_get_widget(builder,"Window");
    window->AcceptButton = yon_gtk_builder_get_widget(builder,"AcceptButton");
    window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
    window->ChosenCell = GTK_CELL_RENDERER(gtk_builder_get_object(builder,"ChosenCell"));
    window->MainTree = yon_gtk_builder_get_widget(builder,"LayoutsTree");
    window->list = main_config.layouts_list;
    gtk_tree_view_set_model(GTK_TREE_VIEW(window->MainTree), GTK_TREE_MODEL(window->list));
    gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(window->MainTree)),GTK_SELECTION_MULTIPLE);

    yon_gtk_window_setup(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->Window),TITLE_LABEL,icon_path,"layout_window");

    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->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
    g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_layouts_accept),dict);
    g_signal_connect(G_OBJECT(window->ChosenCell),"toggled",G_CALLBACK(on_layouts_chosen),window);
    char *languages = config(keyboard_layout_parameter);
    int size;
    config_str parsed = yon_char_parse(languages,&size,",");
    GtkTreeIter iter;
    for_iter(window->list,&iter){
        int found = 0;
        char *id;
        gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,0,&id,-1);
        for (int i=0;i<size;i++){
            if (!strcmp(id,parsed[i])){
                gtk_list_store_set(window->list,&iter,2,1,-1);
                found=1;
                break;
            }
        }
        if (!found) {
            gtk_list_store_set(window->list,&iter,2,0,-1);
        }
    }
}

void on_layouts_remove(GtkWidget *, main_window *widgets){
    GtkTreeModel *model = GTK_TREE_MODEL(widgets->layoutsList);
    GtkTreeIter iter;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->LayoutsTree)),&model,&iter)){
        GtkTreeIter iter_converted;
        char *target;
        gtk_tree_model_get(model,&iter,1,&target,-1);
        gtk_tree_model_filter_convert_iter_to_child_iter(widgets->layoutsFilter,&iter_converted,&iter);
        gtk_list_store_remove(widgets->layoutsList,&iter_converted);
        yon_config_remove_element(keyboard_layout_parameter,target,",");
    }
}

void on_move_up(GtkWidget *, main_window *widgets){
    GtkTreeModel *model = GTK_TREE_MODEL(widgets->layoutsFilter);
    GtkTreeIter iter,*previter;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->LayoutsTree)),&model,&iter)){
        previter = gtk_tree_iter_copy(&iter);
        if (gtk_tree_model_iter_previous(model,previter))
        {
            GtkTreeIter iter_converted, previter_converted;
            gtk_tree_model_filter_convert_iter_to_child_iter(widgets->layoutsFilter,&iter_converted,&iter);
            gtk_tree_model_filter_convert_iter_to_child_iter(widgets->layoutsFilter,&previter_converted,previter);
            gtk_list_store_move_before(widgets->layoutsList,&iter_converted,&previter_converted);
            yon_layouts_save(widgets);
        }
    }
}

void on_move_down(GtkWidget *, main_window *widgets){
    GtkTreeModel *model = GTK_TREE_MODEL(widgets->layoutsFilter);
    GtkTreeIter iter,*nextiter;
    if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->LayoutsTree)),&model,&iter)){
        nextiter = gtk_tree_iter_copy(&iter);
        if (gtk_tree_model_iter_next(model,nextiter)){
            GtkTreeIter iter_converted, nextiter_converted;
            gtk_tree_model_filter_convert_iter_to_child_iter(widgets->layoutsFilter,&iter_converted,&iter);
            gtk_tree_model_filter_convert_iter_to_child_iter(widgets->layoutsFilter,&nextiter_converted,nextiter);
            gtk_list_store_move_after(widgets->layoutsList,&iter_converted,&nextiter_converted);
            yon_layouts_save(widgets);
        }
    }

}



// standard functions


void 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->NumLockCombo = yon_gtk_builder_get_widget(builder,"NumlockCombo");
    widgets->ModelCombo = yon_gtk_builder_get_widget(builder,"ModelCombo");
    widgets->keyboard = yon_gtk_builder_get_widget(builder,"keyboard");
    widgets->keytable = yon_gtk_builder_get_widget(builder,"keytable");
    widgets->grp_toggle = yon_gtk_builder_get_widget(builder,"grp_toggle");
    widgets->OptionsEntry = yon_gtk_builder_get_widget(builder,"OptionsEntry");
    widgets->OptionsButton = yon_gtk_builder_get_widget(builder,"OptionsButton");
    widgets->LayoutsTree = yon_gtk_builder_get_widget(builder,"LayoutsTree");
    widgets->MoveUpButton = yon_gtk_builder_get_widget(builder,"MoveUpButton");
    widgets->MoveDownButton = yon_gtk_builder_get_widget(builder,"MoveDownButton");
    widgets->AddButton = yon_gtk_builder_get_widget(builder,"AddButton");
    widgets->RemoveButton = yon_gtk_builder_get_widget(builder,"RemoveButton");
    widgets->layoutsList = GTK_LIST_STORE(gtk_builder_get_object(builder,"liststore1"));
    widgets->layoutsFilter = GTK_TREE_MODEL_FILTER(gtk_builder_get_object(builder,"LayoutsFilter"));
    widgets->modelsList = GTK_LIST_STORE(gtk_builder_get_object(builder,"liststore2"));

    int size;
    GtkTreeIter iter;
    config_str models = yon_config_load(get_models_command,&size);
    for (int i=0;i<size;i+=2){
        models[i] = yon_char_divide_search(models[i],"\n",-1);
        models[i+1] = yon_char_divide_search(models[i+1],"\n",-1);
        gtk_list_store_append(widgets->modelsList,&iter);
        gtk_list_store_set(widgets->modelsList,&iter,1,models[i],0,_(models[i+1]),-1);
    }
    main_config.layouts_list = gtk_list_store_new(3,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_BOOLEAN);
    int laysize;
    config_str rtn = yon_resource_open_file(layouts_path,&size);
    for (int i=0; i<size; i++){
        yon_char_remove_last_symbol(rtn[i],'\n');
        config_str layout = yon_char_parse(rtn[i],&laysize,";");
        gtk_list_store_append(main_config.layouts_list,&iter);
        gtk_list_store_set(main_config.layouts_list,&iter,0,layout[0],1,_(layout[1]),-1);
    }
    main_config.options_list = gtk_list_store_new(3,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_BOOLEAN);
    rtn = yon_config_load(get_options_command,&size);
    for (int i=0; i<size;i++){
        int option_size;
        rtn[i] = yon_char_divide_search(rtn[i],"\n",-1);
        config_str option = yon_char_parse(rtn[i],&option_size,";");
        gtk_list_store_append(main_config.options_list,&iter);
        gtk_list_store_set(main_config.options_list,&iter,0,option[0],1,_(option[1]),-1);
    }

    /* Widget registration for config monitoring | Регистрация виджетов для мониторинга конфига */
    // yon_window_config_add_custom_parameter(widgets->HeadInfoLabel,"head-text","label",YON_TYPE_STRING); 

    /* Signal connection | Присоединение сигналов */

    g_signal_connect(G_OBJECT(widgets->AddButton),"clicked",G_CALLBACK(on_layouts_add),widgets);
    g_signal_connect(G_OBJECT(widgets->RemoveButton),"clicked",G_CALLBACK(on_layouts_remove),widgets);
    g_signal_connect(G_OBJECT(widgets->ModelCombo),"changed",G_CALLBACK(on_model_changed),widgets);
    g_signal_connect(G_OBJECT(widgets->MoveDownButton),"clicked",G_CALLBACK(on_move_down),widgets);
    g_signal_connect(G_OBJECT(widgets->MoveUpButton),"clicked",G_CALLBACK(on_move_up),widgets);
    g_signal_connect(G_OBJECT(widgets->OptionsButton),"clicked",G_CALLBACK(on_options_open),widgets);
    g_signal_connect(G_OBJECT(widgets->NumLockCombo),"changed",G_CALLBACK(on_num_lock_changed),widgets);
    }

    g_signal_connect(G_OBJECT(widgets->LoadLocalMenuItem),"activate",G_CALLBACK(on_config_local_load),widgets);
    g_signal_connect(G_OBJECT(widgets->LoadGlobalMenuItem),"activate",G_CALLBACK(on_config_global_load),widgets);
    g_signal_connect(G_OBJECT(widgets->LoadCustomMenuItem),"activate",G_CALLBACK(on_config_custom_load),widgets);

    g_signal_connect(G_OBJECT(widgets->SaveMenuItem),"activate",G_CALLBACK(on_config_global_local_save),NULL);
    g_signal_connect(G_OBJECT(widgets->SaveLocalMenuItem),"activate",G_CALLBACK(on_config_local_save),NULL);
    g_signal_connect(G_OBJECT(widgets->SaveGlobalMenuItem),"activate",G_CALLBACK(on_config_global_save),NULL);
    g_signal_connect(G_OBJECT(widgets->SaveCustomMenuItem),"activate",G_CALLBACK(on_config_custom_save),NULL);

    yon_root_button_setup((template_main_window*)widgets,main_config.launch_arguments,main_config.launch_size);
    yon_save_window_set_postsave_function(on_save_done,widgets);

    on_config_local_load(NULL,widgets);
}

int main(int argc, char *argv[]){ 
    setlocale(LC_ALL, "");
    textdomain (LocaleName);
    
    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(); 

    //turn off if custom presented
    // yon_ubl_settings_window_set_standard_callbacks(widgets,config_get_global_command,config_get_local_command,yon_config_get_custom_command("./"),config_get_default_command,config_get_global_only_parameters,config_get_local_only_parameters);

    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);
    main_config.launch_arguments=yon_char_parsed_copy(argv,argc);
    main_config.launch_size=argc;
    gtk_main();
    return 0;
}