#include "ubl-settings-video.h"

config videoconfig;

void yon_on_plug_added(GtkSocket *self, gpointer user_data)
{
}

void yon_on_plug_removed(GtkSocket *self, gpointer user_data)
{
}

void on_subwindow_close(GtkWidget *self)
{
    gtk_widget_destroy(gtk_widget_get_toplevel(self));
}

void on_monitor_config_save(GtkWidget *self, monitor_edit_window *window){
    monitorconfig *config = yon_dictionary_get_data(window->config,monitorconfig*);
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPortCombo))==0){
        videoconfig.status_render.text_to_render=MONITOR_PORT_ERROR_LABEL;
        videoconfig.status_render.type=BACKGROUND_IMAGE_FAIL_TYPE;
        yon_ubl_status_box_render(&videoconfig.status_render);
        return;
    }
    config->main=0;
    config->enable=0;
    config->position=0;
    config->rotation=0;
    config->dpms=0;
    config->cvt=0;
    config->reduced=0;
    config->position_port=NULL;
    config->port=NULL;
    config->resolution=NULL;
    config->frequency=NULL;
        videoconfig.status_render.text_to_render=MONITOR_PORT_SUCCESS_LABEL;
        videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
        yon_ubl_status_box_render(&videoconfig.status_render);
    config->port = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationPortCombo));
    window->config->key = yon_char_new(config->port);
    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationParameterLineCheck))==0){
    config->main = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationMainCheck));
    config->enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationEnableCheck));
    config->dpms = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationModelineCVTCheck));
    config->cvt = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationModelineCVTCheck));
    config->reduced = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationUseCVTReducedCheck));
    config->gtf = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationModelineGTFCheck));
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPositionPosCombo))!=0
                &&gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPositionPortCombo))!=0){
        config->position = gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPositionPosCombo));
        config->position_port = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationPositionPortCombo));
        
    }
    config->resolution=yon_char_divide_search(gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationResolutionCombo))," ",-1);
    int rotation = gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationRotationCombo));
    if (rotation==1) config->rotation=rotation;
    else if (rotation==2) config->rotation=rotation;
    else if (rotation==3) config->rotation=rotation;
    else config->rotation=0;
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo))!=0) {
        char *resolution = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationResolutionCombo));
    }
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo))!=0) {
        char *frequency = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationFrequencyCombo));
    }
    yon_monitor_make_string(config);
    } else {
    char *stringparameters = (char*)gtk_entry_get_text(GTK_ENTRY(window->templateMonitorConfigurationParameterLineEntry));
    }
    yon_monitor_view_update();
    on_subwindow_close(self);
}

void on_driver_pack_install(GtkWidget *self,widgets_dict *widgets){
    GtkTreeIter iter;
    char *name;
    GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->proprietaryTreeView));
    gtk_tree_selection_get_selected(selection,&list_s,&iter);
    gtk_tree_model_get(list_s,&iter,1,&name,-1);
    pthread_t tid;
    pthread_create(&tid,NULL,(void*)yon_launch_with_output,(void*)yon_char_get_augumented(install_proprietary_command,name));
    
}

void on_driver_install(GtkWidget *self,widgets_dict *widgets){

    GtkTreeIter iter;
    char *name;
    GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->driversTreeView));
    gtk_tree_selection_get_selected(selection,&list_s,&iter);
    gtk_tree_model_get(list_s,&iter,1,&name,-1);
    pthread_t tid;
    pthread_create(&tid,NULL,(void*)yon_launch_with_output,(void*)yon_char_get_augumented(install_proprietary_command,name));

}

void on_driver_pack_delete(GtkWidget *self,widgets_dict *widgets){

    GtkTreeIter iter;
    char *name;
    GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->proprietaryTreeView));
    gtk_tree_selection_get_selected(selection,&list_s,&iter);
    gtk_tree_model_get(list_s,&iter,1,&name,-1);
    pthread_t tid;
    pthread_create(&tid,NULL,(void*)yon_launch_with_output,(void*)yon_char_get_augumented(delete_proprietary_command,name));

}

void on_driver_delete(GtkWidget *self,widgets_dict *widgets){

    GtkTreeIter iter;
    char *name;
    GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->driversTreeView));
    gtk_tree_selection_get_selected(selection,&list_s,&iter);
    gtk_tree_model_get(list_s,&iter,1,&name,-1);
    pthread_t tid;
    pthread_create(&tid,NULL,(void*)yon_launch_with_output,(void*)yon_char_get_augumented(delete_proprietary_command,name));

}

void on_driver_pack_info(GtkWidget *self, widgets_dict *widgets){

    pthread_attr_t attr;
    pthread_t tid;
    pthread_attr_init(&attr);
    GtkTreeIter iter;
    char *name;
    GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->proprietaryTreeView));
    gtk_tree_selection_get_selected(selection,&list_s,&iter);
    gtk_tree_model_get(list_s,&iter,1,&name,-1);
    pthread_create(&tid,&attr,(void*)yon_launch_app,yon_char_get_augumented(get_info_proprietary_command,name));
}

void on_driver_info(GtkWidget *self,widgets_dict *widgets){

    pthread_attr_t attr;
    pthread_t tid;
    pthread_attr_init(&attr);
    GtkTreeIter iter;
    char *name;
    GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->driversTreeView));
    gtk_tree_selection_get_selected(selection,&list_s,&iter);
    gtk_tree_model_get(list_s,&iter,1,&name,-1);
    pthread_create(&tid,&attr,(void*)yon_launch_app,yon_char_get_augumented(get_info_proprietary_command,name));

}

void on_port_chosen_changed(GtkWidget *self, monitor_edit_window *window){
    monitorconfig* config = yon_dictionary_get_data(window->config,monitorconfig*);
    dictionary *dict=NULL;
    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationResolutionCombo));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationResolutionCombo),PARAMETER_DEFAULT_LABEL);
    gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo),0);
    char *combo_text=yon_char_new((char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationPortCombo)));
    char *resolution = yon_char_divide_search(combo_text," ",-1);
    if (combo_text)
    if (strcmp(combo_text,MONITOR_CHOOSE_PORT_LABEL)!=0){
            dict=yon_dictionary_find(&videoconfig.supported_resolutions,resolution);
        if (dict){
            resolution_supported *res = yon_dictionary_get_data(dict,resolution_supported*);
            int found_size=0;
            for (int i=0;i<res->size;i++){
                char *check_line;
                for (int j=0;j<videoconfig.resolutionssize;j++){
                    check_line=yon_char_new(videoconfig.resolutions[j]);
                    check_line=yon_char_divide_search(check_line," ",-1);
                    if (strstr(videoconfig.resolutions[j],res->line[i])){
                        found_size++;
                        if(!config->resolutionCapabilities) config->resolutionCapabilities=new(char*);
                        else config->resolutionCapabilities=realloc(config->resolutionCapabilities,sizeof(char*)*found_size);
                        config->resolutionCapabilities[found_size-1]=videoconfig.resolutions[j];
                        config->resolution_size=found_size;
                    }
                }
            }
            yon_gtk_combo_box_fill(window->templateMonitorConfigurationResolutionCombo,config->resolutionCapabilities, config->resolution_size);
        }
    }
}

void on_save_driver_configuration(GtkWidget *self,combo_tree *widgets){
    GtkTreeIter iter;
    char *name;
    GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->tree));
    gtk_tree_selection_get_selected(selection,&list_s,&iter);
    gtk_tree_model_get(list_s,&iter,0,&name,-1);
    int ret = yon_gtk_combo_box_text_find(widgets->combo,name);
    if (ret!=-1)
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->combo),ret);
    
    on_subwindow_close(self);
}

void on_sensitive_change(GtkWidget *self, GtkWidget *toggle)
{
    int state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self));

    gtk_widget_set_sensitive(toggle, state);
}

void on_sensitive_change_reversed(GtkWidget *self, GtkWidget *toggle)
{
    int state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self));

    gtk_widget_set_sensitive(toggle, !state);
}

void on_auto_choose_drivers(GtkWidget *self, widgets_dict *widgets)
{
    int state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self));

    gtk_widget_set_sensitive(widgets->mainDriverFailsafeNvidiaLabel, !state);
    gtk_widget_set_sensitive(widgets->mainDriverFailsafeAMDCombo, !state);
    gtk_widget_set_sensitive(widgets->mainDriverFailsafeAMDLabel, !state);
    gtk_widget_set_sensitive(widgets->mainDriverFailsafeNvidiaCombo, !state);
}

// void on_closed_configuration(GtkWidget *self, MonitorSettings *monitors)
// {
//     gtk_widget_destroy(monitors->templateMonitorConfigurationWindow);
// }

