#include "ubl-settings-video.h"

config videoconfig;

// void on_apps_chooser_open(GtkWidget *self){
//     int size=0;
//     config_str categories=yon_char_parsed_new(NULL,&size,"GTK",NULL);
//     config_str names=yon_char_parsed_new(NULL,&size,"XFCE",NULL);
//     config_str icons=yon_char_parsed_new(NULL,&size,"org.xfce.panel.Launcher",NULL);
//     yon_app_chooser_show(categories,names,icons,size);
// }


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

void on_resized(GtkWidget *window, GdkEventConfigure *event){
    float time_passed = (float)clock()/(float)CLOCKS_PER_SEC;
    if (time_passed>2){
        int width = gdk_window_get_width(gtk_widget_get_window(videoconfig.pack_box));
        int children_width = 138*g_list_length(gtk_container_get_children(GTK_CONTAINER((GtkWidget*)videoconfig.monitor_output_layers->first->data)));
        if (width<children_width||width>children_width+150)
            yon_monitor_view_draw_all();
    }
    
}

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){
        yon_ubl_status_box_render(videoconfig.status_render,MONITOR_PORT_ERROR_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
        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=0;
        yon_ubl_status_box_render(videoconfig.status_render,MONITOR_PORT_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    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));
        
    }
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationFrequencyCombo))>0)
        config->frequency=gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationFrequencyCombo));
    if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo))!=0) {
        config->resolution =yon_char_divide_search((char*)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 *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_terminal_done(GtkWidget *terminal,  int size, widgets_dict *widgets){
    gtk_widget_destroy(terminal);
}

void on_terminal_more(GtkWidget *self, widgets_dict *widgets){
    int active = gtk_revealer_get_child_revealed(GTK_REVEALER(widgets->TerminalMoreRevieler));
    if (active ==1) active = 0;
    else active=1;
gtk_revealer_set_reveal_child(GTK_REVEALER(widgets->TerminalMoreRevieler),active);
}

void on_terminal_destroy(GtkWidget *self, widgets_dict *widgets){
    gtk_revealer_set_reveal_child(GTK_REVEALER(widgets->TerminalRevealer),0);
    gtk_widget_destroy(widgets->TerminalRevealer);
    yon_proprieary_get();
    yon_gtk_list_store_fill_with_proprietaries(videoconfig.list);
    yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_OPETAION_DONE_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
}

static void child_ready(VteTerminal *terminal, GPid pid, GError *error, gpointer user_data)
{
    if (!terminal) return;
    if (pid == -1) printf("Error\n\n\n");
    else vte_terminal_feed_child(VTE_TERMINAL(terminal),(char*)user_data,strlen((char*)user_data));
}

void on_terminal_check_progress(VteTerminal *terminal, widgets_dict *widgets){
    char *text = vte_terminal_get_text(terminal,NULL,NULL,NULL);
        gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(widgets->TerminalInfoLabel),(double)yon_char_find_count(text,"::")/4);
}

void yon_terminal_start(widgets_dict *widgets, char *usr_command){
    char **command=new_arr(char*,2);
    gchar **envp = g_get_environ();
    command[0]=(gchar *)g_strdup(g_environ_getenv(envp, "SHELL"));
    command[1]=NULL;
    char **env=new_arr(char*,2);
    env[0]="";
    env[1]=NULL;

    GtkBuilder *builder=gtk_builder_new_from_file(glade_path);
    widgets->TerminalBox = yon_gtk_builder_get_widget(builder, "TerminalBox");
    widgets->TerminalRevealer = yon_gtk_builder_get_widget(builder, "TerminalRevealer");
    widgets->TerminalMoreRevieler = yon_gtk_builder_get_widget(builder, "TerminalMoreRevieler");
    widgets->TerminalMoreButton = yon_gtk_builder_get_widget(builder, "TerminalMoreButton");
    widgets->TerminalScroll = yon_gtk_builder_get_widget(builder, "TerminalScroll");
    widgets->TerminalInfoLabel = yon_gtk_builder_get_widget(builder, "TerminalInfoLabel");

    GtkWidget *terminal = yon_gtk_builder_get_widget(builder, "TerminalTerminal");
    gtk_button_set_label(GTK_BUTTON(widgets->TerminalMoreButton),MORE_LABEL);
    vte_terminal_set_size(VTE_TERMINAL(terminal),10,15);
    gtk_widget_set_app_paintable(terminal,1);
    gtk_style_context_add_class(gtk_widget_get_style_context(terminal),"opacited");
    gtk_style_context_add_class(gtk_widget_get_style_context(terminal),"workingbg");
    gtk_overlay_add_overlay(GTK_OVERLAY(widgets->TerminalOverlay),widgets->TerminalRevealer);
    g_signal_connect(G_OBJECT(terminal), "child-exited", G_CALLBACK(on_terminal_done), widgets);
    g_signal_connect(G_OBJECT(terminal), "contents-changed", G_CALLBACK(on_terminal_check_progress), widgets);
    g_signal_connect(G_OBJECT(widgets->TerminalMoreButton), "clicked", G_CALLBACK(on_terminal_more), widgets);
    g_signal_connect(G_OBJECT(terminal), "destroy", G_CALLBACK(on_terminal_destroy), widgets);
    gtk_revealer_set_reveal_child(GTK_REVEALER(widgets->TerminalRevealer),1);
    VtePty *pty = vte_pty_new_sync(VTE_PTY_DEFAULT,NULL,NULL);
    vte_terminal_set_pty(VTE_TERMINAL(terminal),pty);
    char *install_command=yon_char_unite("tput cup 0 0 && tput ed; ",usr_command,"  ; sleep 5;exit 0","\n",NULL); 
    vte_terminal_spawn_async(VTE_TERMINAL(terminal),
        VTE_PTY_DEFAULT,
        NULL,   
        command,   
        NULL,  
        0,      
        NULL, NULL,
        NULL,   
        -1, 
        NULL, 
        child_ready,    
        install_command); 
    vte_pty_spawn_async(pty,
        NULL,        
        command,      
        NULL,         
        0,            
        NULL, NULL,   
        NULL,         
        -1,           
        NULL,         
        NULL,           
        NULL);        
        vte_terminal_set_scrollback_lines(VTE_TERMINAL(terminal), 100);
        vte_terminal_set_scroll_on_output(VTE_TERMINAL(terminal), TRUE);
        vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(terminal), TRUE);
        gtk_widget_show_all(widgets->TerminalRevealer);
}

