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

1666 lines
82 KiB
Raw Blame History

#include "ubl-settings-video.h"
config main_config;
void on_terminal_done(GtkWidget *, int , main_window *widgets){
gtk_widget_destroy(widgets->TerminalRevealer);
}
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);
}
void on_terminal_destroy(GtkWidget *, main_window *widgets){
gtk_revealer_set_reveal_child(GTK_REVEALER(widgets->TerminalRevealer),0);
gtk_widget_destroy(widgets->TerminalRevealer);
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->DriversTree)),&model,&iter)){
char *module, *package;
gtk_tree_model_get(model, &iter, 7,&module, 8,&package,-1);
if (!yon_char_is_empty(module)){
if (!system(yon_get_is_installed_command(module))){
gtk_list_store_set(main_config.list,&iter,9,1,-1);
}
} else {
if (!system(yon_get_is_installed_command(package))){
gtk_list_store_set(main_config.list,&iter,10,1,-1);
}
}
}
yon_proprietary_get_thread(NULL,widgets);
yon_ubl_status_box_render(yon_char_unite(PROPRIETARY_OPETAION_DONE_LABEL,". ",PROPRIETARY_LOADING_LABEL,NULL),BACKGROUND_IMAGE_SUCCESS_TYPE);
}
gboolean on_command_execute_success(GtkWidget *self,gint status,main_window *widgets){
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);
}
on_terminal_done(self,0,widgets);
return G_SOURCE_REMOVE;
}
gboolean on_terminal_check_progress(main_window *widgets){
char *text = vte_terminal_get_text_format(VTE_TERMINAL(widgets->terminal),VTE_FORMAT_TEXT);
GRegex *regex = g_regex_new("\\d?\\d?\\d%",0,0,NULL);
GMatchInfo *match = NULL;
g_regex_match(regex,text,0,&match);
g_regex_unref(regex);
double percentage = 0.0;
char *last_match = NULL;
while (g_match_info_matches(match)) {
char *current_match = g_match_info_fetch(match, 0);
if (last_match) {
g_free(last_match);
}
last_match = current_match;
g_match_info_next(match, NULL);
}
if (last_match) {
yon_char_remove_last_symbol(last_match,'%');
percentage = g_ascii_strtod(last_match,NULL);
yon_debug_output("%s\n", text);
yon_debug_output("%s\n", last_match);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(widgets->TerminalInfoLabel), percentage / 100);
g_free(last_match);
}
if (text) g_free(text);
if (match) g_match_info_unref(match);
g_mutex_lock(&main_config.progress_mutex);
if (percentage>99||!main_config.progress_active){
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(widgets->TerminalInfoLabel),0);
g_mutex_unlock(&main_config.progress_mutex);
return G_SOURCE_REMOVE;
}
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 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_terminal_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->TerminalCancelButton = yon_gtk_builder_get_widget(builder, "TerminalCancelButton");
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");
widgets->terminal = yon_gtk_builder_get_widget(builder, "TerminalTerminal");
g_signal_connect(G_OBJECT(widgets->terminal),"child-exited",G_CALLBACK(on_command_execute_success),widgets);
g_signal_connect(G_OBJECT(widgets->TerminalCancelButton),"clicked",G_CALLBACK(on_command_cancel),widgets);
gtk_button_set_label(GTK_BUTTON(widgets->TerminalMoreButton),MORE_LABEL);
vte_terminal_set_size(VTE_TERMINAL(widgets->terminal),10,15);
gtk_widget_set_app_paintable(widgets->terminal,1);
gtk_style_context_add_class(gtk_widget_get_style_context(widgets->terminal),"opacited");
gtk_style_context_add_class(gtk_widget_get_style_context(widgets->terminal),"workingbg");
gtk_overlay_add_overlay(GTK_OVERLAY(widgets->TerminalOverlay),widgets->TerminalRevealer);
g_signal_connect(G_OBJECT(widgets->TerminalMoreButton), "clicked", G_CALLBACK(on_terminal_more), widgets);
g_signal_connect(G_OBJECT(widgets->terminal), "destroy", G_CALLBACK(on_terminal_destroy), widgets);
gtk_revealer_set_reveal_child(GTK_REVEALER(widgets->TerminalRevealer),1);
vte_terminal_reset(VTE_TERMINAL(widgets->terminal),0,1);
yon_terminal_integrated_start(widgets->terminal,usr_command);
vte_terminal_set_scrollback_lines(VTE_TERMINAL(widgets->terminal), 100);
vte_terminal_set_scroll_on_output(VTE_TERMINAL(widgets->terminal), TRUE);
vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(widgets->terminal), TRUE);
gtk_widget_show_all(widgets->TerminalRevealer);
gtk_widget_realize(widgets->terminal);
g_mutex_lock(&main_config.progress_mutex);
main_config.progress_active=1;
g_mutex_unlock(&main_config.progress_mutex);
g_idle_add((GSourceFunc)on_terminal_check_progress,widgets);
}
void on_driver_pack_selection_change(GtkWidget *, main_window *widgets){
GtkTreeIter iter;
GtkTreeModel *list_s=GTK_TREE_MODEL(main_config.list);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->DriversTree));
if (gtk_tree_selection_get_selected(selection,&list_s,&iter)){
gtk_widget_set_sensitive(widgets->InfoButton,1);
int installed=0;
gtk_tree_model_get(gtk_tree_view_get_model(GTK_TREE_VIEW(widgets->DriversTree)),&iter,0,&installed,-1);
if (installed==1){
}
} else {
gtk_widget_set_sensitive(widgets->InfoButton,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){
GtkTreeIter iter;
char *module, *package;
GtkTreeModel *list_s=GTK_TREE_MODEL(main_config.list);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->DriversTree));
if (gtk_tree_selection_get_selected(selection,&list_s,&iter)){
yon_ubl_status_box_render(yon_char_get_localised_from_lib(INFO_PROCESS_LABEL),BACKGROUND_IMAGE_INFO_TYPE);
gtk_tree_model_get(list_s,&iter,7,&module,8,&package,-1);
char *command = get_info_proprietary_command(yon_char_is_empty(module)?package:module);
g_thread_new("info_thread",yon_driver_info_launch,(void*)command);
// yon_launch_app_with_arguments(command,"");
} else {
yon_ubl_status_box_render(PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
void on_pack_install_activate(GtkCellRendererToggle* ,gchar* path,main_window *widgets){
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(widgets->DriversTree));
GtkTreeIter iter;
if (!GTK_IS_TREE_MODEL_FILTER(model)){
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(main_config.list),&iter,path);
model=GTK_TREE_MODEL(main_config.list);
} else {
GtkTreeIter itar;
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(model),&itar,path);
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model),&iter,&itar);
}
char *package;
int installed;
gtk_tree_model_get(GTK_TREE_MODEL(model),&iter,1,&installed,8,&package,-1);
if (!installed){
dialog_confirmation_data *data = yon_confirmation_dialog_data_new();
data->action_text=yon_char_unite(INSTALL_CONFIRMATION_LABEL(package),"\n",INSTALL_ATTENTION_LABEL,NULL);
if (yon_confirmation_dialog_call(widgets->Window,data)==GTK_RESPONSE_ACCEPT){
if (!yon_char_is_empty(package)){
char *command = install_proprietary_command(package);
yon_terminal_start(widgets,command);
yon_ubl_status_box_render(PACKAGE_INSTALL_PROCESS_LABEL(package),BACKGROUND_IMAGE_INFO_TYPE);
}
}
free(data);
} else {
dialog_confirmation_data *data = yon_confirmation_dialog_data_new();
data->action_text=REMOVE_CONFIRMATION_LABEL(package);
if (yon_confirmation_dialog_call(widgets->Window,data)==GTK_RESPONSE_ACCEPT){
if (!yon_char_is_empty(package)){
char *command = delete_proprietary_command(package);
yon_terminal_start(widgets,command);
yon_ubl_status_box_render(PACKAGE_REMOVE_PROCESS_LABEL(package),BACKGROUND_IMAGE_INFO_TYPE);
}
}
free(data);
}
}
void on_module_install_activate(GtkCellRendererToggle* ,gchar* path,main_window *widgets){
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(widgets->DriversTree));
GtkTreeIter iter;
if (!GTK_IS_TREE_MODEL_FILTER(model)){
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(main_config.list),&iter,path);
} else {
GtkTreeIter itar;
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(model),&itar,path);
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model),&iter,&itar);
}
char *package;
int installed;
gtk_tree_model_get(GTK_TREE_MODEL(main_config.list),&iter,1,&installed,7,&package,-1);
if (!installed){
dialog_confirmation_data *data = yon_confirmation_dialog_data_new();
data->action_text=INSTALL_CONFIRMATION_LABEL(package);
if (yon_confirmation_dialog_call(widgets->Window,data)==GTK_RESPONSE_ACCEPT){
if (!yon_char_is_empty(package)){
char *command = install_proprietary_command(package);
yon_terminal_start(widgets,command);
yon_ubl_status_box_render(MODULE_INSTALL_PROCESS_LABEL(package),BACKGROUND_IMAGE_INFO_TYPE);
}
}
free(data);
} else {
dialog_confirmation_data *data = yon_confirmation_dialog_data_new();
data->action_text=REMOVE_CONFIRMATION_LABEL(package);
if (yon_confirmation_dialog_call(widgets->Window,data)==GTK_RESPONSE_ACCEPT){
if (!yon_char_is_empty(package)){
char *command = delete_proprietary_command(package);
yon_terminal_start(widgets,command);
yon_ubl_status_box_render(MODULE_REMOVE_PROCESS_LABEL(package),BACKGROUND_IMAGE_INFO_TYPE);
}
}
free(data);
}
}
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){
int active = gtk_combo_box_get_active(GTK_COMBO_BOX(self));
if (active){
if (!GTK_IS_TREE_MODEL_FILTER(gtk_tree_view_get_model(GTK_TREE_VIEW(widgets->DriversTree)))){
GtkTreeModel *model = gtk_tree_model_filter_new(GTK_TREE_MODEL(main_config.list),NULL);
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->DriversTree),model);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model),(GtkTreeModelFilterVisibleFunc)yon_filter_func,widgets,NULL);
}
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(gtk_tree_view_get_model(GTK_TREE_VIEW(widgets->DriversTree))));
} else {
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(widgets->DriversTree));
if (GTK_IS_TREE_MODEL_FILTER(model)) {
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->DriversTree),NULL);
g_object_unref(model);
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->DriversTree),GTK_TREE_MODEL(main_config.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(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){
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;
}
gboolean yon_proprietary_set(main_window *widgets){
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->DriversTree),GTK_TREE_MODEL(main_config.list));
gtk_widget_set_sensitive(widgets->LoadDriversButton,1);
return G_SOURCE_REMOVE;
}
gboolean yon_proprietary_append(struct proprietary_struct *target){
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])&&!system(yon_get_is_exist_command(target->drivers[1])),10,!yon_char_is_empty(target->drivers[2])&&!system(yon_get_is_exist_command(target->drivers[2])),-1);
free(target);
return G_SOURCE_REMOVE;
}
gboolean yon_proprietary_append_kernels(struct proprietary_kernel_append_struct *append){
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(append->widgets->KernelsCombo),append->kernel);
free(append->kernel);
free(append);
return G_SOURCE_REMOVE;
}
gboolean yon_proprietary_disconnect(main_window *widgets){
g_object_ref(main_config.list);
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->DriversTree),NULL);
return G_SOURCE_REMOVE;
}
gboolean yon_proprietary_connect(main_window *widgets){
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->DriversTree),GTK_TREE_MODEL(main_config.list));
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_debug_output("%s\n",yon_get_kernels_installed),&kernels_size);
if (!kernels_size){
yon_ubl_status_box_render_thread(KERNELS_SUPPORTED_UNFOUND_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
yon_debug_output("%s\n","Kernel add");
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++){
if (rtn[i][strlen(rtn[i])-1]=='\n') rtn[i][strlen(rtn[i])-1] = '\0';
}
g_idle_add((GSourceFunc)yon_proprietary_disconnect,widgets);
for (int dr_desc=1;dr_desc<size;dr_desc++){
yon_debug_output("%s\n","Driver add");
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])&&!system(yon_get_is_exist_command(yon_debug_output("%s\n\n\n",current[1]))))||(!yon_char_is_empty(current[2])&&!system(yon_get_is_exist_command(yon_debug_output("%s\n\n\n",current[2]))))){
int module_status = !yon_char_is_empty(current[1])?!system(yon_get_is_installed_command(current[1])):0;
int package_status = !yon_char_is_empty(current[2])?!system(yon_get_is_installed_command(current[2])):0;
struct proprietary_struct *cur = malloc(sizeof(struct proprietary_struct));
cur->drivers=current;
cur->drivers_size=current_size;
cur->module_status=module_status;
cur->package_status=package_status;
g_idle_add((GSourceFunc)yon_proprietary_append,cur);
}
}
yon_debug_output("%s\n","Driver end");
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);
g_thread_exit (NULL);
}
void yon_proprietary_get_thread(GtkWidget *,main_window *widgets){
yon_ubl_status_box_render(PROPRIETARY_LOADING_LABEL,BACKGROUND_IMAGE_INFO_TYPE);
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->DriversTree),NULL);
g_thread_new("drivers_loading",(GThreadFunc)(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;
}
}
/** 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);
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->DriversTree = yon_gtk_builder_get_widget(builder, "DriversTree");
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->DriversTree = yon_gtk_builder_get_widget(builder,"DriversTree");
widgets->TopTree = yon_gtk_builder_get_widget(builder,"TopTree");
widgets->KernelsCombo = yon_gtk_builder_get_widget(builder,"KernelsCombo");
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->PackageRenderer = GTK_CELL_RENDERER(gtk_builder_get_object(builder, "PackageRenderer"));
widgets->ModuleRenderer = GTK_CELL_RENDERER(gtk_builder_get_object(builder, "ModuleRenderer"));
main_config.list = GTK_LIST_STORE(gtk_builder_get_object(builder, "liststore6"));
main_config.list2 = GTK_LIST_STORE(gtk_builder_get_object(builder, "liststore1"));
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);
if (!getuid()){
g_signal_connect(G_OBJECT(widgets->PackageRenderer), "toggled", G_CALLBACK(on_pack_install_activate), widgets);
g_signal_connect(G_OBJECT(widgets->ModuleRenderer), "toggled", G_CALLBACK(on_module_install_activate), widgets);
}
g_signal_connect(G_OBJECT(widgets->InfoButton), "clicked", G_CALLBACK(on_driver_pack_info), widgets);
g_signal_connect(G_OBJECT(widgets->DriversTree), "cursor-changed", G_CALLBACK(on_driver_pack_selection_change), 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);
{
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_gtk_tree_view_minimal_fixed_size_set_full(GTK_TREE_VIEW(widgets->DriversTree));
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;
}
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();
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();
return 0;
}
Reference in new issue View Git Blame Copy Permalink