char *yon_configuration_get_save_command(char *command){
    char *str = NULL;
    char *dntus = NULL;
    dntus=_("Don't use");
    str=yon_char_new(command);
    if (videoconfig.autoChooseDrivers==0){
        if (strcmp(videoconfig.failsafenVidia, dntus)!=0)
            str = yon_char_get_augumented(str, yon_char_get_augumented(" FAILSAFENVIDIA=", videoconfig.failsafenVidia));
        if (strcmp(videoconfig.failsafeATI, dntus)!=0)
            str = yon_char_get_augumented(str, yon_char_get_augumented(" FAILSAFEATI=", videoconfig.failsafeATI));
    }
    if (strcmp(videoconfig.optirun, dntus)!=0&&strcmp(videoconfig.optirun, "")!=0)
        str = yon_char_get_augumented(str, yon_char_get_augumented(" OPTIRUN=", videoconfig.optirun));
    if (strcmp(videoconfig.primusrun, dntus)!=0&&strcmp(videoconfig.primusrun, "")!=0)
        str = yon_char_get_augumented(str, yon_char_get_augumented(" PRIMUSRUN=", videoconfig.primusrun));

    dictionary *dict=NULL;
    for_dictionaries(dict,videoconfig.monitors){
        if (yon_dictionary_get_data(dict,monitorconfig*)->stringparameters){

            str=yon_char_get_augumented(str, yon_config_make_save_parameter_with_multiple_arguments(yon_dictionary_get_data(dict,monitorconfig*)->stringparameters,XORG_MONITOR(dict->key),","));
            
        }
    }

    if (strcmp(str,command)!=0)
        return str;
    else return NULL;
}

void on_resolutions_unsupported_show(GtkWidget *self, monitor_edit_window *window){
    ((monitorconfig*)window->config->data)->show_usupported = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self));
    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationResolutionCombo));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationResolutionCombo),PARAMETER_DEFAULT_LABEL);
    gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo),0);
    if (((monitorconfig*)window->config->data)->show_usupported==1){
        yon_gtk_combo_box_fill(window->templateMonitorConfigurationResolutionCombo,videoconfig.resolutions,videoconfig.resolutionssize);
    } else {
        yon_gtk_combo_box_fill(window->templateMonitorConfigurationResolutionCombo,((monitorconfig*)window->config->data)->resolutionCapabilities,((monitorconfig*)window->config->data)->resolution_size);

    }
}

char *yon_configuration_get_remove_command(char *command){
    char *str = NULL;
    char *dntus = NULL;
    dntus=_("Don't use");
    str=yon_char_new(command);
    str = yon_char_get_augumented(str, " FAILSAFENVIDIA");
    str = yon_char_get_augumented(str, " FAILSAFATI");
    str = yon_char_get_augumented(str, " OPTIRUN");
    str = yon_char_get_augumented(str, " PRIMUSRUN");
    dictionary *dict=NULL;
    for_dictionaries(dict,videoconfig.monitors){
        str = yon_char_get_augumented(str, yon_char_get_augumented(" XORG_MONITOR[", yon_char_get_augumented(dict->key, "]")));
    }
    if (strcmp(str,command)!=0)
        return str;
    else return NULL;
}

void on_configuration_save_local(GtkWidget *self, widgets_dict *widgets)
{
    yon_update_config(widgets);
    char *str=NULL;
    char *delstr=NULL;
    str=yon_configuration_get_save_command(save_drivers_local_command);
    delstr=yon_configuration_get_remove_command(remove_drivers_local_command);
    if (delstr){ 
        yon_config_save(delstr);
    }
    if (str){
        printf(str);
        yon_config_save(str);
        
        videoconfig.status_render.text_to_render=LOCAL_SAVE_SUCCESS;
        videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
        yon_ubl_status_box_render(&videoconfig.status_render);
    }
     // else
    // yon_ubl_status_box_render(widgets->mainStatusBox, widgets->mainStatusIcon, widgets->mainStatusLabel, _("Local configuration saving failed."), BACKGROUND_IMAGE_FAIL_TYPE);
}

void on_configuration_save_local_global(GtkWidget *self, widgets_dict *widgets)
{
    on_configuration_save_global(self, widgets);
    on_configuration_save_local(self, widgets);
        videoconfig.status_render.text_to_render=GLOBAL_LOCAL_SAVE_SUCCESS;
        videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
    yon_ubl_status_box_render(&videoconfig.status_render);
}

void on_configuration_save_global(GtkWidget *self, widgets_dict *widgets)
{
        videoconfig.status_render.text_to_render=GLOBAL_SAVE_SUCCESS;
        videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
    yon_ubl_status_box_render(&videoconfig.status_render);
    yon_update_config(widgets);
    char *str = NULL;
    if (videoconfig.failsafenVidia)
        str = yon_char_get_augumented(save_drivers_global_command, yon_char_get_augumented(" ", videoconfig.failsafenVidia));
    if (videoconfig.failsafeATI)
        str = yon_char_get_augumented(str, yon_char_get_augumented(" ", videoconfig.failsafeATI));
    if (videoconfig.optirun)
        str = yon_char_get_augumented(str, yon_char_get_augumented(" ", videoconfig.optirun));
    if (videoconfig.primusrun)
        str = yon_char_get_augumented(str, yon_char_get_augumented(" ", videoconfig.primusrun));
    printf(str);
    yon_config_save(str);
}

void yon_update_config(widgets_dict *widgets)
{
    videoconfig.optirun = yon_char_new( (char *)gtk_entry_get_text(GTK_ENTRY(widgets->mainExtraLaunchOptirunEntry)));
    videoconfig.primusrun = yon_char_new( (char *)gtk_entry_get_text(GTK_ENTRY(widgets->mainExtraLaunchPrismusunEntry)));
    videoconfig.failsafenVidia = yon_char_new( gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo)));
    videoconfig.failsafeATI = yon_char_new( gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo)));
}

void on_configuration_load_local(GtkWidget *self, widgets_dict *widgets)
{
        videoconfig.status_render.text_to_render=LOCAL_LOAD_SUCCESS;
        videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
    yon_ubl_status_box_render(&videoconfig.status_render);
    char *command = load_drivers_local_command;
    dictionary *dct;
    for_dictionaries(dct, videoconfig.monitors)
    {
        command = yon_char_get_augumented(command, (yon_char_get_augumented(" XORG_MONITOR[", yon_char_get_augumented(((monitorconfig *)dct->data)->port, "]"))));
    }
    int size = 0;
    char **rtn = yon_ubl_load_global_config(command, &size);
    char *param = NULL;
    // yon_config_init(rtn, size);
    on_config_fill_interface(widgets);
}

void on_configuration_load_global(GtkWidget *self, widgets_dict *widgets)
{
        videoconfig.status_render.text_to_render=GLOBAL_LOAD_SUCCESS;
        videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
    yon_ubl_status_box_render(&videoconfig.status_render);
    char *command = load_drivers_global_command;
    dictionary *dct;
    for_dictionaries(dct, videoconfig.monitors)
    {
        command = yon_char_get_augumented(command, (yon_char_get_augumented(" XORG_MONITOR[", yon_char_get_augumented(((monitorconfig *)dct->data)->port, "]"))));
    }
    int size = 0;
    char **rtn = yon_ubl_load_global_config(command, &size);
    char *param = NULL;
    // yon_config_init(rtn, size);
    on_config_fill_interface(widgets);
}

/**void on_monitor_delete(GtkWidget *self,monitor_view windowd)
 * [EN]
*/
void on_monitor_delete(GtkWidget *self,monitor_view windowd){
    monitor_window *window = yon_dictionary_get_data(windowd,monitor_window*); 
    if(window&&window->config){
        gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(window->templateMonitorscreenOverlay)),window->templateMonitorscreenOverlay);
        yon_dictionary_rip(windowd);
        gtk_widget_destroy(window->templateMonitorscreenOverlay);
        yon_dictionary_rip(window->config);
        free(window);
    }
}

/**void on_monitor_switch(GtkWidget *self,monitor_window *window)
 * [EN]
*/
void on_monitor_switch(GtkWidget *self,monitor_window *window){
    if(window&&window->config){
        int *enable = &yon_dictionary_get_data(window->config,monitorconfig*)->enable;
        *enable=!*enable;
        gtk_widget_set_sensitive(window->templateMonitorImage,*enable); 
    }
}