void on_driver_pack_install(GtkWidget *self,widgets_dict *widgets){
    yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_INSTALLING_IN_PROGRESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    GtkTreeIter iter;
    char *name;
    GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->proprietaryTreeView));
    if(gtk_tree_selection_get_selected(selection,&list_s,&iter)){
        gtk_tree_model_get(list_s,&iter,1,&name,-1);
        yon_terminal_start(widgets,yon_char_get_augumented(install_proprietary_command,name));
    } else {
        yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
    }
}

void on_driver_install(GtkWidget *self,widgets_dict *widgets){
    yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_INSTALLING_IN_PROGRESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    GtkTreeIter iter;
    char *name;
    GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->driversTreeView));
    if (gtk_tree_selection_get_selected(selection,&list_s,&iter)){
        gtk_tree_model_get(list_s,&iter,2,&name,-1);
        yon_terminal_start(widgets,yon_char_get_augumented(install_proprietary_command,name));
    } else {
        yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
    }
}

void on_driver_pack_delete(GtkWidget *self,widgets_dict *widgets){
    yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_DELETING_IN_PROGRESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    GtkTreeIter iter;
    char *name;
    GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->proprietaryTreeView));
    if(gtk_tree_selection_get_selected(selection,&list_s,&iter)){
        gtk_tree_model_get(list_s,&iter,1,&name,-1);
        yon_terminal_start(widgets,yon_char_get_augumented(delete_proprietary_command,name));
    } else {
        yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
    }
}

void on_driver_pack_selection_change(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));
    if (gtk_tree_selection_get_selected(selection,&list_s,&iter)){
        int installed=0;
        gtk_tree_model_get(gtk_tree_view_get_model(GTK_TREE_VIEW(widgets->proprietaryTreeView)),&iter,0,&installed,-1);
        if (installed==1){
            gtk_widget_set_sensitive(widgets->proprietaryInstallButton,0);
            gtk_widget_set_sensitive(widgets->proprietaryDeleteButton,1);
        } else {
            gtk_widget_set_sensitive(widgets->proprietaryInstallButton,1);
            gtk_widget_set_sensitive(widgets->proprietaryDeleteButton,0);
        }
    }
}

void on_driver_selection_change(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));
    if (gtk_tree_selection_get_selected(selection,&list_s,&iter)){
        int installed=0;
        gtk_tree_model_get(gtk_tree_view_get_model(GTK_TREE_VIEW(widgets->driversTreeView)),&iter,0,&installed,-1);
        if (installed==1){
            gtk_widget_set_sensitive(widgets->driversInstallButton,0);
            gtk_widget_set_sensitive(widgets->driversDeleteButton,1);
        } else {
            gtk_widget_set_sensitive(widgets->driversInstallButton,1);
            gtk_widget_set_sensitive(widgets->driversDeleteButton,0);
        }
    }
    
}

void on_driver_delete(GtkWidget *self,widgets_dict *widgets){
    yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_DELETING_IN_PROGRESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    GtkTreeIter iter;
    char *name;
    GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->driversTreeView));
    if (gtk_tree_selection_get_selected(selection,&list_s,&iter)){
        gtk_tree_model_get(list_s,&iter,2,&name,-1);
        yon_terminal_start(widgets,yon_char_get_augumented(delete_proprietary_command,name));
    } else {
        yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
    }
}

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));
    if (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));
    } else {
        yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
    }
}

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));
    if (gtk_tree_selection_get_selected(selection,&list_s,&iter)){
        gtk_tree_model_get(list_s,&iter,2,&name,-1);
        pthread_create(&tid,&attr,(void*)yon_launch_app,yon_char_get_augumented(get_info_proprietary_command,name));
    } else {
        yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
    }
}

void on_port_chosen_changed(GtkWidget *self, monitor_edit_window *window){
    if (yon_dictionary_get_data(window->config,monitorconfig*)->show_usupported==0){
        monitorconfig* config = yon_dictionary_get_data(window->config,monitorconfig*);
        dictionary *dict=NULL;
        for (int i=0;i<window->resolutionssize;i++){
            free(window->resolutions);
        }
        window->resolutions=NULL;
        window->resolutionssize=0;
        int portid=gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPortCombo));
        if (portid!=0)
            window->curport=videoconfig.ports[portid-1];
        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 (window->curport){
            gtk_window_set_title(GTK_WINDOW(gtk_widget_get_toplevel(window->mainMonitorConfigurationBox)),window->curport);
            dict=yon_dictionary_find(&videoconfig.supported_resolutions,window->curport);
            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_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));
    videoconfig.autoChooseDrivers=state;
    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);
}

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));
        else
            str = yon_char_get_augumented(str," FAILSAFENVIDIA=\"\"");
        if (strcmp(videoconfig.failsafeATI, dntus)!=0)
            str = yon_char_get_augumented(str, yon_char_get_augumented(" FAILSAFEATI=", videoconfig.failsafeATI));
        else
            str = yon_char_get_augumented(str," FAILSAFEATI=\"\"");
        str=yon_char_get_augumented(str," VGADRV_AUTO=NO");
    } else {
            str = yon_char_unite(str, " FAILSAFENVIDIA=\"\" FAILSAFEATI=\"\" VGADRV_AUTO=YES", NULL);

    }
    if (videoconfig.optirun&&strcmp(videoconfig.optirun, dntus)!=0&&strcmp(videoconfig.optirun, "")!=0)
        str = yon_char_get_augumented(str, yon_char_unite(" OPTIRUN=","\"",videoconfig.optirun,"\"",NULL));
    else
        str = yon_char_get_augumented(str, yon_char_unite(" OPTIRUN=\"\"",NULL));
    if (videoconfig.primusrun&&strcmp(videoconfig.primusrun, dntus)!=0&&strcmp(videoconfig.primusrun, "")!=0)
        str = yon_char_get_augumented(str, yon_char_unite(" PRIMUSRUN=","\"", videoconfig.primusrun,"\"",NULL));
    else
        str = yon_char_get_augumented(str, yon_char_unite(" PRIMUSRUN=\"\"",NULL));

    dictionary *dict=NULL;
    for (int i=0;i<videoconfig.portssize;i++)
        str=yon_char_unite(str," XORG_MONITOR[",videoconfig.ports[i],"]=\"\"", NULL);
    if(videoconfig.monitors)
    for_dictionaries(dict,videoconfig.monitors){
        if (yon_dictionary_get_data(dict,monitorconfig*)->stringparameters){
            str=yon_char_unite(str," XORG_MONITOR[",dict->key,"]=\"",yon_dictionary_get_data(dict,monitorconfig*)->stringparameters,"\"", NULL);
        } 
    }

    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(int i=0;i<videoconfig.portssize;i++){
        str = yon_char_get_augumented(str, yon_char_get_augumented(" ",XORG_MONITOR(videoconfig.ports[i])));
    }
    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);
    if (str){
        yon_config_save(str);
        yon_ubl_status_box_render(videoconfig.status_render,LOCAL_SAVE_SUCCESS,BACKGROUND_IMAGE_SUCCESS_TYPE);
    }
}

