Applications
/
ubl-settings-video
10
0
Fork 2
Code Issues 5 Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '42d16ebbd0'
${ noResults }
ubl-settings-video/source/ubl-settings-video.c

1457 lines
72 KiB
Raw Blame History

#include "ubl-settings-video.h"
config main_config;
void on_terminal_done(GtkWidget *terminal, int size, main_window *widgets){
gtk_widget_destroy(terminal);
}
void on_terminal_more(GtkWidget *self, main_window *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, main_window *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(main_config.list);
yon_ubl_status_box_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, main_window *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(main_window *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_resource(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,main_window *widgets){
yon_ubl_status_box_render(PROPRIETARY_INSTALLING_IN_PROGRESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(main_config.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_append(install_proprietary_command,name));
} else {
yon_ubl_status_box_render(PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
void on_driver_install(GtkWidget *self,main_window *widgets){
yon_ubl_status_box_render(PROPRIETARY_INSTALLING_IN_PROGRESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(main_config.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_append(install_proprietary_command,name));
gtk_list_store_set(main_config.list,&iter,0,1,-1);
} else {
yon_ubl_status_box_render(PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
void on_driver_pack_delete(GtkWidget *self,main_window *widgets){
yon_ubl_status_box_render(PROPRIETARY_DELETING_IN_PROGRESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(main_config.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_append(delete_proprietary_command,name));
} else {
yon_ubl_status_box_render(PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
void on_driver_pack_selection_change(GtkWidget *self, main_window *widgets){
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(main_config.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, main_window *widgets){
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(main_config.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;
char *module, *package;
gtk_tree_model_get(gtk_tree_view_get_model(GTK_TREE_VIEW(widgets->driversTreeView)),&iter,0,&installed,1,&module,2,&package,-1);
char *target;
if (strcmp(module,""))
target = module;
else
target = package;
if (yon_char_parsed_check_exist(drivers_always_active,drivers_always_active_size,target)>-1){
gtk_widget_set_sensitive(widgets->driversInstallButton,0);
gtk_widget_set_sensitive(widgets->driversDeleteButton,0);
}
else 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,main_window *widgets){
yon_ubl_status_box_render(PROPRIETARY_DELETING_IN_PROGRESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(main_config.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_append(delete_proprietary_command,name));
gtk_list_store_set(main_config.list,&iter,0,0,-1);
} else {
yon_ubl_status_box_render(PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
void on_driver_pack_info(GtkWidget *self, main_window *widgets){
pthread_attr_t attr;
pthread_t tid;
pthread_attr_init(&attr);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(main_config.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,yon_char_append(get_info_proprietary_command,name));
} else {
yon_ubl_status_box_render(PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
void on_driver_info(GtkWidget *self,main_window *widgets){
pthread_attr_t attr;
pthread_t tid;
pthread_attr_init(&attr);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(main_config.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,yon_char_append(get_info_proprietary_command,name));
} else {
yon_ubl_status_box_render(PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
void on_port_chosen_changed(GtkWidget *self, monitor_edit_window *window){
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->PortCombo));
if (portid){
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->ResolutionCombo));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->ResolutionCombo),PARAMETER_DEFAULT_LABEL);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->ResolutionCombo),0);
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->PositionPortCombo));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->PositionPortCombo),PARAMETER_DEFAULT_LABEL);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->PositionPortCombo),0);
char *port_name = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->PortCombo));
gtk_window_set_title(GTK_WINDOW(window->MainWindow),PORT_EDIT_LABEL(port_name));
dict=yon_dictionary_get(&main_config.supported_resolutions,port_name);
if (dict){
int size;
config_str resolutions = yon_file_open(get_resolutions_supportable_command,&size);
resolutions = yon_char_parsed_rip(resolutions,&size,0);
for (int i=0;i<size;i++){
yon_char_remove_last_symbol(resolutions[i],'\n');
}
resolution_supported *res = yon_dictionary_get_data(dict,resolution_supported*);
int found_size=0;
int found = -1;
for (int i=0;i<res->size;i++){
char *check_line;
for (int j=1;j<size;j++){
if (strstr(resolutions[j],res->line[i])){
found = j;
break;
}
}
if (found>-1){
char *current = yon_char_new(resolutions[found]);
int parsed_size;
config_str parsed = yon_char_parse(current,&parsed_size,";");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->ResolutionCombo),yon_char_parsed_to_string(parsed,parsed_size," "));
yon_char_parsed_free(parsed,parsed_size);
} else
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->ResolutionCombo),res->line[i]);
}
}
for (int i=0;i<main_config.portssize;i++){
if (strcmp(port_name,main_config.ports[i])){
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->PositionPortCombo),main_config.ports[i]);
}
}
}
}
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, main_window *widgets)
{
int state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self));
main_config.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);
}
void on_resolutions_unsupported_show(GtkToggleButton *self, monitor_edit_window *window){
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->ResolutionCombo));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->ResolutionCombo),PARAMETER_DEFAULT_LABEL);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->ResolutionCombo),0);
if (gtk_toggle_button_get_active(self)){
int size;
config_str resolutions = yon_file_open(get_resolutions_supportable_command,&size);
// yon_gtk_combo_box_text_fill(window->ResolutionCombo,main_config.resolutions,main_config.resolutionssize);
for (int i=1;i<size;i++){
yon_char_remove_last_symbol(resolutions[i],'\n');
int parsed_size;
config_str parsed = yon_char_parse(resolutions[i],&parsed_size,";");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->ResolutionCombo),yon_char_parsed_to_string(parsed,parsed_size," "));
yon_char_parsed_free(parsed,parsed_size);
}
yon_char_parsed_free(resolutions,size);
} else {
on_port_chosen_changed(window->PortCombo,window);
// yon_gtk_combo_box_text_fill(window->ResolutionCombo,((monitorconfig*)window->config->data)->resolutionCapabilities,((monitorconfig*)window->config->data)->resolution_size);
}
}
void on_save_done(main_window *widgets, config_str output, int size){
if (widgets) {};
char *final_output = yon_char_parsed_to_string(output,size,"");
printf("%s\n",final_output);
free(final_output);
yon_char_parsed_free(output,size);
textdomain(template_ui_LocaleName);
switch (main_config.save_config){
case 0:
yon_ubl_status_box_render(GLOBAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
break;
case 1:
yon_ubl_status_box_render(LOCAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
break;
case 2:
yon_ubl_status_box_render(GLOBAL_LOCAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
break;
}
textdomain(LocaleName);
}
void yon_interface_save(){
char *autodrivers = NULL;
char *freedrivers = NULL;
char *dpms= NULL;
char *dpi = NULL;
char *failsafenvidia = NULL;
char *failsafeati = NULL;
char *optirun = NULL;
char *primusrun = NULL;
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(main_config.widgets->AutoDriverCombo))){
case 0: yon_config_remove_by_key(VGADRV_AUTO);
break;
case 1: yon_config_register(VGADRV_AUTO,VGADRV_AUTO_command,"no");
break;
case 2: yon_config_register(VGADRV_AUTO,VGADRV_AUTO_command,"yes");
break;
}
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(main_config.widgets->FreeDriverCombo))){
case 0: yon_config_remove_by_key(VGADRV_NOFREE);
break;
case 1: yon_config_register(VGADRV_NOFREE,VGADRV_NOFREE_command,"yes");
break;
case 2: yon_config_register(VGADRV_NOFREE,VGADRV_NOFREE_command,"nouveau");
break;
case 3: yon_config_register(VGADRV_NOFREE,VGADRV_NOFREE_command,"radeon");
break;
case 4: yon_config_register(VGADRV_NOFREE,VGADRV_NOFREE_command,"no");
break;
}
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(main_config.widgets->FailsafeAMDCombo))){
case 0: yon_config_remove_by_key(FAILSAFEATI);
break;
case 1: yon_config_register(FAILSAFEATI,FAILSAFEATI_command,"no");
break;
case 2: yon_config_register(FAILSAFEATI,FAILSAFEATI_command,"fbdev");
break;
}
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(main_config.widgets->FailsafeNvidiaCombo))){
case 0: yon_config_remove_by_key(FAILSAFENVIDIA);
break;
case 1: yon_config_register(FAILSAFENVIDIA,FAILSAFENVIDIA_command,"no");
break;
case 2: yon_config_register(FAILSAFENVIDIA,FAILSAFENVIDIA_command,"fbdev");
break;
}
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(main_config.widgets->DontSwitchDisplaysOffCombo))){
case 0: yon_config_remove_by_key(XORG_EXT);
break;
case 1: yon_config_register(XORG_EXT,XORG_EXT_command,"nodpms");
break;
case 2: yon_config_register(XORG_EXT,XORG_EXT_command,"dpms");
break;
}
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(main_config.widgets->DisplayScalingCombo))){
case 0: yon_config_remove_by_key(XORG_DPI);
break;
case 1: yon_config_register(XORG_DPI,XORG_DPI_command,"auto");
break;
default: dpi = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(main_config.widgets->DisplayScalingCombo));
yon_char_divide_search_self(dpi," ",-1);
yon_config_register(XORG_DPI,XORG_DPI_command,dpi);
break;
}
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(main_config.widgets->OptirunCombo))){
case 0: yon_config_remove_by_key(OPTIRUN);
break;
case 1: yon_config_register(OPTIRUN,OPTIRUN_command,"no");
break;
case 2: if (!yon_char_is_empty(gtk_entry_get_text(GTK_ENTRY(main_config.widgets->OptirunEntry))))
yon_config_register(OPTIRUN,OPTIRUN_command,(char*)gtk_entry_get_text(GTK_ENTRY(main_config.widgets->OptirunEntry)));
break;
}
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(main_config.widgets->PrimusrunCombo))){
case 0: yon_config_remove_by_key(PRIMUSRUN);
break;
case 1: yon_config_register(PRIMUSRUN,PRIMUSRUN_command,"no");
break;
case 2: if (!yon_char_is_empty(gtk_entry_get_text(GTK_ENTRY(main_config.widgets->PrimusrunEntry))))
yon_config_register(PRIMUSRUN,PRIMUSRUN_command,(char*)gtk_entry_get_text(GTK_ENTRY(main_config.widgets->PrimusrunEntry)));
break;
}
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(main_config.widgets->FrameGapCombo))){
case 0: yon_config_remove_by_key(GL_YIELD);
yon_config_remove_by_key(KWIN_TRIPLE_BUFFER);
break;
case 2: yon_config_register(GL_YIELD,GL_YIELD_command,"USLEEP");
yon_config_remove_by_key(KWIN_TRIPLE_BUFFER);
break;
case 3: yon_config_register(KWIN_TRIPLE_BUFFER,KWIN_TRIPLE_BUFFER_command,"1");
yon_config_remove_by_key(GL_YIELD);
break;
}
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(main_config.widgets->DisplayDiscreteOnly))){
case 0:
yon_config_remove_by_key(INTEGRATEDVGA);
break;
case 1:yon_config_register(INTEGRATEDVGA,INTEGRATEDVGA_command,"no");
break;
case 2:yon_config_register(INTEGRATEDVGA,INTEGRATEDVGA_command,"yes ");
break;
}
}
void yon_interface_update(){
if (main_config.ports&&main_config.portssize>0){
yon_char_parsed_free(main_config.ports,main_config.portssize);
}
main_config.ports=yon_config_load(get_ports_command,&main_config.portssize);
for (int i=0;i<main_config.portssize;i++){
yon_char_remove_last_symbol(main_config.ports[i],'\n');
}
char *autodrivers = yon_config_get_by_key(VGADRV_AUTO);
char *freedrivers = yon_config_get_by_key(VGADRV_NOFREE);
char *dpms= yon_config_get_by_key(XORG_EXT);
char *dpi = yon_config_get_by_key(XORG_DPI);
char *failsafenvidia = yon_config_get_by_key(FAILSAFENVIDIA);
char *failsafeati = yon_config_get_by_key(FAILSAFEATI);
char *optirun = yon_config_get_by_key(OPTIRUN);
char *primusrun = yon_config_get_by_key(PRIMUSRUN);
char *discrete = yon_config_get_by_key(INTEGRATEDVGA);
char *gapfix1 = yon_config_get_by_key(GL_YIELD);
char *gapfix2 = yon_config_get_by_key(KWIN_TRIPLE_BUFFER);
if (!yon_char_is_empty(autodrivers)&&!strcmp(autodrivers,"yes"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->AutoDriverCombo),2);
else if (!yon_char_is_empty(autodrivers)&&!strcmp(autodrivers,"no"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->AutoDriverCombo),1);
else
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->AutoDriverCombo),0);
if (!yon_char_is_empty(freedrivers)&&!strcmp(freedrivers,"yes"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FreeDriverCombo),1);
else if (!yon_char_is_empty(freedrivers)&&!strcmp(freedrivers,"nouveau"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FreeDriverCombo),2);
else if (!yon_char_is_empty(freedrivers)&&!strcmp(freedrivers,"radeon"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FreeDriverCombo),3);
else if (!yon_char_is_empty(freedrivers)&&!strcmp(freedrivers,"no"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FreeDriverCombo),4);
else
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FreeDriverCombo),0);
if (!yon_char_is_empty(dpi)&&!strcmp(dpi,"auto"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->DisplayScalingCombo),1);
else if (yon_char_is_empty(dpi))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->DisplayScalingCombo),0);
else{
if (!strcmp(dpi,"2K")||!strcmp(dpi,"4K")){
gtk_combo_box_set_active_id(GTK_COMBO_BOX(main_config.widgets),dpi);
} else {
yon_gtk_combo_box_text_find(main_config.widgets->DisplayScalingCombo,dpi);
}
}
if (!yon_char_is_empty(failsafenvidia)&&!strcmp(failsafenvidia,"fbdev"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FailsafeNvidiaCombo),2);
else if (!yon_char_is_empty(failsafenvidia)&&!strcmp(failsafenvidia,"no"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FailsafeNvidiaCombo),1);
else
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FailsafeNvidiaCombo),0);
if (!yon_char_is_empty(failsafeati)&&!strcmp(failsafeati,"fbdev"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FailsafeAMDCombo),2);
else if (!yon_char_is_empty(failsafeati)&&!strcmp(failsafeati,"no"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FailsafeAMDCombo),1);
else
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FailsafeAMDCombo),0);
if (!yon_char_is_empty(optirun)){
if (strcmp(optirun,"no")){
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->OptirunCombo),2);
gtk_entry_set_text(GTK_ENTRY(main_config.widgets->OptirunEntry),optirun);
} else {
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->OptirunCombo),1);
}
} else if (yon_char_is_empty(optirun))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->OptirunCombo),0);
else
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->OptirunCombo),0);
if (!yon_char_is_empty(primusrun)){
if (strcmp(primusrun,"no")){
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->PrimusrunCombo),2);
gtk_entry_set_text(GTK_ENTRY(main_config.widgets->PrimusrunEntry),primusrun);
} else {
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->PrimusrunCombo),1);
}
} else if (yon_char_is_empty(primusrun))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->PrimusrunCombo),0);
else
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->PrimusrunCombo),0);
if (!yon_char_is_empty(dpms)&&!strcmp(dpms,"dpms"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->DontSwitchDisplaysOffCombo),2);
else if (!yon_char_is_empty(dpms)&&!strcmp(dpms,"nodpms"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->DontSwitchDisplaysOffCombo),1);
else
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->DontSwitchDisplaysOffCombo),0);
if (!yon_char_is_empty(discrete)&&!strcmp(discrete,"yes"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->DisplayDiscreteOnly),2);
else if (!yon_char_is_empty(discrete)&&!strcmp(discrete,"no"))
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->DisplayDiscreteOnly),1);
else
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->DisplayDiscreteOnly),0);
// if (!yon_char_is_empty(gapfix1))
// gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FailsafeNvidiaCombo),2);
// else if (!yon_char_is_empty(gapfix2))
// gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FailsafeNvidiaCombo),3);
// else
// gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FailsafeNvidiaCombo),1);
yon_monitor_view_update();
}
void yon_load_proceed(YON_CONFIG_TYPE type){
yon_config_clean();
if (!yon_char_is_empty(config_get_default_command))
yon_config_load_config(YON_CONFIG_DEFAULT,config_get_default_command,NULL);
if (type==YON_CONFIG_GLOBAL){
yon_config_load_config(type,config_get_global_command,NULL);
} else if (type==YON_CONFIG_LOCAL){
yon_config_load_config(type,config_get_local_command,NULL);
} else if (type==YON_CONFIG_CUSTOM){
char *path="";
textdomain(template_ui_LocaleName);
GtkWidget *dialog = gtk_file_chooser_dialog_new(template_app_information.app_title,NULL,GTK_FILE_CHOOSER_ACTION_SAVE,CANCEL_LABEL,GTK_RESPONSE_CANCEL,OPEN_LABEL,GTK_RESPONSE_ACCEPT,NULL);
yon_gtk_window_setup(GTK_WINDOW(dialog),NULL,TITLE_LABEL,icon_name,"FileChooserWindow");
textdomain(LocaleName);
gtk_window_set_icon_name(GTK_WINDOW(dialog),"com.ublinux.ubl-settings-services");
gtk_window_set_title(GTK_WINDOW(dialog),TITLE_LABEL);
GtkFileFilter *filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter,"*.ini");
gtk_file_filter_set_name(filter, "*.ini");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),filter);
gtk_widget_show(dialog);
int response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_ACCEPT){
char *file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if (!yon_char_is_empty(file)){
path=yon_char_unite("'",file,"'",NULL);
free(file);
}
gtk_widget_destroy(dialog);
} else {
gtk_widget_destroy(dialog);
}
yon_config_load_config(type,yon_config_get_custom_command(path),NULL);
}
}
void on_config_local_load(GtkWidget *self,main_window *widgets){
if (self){}
yon_load_proceed(YON_CONFIG_LOCAL);
main_config.load_mode=1;
yon_interface_update();
}
void on_config_global_load(GtkWidget *self,main_window *widgets){
if (self){}
yon_load_proceed(YON_CONFIG_GLOBAL);
main_config.load_mode=0;
yon_interface_update();
}
void on_config_custom_load(GtkWidget *self,main_window *widgets){
if (self){}
yon_load_proceed(YON_CONFIG_CUSTOM);
main_config.load_mode=3;
yon_interface_update();
}
void on_config_global_local_save(){
main_config.save_config=3;
yon_save_proceed(NULL,YON_CONFIG_BOTH,config_get_global_command,NULL);
}
void on_config_local_save(){
yon_interface_save();
main_config.save_config=1;
yon_save_proceed("system",YON_CONFIG_LOCAL,config_get_local_command,NULL);
}
void on_config_global_save(){
yon_interface_save();
main_config.save_config=0;
yon_save_proceed("global",YON_CONFIG_GLOBAL,config_get_global_command,NULL);
}
void on_config_custom_save(GtkWidget *self, main_window *widgets){
yon_interface_save();
if (self&&widgets){}
main_config.save_config=1;
template_saving_window *window = yon_save_proceed(NULL,YON_CONFIG_CUSTOM,yon_config_get_custom_command("system"),NULL);
if (window){};
}
// functions
/**void on_monitor_delete(GtkWidget *self,monitor_data windowd)
* [EN]
*/
void on_monitor_delete(GtkWidget *self,monitor_data *window){
if(window){
GtkWidget *target = gtk_widget_get_parent(window->ScreenOverlay);
GtkWidget *flow_box = gtk_widget_get_parent(target);
gtk_container_remove(GTK_CONTAINER(flow_box),target);
free(window);
}
}
/**void on_monitor_switch(GtkWidget *self,monitor_data *window)
* [EN]
*/
void on_monitor_switch(GtkWidget *self,monitor_data *window){
if(window){
int enable = 0;
gtk_widget_set_sensitive(window->MonitorImage,!enable);
}
}
/**void on_monitor_add(GtkWidget *self,monitor_data *window)
* [EN]
*/
void on_monitor_add(GtkWidget *self,main_window *widgets){
if(widgets){
yon_monitor_new(widgets,0);
}
}
void on_proprietary_get(GtkWidget *self, gpointer data){
if (main_config.dblock==0){
GtkTreeIter iter;
pthread_t tid;
pthread_create(&tid,NULL,(void*)yon_proprieary_get,NULL);
main_config.dblock=1;
}
}
void on_monitor_config_save(GtkWidget *self, monitor_edit_window *window){
int enabled=0;
char *target=NULL;
int main_display=0;
char *resolution = NULL;
char *rotate = NULL;
char *position = NULL;
int switch_off=0;
int modeline_cvt = 0;
int cvt_reduced = 0;
int modeline_gtf = 0;
int do_not_switch_off = 0;
enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->EnableCheck));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->PortCombo))){
target = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->PortCombo));
main_display = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->MainCheck));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->ResolutionCombo)))
resolution = yon_char_divide_search(yon_char_new(gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->ResolutionCombo)))," ",-1);
int rot = gtk_combo_box_get_active(GTK_COMBO_BOX(window->RotationCombo));
rotate = yon_char_append("rotation:",rot == 0?"normal":rot==1?"left":rot==2?"right":"invert");
int pos = gtk_combo_box_get_active(GTK_COMBO_BOX(window->PositionPosCombo));
if (pos&&gtk_combo_box_get_active(GTK_COMBO_BOX(window->PositionPortCombo))){
position = yon_char_append(pos==1?"lo:":pos==2?"ro:":pos==3?"ab:":"be",gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->PositionPortCombo)));
}
switch_off = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->DoNotSwitchOffCheck));
modeline_cvt = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->ModelineCVTCheck));
cvt_reduced = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->UseCVTReducedCheck));
modeline_gtf = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->ModelineGTFCheck));
do_not_switch_off = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->DoNotSwitchOffCheck));
int final_size;
config_str final_parsed=NULL;
if (resolution)
yon_char_parsed_add_or_create_if_exists(final_parsed,&final_size,resolution);
if (modeline_cvt)
yon_char_parsed_add_or_create_if_exists(final_parsed,&final_size,"cvt");
if (modeline_gtf)
yon_char_parsed_add_or_create_if_exists(final_parsed,&final_size,"gtf");
if (cvt_reduced)
yon_char_parsed_add_or_create_if_exists(final_parsed,&final_size,"reduced");
if (enabled)
yon_char_parsed_add_or_create_if_exists(final_parsed,&final_size,"enable");
if (!enabled)
yon_char_parsed_add_or_create_if_exists(final_parsed,&final_size,"disable");
if (main_display)
yon_char_parsed_add_or_create_if_exists(final_parsed,&final_size,"primary");
if (do_not_switch_off){
yon_char_parsed_add_or_create_if_exists(final_parsed,&final_size,"dpms");
}else{
yon_char_parsed_add_or_create_if_exists(final_parsed,&final_size,"nodpms");
}
if (position)
yon_char_parsed_add_or_create_if_exists(final_parsed,&final_size,position);
if (rotate)
yon_char_parsed_add_or_create_if_exists(final_parsed,&final_size,rotate);
char *final_string = yon_char_parsed_to_string(final_parsed,final_size,",");
yon_config_register(XORG_MONITOR(target),XORG_MONITOR_get_command,final_string);
on_subwindow_close(window->MainWindow);
} else {
yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),MISSING_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
yon_ubl_status_highlight_incorrect(window->PortCombo);
}
yon_monitor_view_update();
}
void yon_monitor_parse(monitor_edit_window *window, char *string){
int parsed_size;
config_str parsed = yon_char_parse(string,&parsed_size,",");
if (parsed_size>0){
int resolution = yon_gtk_combo_box_text_find(window->ResolutionCombo,parsed[0]);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->ResolutionCombo),resolution);
for (int i=1; i<parsed_size;i++){
if (!strcmp(parsed[i],"cvt")){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->ModelineCVTCheck),1);
} else if (!strcmp(parsed[i],"gtf")){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->ModelineGTFCheck),1);
} else if (!strcmp(parsed[i],"reduced")||!strcmp(parsed[i],"r")){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->UseCVTReducedCheck),1);
} else if (!strcmp(parsed[i],"dpms")){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->DoNotSwitchOffCheck),1);
} else if (!strcmp(parsed[i],"nodpms")){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->DoNotSwitchOffCheck),0);
} else if (!strcmp(parsed[i],"enable")){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->EnableCheck),1);
} else if (!strcmp(parsed[i],"disable")){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->EnableCheck),0);
} else if (!strcmp(parsed[i],"ignore")){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->ModelineCVTCheck),1);
} else if (!strcmp(parsed[i],"primary")){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->MainCheck),1);
} else if (strstr(parsed[i],"lo:")||strstr(parsed[i],"LeftOf:")){
char *location = yon_char_divide_search(parsed[i],":",-1);
int target = yon_gtk_combo_box_text_find(window->PositionPortCombo,parsed[i]);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->RotationCombo),target);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->PositionPosCombo),1);
} else if (strstr(parsed[i],"ro:")||strstr(parsed[i],"RightOf:")){
char *location = yon_char_divide_search(parsed[i],":",-1);
yon_gtk_combo_box_text_find(window->PositionPortCombo,parsed[i]);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->PositionPosCombo),2);
} else if (strstr(parsed[i],"ab:")||strstr(parsed[i],"Above:")){
char *location = yon_char_divide_search(parsed[i],":",-1);
yon_gtk_combo_box_text_find(window->PositionPortCombo,parsed[i]);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->PositionPosCombo),3);
} else if (strstr(parsed[i],"bee:")||strstr(parsed[i],"Below:")){
char *location = yon_char_divide_search(parsed[i],":",-1);
yon_gtk_combo_box_text_find(window->PositionPortCombo,parsed[i]);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->PositionPosCombo),4);
} else if (strstr(parsed[i],"rotate:")){
char *location = yon_char_divide_search(parsed[i],":",-1);
if (strcmp(parsed[i],"normal")){
gtk_combo_box_set_active(GTK_COMBO_BOX(window->RotationCombo),0);
} else if (strcmp(parsed[i],"left")){
gtk_combo_box_set_active(GTK_COMBO_BOX(window->RotationCombo),1);
} else if (strcmp(parsed[i],"right")){
gtk_combo_box_set_active(GTK_COMBO_BOX(window->RotationCombo),2);
} else if (strcmp(parsed[i],"invert")){
gtk_combo_box_set_active(GTK_COMBO_BOX(window->RotationCombo),3);
}
}
}
}
}
void on_monitor_configure(GtkWidget *self,monitor_data *window){
if(window){
monitor_edit_window *monitors = new(monitor_edit_window);
GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_configuration);
monitors->MainWindow = GTK_WIDGET(gtk_builder_get_object(builder, "MainWindow"));
monitors->StatusBox = GTK_WIDGET(gtk_builder_get_object(builder, "StatusBox"));
monitors->HeadLabel = GTK_WIDGET(gtk_builder_get_object(builder, "HeadLabel"));
monitors->EnableConfigurationBox = GTK_WIDGET(gtk_builder_get_object(builder, "EnableConfigurationBox"));
monitors->InterfaceConfigurationBox = GTK_WIDGET(gtk_builder_get_object(builder, "InterfaceConfigurationBox"));
monitors->EnableCheck = GTK_WIDGET(gtk_builder_get_object(builder, "EnableCheck"));
monitors->PortCombo = GTK_WIDGET(gtk_builder_get_object(builder, "PortCombo"));
monitors->MainCheck = GTK_WIDGET(gtk_builder_get_object(builder, "MainCheck"));
monitors->ResolutionCombo = GTK_WIDGET(gtk_builder_get_object(builder, "ResolutionCombo"));
monitors->UnsupportedCheck = GTK_WIDGET(gtk_builder_get_object(builder, "UnsupportedCheck"));
monitors->FrequencyCombo = GTK_WIDGET(gtk_builder_get_object(builder, "FrequencyCombo"));
monitors->RotationCombo = GTK_WIDGET(gtk_builder_get_object(builder, "RotationCombo"));
monitors->PositionPosCombo = GTK_WIDGET(gtk_builder_get_object(builder, "PositionPosCombo"));
monitors->PositionPortCombo = GTK_WIDGET(gtk_builder_get_object(builder, "PositionPortCombo"));
monitors->DoNotSwitchOffCheck = GTK_WIDGET(gtk_builder_get_object(builder, "DoNotSwitchOffCheck"));
monitors->ModelineCVTCheck = GTK_WIDGET(gtk_builder_get_object(builder, "ModelineCVTCheck"));
monitors->UseCVTReducedCheck = GTK_WIDGET(gtk_builder_get_object(builder, "UseCVTReducedCheck"));
monitors->ModelineGTFCheck = GTK_WIDGET(gtk_builder_get_object(builder, "ModelineGTFCheck"));
monitors->ParameterLineCheck = GTK_WIDGET(gtk_builder_get_object(builder, "ParameterLineCheck"));
monitors->ParameterLineEntry = GTK_WIDGET(gtk_builder_get_object(builder, "ParameterLineEntry"));
monitors->CancelButton = GTK_WIDGET(gtk_builder_get_object(builder, "CancelButton"));
monitors->SaveButton = GTK_WIDGET(gtk_builder_get_object(builder, "SaveButton"));
g_signal_connect(G_OBJECT(monitors->CancelButton), "clicked", G_CALLBACK(on_subwindow_close), NULL);
g_signal_connect(G_OBJECT(monitors->SaveButton), "clicked", G_CALLBACK(on_monitor_config_save), monitors);
g_signal_connect(G_OBJECT(monitors->ParameterLineCheck), "toggled", G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button_inversed), monitors->InterfaceConfigurationBox);
g_signal_connect(G_OBJECT(monitors->ParameterLineCheck), "toggled", G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button), monitors->ParameterLineEntry);
g_signal_connect(G_OBJECT(monitors->UnsupportedCheck), "toggled", G_CALLBACK(on_resolutions_unsupported_show),monitors);
g_signal_connect(G_OBJECT(monitors->PortCombo), "changed", G_CALLBACK(on_port_chosen_changed),monitors);
yon_gtk_window_setup(GTK_WINDOW(monitors->MainWindow),GTK_WINDOW(main_config.widgets->Window),TITLE_LABEL,"com.ublinux.ubl-settings-video","VieoConfigWindow");
char *target = (char*)gtk_label_get_text(GTK_LABEL(window->NameLabel));
monitors->curport=NULL;
dictionary *dict=NULL;
int config_size;
config_str config_ports = yon_config_get_all_by_key(XORG_PARAMETER,&config_size);
for (int i=0;i<config_size;i++){
yon_char_divide_search_self(config_ports[i],"=",-1);
free(yon_char_divide(config_ports[i],strlen(XORG_PARAMETER)));
config_ports[i][strlen(config_ports[i])-1]='\0';
}
for (int i=0;i<main_config.portssize;i++){
int found = yon_char_parsed_check_exist(config_ports,config_size,main_config.ports[i]);
if (found==-1||(!yon_char_is_empty(target)&&!strcmp(target,main_config.ports[i]))){
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->PortCombo),main_config.ports[i]);
}
}
if (gtk_combo_box_get_active(GTK_COMBO_BOX(monitors->PortCombo))){
for (int i=0;i<main_config.portssize;i++){
if (strcmp(main_config.ports[i],gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(monitors->PortCombo))))
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->PositionPortCombo),main_config.ports[i]);
}
}
if (!yon_char_is_empty(target)){
gtk_widget_set_sensitive(monitors->PortCombo,0);
g_signal_handlers_block_by_func(G_OBJECT(monitors->PortCombo),on_port_chosen_changed,monitors);
int found = yon_gtk_combo_box_text_find(monitors->PortCombo,target);
if (found>-1){
gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->PortCombo),found-1);
g_signal_handlers_unblock_by_func(G_OBJECT(monitors->PortCombo),on_port_chosen_changed,monitors);
gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->PortCombo),found);
char *config_string = yon_config_get_by_key(XORG_MONITOR(target));
if (!yon_char_is_empty(config_string)){
yon_monitor_parse(monitors,config_string);
}
}
}
// yon_monitor_data_update(monitors);
gtk_widget_show(monitors->MainWindow);
}
}
/**void yon_monitor_view_update()
* [EN]
*/
void yon_monitor_view_update(){
GList *list = gtk_container_get_children(GTK_CONTAINER(main_config.widgets->MonitorsBox));
for (int i=0;i<g_list_length(list);i++){
gtk_widget_destroy(GTK_WIDGET(g_list_nth_data(list,i)));
}
g_list_free(list);
yon_monitor_new(main_config.widgets,1);
int size;
config_str parameters = yon_config_get_all_by_key(XORG_PARAMETER,&size);
for (int i=0;i<size;i++){
char *current = yon_char_divide_search(parameters[i],"=",-1);
if (yon_config_get_status(current)>-1){
monitor_data *window = yon_monitor_new(main_config.widgets,0);
free(yon_char_divide(current,strlen(XORG_PARAMETER)));
current[strlen(current)-1]='\0';
gtk_label_set_text(GTK_LABEL(window->NameLabel),current);
int parsed_size;
config_str parsed = yon_char_parse(parameters[i],&parsed_size,",");
if (parsed_size>0){
if (strstr(parsed[0],"x")){
gtk_label_set_text(GTK_LABEL(window->ResoulutionLabel),parsed[0]);
}
}
if (yon_char_parsed_check_exist(parsed,parsed_size,"enable")>-1){
gtk_widget_set_sensitive(window->MonitorImage,1);
}
yon_char_parsed_free(parsed,parsed_size);
}
}
}
void yon_proprietary_local_get(){
int drivers_size=0;
int size;
config_str rtn=NULL;
rtn = yon_config_load(get_proprietary_drivers_info_command,&size);
config_str drivers=yon_config_load(get_proprietary_installed_command,&drivers_size);
for (int i=0;i<drivers_size;i++){
if (drivers[i][strlen(drivers[i])-1]=='\n') drivers[i][strlen(drivers[i])-1] = '\0';
}
for (int dr_desc=1;dr_desc<size;dr_desc++){
int current_size;
config_str current = yon_char_parse(rtn[dr_desc],&current_size,";");
if (strcmp(current[0],"")){
int target = yon_char_parsed_check_exist(drivers,drivers_size,current[0]);
if (target>-1){
yon_dictionary_add_or_create_if_exists_with_data(main_config.proprietary,drivers[target],rtn[dr_desc]);
}
} else if (strcmp(current[1],"")){
int target = yon_char_parsed_check_exist(drivers,drivers_size,current[1]);
if (target>-1){
yon_dictionary_add_or_create_if_exists_with_data(main_config.proprietary,drivers[target],rtn[dr_desc]);
}
}
}
if (main_config.proprietary){
yon_gtk_list_store_fill_with_proprietaries(main_config.list);
main_config.proprietary=NULL;
}
}
/**dictionary *yon_proprieary_get()
* [EN]
*/
dictionary *yon_proprieary_get(){
yon_ubl_status_box_render(PROPRIETARY_LOADING_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
main_config.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);
if (main_config.proprietary){
yon_gtk_list_store_fill_with_proprietaries(main_config.list);
main_config.proprietary=NULL;
}
drivers=yon_config_load(get_proprietary_drivers_command,&drivers_size);
for (int i=0;i<drivers_size;i++){
if (drivers[i][strlen(drivers[i])-1]=='\n') drivers[i][strlen(drivers[i])-1] = '\0';
}
for (int di=1;di<size;di++){
int current_size;
config_str current = yon_char_parse(rtn[di],&current_size,";");
if (current_size>2){
if (strcmp(current[0],"")){
int target = yon_char_parsed_check_exist(drivers,drivers_size,current[0]);
if (target>-1){
yon_dictionary_add_or_create_if_exists_with_data(main_config.proprietary,drivers[target],rtn[di]);
} else {
yon_dictionary_add_or_create_if_exists_with_data(main_config.proprietary,current[0],rtn[di]);
}
} else if (strcmp(current[1],"")){
int target = yon_char_parsed_check_exist(drivers,drivers_size,current[1]);
if (target>-1){
yon_dictionary_add_or_create_if_exists_with_data(main_config.proprietary,drivers[target],rtn[di]);
} else {
yon_dictionary_add_or_create_if_exists_with_data(main_config.proprietary,current[1],rtn[di]);
}
}
}
yon_char_parsed_free(current,current_size);
}
if (main_config.proprietary){
yon_gtk_list_store_fill_with_proprietaries(main_config.list);
yon_ubl_status_box_render(PROPRIETARY_OPETAION_DONE_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
} else {
drivers=yon_config_load(get_proprietary_drivers_local_command,&drivers_size);
if (drivers){
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) main_config.proprietary=yon_dictionary_new_with_data(drivers[drivers_found],rtn[i]);
else main_config.proprietary=yon_dictionary_append_with_data(main_config.proprietary,drivers[drivers_found],rtn[i]);
}
}
yon_gtk_list_store_fill_with_proprietaries(main_config.list);
yon_ubl_status_box_render(PROPRIETARY_USE_LOCAL_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
} else {
yon_ubl_status_box_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(main_config.proprietary){
dictionary *dict=NULL;
gtk_list_store_clear(main_config.list);
gtk_list_store_clear(main_config.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,main_config.proprietary){
yon_char_remove_last_symbol(((char*)dict->data),'\n');
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(main_config.list,&iter);
gtk_list_store_set(main_config.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||yon_char_parsed_check_exist(drivers_always_active,drivers_always_active_size,str[1])>-1)
gtk_list_store_set(main_config.list,&iter,0,1,-1);
}
else{
gtk_list_store_append(main_config.list2,&iter);
gtk_list_store_set(main_config.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||yon_char_parsed_check_exist(drivers_always_active,drivers_always_active_size,str[1])>-1){
gtk_list_store_set(main_config.list2,&iter,0,1,-1);
}
}
}
}
}
void yon_monitor_view_dictionary_destroy(void *window){
monitor_data *monitor=(monitor_data*)window;
gtk_widget_destroy(monitor->ScreenOverlay);
}
monitor_data *yon_monitor_new(main_window *widgets,int dull){
GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_monitor);
monitor_data *window = new(monitor_data);
window->ScreenOverlay=yon_gtk_builder_get_widget(builder,"ScreenOverlay");
window->MonitorImage=yon_gtk_builder_get_widget(builder,"MonitorImage");
window->MonitorInfoBox=yon_gtk_builder_get_widget(builder,"MonitorInfoBox");
window->NameLabel=yon_gtk_builder_get_widget(builder,"NameLabel");
window->ResoulutionLabel=yon_gtk_builder_get_widget(builder,"ResoulutionLabel");
window->DeleteButton=yon_gtk_builder_get_widget(builder,"DeleteButton");
window->SwitchButton=yon_gtk_builder_get_widget(builder,"SwitchButton");
window->ConfigureButton=yon_gtk_builder_get_widget(builder,"ConfigureButton");
window->AddButton=yon_gtk_builder_get_widget(builder,"AddButton");
gtk_overlay_add_overlay(GTK_OVERLAY(window->ScreenOverlay),window->MonitorInfoBox);
if (!dull){
gtk_widget_hide(window->AddButton);
g_signal_connect(G_OBJECT(window->ConfigureButton), "clicked", G_CALLBACK(on_monitor_configure), window);
g_signal_connect(G_OBJECT(window->DeleteButton), "clicked", G_CALLBACK(on_monitor_delete), window);
g_signal_connect(G_OBJECT(window->SwitchButton), "clicked", G_CALLBACK(on_monitor_switch), window);
} else {
gtk_widget_show(window->AddButton);
gtk_widget_hide(window->DeleteButton);
gtk_widget_hide(window->SwitchButton);
gtk_widget_hide(window->ConfigureButton);
g_signal_connect(G_OBJECT(window->AddButton), "clicked", G_CALLBACK(on_monitor_add), widgets);
}
GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->MonitorsBox));
gtk_flow_box_insert(GTK_FLOW_BOX(widgets->MonitorsBox),window->ScreenOverlay,g_list_length(list)-1);
g_list_free(list);
return 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(main_config.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_get(&main_config.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(main_window *widgets){
int size=0;
gtk_overlay_add_overlay(GTK_OVERLAY(widgets->InformationOverlay),widgets->InformationCompanyLogoImage);
config_str rtn = yon_config_load(get_adapter_info_json,&size);
struct json_object *jsobject = json_tokener_parse(yon_char_parsed_to_string(rtn,size,""));{
struct json_object *item_obj = json_object_array_get_idx(jsobject, 0);
struct json_object *unit_obj;
const char *desc="";
if (json_object_object_get_ex(item_obj, "description", &unit_obj)) {
desc = json_object_get_string(unit_obj);
}
const char *product ="";
if (json_object_object_get_ex(item_obj, "product", &unit_obj)) {
product = json_object_get_string(unit_obj);
}
const char *vendor="";
if (json_object_object_get_ex(item_obj, "vendor", &unit_obj)) {
vendor = json_object_get_string(unit_obj);
}
const char *driver_use="";
if (json_object_object_get_ex(item_obj, "configuration", &unit_obj)) {
if (json_object_object_get_ex(unit_obj, "driver", &unit_obj))
driver_use = json_object_get_string(unit_obj);
}
const char *driver_all="";
int loaded_size;
config_str loaded = yon_config_load(get_drivers_for_card_command,&loaded_size);
for (int i=0;i<loaded_size;i++){
free(yon_char_divide_search(loaded[i],"=",-1));
yon_char_remove_last_symbol(loaded[i],'\n');
}
int pos = yon_char_parsed_check_exist(loaded,loaded_size,(char*)driver_use);
if (pos>-1){
driver_all=yon_char_new(loaded[pos+1]);
}
yon_char_parsed_free(loaded,loaded_size);
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(widgets->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")||strstr(vendor,"Advanced Micro Devices")){
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 if (strstr(vendor,"VMware")){
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.vmware-logo",64,1,GTK_ICON_LOOKUP_FORCE_SVG),NULL));
}
else {
gtk_widget_destroy(widgets->InformationCompanyLogoImage);
}
}
gtk_overlay_add_overlay(GTK_OVERLAY(widgets->InformationOverlay2),widgets->InformationCompanyLogoImage2);
struct json_object *item_obj = json_object_array_get_idx(jsobject, 1);
if (item_obj){
struct json_object *unit_obj;
const char *desc="";
if (json_object_object_get_ex(item_obj, "description", &unit_obj)) {
desc = json_object_get_string(unit_obj);
}
const char *product ="";
if (json_object_object_get_ex(item_obj, "product", &unit_obj)) {
product = json_object_get_string(unit_obj);
}
const char *vendor="";
if (json_object_object_get_ex(item_obj, "vendor", &unit_obj)) {
vendor = json_object_get_string(unit_obj);
}
const char *driver_use="";
if (json_object_object_get_ex(item_obj, "configuration", &unit_obj)) {
if (json_object_object_get_ex(unit_obj, "driver", &unit_obj))
driver_use = json_object_get_string(unit_obj);
}
const char *driver_all="";
int loaded_size;
config_str loaded = yon_config_load(get_drivers_for_card_command,&loaded_size);
for (int i=0;i<loaded_size;i++){
free(yon_char_divide_search(loaded[i],"=",-1));
yon_char_remove_last_symbol(loaded[i],'\n');
}
int pos = yon_char_parsed_check_exist(loaded,loaded_size,(char*)driver_use);
if (pos>-1){
driver_all=yon_char_new(loaded[pos+1]);
}
yon_char_parsed_free(loaded,loaded_size);
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(widgets->InformationLabel2),final_text);
if (strstr(vendor,"Intel")){
GtkIconTheme *icthm=gtk_icon_theme_get_default();
gtk_image_set_from_pixbuf(GTK_IMAGE(widgets->InformationCompanyLogoImage2),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->InformationCompanyLogoImage2),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"),strstr(vendor,"Advanced Micro Devices")){
GtkIconTheme *icthm=gtk_icon_theme_get_default();
gtk_image_set_from_pixbuf(GTK_IMAGE(widgets->InformationCompanyLogoImage2),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 if (strstr(vendor,"VMware")){
GtkIconTheme *icthm=gtk_icon_theme_get_default();
gtk_image_set_from_pixbuf(GTK_IMAGE(widgets->InformationCompanyLogoImage2),gtk_icon_info_load_icon(gtk_icon_theme_lookup_icon_for_scale(icthm, "com.ublinux.ubl-settings-video.vmware-logo",64,1,GTK_ICON_LOOKUP_FORCE_SVG),NULL));
}
else {
gtk_widget_destroy(widgets->InformationCompanyLogoImage2);
}
} else {
gtk_widget_hide(widgets->InformationOverlay2);
// gtk_widget_hide(GTK_WIDGET(gtk_builder_get_object(widgets->builder,"InformationLabel2")));
}
}
void yon_set_sensitive_from_combo_box(GtkComboBox *toggle, GtkWidget *target){
int active = gtk_combo_box_get_active(toggle);
gtk_widget_set_sensitive(target,active>1 ? 1 : 0);
}
/** void yon_setup_widgets(main_window *widgets)
* [EN]
* Sets up every element on main window
* [RU]
*
* */
void yon_main_window_complete(main_window *widgets){
widgets = yon_remalloc(widgets,sizeof(main_window));
main_config.widgets=widgets;
GtkBuilder *builder = gtk_builder_new_from_resource(glade_path);
gtk_box_pack_start(GTK_BOX(widgets->InterfaceBox),yon_gtk_builder_get_widget(builder,"BoxMain"),1,1,0);
// Custom widgets configuration
{
widgets->AutoDriverCombo = yon_gtk_builder_get_widget(builder,"AutoDriverCombo");
widgets->FreeDriverCombo = yon_gtk_builder_get_widget(builder,"FreeDriverCombo");
widgets->FailsafeNvidiaCombo = yon_gtk_builder_get_widget(builder,"FailsafeNvidiaCombo");
widgets->FailsafeAMDCombo = yon_gtk_builder_get_widget(builder,"FailsafeAMDCombo");
widgets->MonitorsBox = yon_gtk_builder_get_widget(builder,"MonitorsBox");
widgets->DontSwitchDisplaysOffCombo = yon_gtk_builder_get_widget(builder,"DontSwitchDisplaysOffCombo");
widgets->DisplayScalingCombo = yon_gtk_builder_get_widget(builder,"DisplayScalingCombo");
widgets->DisplayDiscreteOnly = yon_gtk_builder_get_widget(builder,"DisplayDiscreteOnly");
widgets->OptirunCombo = yon_gtk_builder_get_widget(builder,"OptirunCombo");
widgets->OptirunEntry = yon_gtk_builder_get_widget(builder,"OptirunEntry");
widgets->OptirunButton = yon_gtk_builder_get_widget(builder,"OptirunButton");
widgets->PrimusrunCombo = yon_gtk_builder_get_widget(builder,"PrimusrunCombo");
widgets->PrimusrunEntry = yon_gtk_builder_get_widget(builder,"PrimusrunEntry");
widgets->PrimusrunButton = yon_gtk_builder_get_widget(builder,"PrimusrunButton");
widgets->FrameGapCombo = yon_gtk_builder_get_widget(builder,"FrameGapCombo");
widgets->proprietaryTreeView = yon_gtk_builder_get_widget(builder, "proprietaryTreeView");
widgets->proprietaryInfoButton = yon_gtk_builder_get_widget(builder, "proprietaryInfoButton");
widgets->proprietaryDeleteButton = yon_gtk_builder_get_widget(builder, "proprietaryDeleteButton");
widgets->proprietaryInstallButton = yon_gtk_builder_get_widget(builder, "proprietaryInstallButton");
widgets->proprietaryTreeSelection = GTK_TREE_SELECTION(gtk_builder_get_object(builder, "proprietaryTreeSelection"));
widgets->driversTreeView = yon_gtk_builder_get_widget(builder, "driversTreeView");
widgets->driversInfoButton = yon_gtk_builder_get_widget(builder, "driversInfoButton");
widgets->driversDeleteButton = yon_gtk_builder_get_widget(builder, "driversDeleteButton");
widgets->driversInstallButton = yon_gtk_builder_get_widget(builder, "driversInstallButton");
widgets->TerminalOverlay = yon_gtk_builder_get_widget(builder, "TerminalOverlay");
widgets->MenusTab = yon_gtk_builder_get_widget(builder, "MenusTab");
widgets->driversTreeSelection = GTK_TREE_SELECTION(gtk_builder_get_object(builder, "driversTreeSelection"));
widgets->LoadDriversButton = yon_gtk_builder_get_widget(builder,"LoadDriversButton");
widgets->proprietaryNotebook = yon_gtk_builder_get_widget(builder,"notebook1");
widgets->proprietartInstalledColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "proprietartInstalledColumn"));
widgets->ProprietaryPackageColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "ProprietaryPackageColumn"));
widgets->ProprietaryDriverColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "ProprietaryDriverColumn"));
widgets->ProprietaryDescriptionColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "ProprietaryDescriptionColumn"));
widgets->ProprietarySupportedColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "ProprietarySupportedColumn"));
widgets->DriverModulesTab = GTK_WIDGET(gtk_builder_get_object(builder, "DriverModulesTab"));
widgets->DriversTab = GTK_WIDGET(gtk_builder_get_object(builder, "DriversTab"));
widgets->MainTabLabel = GTK_WIDGET(gtk_builder_get_object(builder, "MainTabLabel"));
widgets->DriversTabLabel = GTK_WIDGET(gtk_builder_get_object(builder, "DriversTabLabel"));
widgets->InformationTabLabel = GTK_WIDGET(gtk_builder_get_object(builder, "InformationTabLabel"));
widgets->InformationFrameLabel = GTK_WIDGET(gtk_builder_get_object(builder, "InformationFrameLabel"));
widgets->InformationOverlay = GTK_WIDGET(gtk_builder_get_object(builder, "InformationOverlay"));
widgets->InformationCompanyLogoImage = GTK_WIDGET(gtk_builder_get_object(builder, "InformationCompanyLogoImage"));
widgets->InformationOverlay2 = GTK_WIDGET(gtk_builder_get_object(builder, "InformationOverlay2"));
widgets->InformationCompanyLogoImage2 = GTK_WIDGET(gtk_builder_get_object(builder, "InformationCompanyLogoImage2"));
widgets->InformationLabel = GTK_WIDGET(gtk_builder_get_object(builder, "InformationLabel"));
widgets->InformationLabel2 = GTK_WIDGET(gtk_builder_get_object(builder, "InformationLabel2"));
widgets->driverInstalledColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "driverInstalledColumn"));
widgets->driverPackageColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "driverPackageColumn"));
widgets->driverDriverColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "driverDriverColumn"));
widgets->driverDescriptionColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "driverDescriptionColumn"));
widgets->driverSupportedColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "driverSupportedColumn"));
main_config.list = GTK_LIST_STORE(gtk_builder_get_object(builder, "liststore6"));
main_config.list2 = GTK_LIST_STORE(gtk_builder_get_object(builder, "liststore1"));
g_signal_connect(G_OBJECT(widgets->LoadDriversButton), "clicked", 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->LoadLocalMenuItem),"activate",G_CALLBACK(on_config_local_load),widgets);
g_signal_connect(G_OBJECT(widgets->LoadGlobalMenuItem),"activate",G_CALLBACK(on_config_global_load),widgets);
g_signal_connect(G_OBJECT(widgets->LoadCustomMenuItem),"activate",G_CALLBACK(on_config_custom_load),widgets);
g_signal_connect(G_OBJECT(widgets->SaveMenuItem),"activate",G_CALLBACK(on_config_global_local_save),NULL);
g_signal_connect(G_OBJECT(widgets->SaveLocalMenuItem),"activate",G_CALLBACK(on_config_local_save),NULL);
g_signal_connect(G_OBJECT(widgets->SaveGlobalMenuItem),"activate",G_CALLBACK(on_config_global_save),NULL);
g_signal_connect(G_OBJECT(widgets->SaveCustomMenuItem),"activate",G_CALLBACK(on_config_custom_save),NULL);
g_signal_connect(G_OBJECT(widgets->OptirunCombo),"changed",G_CALLBACK(yon_set_sensitive_from_combo_box),widgets->OptirunEntry);
g_signal_connect(G_OBJECT(widgets->PrimusrunCombo),"changed",G_CALLBACK(yon_set_sensitive_from_combo_box),widgets->PrimusrunEntry);
// yon_monitor_view_setup(widgets->mainMonitorVisualConfigurationBox);
yon_adapter_window_setup(widgets);
gtk_notebook_set_action_widget(GTK_NOTEBOOK(widgets->proprietaryNotebook),widgets->LoadDriversButton,GTK_PACK_END);
}
yon_save_window_set_postsave_function(on_save_done,widgets);
on_config_local_load(NULL,widgets);
}
/**config_init()
* [EN]
*
* [RU]
* Функция инициализации всех параметров конфигурации
*/
void config_init(){
main_config.always_open_documentation=0;
main_config.socket_id=-1;
main_config.save_socket_id=-1;
main_config.load_socket_id=-1;
main_config.lock_help=0;
main_config.lock_help=0;
main_config.lock_load_global=0;
main_config.lock_save_global=0;
main_config.lock_save_local=0;
main_config.load_mode=1;
}
int main(int argc, char *argv[]){
local=setlocale(LC_ALL, "");
textdomain (LocaleName);
config_init();
yon_ubl_connect_config((_template_config*)&main_config);
yon_ubl_window_init(TITLE_LABEL,TITLE_INFO_LABEL,LocaleName,CssPath,LocaleName,version_application,WIKI_LINK);
config_str unfound = NULL;
int size=0;
yon_ubl_setup_arguments(argc,argv,&unfound,&size,NULL);
gtk_init(&argc, &argv);
template_main_window *widgets = yon_ubl_window_setup();
yon_main_window_complete((main_window*)widgets);
char *path = yon_char_unite(yon_ubl_user_get_home_directory(),"/.config/",LocaleName,"/",LocaleName,".conf",NULL);
yon_window_config_load(path);
if (getuid()!=0){
textdomain(template_ui_LocaleName);
yon_ubl_status_box_render(ROOT_WARNING_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
textdomain(LocaleName);
}
yon_proprietary_local_get();
// on_config_fill_interface(&widgets);
yon_monitor_set_resolutions();
gtk_main();
return 0;
}
Reference in new issue View Git Blame Copy Permalink