/**void on_monitor_add(GtkWidget *self,monitor_window *window)
 * [EN]
*/
void on_monitor_add(GtkWidget *self,monitor_window *window){
    if(window){
        videoconfig.monitors = yon_monitor_config_new(PARAMETER_DEFAULT_LABEL);
        yon_monitor_view_new(videoconfig.monitors);
        yon_monitor_view_draw_all(NULL);
    }
}

void on_monitor_configure(GtkWidget *self,monitor_window *window){
    if(window&&window->config){
        monitor_edit_window *monitors = new(monitor_edit_window);
        GtkBuilder *builder = gtk_builder_new_from_file(glade_path);
        monitors->templateMonitorConfigurationWindow = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationWindow"));
        monitors->mainMonitorConfigurationBox = GTK_WIDGET(gtk_builder_get_object(builder, "mainMonitorConfigurationBox"));
        monitors->templateMonitorConfigurationBox = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationBox"));
        monitors->templateMonitorConfigurationEnableCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationEnableCheck"));
        monitors->templateMonitorConfigurationPortLabel = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationPortLabel"));
        monitors->templateMonitorConfigurationPortCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationPortCombo"));
        monitors->templateMonitorConfigurationMainCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationMainCheck"));
        monitors->templateMonitorConfigurationResolutionLabel = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationResolutionLabel"));
        monitors->templateMonitorConfigurationResolutionCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationResolutionCombo"));
        monitors->templateMonitorConfigurationShowUnsupportedCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationShowUnsupportedCheck"));
        monitors->templateMonitorConfigurationFrequencyLabel = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationFrequencyLabel"));
        monitors->templateMonitorConfigurationFrequencyCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationFrequencyCombo"));
        monitors->templateMonitorConfigurationRotationLabel = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationRotationLabel"));
        // monitors->templateMonitorConfigurationDoNotSwitchOffLabel = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationDoNotSwitchOffLabel"));
        monitors->templateMonitorConfigurationRotationCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationRotationCombo"));
        monitors->templateMonitorConfigurationPositionLabel = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationPositionLabel"));
        monitors->templateMonitorConfigurationPositionPosCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationPositionPosCombo"));
        monitors->templateMonitorConfigurationPositionPortCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationPositionPortCombo"));

        monitors->templateMonitorConfigurationModelineCVTCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationModelineCVTCheck"));
        monitors->templateMonitorConfigurationUseCVTReducedCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationUseCVTReducedCheck"));
        monitors->templateMonitorConfigurationModelineGTFCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationModelineGTFCheck"));
        monitors->templateMonitorConfigurationParameterLineCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationParameterLineCheck"));
        monitors->templateMonitorConfigurationParameterLineEntry = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationParameterLineEntry"));
        monitors->templateMonitorConfigurationCancelButton = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationCancelButton"));
        monitors->templateMonitorConfigurationSaveButton = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationSaveButton"));
        monitors->templateMonitorConfigurationDoNotSwitchOffCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationDoNotSwitchOffCheck"));
        monitors->config=window->config;
        
        g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationCancelButton), "clicked", G_CALLBACK(on_subwindow_close), NULL);
        g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationSaveButton), "clicked", G_CALLBACK(on_monitor_config_save), monitors);
        g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationParameterLineCheck), "toggled", G_CALLBACK(on_sensitive_change_reversed), monitors->templateMonitorConfigurationBox);
        g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationParameterLineCheck), "toggled", G_CALLBACK(on_sensitive_change), monitors->templateMonitorConfigurationParameterLineEntry);
        g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationShowUnsupportedCheck), "toggled", G_CALLBACK(on_resolutions_unsupported_show),monitors);
        g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationPortCombo), "changed", G_CALLBACK(on_port_chosen_changed),monitors);

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(monitors->templateMonitorConfigurationEnableCheck),yon_dictionary_get_data(monitors->config,monitorconfig*)->enable==1);

        gtk_window_set_title(GTK_WINDOW(monitors->templateMonitorConfigurationWindow),SETTINGS_VIDEO_TITLE_LABEL);

        gtk_label_set_text(GTK_LABEL(monitors->templateMonitorConfigurationPortLabel),MONITOR_PORT_LABEL);
        gtk_label_set_text(GTK_LABEL(monitors->templateMonitorConfigurationResolutionLabel),MONITOR_RESOLUTION_LABEL);
        gtk_label_set_text(GTK_LABEL(monitors->templateMonitorConfigurationFrequencyLabel),MONITOR_FREQUENCY_LABEL);
        gtk_label_set_text(GTK_LABEL(monitors->templateMonitorConfigurationRotationLabel),MONITOR_ROTATION_LABEL);
        gtk_label_set_text(GTK_LABEL(monitors->templateMonitorConfigurationPositionLabel),MONITOR_POSITION_LABEL);

        gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationEnableCheck),MONITOR_ENABLED_LABEL);
        gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationMainCheck),MONITOR_MAIN_DISPLAY_LABEL);
        gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationShowUnsupportedCheck),MONITOR_UNSUPPORTED_LABEL);
        gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationDoNotSwitchOffCheck),MONITOR_SWITCH_OFF_LABEL);
        gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationModelineCVTCheck),MONITOR_CVT_LABEL);
        gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationUseCVTReducedCheck),MONITOR_REDUCED_LABEL);
        gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationModelineGTFCheck),MONITOR_GTF_LABEL);
        gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationParameterLineCheck),MONITOR_MANUALLY_LABEL);
        gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationCancelButton),MONITOR_CANCEL_LABEL);
        gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationSaveButton),MONITOR_SAVE_LABEL);
        
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPortCombo),MONITOR_CHOOSE_PORT_LABEL);
        dictionary *dict=NULL;
        for (int i=0;i<videoconfig.portssize;i++){
            dictionary *check_if_exists = yon_dictionary_find(&videoconfig.monitors,videoconfig.ports[i]);
            if (!yon_dictionary_get_data(check_if_exists,monitorconfig*)->stringparameters)
                gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPortCombo),videoconfig.ports[i]);

        }
        gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationPortCombo),0);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationResolutionCombo),PARAMETER_DEFAULT_LABEL);
        gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationResolutionCombo),0);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationFrequencyCombo),PARAMETER_DEFAULT_LABEL);
        gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationFrequencyCombo),0);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationRotationCombo),MONITOR_NO_ROTATION_LABEL);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationRotationCombo),MONITOR_LEFT_LABEL);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationRotationCombo),MONITOR_RIGHT_LABEL);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationRotationCombo),MONITOR_INVERTED_LABEL);
        gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationRotationCombo),0);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPosCombo),PARAMETER_DEFAULT_LABEL);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPosCombo),MONITOR_LEFT_POS_LABEL);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPosCombo),MONITOR_RIGHT_POS_LABEL);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPosCombo),MONITOR_ABOVE_POS_LABEL);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPosCombo),MONITOR_BELOW_POS_LABEL);
        gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationPositionPosCombo),0);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPortCombo),PARAMETER_DEFAULT_LABEL);
        for (int i=0;i<videoconfig.portssize;i++){
            gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPortCombo),videoconfig.ports[i]);
        }
        gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationPositionPortCombo),0);

        yon_monitor_window_update(monitors);

        gtk_widget_show(monitors->templateMonitorConfigurationWindow);
    }
}

/**void on_about()
 * [EN]
*/
void on_about()
{
    GtkBuilder *builder = gtk_builder_new_from_file(glade_path);
    GtkWidget *window = yon_gtk_builder_get_widget(builder, "aboutWindow");
    GtkWidget *hideButtonBox = yon_gtk_builder_get_widget(builder, "buttonBoxHide");
    gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(window), _("UBlinux Video Configuration"));
    gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(window), version_application);
    gtk_about_dialog_set_website_label(GTK_ABOUT_DIALOG(window), _("Progect Home Page"));
    gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(window), _("Videocard and monitor configuration manager"));
    gtk_widget_set_visible(hideButtonBox, 0);
    gtk_widget_show(window);
}