void on_configuration_save_local_global(GtkWidget *self, widgets_dict *widgets)
{
    on_configuration_save_global_local(self, widgets);
    yon_ubl_status_box_render(videoconfig.status_render,GLOBAL_LOCAL_SAVE_SUCCESS,BACKGROUND_IMAGE_SUCCESS_TYPE);
}

void on_configuration_save_global_local(GtkWidget *self, widgets_dict *widgets)
{
    yon_update_config(widgets);
    char *str=NULL;
    char *delstr=NULL;
    str=yon_configuration_get_save_command(save_drivers_global_local_command);
    if (str){
        yon_config_save(str);
        yon_ubl_status_box_render(videoconfig.status_render,LOCAL_SAVE_SUCCESS,BACKGROUND_IMAGE_SUCCESS_TYPE);
    }
}

void on_configuration_save_global(GtkWidget *self, widgets_dict *widgets)
{
    yon_update_config(widgets);
    char *str=NULL;
    char *delstr=NULL;
    str=yon_configuration_get_save_command(save_drivers_global_command);
    if (str){
        yon_config_save(str);
        yon_ubl_status_box_render(videoconfig.status_render,LOCAL_SAVE_SUCCESS,BACKGROUND_IMAGE_SUCCESS_TYPE);
    }
}

void yon_update_config(widgets_dict *widgets)
{   
    if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchOptirunCheck))==1)
    videoconfig.optirun = yon_char_new( (char *)gtk_entry_get_text(GTK_ENTRY(widgets->mainExtraLaunchOptirunEntry)));
    else videoconfig.optirun = NULL;
    videoconfig.descreteOnly=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->mainHybridGraphicsDiscreteCheck));
    if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchPrismusunCheck))==1)
    videoconfig.primusrun = yon_char_new( (char *)gtk_entry_get_text(GTK_ENTRY(widgets->mainExtraLaunchPrismusunEntry)));
    else videoconfig.primusrun = NULL;
    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)
{
    yon_setup_config(load_drivers_local_command);
    on_config_fill_interface(widgets);
    yon_monitor_view_setup(widgets->mainMonitorVisualConfigurationBox);
    yon_ubl_status_box_render(videoconfig.status_render,LOCAL_LOAD_SUCCESS,BACKGROUND_IMAGE_SUCCESS_TYPE);
}

void on_configuration_load_global(GtkWidget *self, widgets_dict *widgets)
{
       
    yon_setup_config(load_drivers_global_command);
    on_config_fill_interface(widgets);
    yon_monitor_view_setup(widgets->mainMonitorVisualConfigurationBox);
        yon_ubl_status_box_render(videoconfig.status_render,GLOBAL_LOAD_SUCCESS,BACKGROUND_IMAGE_SUCCESS_TYPE);
}

