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 '02bf4dde2e'
${ noResults }
ubl-settings-video/source/ubl-settings-video.c

1626 lines
81 KiB
Raw Blame History

#include "ubl-settings-video.h"
config main_config;
void on_terminal_done(GtkWidget *, int , main_window *widgets){
vte_terminal_feed_child(VTE_TERMINAL(widgets->InstallTerminal),"^C",2);
}
void on_terminal_more(GtkWidget *, 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);
}
gboolean on_command_execute_success(GtkWidget *self,gint status,main_window *widgets){
yon_install_buttons_set_sensitive(widgets,1);
vte_terminal_set_input_enabled(VTE_TERMINAL(self),0);
g_mutex_lock(&main_config.progress_mutex);
main_config.progress_active=0;
g_mutex_unlock(&main_config.progress_mutex);
if (!status){
yon_ubl_status_box_render(yon_char_unite(yon_char_get_localised_from_lib(SUCCESS_LABEL),". ",PROPRIETARY_LOADING_LABEL,NULL),BACKGROUND_IMAGE_SUCCESS_TYPE);
} else {
yon_ubl_status_box_render(yon_char_get_localised_from_lib(FAIL_LABEL),BACKGROUND_IMAGE_FAIL_TYPE);
}
while(gtk_events_pending()) gtk_main_iteration();
on_terminal_done(self,0,widgets);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(widgets->TerminalInfoLabel),0);
return G_SOURCE_REMOVE;
}
gboolean on_terminal_check_progress(main_window *widgets){
g_mutex_lock(&main_config.progress_mutex);
if (!main_config.progress_active){
g_mutex_unlock(&main_config.progress_mutex);
return G_SOURCE_REMOVE;
}
gtk_progress_bar_pulse(GTK_PROGRESS_BAR(widgets->TerminalInfoLabel));
g_mutex_unlock(&main_config.progress_mutex);
return G_SOURCE_CONTINUE;
}
void on_command_cancel(GtkWidget *,main_window *widgets){
g_mutex_lock(&main_config.progress_mutex);
main_config.progress_active=0;
g_mutex_unlock(&main_config.progress_mutex);
on_terminal_done(NULL,0,widgets);
}
void on_driver_pack_selection_change(GtkWidget *, GtkListBoxRow *selection, main_window *widgets){
if (selection){
driver_struct *driver = g_object_get_data(G_OBJECT(selection),"driver_struct");
if (driver->supported_devices_avaliable){
gtk_widget_set_sensitive(widgets->SupportedDevicesButton,1);
} else {
gtk_widget_set_sensitive(widgets->SupportedDevicesButton,0);
}
gtk_widget_set_sensitive(widgets->AboutModuleButton,1);
gtk_widget_set_sensitive(widgets->AboutPackageButton,1);
} else {
gtk_widget_set_sensitive(widgets->SupportedDevicesButton,0);
gtk_widget_set_sensitive(widgets->AboutModuleButton,0);
gtk_widget_set_sensitive(widgets->AboutPackageButton,0);
}
}
gpointer yon_driver_info_launch(void *command){
if (!system((char*)command)){
yon_ubl_status_box_render_thread(yon_char_get_localised_from_lib(SUCCESS_LABEL),BACKGROUND_IMAGE_SUCCESS_TYPE);
} else {
yon_ubl_status_box_render_thread(yon_char_get_localised_from_lib(FAIL_LABEL),BACKGROUND_IMAGE_SUCCESS_TYPE);
}
return NULL;
}
void on_driver_pack_info(GtkWidget *, main_window *widgets){
GtkWidget *selection = GTK_WIDGET(gtk_list_box_get_selected_row(GTK_LIST_BOX(widgets->DriversList)));
if (selection){
driver_struct *driver = g_object_get_data(G_OBJECT(selection),"driver_struct");
yon_ubl_status_box_render(yon_char_get_localised_from_lib(INFO_PROCESS_LABEL),BACKGROUND_IMAGE_INFO_TYPE);
char *command = get_info_proprietary_command(driver->package);
g_thread_new("info_thread",yon_driver_info_launch,(void*)command);
} else {
yon_ubl_status_box_render(PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
void on_driver_module_info(GtkWidget *, main_window *widgets){
GtkWidget *selection = GTK_WIDGET(gtk_list_box_get_selected_row(GTK_LIST_BOX(widgets->DriversList)));
if (selection){
driver_struct *driver = g_object_get_data(G_OBJECT(selection),"driver_struct");
yon_ubl_status_box_render(yon_char_get_localised_from_lib(INFO_PROCESS_LABEL),BACKGROUND_IMAGE_INFO_TYPE);
char *command = get_info_proprietary_command(driver->module);
g_thread_new("info_thread",yon_driver_info_launch,(void*)command);
} else {
yon_ubl_status_box_render(PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
gboolean yon_filter_func(GtkTreeModel* model,GtkTreeIter* iter,main_window *widgets){
const char *target = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->KernelsCombo));
char *cur;
gtk_tree_model_get(model,iter,2,&cur,-1);
if (!yon_char_is_empty(cur)&&!yon_char_is_empty(target)&&!strcmp(cur,target))return 1;
return 0;
}
void on_kernel_filter_changed(GtkWidget *self, main_window *widgets){
const char *active = gtk_combo_box_get_active_id(GTK_COMBO_BOX(self));
if (!yon_char_is_empty(active)){
GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->DriversList));
for (GList *iter = list; iter; iter=iter->next){
driver_struct *driver = g_object_get_data(G_OBJECT(iter->data),"driver_struct");
if (!strcmp(driver->kernel,active)){
gtk_widget_show(GTK_WIDGET(iter->data));
} else {
gtk_widget_hide(GTK_WIDGET(iter->data));
}
}
g_list_free(list);
} else {
GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->DriversList));
for (GList *iter = list; iter; iter=iter->next){
gtk_widget_show(GTK_WIDGET(iter->data));
}
g_list_free(list);
}
}
void on_port_chosen_changed(GtkWidget *, 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));
dict=yon_dictionary_get(&main_config.supported_resolutions,port_name);
if (dict){
int size;
config_str resolutions = yon_resource_open_file(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 = -1;
for (int i=0;i<res->size;i++){
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 *){
int state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self));
main_config.autoChooseDrivers=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_resource_open_file(get_resolutions_supportable_command,&size);
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);
}
}
void on_save_done(main_window *, config_str output, int size){
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 YON_CONFIG_GLOBAL:
yon_ubl_status_box_render(GLOBAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
break;
case YON_CONFIG_LOCAL:
yon_ubl_status_box_render(LOCAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
break;
case YON_CONFIG_BOTH:
yon_ubl_status_box_render(GLOBAL_LOCAL_SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
break;
case YON_CONFIG_CUSTOM:
yon_ubl_status_box_render(SAVE_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
break;
}
textdomain(LocaleName);
}
void yon_interface_save(){
char *dpi = 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->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 = config(GAPFIX1_parameter);
char *gapfix2 = config(GAPFIX2_parameter);
g_signal_handlers_block_by_func(G_OBJECT(main_config.widgets->FrameGapCombo),G_CALLBACK(on_gapfix_changed),main_config.widgets);
if (!yon_char_is_empty(gapfix1)){
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FrameGapCombo),2);
} else if (!yon_char_is_empty(gapfix2)){
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FrameGapCombo),3);
} else {
gtk_combo_box_set_active(GTK_COMBO_BOX(main_config.widgets->FrameGapCombo),0);
}
g_signal_handlers_unblock_by_func(G_OBJECT(main_config.widgets->FrameGapCombo),G_CALLBACK(on_gapfix_changed),main_config.widgets);
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);
yon_monitor_view_update();
}
void yon_load_proceed(YON_CONFIG_TYPE type){
if (type!=YON_CONFIG_CUSTOM){
yon_config_clean();
}
if (!yon_char_is_empty(config_get_default_command))
yon_config_load_config(YON_CONFIG_DEFAULT,config_get_default_command,NULL);
switch (type){
case YON_CONFIG_GLOBAL:
yon_config_load_config(type,config_get_command("global"),NULL);
yon_ubl_status_box_render(yon_char_get_localised_from_lib(GLOBAL_LOAD_SUCCESS_LABEL),BACKGROUND_IMAGE_SUCCESS_TYPE);
break;
case YON_CONFIG_LOCAL:
yon_config_load_config(type,config_get_command("system"),NULL);
yon_ubl_status_box_render(yon_char_get_localised_from_lib(LOCAL_LOAD_SUCCESS_LABEL),BACKGROUND_IMAGE_SUCCESS_TYPE);
break;
case YON_CONFIG_CUSTOM:
char *path = NULL;
path=yon_custom_config_init(GTK_FILE_CHOOSER_ACTION_OPEN);
if (!yon_char_is_empty(path)){
yon_config_clean();
yon_config_load_config(type,config_get_command(path),NULL);
yon_ubl_status_box_render(yon_char_get_localised_from_lib(LOCAL_LOAD_SUCCESS_LABEL),BACKGROUND_IMAGE_SUCCESS_TYPE);
}
break;
default:
break;
}
}
void on_config_local_load(GtkWidget *self,main_window *){
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 *){
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 *){
if (self){}
yon_load_proceed(YON_CONFIG_CUSTOM);
main_config.load_mode=3;
yon_interface_update();
}
void on_config_global_local_save(){
yon_interface_save();
main_config.save_config=YON_CONFIG_BOTH;
yon_save_proceed(NULL,YON_CONFIG_BOTH,config_get_command("global"),NULL);
}
void on_config_local_save(){
yon_interface_save();
main_config.save_config=YON_CONFIG_LOCAL;
yon_save_proceed("system",YON_CONFIG_LOCAL,config_get_command("system"),NULL);
}
void on_config_global_save(){
yon_interface_save();
main_config.save_config=YON_CONFIG_GLOBAL;
yon_save_proceed("global",YON_CONFIG_GLOBAL,config_get_command("global"),NULL);
}
void on_config_custom_save(GtkWidget *self, main_window *widgets){
yon_interface_save();
if (self&&widgets){}
main_config.save_config=YON_CONFIG_CUSTOM;
template_saving_window *window = yon_save_proceed(NULL,YON_CONFIG_CUSTOM,config_get_command("system"),NULL);
if (window){};
}
// functions
/**void on_monitor_delete(GtkWidget *self,monitor_data windowd)
* [EN]
*/
void on_monitor_delete(GtkWidget *,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);
const char *target_monitor = gtk_label_get_text(GTK_LABEL(window->NameLabel));
if (!yon_char_is_empty(target_monitor)){
yon_config_remove_by_key(XORG_MONITOR((char*)target_monitor));
}
free(window);
}
}
/**void on_monitor_switch(GtkWidget *self,monitor_data *window)
* [EN]
*/
void on_monitor_switch(GtkWidget *,monitor_data *window){
if(window){
const char *name = gtk_label_get_text(GTK_LABEL(window->NameLabel));
char *parameter = config(XORG_MONITOR(name));
int size;
config_str parsed = yon_char_parse(parameter,&size,",");
int found = yon_char_parsed_check_exist(parsed,size,"enable");
if (found != -1){
free(parsed[found]);
parsed[found]=yon_char_new("disable");
gtk_widget_set_sensitive(window->MonitorImage,0);
} else {
found = yon_char_parsed_check_exist(parsed,size,"disable");
if (found !=-1){
free(parsed[found]);
parsed[found]=yon_char_new("enable");
} else {
parsed = yon_char_parsed_append(parsed,&size,"enable");
}
gtk_widget_set_sensitive(window->MonitorImage,1);
}
char *final = yon_char_parsed_to_string(parsed,size,",");
yon_config_register(XORG_MONITOR(name),XORG_MONITOR_get_command,final);
yon_char_parsed_free(parsed,size);
}
}
/**void on_monitor_add(GtkWidget *self,monitor_data *window)
* [EN]
*/
void on_monitor_add(GtkWidget *,main_window *widgets){
if(widgets){
yon_monitor_new(widgets,0);
}
}
void on_monitor_config_save(GtkWidget *, monitor_edit_window *window){
int enabled=0;
char *target=NULL;
int main_display=0;
char *resolution = NULL;
const char *frequency = NULL;
char *rotate = NULL;
char *position = NULL;
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))){
char *res_str = yon_char_new(gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->ResolutionCombo)));
frequency = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->FrequencyCombo));
resolution = yon_char_unite(yon_char_divide_search(res_str," ",-1),"x",frequency,NULL);
}
int rot = gtk_combo_box_get_active(GTK_COMBO_BOX(window->RotationCombo));
rotate = yon_char_append("rotate:",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)));
}
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){
for (int i=0; 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],"cvt")){
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:")){
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:")){
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:")){
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],"be:")||strstr(parsed[i],"Below:")){
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:")){
free(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);
}
} else if (g_ascii_isdigit(parsed[i][0])&&strstr(parsed[i],"x")){
if (yon_char_count(parsed[i],"x")>1){
int pos = yon_char_find_last(parsed[i],'x');
char *res = yon_char_divide(parsed[i],pos);
int resolution = yon_gtk_combo_box_text_find(window->FrequencyCombo,parsed[i]);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->FrequencyCombo),resolution==0?-1:resolution);
free(parsed[i]);
parsed[i]=res;
}
int resolution = yon_gtk_combo_box_text_find(window->ResolutionCombo,parsed[i]);
if (resolution == -1){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->UnsupportedCheck),1);
while(gtk_events_pending()) gtk_main_iteration();
}
resolution = yon_gtk_combo_box_text_find(window->ResolutionCombo,parsed[i]);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->ResolutionCombo),resolution==0?-1:resolution);
}
}
}
}
void on_monitor_configure(GtkWidget *,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"));
char *title;
char *cur_port = (char*)gtk_label_get_text(GTK_LABEL(window->NameLabel));
if (!yon_char_is_empty(cur_port)){
title = MONITOR_TITLE_LABEL(cur_port);
} else {
title=TITLE_LABEL;
}
gtk_label_set_text(GTK_LABEL(monitors->HeadLabel),title);
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,"com.ublinux.ubl-settings-video","VieoConfigWindow");
char *target = (char*)gtk_label_get_text(GTK_LABEL(window->NameLabel));
monitors->curport=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]))||yon_config_get_status(XORG_MONITOR(main_config.ports[i]))==-1){
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);
}
}
}
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 (guint 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);
}
}
}
gboolean yon_proprietary_clear(main_window *widgets){
GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->DriversList));
GList *iter = NULL;
for (iter = list; iter; iter=iter->next){
driver_struct *driver = g_object_get_data(G_OBJECT(iter->data),"driver_struct");
free(driver->name);
free(driver->module);
free(driver->package);
free(driver->kernel);
free(driver->description);
free(driver->devices);
gtk_widget_destroy(GTK_WIDGET(iter->data));
}
// gtk_widget_set_sensitive(widgets->LoadDriversButton,0);
// gtk_list_store_clear(main_config.list);
// gtk_list_store_clear(main_config.list2);
// gtk_spinner_start(GTK_SPINNER(widgets->DriversLoadingSpinner));
// gtk_widget_show(widgets->DriversLoadingSpinner);
// gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->KernelsCombo));
// gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->KernelsCombo),ALL_INSTALLED_KERNELS_LABEL);
// gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->KernelsCombo),0);
return G_SOURCE_REMOVE;
}
void yon_drivers_resize(main_window *widgets){
GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->DriversList));
GList *iter;
int module_width=0;
int package_width=0;
int kernel_width=0;
int driver_width=0;
int description_width=0;
gtk_widget_get_preferred_width(widgets->InstalledModuleLabel,&module_width,NULL);
gtk_widget_get_preferred_width(widgets->InstalledPackageLabel,&package_width,NULL);
gtk_widget_get_preferred_width(widgets->KernelLabel,&kernel_width,NULL);
gtk_widget_get_preferred_width(widgets->DriverLabel,&driver_width,NULL);
gtk_widget_get_preferred_width(widgets->DescriptionLabel,NULL,&description_width);
for (iter = list;iter;iter=iter->next){
driver_struct *data = g_object_get_data(G_OBJECT(iter->data),"driver_struct");
gtk_widget_realize(data->ModuleInstalledCheck);
gtk_widget_realize(data->PackageInstalledCheck);
gtk_widget_realize(data->KernelLabel);
gtk_widget_realize(data->DriverLabel);
gtk_widget_realize(data->DescriptionLabel);
gtk_widget_realize(data->DevicesBox);
int temp_width = 0;
gtk_widget_get_preferred_width(data->ModuleInstalledCheck,&temp_width,NULL);
if (temp_width > module_width) module_width=temp_width;
gtk_widget_get_preferred_width(data->PackageInstalledCheck,&temp_width,NULL);
if (temp_width > package_width) package_width=temp_width;
gtk_widget_get_preferred_width(data->KernelLabel,&temp_width,NULL);
if (temp_width > kernel_width) kernel_width=temp_width;
gtk_widget_get_preferred_width(data->DriverLabel,&temp_width,NULL);
if (temp_width > driver_width) driver_width=temp_width;
gtk_widget_get_preferred_width(data->DescriptionLabel,NULL,&temp_width);
if (temp_width > description_width) description_width=temp_width;
}
if (module_width||package_width||kernel_width||driver_width||description_width){
for (iter = list;iter;iter=iter->next){
driver_struct *data = g_object_get_data(G_OBJECT(iter->data),"driver_struct");
if (module_width)
gtk_widget_set_size_request(gtk_widget_get_parent(data->ModuleInstalledCheck),module_width,-1);
if (package_width)
gtk_widget_set_size_request(gtk_widget_get_parent(data->PackageInstalledCheck),package_width,-1);
if (kernel_width)
gtk_widget_set_size_request(gtk_widget_get_parent(data->KernelLabel),kernel_width,-1);
if (driver_width)
gtk_widget_set_size_request(gtk_widget_get_parent(data->DriverLabel),driver_width,-1);
if (description_width)
gtk_widget_set_size_request(gtk_widget_get_parent(data->DescriptionLabel),description_width,-1);
}
g_list_free(list);
if (module_width) gtk_widget_set_size_request(widgets->InstalledModuleLabel,module_width,-1);
if (package_width) gtk_widget_set_size_request(widgets->InstalledPackageLabel,package_width,-1);
if (kernel_width) gtk_widget_set_size_request(widgets->KernelLabel,kernel_width,-1);
if (driver_width) gtk_widget_set_size_request(widgets->DriverLabel,driver_width,-1);
if (description_width) gtk_widget_set_size_request(widgets->DescriptionLabel,description_width,-1);
}
}
gboolean yon_proprietary_set(main_window *widgets){
gtk_widget_set_sensitive(widgets->LoadDriversButton,1);
return G_SOURCE_REMOVE;
}
gboolean yon_proprietary_append(driver_struct *){
// GtkTreeIter iter;
// gtk_list_store_append(main_config.list,&iter);
// gtk_list_store_set(main_config.list,&iter,0,target->module_status,1,target->package_status,2,target->drivers[0],3,target->drivers[3],4,_(target->drivers[4]),5,_(target->drivers[5]),7,target->drivers[1],8,target->drivers[2],9,!yon_char_is_empty(target->drivers[1])&&target->module_exist,10,!yon_char_is_empty(target->drivers[2])&&target->package_exist,-1);
// free(target);
return G_SOURCE_REMOVE;
}
gboolean yon_proprietary_append_kernels(struct proprietary_kernel_append_struct *append){
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(append->widgets->KernelsCombo),append->kernel,append->kernel);
free(append->kernel);
free(append);
return G_SOURCE_REMOVE;
}
gboolean yon_proprietary_connect(main_window *widgets){
gtk_spinner_stop(GTK_SPINNER(widgets->DriversLoadingSpinner));
gtk_widget_hide(widgets->DriversLoadingSpinner);
return G_SOURCE_REMOVE;
}
void yon_proprietary_local_get(main_window *widgets){
g_idle_add((GSourceFunc)yon_proprietary_clear,widgets);
int kernels_size;
config_str kernels_installed=yon_config_load(yon_get_kernels_installed,&kernels_size);
if (!kernels_size){
yon_ubl_status_box_render_thread(KERNELS_SUPPORTED_UNFOUND_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
for (int i=0;i<kernels_size;i++){
yon_char_remove_last_symbol(kernels_installed[i],'\n');
struct proprietary_kernel_append_struct *cur = malloc(sizeof(struct proprietary_kernel_append_struct));
cur->widgets=widgets;
cur->kernel=yon_char_new(kernels_installed[i]);
g_idle_add((GSourceFunc)yon_proprietary_append_kernels,cur);
}
int size;
config_str rtn=NULL;
rtn = yon_resource_open_file(get_proprietary_drivers_info_path,&size);
for (int i=1;i<size;i++){
yon_char_remove_last_symbol(rtn[i],'\n');
}
for (int dr_desc=1;dr_desc<size;dr_desc++){
while(gtk_events_pending()) gtk_main_iteration();
int current_size;
config_str current = yon_char_parse(rtn[dr_desc],&current_size,";");
if ((!strcmp(current[0],"")||
yon_char_parsed_check_exist(kernels_installed,kernels_size,current[0])>-1)){
if ((!yon_char_is_empty(current[1])&&
yon_packages_check_exist(current[1]))||
(!yon_char_is_empty(current[2])&&
yon_packages_check_exist(current[2]))){
driver_struct *target = yon_driver_struct_new();
target->name = yon_char_new(current[3]);
target->module = current[1];
target->package = current[2];
target->kernel = current[0];
target->devices = current_size>5?current[5]:NULL;
target->description = current[4];
target->module_installed = yon_packages_check_installed(current[1]);
target->package_installed = yon_packages_check_installed(current[2]);
target->module_exist = yon_packages_check_exist(current[1]);
target->package_exist = yon_packages_check_exist(current[2]);
GtkWidget *list_row = gtk_list_box_row_new();
gtk_widget_show(list_row);
g_signal_connect(G_OBJECT(target->ModuleInstalledCheck),"clicked", G_CALLBACK(on_install_activate),widgets);
g_signal_connect(G_OBJECT(target->PackageInstalledCheck),"clicked", G_CALLBACK(on_install_activate),widgets);
gtk_container_add(GTK_CONTAINER(list_row),target->MainBox);
g_object_set_data(G_OBJECT(list_row),"driver_struct",target);
gtk_list_box_insert(GTK_LIST_BOX(widgets->DriversList),list_row,-1);
yon_driver_struct_update(widgets,target);
// yon_proprietary_append(cur);
free(current);
}
}
if (dr_desc==size-1) {
g_idle_add((GSourceFunc)yon_proprietary_connect,widgets);
}
}
if (!size){
g_idle_add((GSourceFunc)yon_proprietary_connect,widgets);
}
char *status_text = yon_char_unite(yon_char_get_localised_from_lib(SUCCESS_LABEL),". ", !getuid()? main_config.load_mode==1?yon_char_get_localised_from_lib(LOCAL_LOAD_SUCCESS_LABEL):yon_char_get_localised_from_lib(GLOBAL_LOAD_SUCCESS_LABEL):yon_char_get_localised_from_lib(ROOT_WARNING_LABEL),NULL);
yon_ubl_status_box_render_thread(status_text,!getuid()?BACKGROUND_IMAGE_SUCCESS_TYPE:BACKGROUND_IMAGE_FAIL_TYPE);
free(status_text);
g_idle_add((GSourceFunc)yon_proprietary_set,widgets);
yon_drivers_resize(widgets);
}
void yon_proprietary_get_thread(GtkWidget *,main_window *widgets){
yon_ubl_status_box_render(PROPRIETARY_LOADING_LABEL,BACKGROUND_IMAGE_INFO_TYPE);
yon_proprietary_local_get(widgets);
}
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);
}
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 on_app_chooser_open(GtkWidget *self, main_window *widgets){
yon_app_chooser_window *window = yon_app_chooser_window_new(1);
const char *prev_selection = gtk_entry_get_text(GTK_ENTRY(self==widgets->OptirunButton?widgets->OptirunEntry:widgets->PrimusrunEntry));
if (!yon_char_is_empty(prev_selection)){
int size;
config_str parsed = yon_char_parse((char*)prev_selection,&size,",");
yon_app_chooser_window_select(window,parsed,size);
yon_char_parsed_free(parsed,size);
}
int size;
config_str parsed = yon_app_chooser_window_run(window,&size);
if (parsed&&size){
char *string = yon_char_parsed_to_string(parsed,size,",");
if (self==widgets->OptirunButton){
gtk_entry_set_text(GTK_ENTRY(widgets->OptirunEntry),string);
} else if (self == widgets->PrimusrunButton){
gtk_entry_set_text(GTK_ENTRY(widgets->PrimusrunEntry),string);
}
}
}
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]);
}
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);
}
}
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 on_database_update(void *,void *widgets){
yon_terminal_window_launch(GTK_WINDOW(((main_window*)widgets)->Window),install_proprietary_command(""),yon_char_get_localised_from_lib(SUCCESS_LABEL),OPERATION_FAIL_LABEL);
}
void on_gapfix_changed(GtkWidget*, main_window *widgets){
int active = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->FrameGapCombo));
switch(active){
case 0: {
yon_config_remove_by_key(GAPFIX1_parameter);
yon_config_remove_by_key(GAPFIX2_parameter);
} break;
case 1: {
yon_config_remove_by_key(GAPFIX2_parameter);
yon_config_remove_by_key(GAPFIX2_parameter);
} break;
case 2:{
yon_config_register(GAPFIX1_parameter,GAPFIX1_command,"USLEEP");
yon_config_remove_by_key(GAPFIX2_parameter);
} break;
case 3:{
yon_config_register(GAPFIX2_parameter,GAPFIX2_command,"1");
yon_config_remove_by_key(GAPFIX1_parameter);
} break;
}
}
int check_rmb_menu(void *data){
main_window *widgets = (main_window*)data;
GtkListBoxRow *selection = gtk_list_box_get_selected_row(GTK_LIST_BOX(widgets->DriversList));
if (selection){
driver_struct *driver = g_object_get_data(G_OBJECT(selection),"driver_struct");
if (driver->supported_devices_avaliable){
gtk_widget_set_sensitive(GTK_WIDGET(widgets->menu->buttons->first->data),1);
} else {
gtk_widget_set_sensitive(GTK_WIDGET(widgets->menu->buttons->first->data),0);
}
return 1;
}
return 0;
}
/** void yon_setup_widgets(main_window *widgets)
* [EN]
* Sets up every element on main window
* [RU]
*
* */
template_main_window *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);
widgets->MainBox = yon_gtk_builder_get_widget(builder,"BoxMain");
gtk_box_pack_start(GTK_BOX(widgets->InterfaceBox),widgets->MainBox,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->InfoButton = yon_gtk_builder_get_widget(builder, "InfoButton");
widgets->TerminalOverlay = yon_gtk_builder_get_widget(builder, "TerminalOverlay");
widgets->MenusTab = yon_gtk_builder_get_widget(builder, "MenusTab");
widgets->LoadDriversButton = yon_gtk_builder_get_widget(builder,"LoadDriversButton");
widgets->SupportedDevicesButton = yon_gtk_builder_get_widget(builder,"SupportedDevicesButton");
widgets->AboutModuleButton = yon_gtk_builder_get_widget(builder,"AboutModuleButton");
widgets->AboutPackageButton = yon_gtk_builder_get_widget(builder,"AboutPackageButton");
widgets->KernelsCombo = yon_gtk_builder_get_widget(builder,"KernelsCombo");
widgets->InstalledBox = yon_gtk_builder_get_widget(builder,"InstalledBox");
widgets->InstalledModuleLabel = yon_gtk_builder_get_widget(builder,"InstalledModuleLabel");
widgets->InstalledPackageLabel = yon_gtk_builder_get_widget(builder,"InstalledPackageLabel");
widgets->KernelLabel = yon_gtk_builder_get_widget(builder,"KernelLabel");
widgets->DriverLabel = yon_gtk_builder_get_widget(builder,"DriverLabel");
widgets->DescriptionLabel = yon_gtk_builder_get_widget(builder,"DescriptionLabel");
widgets->DevicesLabel = yon_gtk_builder_get_widget(builder,"DevicesLabel");
widgets->MoreButton = yon_gtk_builder_get_widget(builder,"TerminalMoreButton");
widgets->TerminalPaned = yon_gtk_builder_get_widget(builder,"TerminalPaned");
widgets->TerminalMoreRevieler = yon_gtk_builder_get_widget(builder,"TerminalMoreRevieler");
widgets->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
widgets->TerminalBox = yon_gtk_builder_get_widget(builder,"TerminalBox");
// widgets->InstallTerminal = vte_terminal_new();
widgets->InstallTerminal = yon_gtk_builder_get_widget(builder,"TerminalTerminal");
widgets->TerminalRevealer = yon_gtk_builder_get_widget(builder,"TerminalMoreRevieler");
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->DriversLoadingOverlay = GTK_WIDGET(gtk_builder_get_object(builder, "DriversLoadingOverlay"));
widgets->DriversLoadingSpinner = GTK_WIDGET(gtk_builder_get_object(builder, "DriversLoadingSpinner"));
widgets->DriversList = yon_gtk_builder_get_widget(builder, "DriversList");
widgets->TerminalCancelButton = yon_gtk_builder_get_widget(builder, "TerminalCancelButton");
widgets->TerminalInfoLabel = yon_gtk_builder_get_widget(builder, "TerminalInfoLabel");
widgets->TerminalMoveBox = yon_gtk_builder_get_widget(builder, "TerminalMoveBox");
widgets->TerminalMoveTargetBox = yon_gtk_builder_get_widget(builder, "TerminalMoveTargetBox");
gtk_overlay_add_overlay(GTK_OVERLAY(widgets->DriversLoadingOverlay),widgets->DriversLoadingSpinner);
g_signal_connect(G_OBJECT(widgets->LoadDriversButton), "clicked", G_CALLBACK(yon_proprietary_get_thread), widgets);
g_signal_connect(G_OBJECT(widgets->SupportedDevicesButton), "clicked", G_CALLBACK(on_devices_button_clicked), widgets);
g_signal_connect(G_OBJECT(widgets->AboutModuleButton), "clicked", G_CALLBACK(on_driver_pack_info), widgets);
g_signal_connect(G_OBJECT(widgets->AboutPackageButton), "clicked", G_CALLBACK(on_driver_module_info), widgets);
g_signal_connect(G_OBJECT(widgets->DriversList), "row-selected", G_CALLBACK(on_driver_pack_selection_change), widgets);
g_signal_connect(G_OBJECT(widgets->InstallTerminal),"child-exited",G_CALLBACK(on_command_execute_success),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->OptirunCombo),"changed",G_CALLBACK(yon_set_sensitive_from_combo_box),widgets->OptirunButton);
g_signal_connect(G_OBJECT(widgets->PrimusrunCombo),"changed",G_CALLBACK(yon_set_sensitive_from_combo_box),widgets->PrimusrunEntry);
g_signal_connect(G_OBJECT(widgets->PrimusrunCombo),"changed",G_CALLBACK(yon_set_sensitive_from_combo_box),widgets->PrimusrunButton);
g_signal_connect(G_OBJECT(widgets->KernelsCombo),"changed",G_CALLBACK(on_kernel_filter_changed),widgets);
g_signal_connect(G_OBJECT(widgets->FrameGapCombo),"changed",G_CALLBACK(on_gapfix_changed),widgets);
g_signal_connect(G_OBJECT(widgets->OptirunButton),"clicked",G_CALLBACK(on_app_chooser_open),widgets);
g_signal_connect(G_OBJECT(widgets->PrimusrunButton),"clicked",G_CALLBACK(on_app_chooser_open),widgets);
g_signal_connect(G_OBJECT(widgets->MoreButton),"clicked",G_CALLBACK(on_terminal_revealer_open),widgets);
g_signal_connect(G_OBJECT(widgets->TerminalCancelButton),"clicked",G_CALLBACK(on_command_cancel),widgets);
g_object_set_data(G_OBJECT(widgets->InstallTerminal),"widgets",widgets);
{
gtk_paned_add2(GTK_PANED(widgets->TerminalPaned),widgets->TerminalRevealer);
vte_terminal_set_scrollback_lines(VTE_TERMINAL(widgets->InstallTerminal), 100);
vte_terminal_set_scroll_on_output(VTE_TERMINAL(widgets->InstallTerminal), TRUE);
vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(widgets->InstallTerminal), TRUE);
vte_terminal_set_input_enabled(VTE_TERMINAL(widgets->InstallTerminal),1);
gtk_progress_bar_set_pulse_step(GTK_PROGRESS_BAR(widgets->TerminalInfoLabel),0.1);
}
widgets->menu = yon_rmb_menu_setup(widgets->DriversList,check_rmb_menu,widgets,
SUPPORTED_LABEL,icon_devices_path,G_CALLBACK(on_devices_button_clicked),widgets,
MODULE_INFO_LABEL,icon_module_path,G_CALLBACK(on_driver_module_info),widgets,
PACKAGE_INFO_LABEL,icon_package_path,G_CALLBACK(on_driver_pack_info),widgets,
NULL);
{
int size;
config_str default_driver = yon_config_load(yon_config_parameter_prepare_command(VGADRV_AUTO_command,"default",NULL,NULL),&size);
char *final=NULL;
if (size&&strcmp(default_driver[0],"(null)\n")){
if (!strcmp(default_driver[0],"yes")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(ON_LABEL));
} else if (!strcmp(default_driver[0],"no")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(OFF_LABEL));
}
} else {
final = yon_char_get_localised_from_lib(DEFAULT_LABEL);
}
gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(widgets->AutoDriverCombo),final);
}
{
int size;
config_str default_driver = yon_config_load(yon_config_parameter_prepare_command(VGADRV_NOFREE_command,"default",NULL,NULL),&size);
char *final=NULL;
if (size&&strcmp(default_driver[0],"(null)\n")){
if (!strcmp(default_driver[0],"yes")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(FREE_DRIVERS_ON_LABEL));
} else if (!strcmp(default_driver[0],"no")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(NOUVEAU_RADEON_OFF_LABEL));
} else if (!strcmp(default_driver[0],"nouveau")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(RADEON_OFF_LABEL));
} else if (!strcmp(default_driver[0],"radeon")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(NOUVEAU_OFF_LABEL));
}
} else {
final = yon_char_get_localised_from_lib(DEFAULT_LABEL);
}
gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(widgets->FreeDriverCombo),final);
}
{
int size;
config_str default_driver = yon_config_load(yon_config_parameter_prepare_command(FAILSAFENVIDIA_command,"default",NULL,NULL),&size);
char *final=NULL;
if (size&&strcmp(default_driver[0],"(null)\n")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(default_driver[0]));
} else {
final = yon_char_get_localised_from_lib(DEFAULT_LABEL);
}
gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(widgets->FailsafeNvidiaCombo),final);
}
{
int size;
config_str default_driver = yon_config_load(yon_config_parameter_prepare_command(FAILSAFEATI_command,"default",NULL,NULL),&size);
char *final=NULL;
if (size&&strcmp(default_driver[0],"(null)\n")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(default_driver[0]));
} else {
final = yon_char_get_localised_from_lib(DEFAULT_LABEL);
}
gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(widgets->FailsafeAMDCombo),final);
}
{
int size;
config_str default_driver = yon_config_load(yon_config_parameter_prepare_command(XORG_EXT_command,"default",NULL,NULL),&size);
char *final=NULL;
if (size&&strcmp(default_driver[0],"(null)\n")){
if (!strcmp(default_driver[0],"dpms")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(ON_LABEL));
} else if (!strcmp(default_driver[0],"nodpms")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(OFF_LABEL));
}
} else {
final = yon_char_get_localised_from_lib(DEFAULT_LABEL);
}
gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(widgets->DontSwitchDisplaysOffCombo),final);
}
{
int size;
config_str default_driver = yon_config_load(yon_config_parameter_prepare_command(XORG_DPI_command,"default",NULL,NULL),&size);
char *final=NULL;
if (size&&strcmp(default_driver[0],"(null)\n")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(default_driver[0]));
} else {
final = yon_char_get_localised_from_lib(DEFAULT_LABEL);
}
gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(widgets->DisplayScalingCombo),final);
}
{
int size;
config_str default_driver = yon_config_load(yon_config_parameter_prepare_command(INTEGRATEDVGA_command,"default",NULL,NULL),&size);
char *final=NULL;
if (size&&strcmp(default_driver[0],"(null)\n")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(default_driver[0]));
} else {
final = yon_char_get_localised_from_lib(DEFAULT_LABEL);
}
gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(widgets->DisplayDiscreteOnly),final);
}
{
int size;
config_str default_driver = yon_config_load(yon_config_parameter_prepare_command(OPTIRUN_command,"default",NULL,NULL),&size);
char *final=NULL;
if (size&&strcmp(default_driver[0],"(null)\n")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(default_driver[0]));
} else {
final = yon_char_get_localised_from_lib(DEFAULT_LABEL);
}
gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(widgets->OptirunCombo),final);
}
{
int size;
config_str default_driver = yon_config_load(yon_config_parameter_prepare_command(PRIMUSRUN_command,"default",NULL,NULL),&size);
char *final=NULL;
if (size&&strcmp(default_driver[0],"(null)\n")){
final = yon_char_get_localised_from_lib(DEFAULT_CUSTOM_LABEL(default_driver[0]));
} else {
final = yon_char_get_localised_from_lib(DEFAULT_LABEL);
}
gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(widgets->PrimusrunCombo),final);
}
yon_adapter_window_setup(widgets);
}
yon_save_window_set_postsave_function(on_save_done,widgets);
on_config_local_load(NULL,widgets);
return (template_main_window*)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;
main_config.progress_active=0;
yon_packages_init();
}
int main(int argc, char *argv[]){
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();
widgets = 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);
yon_root_button_setup(widgets,argv,argc);
if (system(yon_check_database_command)){
dialog_confirmation_data *data = yon_confirmation_dialog_data_new();
data->action_text=DATABASE_UNACCESSIBLE_LABEL;
data->function = on_database_update;
data->data = widgets;
yon_confirmation_dialog_call(widgets->HeadOverlay,data);
}
yon_proprietary_get_thread(NULL,(main_window*)widgets);
yon_monitor_set_resolutions();
gtk_main();
yon_packages_finish();
return 0;
}
Reference in new issue View Git Blame Copy Permalink