void yon_monitor_window_update(monitor_edit_window *window){
    if (window){
        int found = yon_gtk_combo_box_text_find(window->templateMonitorConfigurationPortCombo, window->config->key);
        if (found==-1)
            found=0;
        gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPortCombo),found);
        gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo),found);
    
        found = yon_gtk_combo_box_text_find(window->templateMonitorConfigurationPositionPortCombo, yon_dictionary_get_data(window->config,monitorconfig*)->position_port);
        if (found==-1)
            found=0;
        gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPositionPortCombo),found);
        gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPositionPosCombo),yon_dictionary_get_data(window->config,monitorconfig*)->position);
        gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationRotationCombo),yon_dictionary_get_data(window->config,monitorconfig*)->rotation);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationDoNotSwitchOffCheck),yon_dictionary_get_data(window->config,monitorconfig*)->dpms);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationMainCheck),yon_dictionary_get_data(window->config,monitorconfig*)->main);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationModelineCVTCheck),yon_dictionary_get_data(window->config,monitorconfig*)->cvt);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationUseCVTReducedCheck),yon_dictionary_get_data(window->config,monitorconfig*)->reduced);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationModelineGTFCheck),yon_dictionary_get_data(window->config,monitorconfig*)->gtf);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationEnableCheck),yon_dictionary_get_data(window->config,monitorconfig*)->enable);
        if(yon_dictionary_get_data(window->config,monitorconfig*)->stringparameters)
            gtk_entry_set_text(GTK_ENTRY(window->templateMonitorConfigurationParameterLineEntry),yon_dictionary_get_data(window->config,monitorconfig*)->stringparameters);
    }

}

void yon_popen(thread_input *input){
    *(FILE**)input->data=popen(input->command,"r");
}

void yon_launch_with_output(char *command){
    pthread_t tid;
    FILE *output =NULL;
    FILE **output_file=&output;
    thread_input input;
    input.command=command;
    input.data=output_file;
    pthread_create(&tid,NULL,(void*)yon_popen,&input);
    // char **output_strings = NULL;
    // output_strings = malloc(sizeof(char));
    // int i = 0;
    // char str[1000];
    // memset(str, 0, 1000);
    // while (1){
    //     if (output){
    //         if (fgets(str, 1000, output)){
    //             videoconfig.status_render.text_to_render=str;
    //             videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
    //             _yon_ubl_status_box_render(&videoconfig.status_render);
    //         }
    //     }
    // }
}

/**void yon_monitor_view_draw_all(GtkWidget *cnt)
 * [EN]
*/
void yon_monitor_view_draw_all(GtkWidget *cnt){
    monitor_view dict=NULL;
    GtkWidget *container=NULL;
    if(!container&&cnt) container=cnt;
    if(videoconfig.monitor_visuals){
        for_dictionaries(dict,videoconfig.monitor_visuals){
            monitor_window *window = yon_dictionary_get_data(dict,monitor_window*);
            if (!container) container = gtk_widget_get_parent(window->templateMonitorscreenOverlay); 
            if(container){
            g_object_ref(G_OBJECT(window->templateMonitorscreenOverlay));
            gtk_container_remove(GTK_CONTAINER(container),window->templateMonitorscreenOverlay);
            }
        }
        if (container)
        for_dictionaries(dict,videoconfig.monitor_visuals){
            monitor_window *window = yon_dictionary_get_data(dict,monitor_window*);
            if(dict->first==dict) {}
            else gtk_box_pack_start(GTK_BOX(container),window->templateMonitorscreenOverlay,0,0,0);
        }
        monitor_window *window = yon_dictionary_get_data(videoconfig.monitor_visuals->first,monitor_window*);
        gtk_box_pack_start(GTK_BOX(container),window->templateMonitorscreenOverlay,0,0,0);
    }
    yon_monitor_view_update();
}

/**void yon_monitor_view_setup(GtkWidget *container)
 * [EN]
*/
void yon_monitor_view_setup(GtkWidget *container){
    if(container){
        monitor_config config=NULL;
        yon_monitor_view_new(NULL);
        if (videoconfig.monitors){
            for_dictionaries(config,videoconfig.monitors){
                if (yon_dictionary_get_data(config,monitorconfig*)->stringparameters)
                    yon_monitor_view_new(config);
            }
        }
        yon_monitor_view_draw_all(container);
    }
}

/**void yon_monitor_view_update()
 * [EN]
*/
void yon_monitor_view_update(){
    monitor_view dict=NULL;
    for_dictionaries(dict,videoconfig.monitor_visuals){
        if(dict!=videoconfig.monitor_visuals->first){
            monitor_window *monitor = yon_dictionary_get_data(dict,monitor_window*);
            monitorconfig *config = yon_dictionary_get_data(monitor->config,monitorconfig*);
            if (strcmp(monitor->config->key,PARAMETER_DEFAULT_LABEL)!=0)
                gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoNameLabel),yon_char_get_augumented(MONITOR_LABEL,monitor->config->key));
            else
                gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoNameLabel),yon_char_get_augumented(MONITOR_LABEL,""));
            if (config->resolution)
                gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoResolutionLabel),config->resolution);
            else
                gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoResolutionLabel),PARAMETER_DEFAULT_LABEL);
        }
    }
}

/**char *yon_monitor_make_string(monitorconfig* config)
 * [EN]
*/
char *yon_monitor_make_string(monitorconfig* config)
{
    int first=1;
    char *main="";
    if (config->main==1){
        main="primary";
        first=0;
    }

    char *resolution="";
    if(config->resolution)
        if (first==1){
        resolution=config->resolution;
        first=0;
        }else{
        resolution=yon_char_get_augumented(",",config->resolution);
        }

    char *enable="";
    if (config->enable==1)
        if (first==1){
        enable="enable";
        first=0;
        }else{
        enable=",enable";
        }
    else 
        if (first==1){
        enable="disable";
        first=0;
        }else{
        enable=",disable";
        }

    char *position="";
    if (config->position==1)
        if (first==1){
        position=yon_char_get_augumented("lo:",config->position_port);
        first=0;
        }else{
        position=yon_char_get_augumented(",lo:",config->position_port);
        }
    else if (config->position==2)
        if (first==1){
        position=yon_char_get_augumented("ro:",config->position_port);
        first=0;
        }else{
        position=yon_char_get_augumented(",ro:",config->position_port);
        }
    else if (config->position==3)
        if (first==1){
        position=yon_char_get_augumented("ab:",config->position_port);
        first=0;
        }else{
        position=yon_char_get_augumented(",ab:",config->position_port);
        }
    else if (config->position==4)
        if (first==1){
        position=yon_char_get_augumented("be:",config->position_port);
        first=0;
        }else{
        position=yon_char_get_augumented(",be:",config->position_port);
        }

    char *rotation="";
    if (config->rotation==0)
        if (first==1){
        rotation="rotate:normal";
        first=0;
        }else{
        rotation=",rotate:normal";
        }
    else if (config->rotation==1)
        if (first==1){
        rotation="rotate:left";
        first=0;
        }else{
        rotation=",rotate:left";
        }
    else if (config->rotation==2)
        if (first==1){
        rotation="rotate:right";
        first=0;
        }else{
        rotation=",rotate:right";
        }
    else if (config->rotation==3)
        if (first==1){
            rotation="rotate:invert";
        first=0;
        }else{
            rotation=",rotate:invert";
        }

    char *dpms="";
    if (config->dpms==1)
        if (first==1){
        dpms="dpms";
        first=0;
        }else{
        dpms=",dpms";
        }

    char *cvt="";
    if (config->cvt==1)
        if (first==1){
        cvt="cvt";
        first=0;
        }else{
        cvt=",cvt";
        }

    char *reduced="";
    if (config->reduced==1)
        if (first==1){
        reduced="reduced";
        first=0;
        }else{
        reduced=",reduced";
        }

    char *gtf="";
    if (config->gtf==1)
        if (first==1){
        gtf="gtf";
        first=0;
        }else{
        gtf=",gtf";
        }
        

    char *frequency="";   
    if (config->frequency)
        if (first==1){
        frequency=config->frequency;
        first=0;
        }else{
        frequency=yon_char_get_augumented(",",config->frequency);
        } 
    
    char *stringparameters=yon_char_unite("",main,resolution,frequency,enable,position,rotation,dpms,cvt,reduced,gtf,NULL);
    config->stringparameters=yon_char_new(stringparameters);
}

/**void on_config_fill_interface(widgets_dict *widgets)
 * [EN]
*/
void on_config_fill_interface(widgets_dict *widgets)
{
    gtk_widget_grab_focus(widgets->mainHeaderSettingsButton);
    char *str = videoconfig.optirun;
    gtk_entry_set_text(GTK_ENTRY(widgets->mainExtraLaunchOptirunEntry), "");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchOptirunCheck), 0);
    if (str)
    {
        yon_char_divide_search((str = yon_char_new(videoconfig.optirun)), "=", -1);
        gtk_entry_set_text(GTK_ENTRY(widgets->mainExtraLaunchOptirunEntry), str);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchOptirunCheck), 1);
    }
    str = videoconfig.primusrun;
    gtk_entry_set_text(GTK_ENTRY(widgets->mainExtraLaunchPrismusunEntry), "");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchPrismusunCheck), 0);
    if (str)
    {
        yon_char_divide_search((str = yon_char_new(videoconfig.primusrun)), "=", 1);
        gtk_entry_set_text(GTK_ENTRY(widgets->mainExtraLaunchPrismusunEntry), str);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchPrismusunCheck), 1);
    }

    
    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo));

    str = videoconfig.failsafenVidia;
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo), _("Don't use"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo), _("fbdev"));
    if (str)
    {
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->mainDriverFailsafeNvidiaCombo), 1);
    }
    else
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->mainDriverFailsafeNvidiaCombo), 0);
    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo));

    str = videoconfig.failsafeATI;
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo), _("Don't use"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo), _("fbdev"));
    if (str)
    {
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->mainDriverFailsafeAMDCombo), 1);
    }
    else
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->mainDriverFailsafeAMDCombo), 0);
    dictionary *dict = NULL;
}