/**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);
        videoconfig.monitor_visuals = yon_dictionary_rip(windowd);
        gtk_widget_destroy(window->templateMonitorscreenOverlay);
        videoconfig.monitors = 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_proprietary_get(GtkWidget *notebook, GtkWidget *page, int pagen, gpointer data){
    if (pagen==1&&videoconfig.dblock==0){
        GtkTreeIter iter;
        if(!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(videoconfig.list),&iter)){
            pthread_t tid;
            pthread_create(&tid,NULL,(void*)yon_proprieary_get,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->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);
        monitors->curport=NULL;
        dictionary *dict=NULL;
        for (int i=0;i<videoconfig.portssize;i++){
            dictionary *check_if_exists = yon_dictionary_find(&videoconfig.monitors,videoconfig.ports[i]);
            if (!check_if_exists||!yon_dictionary_get_data(check_if_exists,monitorconfig*)->stringparameters||check_if_exists==monitors->config)
                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++){
            if (videoconfig.ports[i]!=monitors->config->key)
                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_read_documentation(GtkWidget *self,gpointer user_data){
    yon_ubl_browser_window_open(user_data,WEB_VIEW_TITLE_LABEL);

}

void on_toggle(GtkWidget *self, int *changing_var){
    *changing_var = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self));
}

void on_link(GtkWidget *self, char* link, gpointer user_data){
    if (GTK_IS_ABOUT_DIALOG(self)){
        gtk_widget_destroy(self);
    }
    if (!link)
        link=UBLINUX_WIKI_LINK;
    if (videoconfig.alwaysredirect==0){
        GtkBuilder *builder=gtk_builder_new_from_file(glade_path);
        GtkWidget *sureWindow=yon_gtk_builder_get_widget(builder,"HelpSureWindow");
        GtkWidget *readButton=yon_gtk_builder_get_widget(builder,"ReadHelpButton");
        GtkWidget *cancelButton=yon_gtk_builder_get_widget(builder,"CancelHelpButton");
        GtkWidget *titleLabel=yon_gtk_builder_get_widget(builder,"helpHeader");
        GtkWidget *headQuestionLabel=yon_gtk_builder_get_widget(builder,"webHeaderNameLabel");
        GtkWidget *textLabel=yon_gtk_builder_get_widget(builder,"helpText");
        GtkWidget *alwaysOpenCheck=yon_gtk_builder_get_widget(builder,"AlwaysOpenHelpCheckbox");

        g_signal_connect(G_OBJECT(readButton),"clicked",G_CALLBACK(on_read_documentation),yon_char_new(link));
        g_signal_connect(G_OBJECT(readButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
        g_signal_connect(G_OBJECT(cancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
        g_signal_connect(G_OBJECT(alwaysOpenCheck),"toggled",G_CALLBACK(on_toggle),&videoconfig.alwaysredirect);

        gtk_label_set_text(GTK_LABEL(titleLabel),SETTINGS_VIDEO_TITLE_LABEL);
        gtk_label_set_text(GTK_LABEL(headQuestionLabel),HELP_TITLE_LABEL);
        gtk_label_set_text(GTK_LABEL(textLabel),HELP_INFO_LABEL);
        gtk_button_set_label(GTK_BUTTON(alwaysOpenCheck),HELP_ALWAYS_OPEN_LABEL);
        gtk_button_set_label(GTK_BUTTON(readButton),READ_DOCUMENTATION_LABEL);
        gtk_button_set_label(GTK_BUTTON(cancelButton),MONITOR_CANCEL_LABEL);

        gtk_widget_show(sureWindow);
    }else {
        on_read_documentation(NULL,link);
    }
}

/**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), _("Project Home Page"));
    gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(window), _("Videocard and monitor configuration manager"));
    g_signal_connect(G_OBJECT(window),"activate-link",G_CALLBACK(on_link),NULL);
    gtk_widget_set_visible(hideButtonBox, 0);
    gtk_widget_show(window);
}

void yon_monitor_window_update(monitor_edit_window *window){
    if (window){
        int found = yon_char_parsed_check_exist(videoconfig.ports,videoconfig.portssize, window->config->key);
        if (found==-1)
            found=0;
        else
            found++;
        gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPortCombo),found);
        on_resolutions_unsupported_show(window->templateMonitorConfigurationShowUnsupportedCheck,window);
        if (((monitorconfig*)window->config->data)->resolutionCapabilities){
            // printf("%s\n",((monitorconfig*)window->config->data)->resolution);
        found = yon_gtk_combo_box_text_find(window->templateMonitorConfigurationResolutionCombo, ((monitorconfig*)window->config->data)->resolution);
        }else{
            gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationShowUnsupportedCheck),1);
            found = yon_gtk_combo_box_text_find(window->templateMonitorConfigurationResolutionCombo, ((monitorconfig*)window->config->data)->resolution);
        }
        if (found==-1)
            found=0;
        gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo),found);
        gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationFrequencyCombo));
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationFrequencyCombo),PARAMETER_DEFAULT_LABEL);
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationFrequencyCombo),"60");
        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationFrequencyCombo),"75");
        gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationFrequencyCombo),0);
        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_monitor_view_draw_all(GtkWidget *cnt)
 * [EN]
*/
void yon_monitor_view_draw_all(){
    monitor_view dict=NULL;
    GtkWidget *container=NULL;



    if(videoconfig.monitor_visuals){
        for_dictionaries(dict,videoconfig.monitor_visuals){
            monitor_window *window = yon_dictionary_get_data(dict,monitor_window*);
             container = gtk_widget_get_parent(window->templateMonitorscreenOverlay); 
            if(container){
            g_object_ref(G_OBJECT(window->templateMonitorscreenOverlay));
            gtk_container_remove(GTK_CONTAINER(container),window->templateMonitorscreenOverlay);
            }
        }
        dictionary *boxes=NULL;
        if (videoconfig.monitor_output_layers)
        for_dictionaries(boxes,videoconfig.monitor_output_layers){
            gtk_widget_destroy((GtkWidget*)boxes->data);
            if (boxes->prev)
                free(boxes->prev);
            boxes->prev=NULL;
        }
        free(boxes);
        videoconfig.monitor_output_layers=NULL;
        int overall_width=0;
        yon_dictionary_add_or_create_if_exists_with_data(videoconfig.monitor_output_layers,"Box",gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0));
        gtk_style_context_add_class(gtk_widget_get_style_context((GtkWidget*)videoconfig.monitor_output_layers->data),"primary-toolbar");
        gtk_box_pack_start(GTK_BOX(videoconfig.pack_box),&*(GtkWidget*)videoconfig.monitor_output_layers->data,0,0,0);
        gtk_widget_show((GtkWidget*)videoconfig.monitor_output_layers->data);
        for_dictionaries(dict,videoconfig.monitor_visuals){
            monitor_window *window = yon_dictionary_get_data(dict,monitor_window*);
            if(dict->first==dict) {}
            else {
                overall_width+=138;
                GtkWidget *boxpack=(GtkWidget*)videoconfig.monitor_output_layers->data;
                gtk_box_pack_start(GTK_BOX(boxpack),window->templateMonitorscreenOverlay,0,0,0);
            }
            int width=0;
            GdkWindow *cur_window = gtk_widget_get_window(videoconfig.pack_box);
            if(cur_window)
            width = gdk_window_get_width(cur_window);
            if (overall_width+138>width){
                overall_width=0;
                GtkWidget *boxpack=NULL;
                yon_dictionary_add_or_create_if_exists_with_data(videoconfig.monitor_output_layers,"Box",(boxpack=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0)));
                gtk_style_context_add_class(gtk_widget_get_style_context((GtkWidget*)videoconfig.monitor_output_layers->data),"primary-toolbar");
                gtk_widget_show((GtkWidget*)videoconfig.monitor_output_layers->data);
                gtk_box_pack_start(GTK_BOX(videoconfig.pack_box),boxpack,0,0,0);
            }
            
        }
        gtk_widget_show((GtkWidget*)videoconfig.monitor_output_layers->data);
        monitor_window *window = yon_dictionary_get_data(videoconfig.monitor_visuals->first,monitor_window*);
        gtk_box_pack_start(GTK_BOX(((GtkWidget*)videoconfig.monitor_output_layers->data)),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,""));
            monitorconfig *params=yon_dictionary_get_data(yon_dictionary_get_data(dict,monitor_window*)->config,monitorconfig*);
            gtk_widget_set_sensitive(yon_dictionary_get_data(dict,monitor_window*)->templateMonitorImage,params->enable);
            if (config->resolution){
                char *freq="";
                if (config->frequency>0){
                    if (config->frequency==1) freq ="60";
                    else if (config->frequency==2) freq="75";
                } 
                gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoResolutionLabel),yon_char_unite(config->resolution,":",freq,NULL)); 
            }else if (params->stringparameters){
                int size=0;
                config_str rtn=yon_char_parse(params->stringparameters,&size,",");
                char *res=yon_char_divide_search(yon_char_new(yon_char_parsed_get_resolution(rtn,size))," ",-1);
                if (res&&strcmp(res,"")!=0)
                    gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoResolutionLabel),res);
                else
                    gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoResolutionLabel),PARAMETER_DEFAULT_LABEL);

            }
            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 (config->frequency==1) frequency="x60";
            else if (config->frequency==2) frequency="x75";
    }
    if (strcmp(resolution,"")!=0)
        resolution=yon_char_get_augumented(resolution,frequency);

    
    char *stringparameters=yon_char_unite("",main,resolution,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), DONT_USE_LABEL);
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo), FBDEV_LABEL);
    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), DONT_USE_LABEL);
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo), FBDEV_LABEL);
    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);
    if (videoconfig.autoChooseDrivers==1){
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainDriverAutomaticallyChooseCheck),1);
    }
    else
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainDriverAutomaticallyChooseCheck),0);
    dictionary *dict = NULL;
}