/**dictionary *yon_proprieary_get()
 * [EN]
*/
dictionary *yon_proprieary_get(){
    int size=0;
    char **rtn = yon_config_load(get_proprietary_drivers_command,&size);

    for (int i=0;i<size;i++){
        rtn[i] = yon_char_divide_search(rtn[i],"\n",-1);
        char *key=yon_char_new(rtn[i]);
        if (key[0]==':')
            yon_char_divide_search(key,":",-1);
        key = yon_char_divide_search(key,":",-1);
        if (i==0) videoconfig.proprietary=yon_dictionary_create_with_data(key,rtn[i]);
        else videoconfig.proprietary=yon_dictionary_create_with_data_connected(videoconfig.proprietary,key,rtn[i]);
    }
}

/**void yon_gtk_list_store_fill_with_proprietaries(GtkListStore *list)
 * [EN]
*/
void yon_gtk_list_store_fill_with_proprietaries(GtkListStore *list){
    dictionary *dict=NULL;
    for_dictionaries(dict,videoconfig.proprietary){
        GtkTreeIter iter;
        int size=0;
        config_str str = yon_char_parse((char*)dict->data,&size,":");
        gtk_list_store_append(list,&iter);
        gtk_list_store_set(list,&iter,1,str[1],2,str[2],3,str[3],4,str[4],-1);
    }
}

/**void yon_setup_config(char *configcommand)
 * [EN]
*/
void yon_setup_config(char *configcommand)
{
    videoconfig.portssize=0;
    videoconfig.ports=yon_config_load(get_ports_command,&videoconfig.portssize);

    int size = 0;

    char *command = configcommand;
    dictionary *dct;
    for(int i=0; i<videoconfig.portssize;i++)
    {
        command = yon_char_get_augumented(command, XORG_MONITOR(yon_char_divide_search(yon_char_new(videoconfig.ports[i]),"\n",-1)));
    }
    videoconfig.configsize=0;
    videoconfig.loaded_config = yon_ubl_load_global_config(command, &videoconfig.configsize);
    char *param = NULL;
    param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,"FAILSAFENVIDIA");
    if (param){
        yon_char_divide_search(param,"=",-1);
        videoconfig.failsafenVidia=yon_char_new(param);

    }
    param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,"FAILSAFEATI");
    if (param){
        yon_char_divide_search(param,"=",-1);
        videoconfig.failsafeATI=yon_char_new(param);

    }
    param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,"OPTIRUN");
    if (param){
        yon_char_divide_search(param,"=",-1);
        videoconfig.optirun=yon_char_new(param);

    }
    param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,"PRIMUSRUN");
    if (param){
        yon_char_divide_search(param,"=",-1);
        videoconfig.primusrun=yon_char_new(param);

    }
    for (int i=0;i<videoconfig.portssize;i++){
        videoconfig.ports[i] = yon_char_divide_search(videoconfig.ports[i],"\n",-1);
        param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,XORG_MONITOR(videoconfig.ports[i]));
        videoconfig.monitors = yon_monitor_config_new(videoconfig.ports[i]);
        if (param){
            yon_char_divide_search(param,"=",-1);
            yon_monitor_config_update(yon_dictionary_get_data(videoconfig.monitors,monitorconfig*),videoconfig.ports[i],param);
        }
    }
    
    videoconfig.resolutions=yon_config_load(get_resolutions_supportable_command,&videoconfig.resolutionssize);
    for (int i=0;i<videoconfig.resolutionssize;i++){
        videoconfig.resolutions[i]=yon_char_divide_search(videoconfig.resolutions[i],"\n",-1);
    }
    yon_proprieary_get();
}

driver_window *on_driver_window_open(GtkWidget *self, GtkWidget *comboe)
{
    GtkBuilder *builder = gtk_builder_new_from_file(glade_path);
    driver_window *widgets = NULL;
    widgets = malloc(sizeof(driver_window));
    widgets->window = yon_gtk_builder_get_widget(builder, "ProprietaryDriverChooseWindow");

    widgets->propriearyTreeView = yon_gtk_builder_get_widget(builder, "propriearyTreeView");
    widgets->ProprietaryDriverColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "ProprietaryDriverColumn"));
    widgets->ProprietaryDescriptionColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "ProprietaryDescriptionColumn"));

    widgets->ProprietaryCloseButton = yon_gtk_builder_get_widget(builder, "ProprietaryCloseButton");
    widgets->ProprietaryAcceptButton = yon_gtk_builder_get_widget(builder, "ProprietaryAcceptButton");
    if(!videoconfig.list)
        videoconfig.list = GTK_LIST_STORE(gtk_builder_get_object(builder, "liststore6"));
    gtk_list_store_clear(videoconfig.list);
    yon_gtk_list_store_fill_with_proprietaries(videoconfig.list);
    gtk_button_set_label(GTK_BUTTON(widgets->ProprietaryCloseButton), _("Cancel"));
    gtk_button_set_label(GTK_BUTTON(widgets->ProprietaryAcceptButton), _("Accept"));
    gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->propriearyTreeView),GTK_TREE_MODEL(videoconfig.list));
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), _("Installed"));
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), _("Package"));
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), _("Supported Devices"));
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), _("Driver"));
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDescriptionColumn), _("Description"));
    gtk_widget_show(widgets->window);
    g_signal_connect(G_OBJECT(widgets->ProprietaryCloseButton), "clicked", G_CALLBACK(on_subwindow_close), NULL);
    combo_tree *trcm=NULL;
    trcm=malloc(sizeof(combo_tree));
    trcm->combo=comboe;
    trcm->tree=widgets->propriearyTreeView;
    g_signal_connect(G_OBJECT(widgets->ProprietaryAcceptButton), "clicked", G_CALLBACK(on_save_driver_configuration), trcm);
}

/** monitor_config yon_monitor_config_new(char *port)
 * [EN]
*/
monitor_config yon_monitor_config_new(char *port){
    if (port){
        monitorconfig *monitor=new(monitorconfig);
        monitor->main=0;
        monitor->enable=0;
        monitor->position=0;
        monitor->port=NULL;
        monitor->position_port=NULL;
        monitor->resolution=NULL;
        monitor->resolutionCapabilities=NULL;
        monitor->frequency=NULL;
        monitor->rotation=0;
        monitor->stringparameters=NULL;
        monitor->dpms=0;
        monitor->resolution_size=0;
        monitor->cvt=0;
        monitor->reduced=0;
        monitor->gtf=0;
        if (videoconfig.monitors)
            videoconfig.monitors=yon_dictionary_create_with_data_connected(videoconfig.monitors,port,monitor);
        else 
            videoconfig.monitors=yon_dictionary_create_with_data(port,monitor);
        return videoconfig.monitors;
    }
}