/**dictionary *yon_proprieary_get()
 * [EN]
*/
dictionary *yon_proprieary_get(){
    yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_LOADING_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
    videoconfig.dblock=1;
    videoconfig.proprietary=NULL;
    int drivers_size=0;
    int size=0;
    config_str drivers=NULL;
    config_str rtn=NULL;
    rtn = yon_config_load(get_proprietary_drivers_info_command,&size);
    drivers=yon_config_load(get_proprietary_drivers_command,&drivers_size);
    for (int dr_desc=0;dr_desc<size;dr_desc++){
        for (int dr_foun=0;dr_foun<drivers_size;dr_foun++){
            drivers[dr_foun]=yon_char_divide_search(drivers[dr_foun],"\n",-1);
            char *pack=yon_char_new(rtn[dr_desc]);
            char *ubm=yon_char_divide_search(pack,";",-1);
            pack=yon_char_divide_search(pack,";",-1);
            if (strcmp(drivers[dr_foun],ubm)==0){
                yon_dictionary_add_or_create_if_exists_with_data(videoconfig.proprietary,drivers[dr_foun],rtn[dr_desc]);
            }
            else if (strcmp(pack,"")!=0&&!yon_dictionary_find(&videoconfig.proprietary,pack)){
                yon_dictionary_add_or_create_if_exists_with_data(videoconfig.proprietary,pack,rtn[dr_desc]);
            }
        }
    }
    if (videoconfig.proprietary){
        yon_gtk_list_store_fill_with_proprietaries(videoconfig.list);
        yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_OPETAION_DONE_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
    } else {
        drivers=yon_config_load(get_proprietary_drivers_local_command,&drivers_size);
        if (drivers){
            printf("%s\n",drivers[0]);
            for (int drivers_found=0;drivers_found<drivers_size;drivers_found++){
                drivers[drivers_found]=yon_char_divide_search(drivers[drivers_found],"\n",-1);
                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);
                    char *driver_name=yon_char_divide_search(yon_char_new(drivers[drivers_found])," ",-1);
                    if (strcmp(key,driver_name)==0)
                        if (i==0) videoconfig.proprietary=yon_dictionary_create_with_data(drivers[drivers_found],rtn[i]);
                        else videoconfig.proprietary=yon_dictionary_create_with_data_connected(videoconfig.proprietary,drivers[drivers_found],rtn[i]);
                }
            }

            yon_gtk_list_store_fill_with_proprietaries(videoconfig.list);
            yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_USE_LOCAL_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
        } else {
            videoconfig.dblock=0;
            yon_ubl_status_box_render(videoconfig.status_render,PROPRIETARY_LOADING_FAILED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
        }
    }
}


/**void yon_gtk_list_store_fill_with_proprietaries(GtkListStore *list)
 * [EN]
*/
void yon_gtk_list_store_fill_with_proprietaries(GtkListStore *list){
    if(videoconfig.proprietary){
        dictionary *dict=NULL;
        gtk_list_store_clear(videoconfig.list);
        gtk_list_store_clear(videoconfig.list2);
        int inssize=0;
        config_str installed=yon_config_load(get_proprietary_installed_command,&inssize);
        for (int i=0;i<inssize;i++)
            installed[i]=yon_char_divide_search(installed[i],"\n",-1);

        for_dictionaries(dict,videoconfig.proprietary){
            GtkTreeIter iter;
            int size=0;
            config_str str = yon_char_parse((char*)dict->data,&size,";");
            if (strcmp(str[0],"")!=0&&str[0]){
            gtk_list_store_append(videoconfig.list,&iter);
                gtk_list_store_set(videoconfig.list,&iter,1,str[0],2,str[1],3,str[2],4,_(str[3]),5,_(str[4]),-1);
            if (yon_char_parsed_check_exist(installed,inssize,str[0])!=-1)
                gtk_list_store_set(videoconfig.list,&iter,0,1,-1);
            }
            else{
            gtk_list_store_append(videoconfig.list2,&iter);
                gtk_list_store_set(videoconfig.list2,&iter,1,str[0],2,str[1],3,str[2],4,_(str[3]),5,_(str[4]),-1);
            if (yon_char_parsed_check_exist(installed,inssize,str[1])!=-1)
                gtk_list_store_set(videoconfig.list2,&iter,0,1,-1);
            }
        }
    }
}

char *yon_char_remove_brackets(char* source){
    if (source){
        char *src=yon_char_new(source);
        if (src[0]=='\"') yon_char_divide_search(src,"\"",-1);
        if (src[strlen(src)-1]=='\"') src=yon_char_divide_search(src,"\"",-1);
        return src;
    }
    return NULL;
}

void yon_monitor_view_dictionary_destroy(void *window){
    monitor_window *monitor=(monitor_window*)window;
    gtk_widget_destroy(monitor->templateMonitorscreenOverlay);
}

/**void yon_setup_config(char *configcommand)
 * [EN]
*/
void yon_setup_config(char *configcommand)
{
    videoconfig.monitors=NULL;
    if(videoconfig.monitor_visuals)
        yon_dictionary_free_all(videoconfig.monitor_visuals,yon_monitor_view_dictionary_destroy);
    videoconfig.monitor_visuals=NULL;
    videoconfig.autoChooseDrivers=0;
    videoconfig.configsize=0;
    videoconfig.descreteOnly=0;
    videoconfig.failsafeATI=NULL;
    videoconfig.failsafenVidia=NULL;
    videoconfig.gapfix=0;
    videoconfig.loaded_config=NULL;
    videoconfig.dblock=0;
    if(videoconfig.optirun)
        free(videoconfig.optirun);
    videoconfig.optirun=NULL;
    if (videoconfig.primusrun)
        free(videoconfig.primusrun);
    videoconfig.primusrun=NULL;
    if (videoconfig.ports)
        for (int i=0;i<videoconfig.portssize;i++)
            free(videoconfig.ports[i]);
        videoconfig.ports=NULL;
    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,"VGADRV_AUTO");
    if (param){
        yon_char_divide_search(param,"=",-1);
        if (strcmp(param,"NO")!=0)
        videoconfig.autoChooseDrivers=1;

    }
    param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,"FAILSAFENVIDIA");
    if (param){
        yon_char_divide_search(param,"=",-1);
        if (strcmp(param,"")!=0)
        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);
        if (strcmp(param,"")!=0)
        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_remove_brackets(yon_char_new(param));
        if (strcmp(videoconfig.optirun,"")==0) videoconfig.optirun=NULL;

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

    }
    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]));
        char *leftover=yon_char_new(param);
        yon_char_divide_search(leftover,"=",-1);
        if (param&&strcmp(leftover,"")!=0){
            videoconfig.monitors = yon_monitor_config_new(videoconfig.ports[i]);
            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);
    }
}