/**void yon_monitor_config_update(monitorconfig* monitor, char *port, char *config_string)
 * [EN]
*/
void yon_monitor_config_update(monitorconfig* monitor, char *port, char *config_string){
    if (port&&config_string){
        monitor->stringparameters=yon_char_new(config_string);
        int size=0;
        config_str cnf = yon_char_parse(config_string,&size,",");
        if (yon_char_parsed_check_exist(cnf,size,"primary")!=-1)
            monitor->main=1;
        if (yon_char_parsed_check_exist(cnf,size,"enable")!=-1)
            monitor->enable=1;
        if (yon_char_parsed_check_exist(cnf,size,"disable")!=-1)
            monitor->enable=0;
        // if (yon_char_parsed_check_exist(cnf,size,"ignore")==1)
        //     monitor->enable=0;
        if (yon_char_parsed_check_exist(cnf,size,"LeftOf:")!=-1)
            monitor->position=1;
        if (yon_char_parsed_check_exist(cnf,size,"lo:")!=-1)
            monitor->position=1;
        if (yon_char_parsed_check_exist(cnf,size,"RightOf:")!=-1)
            monitor->position=2;
        if (yon_char_parsed_check_exist(cnf,size,"ro:")!=-1)
            monitor->position=2;
        if (yon_char_parsed_check_exist(cnf,size,"Below:")!=-1)
            monitor->position=4;
        if (yon_char_parsed_check_exist(cnf,size,"be:")!=-1)
            monitor->position=4;
        if (yon_char_parsed_check_exist(cnf,size,"Above:")!=-1)
            monitor->position=3;
        if (yon_char_parsed_check_exist(cnf,size,"ab:")!=-1)
            monitor->position=3;
        if (yon_char_parsed_check_exist(cnf,size,"rotate:")!=-1)
            monitor->rotation=0;
        if (yon_char_parsed_check_exist(cnf,size,"dpms")!=-1)
            monitor->dpms=1;
        if (yon_char_parsed_check_exist(cnf,size,"nodpms")!=-1)
            monitor->dpms=0;
        if (yon_char_parsed_check_exist(cnf,size,"cvt")!=-1)
            monitor->cvt=1;
        if (yon_char_parsed_check_exist(cnf,size,"reduced")!=-1)
            monitor->reduced=1;
        if (yon_char_parsed_check_exist(cnf,size,"r")!=-1)
            monitor->reduced=1;
        if (yon_char_parsed_check_exist(cnf,size,"gtf")!=-1)
            monitor->gtf=1;
    }
}

int yon_char_get_if_resolution(char *parsed_string){
    char *left=NULL, *right=NULL;
    right=yon_char_new(parsed_string);
    left=yon_char_divide_search(right,"x",1);
    if (left&&right)
        if (atoi(left)&&atoi(right))
            return 1;
    return 0;
}

void yon_monitor_view_new(monitor_config monitor){
    GtkBuilder *builder = gtk_builder_new_from_file(glade_path);
    monitor_window *window = new(monitor_window);
    window->templateMonitorscreenOverlay=yon_gtk_builder_get_widget(builder,"templateMonitorscreenOverlay");
    window->templateMonitorImage=yon_gtk_builder_get_widget(builder,"templateMonitorImage");
    window->templateMonitorInfoBox=yon_gtk_builder_get_widget(builder,"templateMonitorInfoBox");
    window->templateMonitorInfoNameLabel=yon_gtk_builder_get_widget(builder,"templateMonitorInfoNameLabel");
    window->templateMonitorInfoResolutionLabel=yon_gtk_builder_get_widget(builder,"templateMonitorInfoResolutionLabel");
    window->templateMonitorDeleteButton=yon_gtk_builder_get_widget(builder,"templateMonitorDeleteButton");
    window->templateMonitorSwitchButton=yon_gtk_builder_get_widget(builder,"templateMonitorSwitchButton");
    window->templateMonitorInfoConfigureButton=yon_gtk_builder_get_widget(builder,"templateMonitorInfoConfigureButton");
    window->templateMonitorInfoAddButton=yon_gtk_builder_get_widget(builder,"templateMonitorInfoAddButton");
    window->config=NULL;
    gtk_overlay_add_overlay(GTK_OVERLAY(window->templateMonitorscreenOverlay),window->templateMonitorInfoBox);
    if (monitor){
        window->config=monitor;
        gtk_widget_hide(window->templateMonitorInfoAddButton);
        g_signal_connect(G_OBJECT(window->templateMonitorInfoConfigureButton), "clicked", G_CALLBACK(on_monitor_configure), window);
        if (videoconfig.monitor_visuals) videoconfig.monitor_visuals = yon_dictionary_create_with_data_connected(videoconfig.monitor_visuals, window->config->key,window);
        else videoconfig.monitor_visuals = yon_dictionary_create_with_data(window->config->key,window);

        g_signal_connect(G_OBJECT(window->templateMonitorDeleteButton), "clicked", G_CALLBACK(on_monitor_delete), videoconfig.monitor_visuals);
        g_signal_connect(G_OBJECT(window->templateMonitorSwitchButton), "clicked", G_CALLBACK(on_monitor_switch), window);
    } else {
        gtk_widget_show(window->templateMonitorInfoAddButton);
        gtk_widget_hide(window->templateMonitorDeleteButton);
        gtk_widget_hide(window->templateMonitorSwitchButton);
        gtk_widget_hide(window->templateMonitorInfoConfigureButton);
        g_signal_connect(G_OBJECT(window->templateMonitorInfoAddButton), "clicked", G_CALLBACK(on_monitor_add), window);
        if (videoconfig.monitor_visuals) videoconfig.monitor_visuals = yon_dictionary_create_with_data_connected(videoconfig.monitor_visuals, "GENERIC",window);
        else videoconfig.monitor_visuals = yon_dictionary_create_with_data("GENERIC",window);
    }
}

void yon_monitor_set_resolutions(){
    dictionary *dact=NULL;
    int size_connected=0;
    config_str connected_ports = yon_config_load(get_resolution_ports_command,&size_connected);
    int resolutions_size=0;
    config_str resolutions = yon_config_load(get_resolutions_command,&resolutions_size);
    for (int i=0;i<size_connected;i++){
        int a=atoi(yon_char_divide_search(connected_ports[i],":",-1));
        int *cur_pos=new(int);
        memcpy(cur_pos,&a,sizeof(int));
        connected_ports[i]=yon_char_divide_search(connected_ports[i],"\n",-1);
        connected_ports[i]=yon_char_divide_search(connected_ports[i]," ",-1);
        yon_dictionary_add_or_create_if_exists_with_data(dact,connected_ports[i],cur_pos);
        config_str resol=new(char*);
        resolution_supported *supported=new(resolution_supported);
        supported->line=resol;
        supported->size=0;
        yon_dictionary_add_or_create_if_exists_with_data(videoconfig.supported_resolutions,connected_ports[i],supported);
    }
    config_str final=NULL;
    for(int i=0;i<resolutions_size;i++){
        int cur_pos=atoi(yon_char_divide_search(resolutions[i],":",-1));
        dictionary *dct=NULL;
        char *port_for_res=NULL;
        int equals=0;
        for_dictionaries (dct,dact){
            if (cur_pos==*((int*)dct->data)){
                equals=1;
                port_for_res=NULL;
            }
            if (cur_pos>*((int*)dct->data)&&equals==0)
                port_for_res=yon_char_new(dct->key);
        }
        if(port_for_res){
            dct=yon_dictionary_find(&videoconfig.supported_resolutions,port_for_res);
            resolution_supported *sup=yon_dictionary_get_data(dct,resolution_supported*);
            sup->size++;
            sup->line=realloc(sup->line,sizeof(char*)*sup->size);
            sup->line[sup->size-1]=yon_char_new(yon_char_divide_search(resolutions[i],"\n",-1));
        }
    }
    
}

/** void yon_setup_widgets(widgets_dict *widgets)
 * [EN]
 * Sets up every element on main window
 * [RU]
 * 
 * */