/** 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=0;
        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:left")!=-1)
            monitor->rotation=1;
        if (yon_char_parsed_check_exist(cnf,size,"rotate:right")!=-1)
            monitor->rotation=2;
        if (yon_char_parsed_check_exist(cnf,size,"rotate:invert")!=-1)
            monitor->rotation=3;
        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;
    }
}


char *yon_char_parsed_get_resolution(config_str parsed_string, int size){
    char *left=NULL, *right=NULL, *freq=NULL;
    for (int i=0;i<size;i++){
        right=yon_char_new(parsed_string[i]);
        left=yon_char_divide_search(right,"x",1);
        if (freq=strstr(left,"x"))
            left=yon_char_divide_search(left,"x",-1);
        if (left&&right)
            if (atoi(left)&&atoi(right))
                return parsed_string[i];
    }
    return NULL;
}

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);
    gtk_widget_set_tooltip_text(window->templateMonitorDeleteButton,DELETE_LABEL);
    gtk_widget_set_tooltip_text(window->templateMonitorInfoConfigureButton,CONFIGURE_LABEL);
    gtk_widget_set_tooltip_text(window->templateMonitorSwitchButton,SWITCH_LABEL);
    gtk_widget_set_tooltip_text(window->templateMonitorInfoAddButton,ADD_LABEL);
    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_adapter_window_setup(widgets_dict *widgets){
    int size=0;
    gtk_overlay_add_overlay(GTK_OVERLAY(widgets->InformationOverlay),widgets->InformationCompanyLogoImage);
    config_str rtn=yon_config_load(get_adapter_info,&size);
    char *desc = yon_config_get_parameter(rtn,size,"description");
    yon_char_divide_search(desc,"=",-1);
    char *product = yon_config_get_parameter(rtn,size,"product");
    yon_char_divide_search(product,"=",-1);
    char *vendor = yon_config_get_parameter(rtn,size,"vendor");
    yon_char_divide_search(vendor,"=",-1);
    char *driver_use = yon_config_get_parameter(rtn,size,"Kernel-driver-in-use");
    yon_char_divide_search(driver_use,"=",-1);
    char *driver_all = yon_config_get_parameter(rtn,size,"Kernel-modules");
    driver_all = yon_char_replace(driver_all,"-"," ");
    yon_char_divide_search(driver_all,"=",-1);
    char *final_text = yon_char_unite("<span size=\"12pt\"><span weight='bold' color='#1a5fb4'>",DESCRIPTION_LABEL,":</span> ",_(desc),
    "\n<span weight='bold' color='#1a5fb4'>",VENDOR_LABEL,":</span> ",vendor,
    "\n<span weight='bold' color='#1a5fb4'>",MODEL_LABEL,":</span> ",product,
    "\n<span weight='bold' color='#1a5fb4'>",USED_KERNEL_DRIVER_LABEL,":</span> ",driver_use,
    "\n<span weight='bold' color='#1a5fb4'>",AVALIABLE_KERNEL_DRIVERS_LABEL,":</span> ",driver_all,"</span>",NULL);
    gtk_label_set_markup(GTK_LABEL(gtk_builder_get_object(widgets->builder,"InformationLabel")),final_text);
    if (strstr(vendor,"Intel")){
        GtkIconTheme *icthm=gtk_icon_theme_get_default();
        gtk_image_set_from_pixbuf(GTK_IMAGE(widgets->InformationCompanyLogoImage),gtk_icon_info_load_icon(gtk_icon_theme_lookup_icon_for_scale(icthm, "com.ublinux.ubl-settings-video.intel-logo",64,1,GTK_ICON_LOOKUP_FORCE_SVG),NULL));
    }
    else if (strstr(vendor,"NVIDIA")){
        GtkIconTheme *icthm=gtk_icon_theme_get_default();
        gtk_image_set_from_pixbuf(GTK_IMAGE(widgets->InformationCompanyLogoImage),gtk_icon_info_load_icon(gtk_icon_theme_lookup_icon_for_scale(icthm, "com.ublinux.ubl-settings-video.nvidia-logo",64,1,GTK_ICON_LOOKUP_FORCE_SVG),NULL));
    }
    else if (strstr(vendor,"AMD")){
        GtkIconTheme *icthm=gtk_icon_theme_get_default();
        gtk_image_set_from_pixbuf(GTK_IMAGE(widgets->InformationCompanyLogoImage),gtk_icon_info_load_icon(gtk_icon_theme_lookup_icon_for_scale(icthm, "com.ublinux.ubl-settings-video.amd-logo",64,1,GTK_ICON_LOOKUP_FORCE_SVG),NULL));
    }
    else {
        gtk_widget_destroy(widgets->InformationCompanyLogoImage);
    }
}

/** 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->PlugBox = yon_gtk_builder_get_widget(widgets->builder, "mainPlugBox");
    widgets->PlugSaveBox = yon_gtk_builder_get_widget(widgets->builder, "plugLoadButton");
    widgets->PlugLoadBox = yon_gtk_builder_get_widget(widgets->builder, "plugSaveButton");

    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->TerminalOverlay = yon_gtk_builder_get_widget(widgets->builder, "TerminalOverlay");
    widgets->MenusTab = yon_gtk_builder_get_widget(widgets->builder, "MenusTab");
    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->DriverModulesTab = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "DriverModulesTab"));
    widgets->DriversTab = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "DriversTab"));
    widgets->MainTabLabel = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "MainTabLabel"));
    widgets->DriversTabLabel = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "DriversTabLabel"));
    widgets->InformationTabLabel = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "InformationTabLabel"));
    widgets->InformationFrameLabel = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "InformationFrameLabel"));
    widgets->InformationOverlay = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "InformationOverlay"));
    widgets->InformationCompanyLogoImage = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "InformationCompanyLogoImage"));

    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.pack_box=widgets->mainMonitorVisualConfigurationBox;
    // g_signal_connect(G_OBJECT(widgets->MainWindow), "check-resize", G_CALLBACK(on_resized), NULL);
    gtk_window_set_title(GTK_WINDOW(widgets->MainWindow),SETTINGS_VIDEO_TITLE_LABEL);

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

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

    g_signal_connect(G_OBJECT(widgets->MenusTab), "switch-page", G_CALLBACK(on_proprietary_get), widgets);

    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->proprietaryTreeView), "cursor-changed", G_CALLBACK(on_driver_pack_selection_change), widgets);
    g_signal_connect(G_OBJECT(widgets->driversTreeView), "cursor-changed", G_CALLBACK(on_driver_selection_change), 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), NULL);
    // 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_link), 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_LABEL);
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo), FBDEV_LABEL);
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo), OFF_LABEL);
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo), FBDEV_LABEL);

    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainExtraFixGapCombo), SWITCHED_OFF_LABEL);
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainExtraFixGapCombo), GAP_FIX_1_LABEL);
    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainExtraFixGapCombo), GAP_FIX_2_LABEL);
    gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->mainExtraFixGapCombo),0);
    gtk_label_set_text(GTK_LABEL(widgets->headInfoLabel), SETTINGS_VIDEO_TITLE_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->mainDriverFailsafeNvidiaLabel), FAILSAFE_NVIDIA_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->mainDriverFailsafeAMDLabel), FAILSAFE_ATI_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->mainDriverFrameLabel), DRIVER_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->mainMonitorConfigurationFrameLabel), MONITOR_CONFIGURATION_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->mainHybridGraphicsFrameLabel), HYBRID_GRAPHICS_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->mainExtraFixGapLabel), FIX_GAP_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->mainExtraFrameLabel), EXTRA_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->mainHeaderTitleLabel), SETTINGS_VIDEO_TITLE_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->mainHeaderConfigLoadLabel), LOAD_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->mainHeaderSaveConfigurationLabel), SAVE_LABEL);

    gtk_button_set_label(GTK_BUTTON(widgets->mainHybridGraphicsDiscreteCheck), ON_LABEL);
    gtk_button_set_label(GTK_BUTTON(widgets->mainDriverAutomaticallyChooseCheck), AUTO_CHOOSE_DRIVERS_LABEL);
    gtk_button_set_label(GTK_BUTTON(widgets->mainExtraLaunchOptirunCheck), LAUNCH_OPTIRUN_LABEL);
    gtk_button_set_label(GTK_BUTTON(widgets->mainExtraLaunchPrismusunCheck), LAUNCH_PRIMUSRUN_LABEL);
    gtk_button_set_label(GTK_BUTTON(widgets->mainHybridGraphicsDiscreteCheck), DISCRETE_ONLY_LABEL);

    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderLoadGlobalMenuItem), LOAD_GLOBAL_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderLoadLocalMenuItem), LOAD_LOCAL_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSaveGlobalLocalMenuItem), SAVE_GLOBAL_LOCAL_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSaveGlobalMenuItem), SAVE_GLOBAL_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSaveLocalMenuItem), SAVE_LOCAL_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSettingsDocumentationMenuItem), DOCUMENTATION_LABEL);
    gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSettingsAboutMenuItem), ABOUT_LABEL);


    gtk_label_set_text(GTK_LABEL(widgets->DriverModulesTab), DRIVER_MODULES_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->DriversTab), DRIVERS_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->MainTabLabel), MAIN_SETTINGS_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->DriversTabLabel), DRIVERS_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->InformationTabLabel), INFORMATION_LABEL);
    gtk_label_set_text(GTK_LABEL(widgets->InformationFrameLabel), DEVICES_DRIVERS_LABEL);

    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), INSTALLED_LABEL);
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), PACKAGE_LABEL);
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), SUPPORTED_LABEL);
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), DRIVER_LABEL);
    gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDescriptionColumn), DESCRIPTION_LABEL);

    yon_ubl_header_setup(widgets->mainHeadOverlay, widgets->headBox, widgets->mainHeadBackgroundImage, banner_path);
    yon_monitor_view_setup(widgets->mainMonitorVisualConfigurationBox);

    videoconfig.status_render.icon=widgets->mainStatusIcon;
    videoconfig.status_render.label=widgets->mainStatusLabel;
    videoconfig.status_render.box=widgets->mainStatusBox;
    if (videoconfig.lock_load_global==1)
        gtk_widget_set_sensitive(widgets->mainHeaderLoadGlobalMenuItem,0);
    if (videoconfig.lock_save_global==1)
        gtk_widget_set_sensitive(widgets->mainHeaderSaveGlobalMenuItem,0);
    if (videoconfig.lock_save_local==1)
        gtk_widget_set_sensitive(widgets->mainHeaderSaveLocalMenuItem,0);
    if (videoconfig.lock_save_global==1||videoconfig.lock_save_local==1)
        gtk_widget_set_sensitive(widgets->mainHeaderSaveGlobalLocalMenuItem,0);
}

int main(int argc, char *argv[])
{
    {
        int show_help=0;
        videoconfig.socket_id=-1;
        videoconfig.save_socket_id=-1;
        videoconfig.load_socket_id=-1;
        videoconfig.lock_help=-1;
        videoconfig.lock_load_global=-1;
        videoconfig.lock_save_global=-1;
        videoconfig.lock_save_local=-1;
        local = setlocale(LC_ALL, "");
        textdomain(LocaleName);
        int option_index=0;
        struct option long_options[] = {
                {"help", 0, 0, 'h'},
                {"version", 0, 0, 'V'},
                {"lock-help", 0,0, 1},
                // {"lock-settings", 0,0, -16},
                {"lock-save", 0,0, 2},
                {"lock-save-local", 0,0, 3},
                {"lock-save-global", 0,0, 4},
                {"lock-load-global", 0,0, 5},
                {"socket-id", 1, 0, 's'},
                {"socket-ext-id", 1,0, 'e'},
                {"socket-trd-id", 1,0, 't'},
                { NULL, 0, NULL, 0 }
        };
        for (int i=0;i<argc;i++){
            int argument=getopt_long(argc,argv,"hVvs:e:t:",long_options,&option_index);
            switch(argument){
                case 'h':
                    show_help=1;
                    break;
                case 'v':
                case 'V':
                    printf("%s\n",VERSION_LABEL);
                    exit(0);
                    break;
                case 's':
                    if(optarg)
                        videoconfig.socket_id=atoi(optarg);
                    break;
                case 'e':
                    if(optarg)
                        videoconfig.load_socket_id=atoi(optarg);
                    break;
                case 't':
                    if(optarg)
                        videoconfig.save_socket_id=atoi(optarg);
                    break;
                case 1:
                    videoconfig.lock_help=1;
                    break;
                // case -16:
                //     break;
                case 2:
                    videoconfig.lock_save_local=1;
                    videoconfig.lock_save_global=1;
                    break;
                case 3:
                    videoconfig.lock_save_local=1;
                    break;
                case 4:
                    videoconfig.lock_save_global=1;
                    break;
                case 5:
                    videoconfig.lock_load_global=1;
                    break;
            }
        }
        if (show_help==1&&videoconfig.lock_help==-1){
            printf("%s\n",HELP_LABEL);
            exit(0);
            }
    }
    
    if (getuid()!=0){
        char *args="";
        for (int i=0;i<argc;i++)
            args=yon_char_unite(args," ",argv[i],NULL);
        if (system(yon_char_get_augumented("/usr/bin/pkexec ubl-settings-video ",args)));
        return 0;
    } else {
        int ssize=0;
        yon_config_load("pkexec pacman -Sy",&ssize);
        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);
        // yon_gtk_list_store_fill_with_proprietaries(videoconfig.modulelist);
        gtk_widget_show(widgets.MainWindow);
        yon_ubl_status_box_render(videoconfig.status_render,LOCAL_LOAD_SUCCESS,BACKGROUND_IMAGE_SUCCESS_TYPE);
        on_config_fill_interface(&widgets);
        yon_monitor_set_resolutions();
        yon_adapter_window_setup(&widgets);
        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);
        yon_monitor_view_update();
        yon_ubl_setup_sockets(widgets.PlugBox,widgets.PlugLoadBox,widgets.PlugSaveBox,videoconfig.socket_id,videoconfig.load_socket_id,videoconfig.save_socket_id);
        g_signal_connect(G_OBJECT(gtk_widget_get_parent(widgets.mainPlugBox)), "check-resize", G_CALLBACK(on_resized), NULL);
        gtk_main();
        return 0;
    }
}