void yon_setup_widgets(widgets_dict *widgets)
{
    widgets->builder = gtk_builder_new_from_file(glade_path);
    widgets->appsPackWindow = yon_gtk_builder_get_widget(widgets->builder, "appsPackWindow");
    widgets->appsPackBox = yon_gtk_builder_get_widget(widgets->builder, "appsPackBox");
    widgets->MainWindow = yon_gtk_builder_get_widget(widgets->builder, "MainWindow");
    widgets->headBox = yon_gtk_builder_get_widget(widgets->builder, "headBox");
    widgets->headInfoLabel = yon_gtk_builder_get_widget(widgets->builder, "headInfoLabel");
    widgets->mainPlugBox = yon_gtk_builder_get_widget(widgets->builder, "mainPlugBox");
    widgets->mainErrorBox = yon_gtk_builder_get_widget(widgets->builder, "mainErrorBox");
    widgets->mainHeadOverlay = yon_gtk_builder_get_widget(widgets->builder, "mainHeadOverlay");
    widgets->extraOptirunChooseAppsButton = yon_gtk_builder_get_widget(widgets->builder, "extraOptirunChooseAppsButton");
    widgets->extraPrimusunChooseAppsButton = yon_gtk_builder_get_widget(widgets->builder, "extraPrimusunChooseAppsButton");
    widgets->mainHeadBackgroundImage = yon_gtk_builder_get_widget(widgets->builder, "mainHeadBackgroundImage");
    widgets->mainDriverAutomaticallyChooseCheck = yon_gtk_builder_get_widget(widgets->builder, "mainDriverAutomaticallyChooseCheck");
    widgets->mainDriverFailsafeNvidiaLabel = yon_gtk_builder_get_widget(widgets->builder, "mainDriverFailsafeNvidiaLabel");
    widgets->mainDriverFailsafeAMDLabel = yon_gtk_builder_get_widget(widgets->builder, "mainDriverFailsafeAMDLabel");
    widgets->mainExtraFixGapCombo = yon_gtk_builder_get_widget(widgets->builder, "mainExtraFixGapCombo");
    widgets->mainDriverFailsafeNvidiaCombo = yon_gtk_builder_get_widget(widgets->builder, "mainDriverFailsafeNvidiaCombo");
    widgets->mainDriverFailsafeAMDCombo = yon_gtk_builder_get_widget(widgets->builder, "mainDriverFailsafeAMDCombo");
    widgets->mainDriverFrameLabel = yon_gtk_builder_get_widget(widgets->builder, "mainDriverFrameLabel");
    widgets->monitorConfigurationMethodLabel = yon_gtk_builder_get_widget(widgets->builder, "monitorConfigurationMethodLabel");
    widgets->monitorConfigurationMethodCombo = yon_gtk_builder_get_widget(widgets->builder, "monitorConfigurationMethodCombo");
    widgets->mainMonitorVisualConfigurationBox = yon_gtk_builder_get_widget(widgets->builder, "mainMonitorVisualConfigurationBox");
    widgets->mainMonitorConfigurationBox = yon_gtk_builder_get_widget(widgets->builder, "mainMonitorConfigurationBox");
    widgets->mainMonitorConfigurationFrameLabel = yon_gtk_builder_get_widget(widgets->builder, "mainMonitorConfigurationFrameLabel");
    widgets->mainHybridGraphicsDiscreteLabel = yon_gtk_builder_get_widget(widgets->builder, "mainHybridGraphicsDiscreteLabel");
    widgets->mainHybridGraphicsDiscreteCheck = yon_gtk_builder_get_widget(widgets->builder, "mainHybridGraphicsDiscreteCheck");
    widgets->mainHybridGraphicsFrameLabel = yon_gtk_builder_get_widget(widgets->builder, "mainHybridGraphicsFrameLabel");
    widgets->mainExtraLaunchOptirunCheck = yon_gtk_builder_get_widget(widgets->builder, "mainExtraLaunchOptirunCheck");
    widgets->mainExtraLaunchPrismusunCheck = yon_gtk_builder_get_widget(widgets->builder, "mainExtraLaunchPrismusunCheck");
    widgets->mainExtraFixGapLabel = yon_gtk_builder_get_widget(widgets->builder, "mainExtraFixGapLabel");
    widgets->mainExtraLaunchOptirunEntry = yon_gtk_builder_get_widget(widgets->builder, "mainExtraLaunchOptirunEntry");
    widgets->mainExtraLaunchPrismusunEntry = yon_gtk_builder_get_widget(widgets->builder, "mainExtraLaunchPrismusunEntry");
    widgets->mainExtraFixGapLabelCombo = yon_gtk_builder_get_widget(widgets->builder, "mainExtraFixGapLabelCombo");
    widgets->mainExtraLaunchThroughButton = yon_gtk_builder_get_widget(widgets->builder, "mainExtraLaunchThroughButton");
    widgets->mainExtraFrameLabel = yon_gtk_builder_get_widget(widgets->builder, "mainExtraFrameLabel");
    widgets->mainHeaderTitleLabel = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderTitleLabel");
    widgets->mainHeaderLoadButton = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderLoadButton");
    widgets->mainHeaderConfigLoadLabel = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderConfigLoadLabel");
    widgets->mainHeaderSaveConfigurationLabel = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSaveConfigurationLabel");
    widgets->mainHeaderSaveButton = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSaveButton");
    widgets->mainHeaderSettingsButton = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSettingsButton");
    widgets->mainHeaderLoadGlobalMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderLoadGlobalMenuItem");
    widgets->mainHeaderLoadLocalMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderLoadLocalMenuItem");
    widgets->mainHeaderSaveGlobalLocalMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSaveGlobalLocalMenuItem");
    widgets->mainHeaderSaveGlobalMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSaveGlobalMenuItem");
    widgets->mainHeaderSaveLocalMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSaveLocalMenuItem");
    widgets->mainHeaderSettingsDocumentationMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSettingsDocumentationMenuItem");
    widgets->mainHeaderSettingsAboutMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSettingsAboutMenuItem");
    widgets->mainStatusBox = yon_gtk_builder_get_widget(widgets->builder, "mainStatusBox");
    widgets->mainStatusIcon = yon_gtk_builder_get_widget(widgets->builder, "mainStatusIcon");
    widgets->mainStatusLabel = yon_gtk_builder_get_widget(widgets->builder, "mainStatusLabel");
    widgets->templateMonitorConfigurationBox = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationBox");
    widgets->templateMonitorConfigurationMonitorLabel = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationMonitorLabel");
    widgets->templateMonitorConfigurationResolutionLabel = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationResolutionLabel");
    widgets->templateMonitorConfigurationResolutionCombo = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationResolutionCombo");
    widgets->templateMonitorConfigurationFrequencyLabel = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationFrequencyLabel");
    widgets->templateMonitorConfigurationFrequencyCombo = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationFrequencyCombo");
    widgets->templateMonitorConfigurationRotationLabel = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationRotationLabel");
    widgets->templateMonitorConfigurationRotationCombo = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationRotationCombo");
    widgets->templateMonitorConfigurationMainRadio = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationMainRadio");
    widgets->templateMonitorConfigurationParameterLineCheck = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationParameterLineCheck");
    widgets->templateMonitorConfigurationParameterLineEntry = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationParameterLineEntry");
    widgets->templateMonitorConfigurationDoNotSwitchOffLabel = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationDoNotSwitchOffLabel");
    widgets->templateMonitorConfigurationDoNotSwitchOffCheck = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationDoNotSwitchOffCheck");

    widgets->proprietaryTreeView = yon_gtk_builder_get_widget(widgets->builder, "proprietaryTreeView");
    widgets->proprietaryInfoButton = yon_gtk_builder_get_widget(widgets->builder, "proprietaryInfoButton");
    widgets->proprietaryDeleteButton = yon_gtk_builder_get_widget(widgets->builder, "proprietaryDeleteButton");
    widgets->proprietaryInstallButton = yon_gtk_builder_get_widget(widgets->builder, "proprietaryInstallButton");
    widgets->proprietaryTreeSelection = GTK_TREE_SELECTION(gtk_builder_get_object(widgets->builder, "proprietaryTreeSelection"));
    widgets->driversTreeView = yon_gtk_builder_get_widget(widgets->builder, "driversTreeView");
    widgets->driversInfoButton = yon_gtk_builder_get_widget(widgets->builder, "driversInfoButton");
    widgets->driversDeleteButton = yon_gtk_builder_get_widget(widgets->builder, "driversDeleteButton");
    widgets->driversInstallButton = yon_gtk_builder_get_widget(widgets->builder, "driversInstallButton");
    widgets->driversTreeSelection = GTK_TREE_SELECTION(gtk_builder_get_object(widgets->builder, "driversTreeSelection"));
    
    widgets->proprietartInstalledColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "proprietartInstalledColumn"));
    widgets->ProprietaryPackageColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "ProprietaryPackageColumn"));
    widgets->ProprietaryDriverColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "ProprietaryDriverColumn"));
    widgets->ProprietaryDescriptionColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "ProprietaryDescriptionColumn"));
    widgets->ProprietarySupportedColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "ProprietarySupportedColumn"));

    widgets->driverInstalledColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "driverInstalledColumn"));
    widgets->driverPackageColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "driverPackageColumn"));
    widgets->driverDriverColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "driverDriverColumn"));
    widgets->driverDescriptionColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "driverDescriptionColumn"));
    widgets->driverSupportedColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "driverSupportedColumn"));
    

    videoconfig.list = GTK_LIST_STORE(gtk_builder_get_object(widgets->  builder, "liststore6"));

    gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->proprietaryTreeView),GTK_TREE_MODEL(videoconfig.list));

    g_signal_connect(G_OBJECT(widgets->proprietaryDeleteButton), "clicked", G_CALLBACK(on_driver_pack_delete), widgets);
    g_signal_connect(G_OBJECT(widgets->proprietaryInstallButton), "clicked", G_CALLBACK(on_driver_pack_install), widgets);
    g_signal_connect(G_OBJECT(widgets->proprietaryInfoButton), "clicked", G_CALLBACK(on_driver_pack_info), widgets);

    g_signal_connect(G_OBJECT(widgets->driversDeleteButton), "clicked", G_CALLBACK(on_driver_delete), widgets);
    g_signal_connect(G_OBJECT(widgets->driversInstallButton), "clicked", G_CALLBACK(on_driver_install), widgets);
    g_signal_connect(G_OBJECT(widgets->driversInfoButton), "clicked", G_CALLBACK(on_driver_info), widgets);

    g_signal_connect(G_OBJECT(widgets->mainDriverAutomaticallyChooseCheck), "toggled", G_CALLBACK(on_auto_choose_drivers), widgets);
    // g_signal_connect(G_OBJECT(widgets->mainHybridGraphicsDiscreteCheck), "toggled", G_CALLBACK(on_sensitive_change), widgets);
    g_signal_connect(G_OBJECT(widgets->mainExtraLaunchOptirunCheck), "toggled", G_CALLBACK(on_sensitive_change), widgets->mainExtraLaunchOptirunEntry);
    g_signal_connect(G_OBJECT(widgets->mainExtraLaunchPrismusunCheck), "toggled", G_CALLBACK(on_sensitive_change), widgets->mainExtraLaunchPrismusunEntry);
    g_signal_connect(G_OBJECT(widgets->mainExtraLaunchOptirunCheck), "toggled", G_CALLBACK(on_sensitive_change), widgets->extraOptirunChooseAppsButton);
    g_signal_connect(G_OBJECT(widgets->mainExtraLaunchPrismusunCheck), "toggled", G_CALLBACK(on_sensitive_change), widgets->extraPrimusunChooseAppsButton);


    g_signal_connect(G_OBJECT(widgets->MainWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    // g_signal_connect(G_OBJECT(widgets->extraOptirunChooseAppsButton), "clicked", G_CALLBACK(on_apps_chooser_open), widgets);
    // g_signal_connect(G_OBJECT(widgets->extraPrimusunChooseAppsButton), "clicked", G_CALLBACK(on_apps_chooser_open), widgets);

    g_signal_connect(G_OBJECT(widgets->mainHeaderSettingsAboutMenuItem), "activate", G_CALLBACK(on_about), NULL);
    g_signal_connect(G_OBJECT(widgets->mainHeaderSettingsDocumentationMenuItem), "activate", G_CALLBACK(on_about), NULL);

    g_signal_connect(G_OBJECT(widgets->mainHeaderLoadGlobalMenuItem), "activate", G_CALLBACK(on_configuration_load_global), widgets);
    g_signal_connect(G_OBJECT(widgets->mainHeaderLoadLocalMenuItem), "activate", G_CALLBACK(on_configuration_load_local), widgets);

    g_signal_connect(G_OBJECT(widgets->mainHeaderSaveGlobalLocalMenuItem), "activate", G_CALLBACK(on_configuration_save_local_global), widgets);
    g_signal_connect(G_OBJECT(widgets->mainHeaderSaveGlobalMenuItem), "activate", G_CALLBACK(on_configuration_save_global), widgets);
    g_signal_connect(G_OBJECT(widgets->mainHeaderSaveLocalMenuItem), "activate", G_CALLBACK(on_configuration_save_local), widgets);

    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo), _("Off"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo), _("fbdev"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo), _("Off"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo), _("fbdev"));

    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainExtraFixGapCombo), _("1st variant. May cause perfomance drops in video games"));
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainExtraFixGapCombo), _("2nd variant. May not work on specific video cards"));
    gtk_label_set_text(GTK_LABEL(widgets->headInfoLabel), _("Video output configuration"));
    gtk_label_set_text(GTK_LABEL(widgets->mainDriverFailsafeNvidiaLabel), _("Failsafe driver nVidia: "));
    gtk_label_set_text(GTK_LABEL(widgets->mainDriverFailsafeAMDLabel), _("Failsafe driver AMD/ATI: "));
    gtk_label_set_text(GTK_LABEL(widgets->mainDriverFrameLabel), _("Driver"));
    // gtk_label_set_text(GTK_LABEL(widgets->monitorConfigurationMethodLabel),_("Configuration method"));
    gtk_label_set_text(GTK_LABEL(widgets->mainMonitorConfigurationFrameLabel), _("Monitor configuration"));
    gtk_label_set_text(GTK_LABEL(widgets->mainHybridGraphicsFrameLabel), _("Hybrid graphics"));
    gtk_label_set_text(GTK_LABEL(widgets->mainExtraFixGapLabel), _("Fix frame gap (nVidia)"));
    gtk_label_set_text(GTK_LABEL(widgets->mainExtraFrameLabel), _("Extra"));
    gtk_label_set_text(GTK_LABEL(widgets->mainHeaderTitleLabel), _("UBlinux Video Configuration"));
    gtk_label_set_text(GTK_LABEL(widgets->mainHeaderConfigLoadLabel), _("Load"));
    gtk_label_set_text(GTK_LABEL(widgets->mainHeaderSaveConfigurationLabel), _("Save"));

    gtk_button_set_label(GTK_BUTTON(widgets->mainHybridGraphicsDiscreteCheck), _("On"));
    gtk_button_set_label(GTK_BUTTON(widgets->mainDriverAutomaticallyChooseCheck), _("Automatically choose and use driver"));
    gtk_button_set_label(GTK_BUTTON(widgets->mainExtraLaunchOptirunCheck), _("Launch programms through optirun (nVidia): "));
    gtk_button_set_label(GTK_BUTTON(widgets->mainExtraLaunchPrismusunCheck), _("Launch programs through primusun (nVidia): "));
    gtk_button_set_label(GTK_BUTTON(widgets->mainHybridGraphicsDiscreteCheck), _("discrete video only (AMD/ATI)"));

    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderLoadGlobalMenuItem), _("Load from global configuration"));
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderLoadLocalMenuItem), _("Load from local configuration"));
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSaveGlobalLocalMenuItem), _("Save to global an local configuration"));
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSaveGlobalMenuItem), _("Save to global configuration"));
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSaveLocalMenuItem), _("Save to local configuration"));
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSettingsDocumentationMenuItem), _("Documentation"));
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSettingsAboutMenuItem), _("About"));

    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), _("Installed"));
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), _("Package"));
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), _("Supported Devices"));
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), _("Driver"));
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDescriptionColumn), _("Description"));
    // gtk_button_set_label(GTK_BUTTON(widgets->mainExtraLaunchThroughButton),_("Change"));
    yon_ubl_header_setup(widgets->mainHeadOverlay, widgets->headBox, widgets->mainHeadBackgroundImage, banner_path);
    // gtk_overlay_add_overlay(GTK_OVERLAY(widgets->mainHeadOverlay),widgets->headBox);
    yon_monitor_view_setup(widgets->mainMonitorVisualConfigurationBox);
    yon_monitor_view_update();

    videoconfig.status_render.icon=widgets->mainStatusIcon;
    videoconfig.status_render.label=widgets->mainStatusLabel;
    videoconfig.status_render.box=widgets->mainStatusBox;
    // gtk_image_set_from_file(GTK_IMAGE(widgets->mainHeadBackgroundImage),banner_path);
    // MonitorSettings *monitors = yon_setup_monitor_settings();
    // videoconfig.monitors=yon_dictionary_pack_monitors(monitors,yon_check_for_monitors());
    // widgets->overlays = yon_dictionary_pack_overlays(monitors);
    // yon_dictionary_gtk_pack_start_multiple_widgets(widgets->overlays, widgets->mainMonitorVisualConfigurationBox, 0, 0, 0);
    // yon_dictionary_gtk_pack_start_multiple_widgets(widgets->monitors,widgets->mainMonitorConfigurationBox,0,0,0);
}

int main(int argc, char *argv[])
{

    local = setlocale(LC_ALL, "");
    textdomain(LocaleName);
    gtk_init(&argc, &argv);

    GError error;
    yon_setup_config(load_drivers_local_command);
    widgets_dict widgets;
    yon_setup_widgets(&widgets);
    yon_gtk_list_store_fill_with_proprietaries(videoconfig.list);
    gtk_widget_show(widgets.MainWindow);
    // yon_fill_ui(&widgets);
        videoconfig.status_render.text_to_render=LOCAL_LOAD_SUCCESS;
        videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
    yon_ubl_status_box_render(&videoconfig.status_render);
    on_config_fill_interface(&widgets);
    yon_monitor_set_resolutions();
    GtkCssProvider *css = gtk_css_provider_new();
    gtk_css_provider_load_from_path(css, CssPath, NULL);
    gtk_style_context_add_provider_for_screen(gdk_screen_get_default(),
                                              GTK_STYLE_PROVIDER(css),
                                              -1);
    gtk_main();
    return 0;
}