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

1720 lines
92 KiB
Raw Blame History

#include "ubl-settings-video.h"
config videoconfig;
void yon_on_plug_added(GtkSocket *self, gpointer user_data)
{
}
void yon_on_plug_removed(GtkSocket *self, gpointer user_data)
{
}
void on_subwindow_close(GtkWidget *self)
{
gtk_widget_destroy(gtk_widget_get_toplevel(self));
}
void on_monitor_config_save(GtkWidget *self, monitor_edit_window *window){
monitorconfig *config = yon_dictionary_get_data(window->config,monitorconfig*);
if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPortCombo))==0){
videoconfig.status_render.text_to_render=MONITOR_PORT_ERROR_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_FAIL_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
return;
}
config->main=0;
config->enable=0;
config->position=0;
config->rotation=0;
config->dpms=0;
config->cvt=0;
config->reduced=0;
config->position_port=NULL;
config->port=NULL;
config->resolution=NULL;
config->frequency=0;
videoconfig.status_render.text_to_render=MONITOR_PORT_SUCCESS_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
config->port = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationPortCombo));
window->config->key = yon_char_new(config->port);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationParameterLineCheck))==0){
config->main = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationMainCheck));
config->enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationEnableCheck));
config->dpms = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationModelineCVTCheck));
config->cvt = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationModelineCVTCheck));
config->reduced = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationUseCVTReducedCheck));
config->gtf = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationModelineGTFCheck));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPositionPosCombo))!=0
&&gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPositionPortCombo))!=0){
config->position = gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPositionPosCombo));
config->position_port = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationPositionPortCombo));
}
if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationFrequencyCombo))>0)
config->frequency=gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationFrequencyCombo));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo))!=0) {
config->resolution =yon_char_divide_search((char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationResolutionCombo)),";",-1);
int rotation = gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationRotationCombo));
if (rotation==1) config->rotation=rotation;
else if (rotation==2) config->rotation=rotation;
else if (rotation==3) config->rotation=rotation;
else config->rotation=0;
}
if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo))!=0) {
char *frequency = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationFrequencyCombo));
}
yon_monitor_make_string(config);
} else {
char *stringparameters = (char*)gtk_entry_get_text(GTK_ENTRY(window->templateMonitorConfigurationParameterLineEntry));
}
yon_monitor_view_update();
on_subwindow_close(self);
}
void on_terminal_done(GtkWidget *terminal, int size, widgets_dict *widgets){
gtk_widget_destroy(terminal);
}
void on_terminal_more(GtkWidget *self, widgets_dict *widgets){
int active = gtk_revealer_get_child_revealed(GTK_REVEALER(widgets->TerminalMoreRevieler));
if (active ==1) active = 0;
else active=1;
gtk_revealer_set_reveal_child(GTK_REVEALER(widgets->TerminalMoreRevieler),active);
}
void on_terminal_destroy(GtkWidget *self, widgets_dict *widgets){
gtk_revealer_set_reveal_child(GTK_REVEALER(widgets->TerminalRevealer),0);
gtk_widget_destroy(widgets->TerminalRevealer);
yon_proprieary_get();
yon_gtk_list_store_fill_with_proprietaries(videoconfig.list);
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_OPETAION_DONE_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
static void child_ready(VteTerminal *terminal, GPid pid, GError *error, gpointer user_data)
{
if (!terminal) return;
if (pid == -1) printf("Error\n\n\n");
else vte_terminal_feed_child(VTE_TERMINAL(terminal),(char*)user_data,strlen((char*)user_data));
}
void on_terminal_check_progress(VteTerminal *terminal, widgets_dict *widgets){
char *text = vte_terminal_get_text(terminal,NULL,NULL,NULL);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(widgets->TerminalInfoLabel),(double)yon_char_find_count(text,"::")/4);
}
void yon_terminal_start(widgets_dict *widgets, char *usr_command){
char **command=new_arr(char*,2);
gchar **envp = g_get_environ();
command[0]=(gchar *)g_strdup(g_environ_getenv(envp, "SHELL"));
command[1]=NULL;
char **env=new_arr(char*,2);
env[0]="";
env[1]=NULL;
GtkBuilder *builder=gtk_builder_new_from_file(glade_path);
widgets->TerminalBox = yon_gtk_builder_get_widget(builder, "TerminalBox");
widgets->TerminalRevealer = yon_gtk_builder_get_widget(builder, "TerminalRevealer");
widgets->TerminalMoreRevieler = yon_gtk_builder_get_widget(builder, "TerminalMoreRevieler");
widgets->TerminalMoreButton = yon_gtk_builder_get_widget(builder, "TerminalMoreButton");
widgets->TerminalScroll = yon_gtk_builder_get_widget(builder, "TerminalScroll");
widgets->TerminalInfoLabel = yon_gtk_builder_get_widget(builder, "TerminalInfoLabel");
GtkWidget *terminal = yon_gtk_builder_get_widget(builder, "TerminalTerminal");
vte_terminal_set_size(VTE_TERMINAL(terminal),10,15);
gtk_widget_set_app_paintable(terminal,1);
gtk_style_context_add_class(gtk_widget_get_style_context(terminal),"opacited");
gtk_style_context_add_class(gtk_widget_get_style_context(terminal),"workingbg");
gtk_overlay_add_overlay(GTK_OVERLAY(widgets->TerminalOverlay),widgets->TerminalRevealer);
g_signal_connect(G_OBJECT(terminal), "child-exited", G_CALLBACK(on_terminal_done), widgets);
g_signal_connect(G_OBJECT(terminal), "contents-changed", G_CALLBACK(on_terminal_check_progress), widgets);
g_signal_connect(G_OBJECT(widgets->TerminalMoreButton), "clicked", G_CALLBACK(on_terminal_more), widgets);
g_signal_connect(G_OBJECT(terminal), "destroy", G_CALLBACK(on_terminal_destroy), widgets);
gtk_revealer_set_reveal_child(GTK_REVEALER(widgets->TerminalRevealer),1);
VtePty *pty = vte_pty_new_sync(VTE_PTY_DEFAULT,NULL,NULL);
vte_terminal_set_pty(VTE_TERMINAL(terminal),pty);
char *install_command=yon_char_unite("tput cup 0 0 && tput ed; ",usr_command," ; sleep 5;exit 0","\n",NULL);
vte_terminal_spawn_async(VTE_TERMINAL(terminal),
VTE_PTY_DEFAULT,
NULL,
command,
NULL,
0,
NULL, NULL,
NULL,
-1,
NULL,
child_ready,
install_command);
vte_pty_spawn_async(pty,
NULL,
command,
NULL,
0,
NULL, NULL,
NULL,
-1,
NULL,
NULL,
NULL);
vte_terminal_set_scrollback_lines(VTE_TERMINAL(terminal), 100);
vte_terminal_set_scroll_on_output(VTE_TERMINAL(terminal), TRUE);
vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(terminal), TRUE);
gtk_widget_show_all(widgets->TerminalRevealer);
}
void on_driver_pack_install(GtkWidget *self,widgets_dict *widgets){
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_INSTALLING_IN_PROGRESS_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->proprietaryTreeView));
if(gtk_tree_selection_get_selected(selection,&list_s,&iter)){
gtk_tree_model_get(list_s,&iter,1,&name,-1);
yon_terminal_start(widgets,yon_char_get_augumented(install_proprietary_command,name));
} else {
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_NOTHING_SELECTED_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_FAIL_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
}
void on_driver_install(GtkWidget *self,widgets_dict *widgets){
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_INSTALLING_IN_PROGRESS_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->driversTreeView));
if (gtk_tree_selection_get_selected(selection,&list_s,&iter)){
gtk_tree_model_get(list_s,&iter,1,&name,-1);
yon_terminal_start(widgets,yon_char_get_augumented(install_proprietary_command,name));
} else {
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_NOTHING_SELECTED_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_FAIL_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
}
void on_driver_pack_delete(GtkWidget *self,widgets_dict *widgets){
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_DELETING_IN_PROGRESS_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->proprietaryTreeView));
if(gtk_tree_selection_get_selected(selection,&list_s,&iter)){
gtk_tree_model_get(list_s,&iter,1,&name,-1);
yon_terminal_start(widgets,yon_char_get_augumented(delete_proprietary_command,name));
} else {
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_NOTHING_SELECTED_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_FAIL_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
}
void on_driver_delete(GtkWidget *self,widgets_dict *widgets){
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_DELETING_IN_PROGRESS_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->driversTreeView));
if (gtk_tree_selection_get_selected(selection,&list_s,&iter)){
gtk_tree_model_get(list_s,&iter,1,&name,-1);
yon_terminal_start(widgets,yon_char_get_augumented(delete_proprietary_command,name));
} else {
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_NOTHING_SELECTED_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_FAIL_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
}
void on_driver_pack_info(GtkWidget *self, widgets_dict *widgets){
pthread_attr_t attr;
pthread_t tid;
pthread_attr_init(&attr);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->proprietaryTreeView));
if (gtk_tree_selection_get_selected(selection,&list_s,&iter)){
gtk_tree_model_get(list_s,&iter,1,&name,-1);
pthread_create(&tid,&attr,(void*)yon_launch_app,yon_char_get_augumented(get_info_proprietary_command,name));
} else {
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_NOTHING_SELECTED_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_FAIL_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
}
void on_driver_info(GtkWidget *self,widgets_dict *widgets){
pthread_attr_t attr;
pthread_t tid;
pthread_attr_init(&attr);
GtkTreeIter iter;
char *name;
GtkTreeModel *list_s=GTK_TREE_MODEL(videoconfig.list);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->driversTreeView));
if (gtk_tree_selection_get_selected(selection,&list_s,&iter)){
gtk_tree_model_get(list_s,&iter,1,&name,-1);
pthread_create(&tid,&attr,(void*)yon_launch_app,yon_char_get_augumented(get_info_proprietary_command,name));
} else {
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_NOTHING_SELECTED_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_FAIL_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
}
void on_port_chosen_changed(GtkWidget *self, monitor_edit_window *window){
monitorconfig* config = yon_dictionary_get_data(window->config,monitorconfig*);
dictionary *dict=NULL;
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationResolutionCombo));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationResolutionCombo),PARAMETER_DEFAULT_LABEL);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo),0);
char *combo_text=yon_char_new((char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationPortCombo)));
char *resolution = yon_char_divide_search(combo_text," ",-1);
if (combo_text)
if (strcmp(combo_text,MONITOR_CHOOSE_PORT_LABEL)!=0){
dict=yon_dictionary_find(&videoconfig.supported_resolutions,resolution);
if (dict){
resolution_supported *res = yon_dictionary_get_data(dict,resolution_supported*);
int found_size=0;
for (int i=0;i<res->size;i++){
char *check_line;
for (int j=0;j<videoconfig.resolutionssize;j++){
check_line=yon_char_new(videoconfig.resolutions[j]);
check_line=yon_char_divide_search(check_line," ",-1);
if (strstr(videoconfig.resolutions[j],res->line[i])){
found_size++;
if(!config->resolutionCapabilities) config->resolutionCapabilities=new(char*);
else config->resolutionCapabilities=realloc(config->resolutionCapabilities,sizeof(char*)*found_size);
config->resolutionCapabilities[found_size-1]=videoconfig.resolutions[j];
config->resolution_size=found_size;
}
}
}
yon_gtk_combo_box_fill(window->templateMonitorConfigurationResolutionCombo,config->resolutionCapabilities, config->resolution_size);
}
}
}
void on_sensitive_change(GtkWidget *self, GtkWidget *toggle)
{
int state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self));
gtk_widget_set_sensitive(toggle, state);
}
void on_sensitive_change_reversed(GtkWidget *self, GtkWidget *toggle)
{
int state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self));
gtk_widget_set_sensitive(toggle, !state);
}
void on_auto_choose_drivers(GtkWidget *self, widgets_dict *widgets)
{
int state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self));
videoconfig.autoChooseDrivers=state;
gtk_widget_set_sensitive(widgets->mainDriverFailsafeNvidiaLabel, !state);
gtk_widget_set_sensitive(widgets->mainDriverFailsafeAMDCombo, !state);
gtk_widget_set_sensitive(widgets->mainDriverFailsafeAMDLabel, !state);
gtk_widget_set_sensitive(widgets->mainDriverFailsafeNvidiaCombo, !state);
}
char *yon_configuration_get_save_command(char *command){
char *str = NULL;
char *dntus = NULL;
dntus=_("Don't use");
str=yon_char_new(command);
if (videoconfig.autoChooseDrivers==0){
if (strcmp(videoconfig.failsafenVidia, dntus)!=0)
str = yon_char_get_augumented(str, yon_char_get_augumented(" FAILSAFENVIDIA=", videoconfig.failsafenVidia));
else
str = yon_char_get_augumented(str," FAILSAFENVIDIA=\"\"");
if (strcmp(videoconfig.failsafeATI, dntus)!=0)
str = yon_char_get_augumented(str, yon_char_get_augumented(" FAILSAFEATI=", videoconfig.failsafeATI));
else
str = yon_char_get_augumented(str," FAILSAFEATI=\"\"");
str=yon_char_get_augumented(str," VGADRV_AUTO=NO");
} else {
str = yon_char_unite(str, " FAILSAFENVIDIA=\"\" FAILSAFEATI=\"\" VGADRV_AUTO=YES", NULL);
}
if (videoconfig.optirun&&strcmp(videoconfig.optirun, dntus)!=0&&strcmp(videoconfig.optirun, "")!=0)
str = yon_char_get_augumented(str, yon_char_unite(" OPTIRUN=","\"",videoconfig.optirun,"\"",NULL));
else
str = yon_char_get_augumented(str, yon_char_unite(" OPTIRUN=\"\"",NULL));
if (videoconfig.primusrun&&strcmp(videoconfig.primusrun, dntus)!=0&&strcmp(videoconfig.primusrun, "")!=0)
str = yon_char_get_augumented(str, yon_char_unite(" PRIMUSRUN=","\"", videoconfig.primusrun,"\"",NULL));
else
str = yon_char_get_augumented(str, yon_char_unite(" PRIMUSRUN=\"\"",NULL));
dictionary *dict=NULL;
for (int i=0;i<videoconfig.portssize;i++)
str=yon_char_unite(str," XORG_MONITOR[",videoconfig.ports[i],"]=\"\"", NULL);
if(videoconfig.monitors)
for_dictionaries(dict,videoconfig.monitors){
if (yon_dictionary_get_data(dict,monitorconfig*)->stringparameters){
str=yon_char_unite(str," XORG_MONITOR[",dict->key,"]=\"",yon_dictionary_get_data(dict,monitorconfig*)->stringparameters,"\"", NULL);
}
}
if (strcmp(str,command)!=0)
return str;
else return NULL;
}
void on_resolutions_unsupported_show(GtkWidget *self, monitor_edit_window *window){
((monitorconfig*)window->config->data)->show_usupported = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self));
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationResolutionCombo));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationResolutionCombo),PARAMETER_DEFAULT_LABEL);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo),0);
if (((monitorconfig*)window->config->data)->show_usupported==1){
yon_gtk_combo_box_fill(window->templateMonitorConfigurationResolutionCombo,videoconfig.resolutions,videoconfig.resolutionssize);
} else {
yon_gtk_combo_box_fill(window->templateMonitorConfigurationResolutionCombo,((monitorconfig*)window->config->data)->resolutionCapabilities,((monitorconfig*)window->config->data)->resolution_size);
}
}
char *yon_configuration_get_remove_command(char *command){
char *str = NULL;
char *dntus = NULL;
dntus=_("Don't use");
str=yon_char_new(command);
str = yon_char_get_augumented(str, " FAILSAFENVIDIA");
str = yon_char_get_augumented(str, " FAILSAFATI");
str = yon_char_get_augumented(str, " OPTIRUN");
str = yon_char_get_augumented(str, " PRIMUSRUN");
dictionary *dict=NULL;
for(int i=0;i<videoconfig.portssize;i++){
str = yon_char_get_augumented(str, yon_char_get_augumented(" ",XORG_MONITOR(videoconfig.ports[i])));
}
if (strcmp(str,command)!=0)
return str;
else return NULL;
}
void on_configuration_save_local(GtkWidget *self, widgets_dict *widgets)
{
yon_update_config(widgets);
char *str=NULL;
char *delstr=NULL;
str=yon_configuration_get_save_command(save_drivers_local_command);
// delstr=yon_configuration_get_remove_command(remove_drivers_local_command);
// if (delstr){
// yon_config_save(delstr);
// }
if (str){
yon_config_save(str);
videoconfig.status_render.text_to_render=LOCAL_SAVE_SUCCESS;
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
// else
// yon_ubl_status_box_render(widgets->mainStatusBox, widgets->mainStatusIcon, widgets->mainStatusLabel, _("Local configuration saving failed."), BACKGROUND_IMAGE_FAIL_TYPE);
}
void on_configuration_save_local_global(GtkWidget *self, widgets_dict *widgets)
{
on_configuration_save_global_local(self, widgets);
videoconfig.status_render.text_to_render=GLOBAL_LOCAL_SAVE_SUCCESS;
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
void on_configuration_save_global_local(GtkWidget *self, widgets_dict *widgets)
{
yon_update_config(widgets);
char *str=NULL;
char *delstr=NULL;
str=yon_configuration_get_save_command(save_drivers_global_local_command);
if (str){
yon_config_save(str);
videoconfig.status_render.text_to_render=LOCAL_SAVE_SUCCESS;
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
}
void on_configuration_save_global(GtkWidget *self, widgets_dict *widgets)
{
yon_update_config(widgets);
char *str=NULL;
char *delstr=NULL;
str=yon_configuration_get_save_command(save_drivers_global_command);
// delstr=yon_configuration_get_remove_command(remove_drivers_global_command);
// if (delstr){
// yon_config_save(delstr);
// }
if (str){
yon_config_save(str);
videoconfig.status_render.text_to_render=LOCAL_SAVE_SUCCESS;
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
}
void yon_update_config(widgets_dict *widgets)
{
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchOptirunCheck))==1)
videoconfig.optirun = yon_char_new( (char *)gtk_entry_get_text(GTK_ENTRY(widgets->mainExtraLaunchOptirunEntry)));
else videoconfig.optirun = NULL;
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchPrismusunCheck))==1)
videoconfig.primusrun = yon_char_new( (char *)gtk_entry_get_text(GTK_ENTRY(widgets->mainExtraLaunchPrismusunEntry)));
else videoconfig.primusrun = NULL;
videoconfig.failsafenVidia = yon_char_new( gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo)));
videoconfig.failsafeATI = yon_char_new( gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo)));
}
void on_configuration_load_local(GtkWidget *self, widgets_dict *widgets)
{
yon_setup_config(load_drivers_local_command);
on_config_fill_interface(widgets);
yon_monitor_view_setup(widgets->mainMonitorVisualConfigurationBox);
}
void on_configuration_load_global(GtkWidget *self, widgets_dict *widgets)
{
yon_setup_config(load_drivers_global_command);
on_config_fill_interface(widgets);
yon_monitor_view_setup(widgets->mainMonitorVisualConfigurationBox);
}
/**void on_monitor_delete(GtkWidget *self,monitor_view windowd)
* [EN]
*/
void on_monitor_delete(GtkWidget *self,monitor_view windowd){
monitor_window *window = yon_dictionary_get_data(windowd,monitor_window*);
if(window&&window->config){
gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(window->templateMonitorscreenOverlay)),window->templateMonitorscreenOverlay);
videoconfig.monitor_visuals = yon_dictionary_rip(windowd);
gtk_widget_destroy(window->templateMonitorscreenOverlay);
videoconfig.monitors = yon_dictionary_rip(window->config);
free(window);
}
}
/**void on_monitor_switch(GtkWidget *self,monitor_window *window)
* [EN]
*/
void on_monitor_switch(GtkWidget *self,monitor_window *window){
if(window&&window->config){
int *enable = &yon_dictionary_get_data(window->config,monitorconfig*)->enable;
*enable=!*enable;
gtk_widget_set_sensitive(window->templateMonitorImage,*enable);
}
}
/**void on_monitor_add(GtkWidget *self,monitor_window *window)
* [EN]
*/
void on_monitor_add(GtkWidget *self,monitor_window *window){
if(window){
videoconfig.monitors = yon_monitor_config_new(PARAMETER_DEFAULT_LABEL);
yon_monitor_view_new(videoconfig.monitors);
yon_monitor_view_draw_all(NULL);
}
}
void on_proprietary_get(GtkWidget *notebook, GtkWidget *page, int pagen, gpointer data){
if (pagen==1){
GtkTreeIter iter;
if(!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(videoconfig.list),&iter)){
pthread_t tid;
pthread_create(&tid,NULL,(void*)yon_proprieary_get,NULL);
}
}
}
void on_monitor_configure(GtkWidget *self,monitor_window *window){
if(window&&window->config){
monitor_edit_window *monitors = new(monitor_edit_window);
GtkBuilder *builder = gtk_builder_new_from_file(glade_path);
monitors->templateMonitorConfigurationWindow = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationWindow"));
monitors->mainMonitorConfigurationBox = GTK_WIDGET(gtk_builder_get_object(builder, "mainMonitorConfigurationBox"));
monitors->templateMonitorConfigurationBox = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationBox"));
monitors->templateMonitorConfigurationEnableCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationEnableCheck"));
monitors->templateMonitorConfigurationPortLabel = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationPortLabel"));
monitors->templateMonitorConfigurationPortCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationPortCombo"));
monitors->templateMonitorConfigurationMainCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationMainCheck"));
monitors->templateMonitorConfigurationResolutionLabel = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationResolutionLabel"));
monitors->templateMonitorConfigurationResolutionCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationResolutionCombo"));
monitors->templateMonitorConfigurationShowUnsupportedCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationShowUnsupportedCheck"));
monitors->templateMonitorConfigurationFrequencyLabel = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationFrequencyLabel"));
monitors->templateMonitorConfigurationFrequencyCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationFrequencyCombo"));
monitors->templateMonitorConfigurationRotationLabel = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationRotationLabel"));
monitors->templateMonitorConfigurationRotationCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationRotationCombo"));
monitors->templateMonitorConfigurationPositionLabel = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationPositionLabel"));
monitors->templateMonitorConfigurationPositionPosCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationPositionPosCombo"));
monitors->templateMonitorConfigurationPositionPortCombo = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationPositionPortCombo"));
monitors->templateMonitorConfigurationModelineCVTCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationModelineCVTCheck"));
monitors->templateMonitorConfigurationUseCVTReducedCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationUseCVTReducedCheck"));
monitors->templateMonitorConfigurationModelineGTFCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationModelineGTFCheck"));
monitors->templateMonitorConfigurationParameterLineCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationParameterLineCheck"));
monitors->templateMonitorConfigurationParameterLineEntry = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationParameterLineEntry"));
monitors->templateMonitorConfigurationCancelButton = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationCancelButton"));
monitors->templateMonitorConfigurationSaveButton = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationSaveButton"));
monitors->templateMonitorConfigurationDoNotSwitchOffCheck = GTK_WIDGET(gtk_builder_get_object(builder, "templateMonitorConfigurationDoNotSwitchOffCheck"));
monitors->config=window->config;
g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationCancelButton), "clicked", G_CALLBACK(on_subwindow_close), NULL);
g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationSaveButton), "clicked", G_CALLBACK(on_monitor_config_save), monitors);
g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationParameterLineCheck), "toggled", G_CALLBACK(on_sensitive_change_reversed), monitors->templateMonitorConfigurationBox);
g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationParameterLineCheck), "toggled", G_CALLBACK(on_sensitive_change), monitors->templateMonitorConfigurationParameterLineEntry);
g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationShowUnsupportedCheck), "toggled", G_CALLBACK(on_resolutions_unsupported_show),monitors);
g_signal_connect(G_OBJECT(monitors->templateMonitorConfigurationPortCombo), "changed", G_CALLBACK(on_port_chosen_changed),monitors);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(monitors->templateMonitorConfigurationEnableCheck),yon_dictionary_get_data(monitors->config,monitorconfig*)->enable==1);
gtk_window_set_title(GTK_WINDOW(monitors->templateMonitorConfigurationWindow),SETTINGS_VIDEO_TITLE_LABEL);
gtk_label_set_text(GTK_LABEL(monitors->templateMonitorConfigurationPortLabel),MONITOR_PORT_LABEL);
gtk_label_set_text(GTK_LABEL(monitors->templateMonitorConfigurationResolutionLabel),MONITOR_RESOLUTION_LABEL);
gtk_label_set_text(GTK_LABEL(monitors->templateMonitorConfigurationFrequencyLabel),MONITOR_FREQUENCY_LABEL);
gtk_label_set_text(GTK_LABEL(monitors->templateMonitorConfigurationRotationLabel),MONITOR_ROTATION_LABEL);
gtk_label_set_text(GTK_LABEL(monitors->templateMonitorConfigurationPositionLabel),MONITOR_POSITION_LABEL);
gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationEnableCheck),MONITOR_ENABLED_LABEL);
gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationMainCheck),MONITOR_MAIN_DISPLAY_LABEL);
gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationShowUnsupportedCheck),MONITOR_UNSUPPORTED_LABEL);
gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationDoNotSwitchOffCheck),MONITOR_SWITCH_OFF_LABEL);
gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationModelineCVTCheck),MONITOR_CVT_LABEL);
gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationUseCVTReducedCheck),MONITOR_REDUCED_LABEL);
gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationModelineGTFCheck),MONITOR_GTF_LABEL);
gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationParameterLineCheck),MONITOR_MANUALLY_LABEL);
gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationCancelButton),MONITOR_CANCEL_LABEL);
gtk_button_set_label(GTK_BUTTON(monitors->templateMonitorConfigurationSaveButton),MONITOR_SAVE_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPortCombo),MONITOR_CHOOSE_PORT_LABEL);
dictionary *dict=NULL;
for (int i=0;i<videoconfig.portssize;i++){
dictionary *check_if_exists = yon_dictionary_find(&videoconfig.monitors,videoconfig.ports[i]);
if (!check_if_exists||!yon_dictionary_get_data(check_if_exists,monitorconfig*)->stringparameters||check_if_exists==monitors->config)
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPortCombo),videoconfig.ports[i]);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationPortCombo),0);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationResolutionCombo),PARAMETER_DEFAULT_LABEL);
gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationResolutionCombo),0);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationFrequencyCombo),PARAMETER_DEFAULT_LABEL);
gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationFrequencyCombo),0);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationRotationCombo),MONITOR_NO_ROTATION_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationRotationCombo),MONITOR_LEFT_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationRotationCombo),MONITOR_RIGHT_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationRotationCombo),MONITOR_INVERTED_LABEL);
gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationRotationCombo),0);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPosCombo),PARAMETER_DEFAULT_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPosCombo),MONITOR_LEFT_POS_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPosCombo),MONITOR_RIGHT_POS_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPosCombo),MONITOR_ABOVE_POS_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPosCombo),MONITOR_BELOW_POS_LABEL);
gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationPositionPosCombo),0);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPortCombo),PARAMETER_DEFAULT_LABEL);
for (int i=0;i<videoconfig.portssize;i++){
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(monitors->templateMonitorConfigurationPositionPortCombo),videoconfig.ports[i]);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(monitors->templateMonitorConfigurationPositionPortCombo),0);
yon_monitor_window_update(monitors);
gtk_widget_show(monitors->templateMonitorConfigurationWindow);
}
}
/**void on_about()
* [EN]
*/
void on_about()
{
GtkBuilder *builder = gtk_builder_new_from_file(glade_path);
GtkWidget *window = yon_gtk_builder_get_widget(builder, "aboutWindow");
GtkWidget *hideButtonBox = yon_gtk_builder_get_widget(builder, "buttonBoxHide");
gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(window), _("UBlinux Video Configuration"));
gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(window), version_application);
gtk_about_dialog_set_website_label(GTK_ABOUT_DIALOG(window), _("Project Home Page"));
gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(window), _("Videocard and monitor configuration manager"));
gtk_widget_set_visible(hideButtonBox, 0);
gtk_widget_show(window);
}
void yon_monitor_window_update(monitor_edit_window *window){
if (window){
int found = yon_gtk_combo_box_text_find(window->templateMonitorConfigurationPortCombo, window->config->key);
if (found==-1)
found=0;
gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPortCombo),found);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationResolutionCombo),found);
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationFrequencyCombo));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationFrequencyCombo),PARAMETER_DEFAULT_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationFrequencyCombo),"60");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->templateMonitorConfigurationFrequencyCombo),"75");
gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationFrequencyCombo),0);
found = yon_gtk_combo_box_text_find(window->templateMonitorConfigurationPositionPortCombo, yon_dictionary_get_data(window->config,monitorconfig*)->position_port);
if (found==-1)
found=0;
gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPositionPortCombo),found);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationPositionPosCombo),yon_dictionary_get_data(window->config,monitorconfig*)->position);
gtk_combo_box_set_active(GTK_COMBO_BOX(window->templateMonitorConfigurationRotationCombo),yon_dictionary_get_data(window->config,monitorconfig*)->rotation);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationDoNotSwitchOffCheck),yon_dictionary_get_data(window->config,monitorconfig*)->dpms);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationMainCheck),yon_dictionary_get_data(window->config,monitorconfig*)->main);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationModelineCVTCheck),yon_dictionary_get_data(window->config,monitorconfig*)->cvt);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationUseCVTReducedCheck),yon_dictionary_get_data(window->config,monitorconfig*)->reduced);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationModelineGTFCheck),yon_dictionary_get_data(window->config,monitorconfig*)->gtf);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->templateMonitorConfigurationEnableCheck),yon_dictionary_get_data(window->config,monitorconfig*)->enable);
if(yon_dictionary_get_data(window->config,monitorconfig*)->stringparameters)
gtk_entry_set_text(GTK_ENTRY(window->templateMonitorConfigurationParameterLineEntry),yon_dictionary_get_data(window->config,monitorconfig*)->stringparameters);
}
}
/**void yon_monitor_view_draw_all(GtkWidget *cnt)
* [EN]
*/
void yon_monitor_view_draw_all(GtkWidget *cnt){
monitor_view dict=NULL;
GtkWidget *container=NULL;
if(!container&&cnt) container=cnt;
if(videoconfig.monitor_visuals){
for_dictionaries(dict,videoconfig.monitor_visuals){
monitor_window *window = yon_dictionary_get_data(dict,monitor_window*);
if (!container) container = gtk_widget_get_parent(window->templateMonitorscreenOverlay);
if(container){
g_object_ref(G_OBJECT(window->templateMonitorscreenOverlay));
gtk_container_remove(GTK_CONTAINER(container),window->templateMonitorscreenOverlay);
}
}
if (container)
for_dictionaries(dict,videoconfig.monitor_visuals){
monitor_window *window = yon_dictionary_get_data(dict,monitor_window*);
if(dict->first==dict) {}
else {
gtk_box_pack_start(GTK_BOX(container),window->templateMonitorscreenOverlay,0,0,0);
}
}
monitor_window *window = yon_dictionary_get_data(videoconfig.monitor_visuals->first,monitor_window*);
gtk_box_pack_start(GTK_BOX(container),window->templateMonitorscreenOverlay,0,0,0);
}
yon_monitor_view_update();
}
/**void yon_monitor_view_setup(GtkWidget *container)
* [EN]
*/
void yon_monitor_view_setup(GtkWidget *container){
if(container){
monitor_config config=NULL;
yon_monitor_view_new(NULL);
if (videoconfig.monitors){
for_dictionaries(config,videoconfig.monitors){
if (yon_dictionary_get_data(config,monitorconfig*)->stringparameters)
yon_monitor_view_new(config);
}
}
yon_monitor_view_draw_all(container);
}
}
/**void yon_monitor_view_update()
* [EN]
*/
void yon_monitor_view_update(){
monitor_view dict=NULL;
for_dictionaries(dict,videoconfig.monitor_visuals){
if(dict!=videoconfig.monitor_visuals->first){
monitor_window *monitor = yon_dictionary_get_data(dict,monitor_window*);
monitorconfig *config = yon_dictionary_get_data(monitor->config,monitorconfig*);
if (strcmp(monitor->config->key,PARAMETER_DEFAULT_LABEL)!=0)
gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoNameLabel),yon_char_get_augumented(MONITOR_LABEL,monitor->config->key));
else
gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoNameLabel),yon_char_get_augumented(MONITOR_LABEL,""));
monitorconfig *params=yon_dictionary_get_data(yon_dictionary_get_data(dict,monitor_window*)->config,monitorconfig*);
gtk_widget_set_sensitive(yon_dictionary_get_data(dict,monitor_window*)->templateMonitorImage,params->enable);
if (config->resolution){
char *freq="";
if (config->frequency>0){
if (config->frequency==1) freq ="60";
else if (config->frequency==2) freq="75";
}
gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoResolutionLabel),yon_char_unite(config->resolution,":",freq,NULL));
}else if (params->stringparameters){
int size=0;
config_str rtn=yon_char_parse(params->stringparameters,&size,",");
char *res=yon_char_divide_search(yon_char_new(yon_char_parsed_get_resolution(rtn,size))," ",-1);
if (res&&strcmp(res,"")!=0)
gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoResolutionLabel),res);
else
gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoResolutionLabel),PARAMETER_DEFAULT_LABEL);
}
else
gtk_label_set_text(GTK_LABEL(monitor->templateMonitorInfoResolutionLabel),PARAMETER_DEFAULT_LABEL);
}
}
}
/**char *yon_monitor_make_string(monitorconfig* config)
* [EN]
*/
char *yon_monitor_make_string(monitorconfig* config)
{
int first=1;
char *main="";
if (config->main==1){
main="primary";
first=0;
}
char *resolution="";
if(config->resolution)
if (first==1){
resolution=config->resolution;
first=0;
}else{
resolution=yon_char_get_augumented(",",config->resolution);
}
char *enable="";
if (config->enable==1)
if (first==1){
enable="enable";
first=0;
}else{
enable=",enable";
}
else
if (first==1){
enable="disable";
first=0;
}else{
enable=",disable";
}
char *position="";
if (config->position==1)
if (first==1){
position=yon_char_get_augumented("lo:",config->position_port);
first=0;
}else{
position=yon_char_get_augumented(",lo:",config->position_port);
}
else if (config->position==2)
if (first==1){
position=yon_char_get_augumented("ro:",config->position_port);
first=0;
}else{
position=yon_char_get_augumented(",ro:",config->position_port);
}
else if (config->position==3)
if (first==1){
position=yon_char_get_augumented("ab:",config->position_port);
first=0;
}else{
position=yon_char_get_augumented(",ab:",config->position_port);
}
else if (config->position==4)
if (first==1){
position=yon_char_get_augumented("be:",config->position_port);
first=0;
}else{
position=yon_char_get_augumented(",be:",config->position_port);
}
char *rotation="";
if (config->rotation==0)
if (first==1){
rotation="rotate:normal";
first=0;
}else{
rotation=",rotate:normal";
}
else if (config->rotation==1)
if (first==1){
rotation="rotate:left";
first=0;
}else{
rotation=",rotate:left";
}
else if (config->rotation==2)
if (first==1){
rotation="rotate:right";
first=0;
}else{
rotation=",rotate:right";
}
else if (config->rotation==3)
if (first==1){
rotation="rotate:invert";
first=0;
}else{
rotation=",rotate:invert";
}
char *dpms="";
if (config->dpms==1)
if (first==1){
dpms="dpms";
first=0;
}else{
dpms=",dpms";
}
char *cvt="";
if (config->cvt==1)
if (first==1){
cvt="cvt";
first=0;
}else{
cvt=",cvt";
}
char *reduced="";
if (config->reduced==1)
if (first==1){
reduced="reduced";
first=0;
}else{
reduced=",reduced";
}
char *gtf="";
if (config->gtf==1)
if (first==1){
gtf="gtf";
first=0;
}else{
gtf=",gtf";
}
char *frequency="";
if (config->frequency){
if (config->frequency==1) frequency="x60";
else if (config->frequency==2) frequency="x75";
}
if (strcmp(resolution,"")!=0)
resolution=yon_char_get_augumented(resolution,frequency);
char *stringparameters=yon_char_unite("",main,resolution,enable,position,rotation,dpms,cvt,reduced,gtf,NULL);
config->stringparameters=yon_char_new(stringparameters);
}
/**void on_config_fill_interface(widgets_dict *widgets)
* [EN]
*/
void on_config_fill_interface(widgets_dict *widgets)
{
gtk_widget_grab_focus(widgets->mainHeaderSettingsButton);
char *str = videoconfig.optirun;
gtk_entry_set_text(GTK_ENTRY(widgets->mainExtraLaunchOptirunEntry), "");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchOptirunCheck), 0);
if (str)
{
yon_char_divide_search((str = yon_char_new(videoconfig.optirun)), "=", -1);
gtk_entry_set_text(GTK_ENTRY(widgets->mainExtraLaunchOptirunEntry), str);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchOptirunCheck), 1);
}
str = videoconfig.primusrun;
gtk_entry_set_text(GTK_ENTRY(widgets->mainExtraLaunchPrismusunEntry), "");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchPrismusunCheck), 0);
if (str)
{
yon_char_divide_search((str = yon_char_new(videoconfig.primusrun)), "=", 1);
gtk_entry_set_text(GTK_ENTRY(widgets->mainExtraLaunchPrismusunEntry), str);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainExtraLaunchPrismusunCheck), 1);
}
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo));
str = videoconfig.failsafenVidia;
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo), DONT_USE_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo), FBDEV_LABEL);
if (str)
{
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->mainDriverFailsafeNvidiaCombo), 1);
}
else
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->mainDriverFailsafeNvidiaCombo), 0);
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo));
str = videoconfig.failsafeATI;
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo), DONT_USE_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo), FBDEV_LABEL);
if (str)
{
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->mainDriverFailsafeAMDCombo), 1);
}
else
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->mainDriverFailsafeAMDCombo), 0);
if (videoconfig.autoChooseDrivers==1){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainDriverAutomaticallyChooseCheck),1);
}
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->mainDriverAutomaticallyChooseCheck),0);
dictionary *dict = NULL;
}
/**dictionary *yon_proprieary_get()
* [EN]
*/
dictionary *yon_proprieary_get(){
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_LOADING_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_FAIL_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
videoconfig.proprietary=NULL;
int drivers_size=0;
config_str drivers=yon_config_load(get_proprietary_drivers_command,&drivers_size);
int size=0;
char **rtn = yon_config_load(get_proprietary_drivers_info_command,&size);
for (int drivers_found=0;drivers_found<drivers_size;drivers_found++){
drivers[drivers_found]=yon_char_divide_search(drivers[drivers_found],"\n",-1);
for (int i=0;i<size;i++){
rtn[i] = yon_char_divide_search(rtn[i],"\n",-1);
char *key=yon_char_new(rtn[i]);
if (key[0]==';')
yon_char_divide_search(key,";",-1);
key = yon_char_divide_search(key,";",-1);
char *driver_name=yon_char_divide_search(yon_char_new(drivers[drivers_found])," ",-1);
if (strcmp(key,driver_name)==0)
if (i==0) videoconfig.proprietary=yon_dictionary_create_with_data(drivers[drivers_found],rtn[i]);
else videoconfig.proprietary=yon_dictionary_create_with_data_connected(videoconfig.proprietary,drivers[drivers_found],rtn[i]);
}
}
if (videoconfig.proprietary){
yon_gtk_list_store_fill_with_proprietaries(videoconfig.list);
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render="";
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
} else {
drivers=yon_config_load(get_proprietary_drivers_local_command,&drivers_size);
for (int drivers_found=0;drivers_found<drivers_size;drivers_found++){
drivers[drivers_found]=yon_char_divide_search(drivers[drivers_found],"\n",-1);
for (int i=0;i<size;i++){
rtn[i] = yon_char_divide_search(rtn[i],"\n",-1);
char *key=yon_char_new(rtn[i]);
if (key[0]==';')
yon_char_divide_search(key,";",-1);
key = yon_char_divide_search(key,";",-1);
char *driver_name=yon_char_divide_search(yon_char_new(drivers[drivers_found])," ",-1);
if (strcmp(key,driver_name)==0)
if (i==0) videoconfig.proprietary=yon_dictionary_create_with_data(drivers[drivers_found],rtn[i]);
else videoconfig.proprietary=yon_dictionary_create_with_data_connected(videoconfig.proprietary,drivers[drivers_found],rtn[i]);
}
}
videoconfig.status_render.strings_size=0;
videoconfig.status_render.text_strings_to_render=NULL;
videoconfig.status_render.text_to_render=PROPRIETARY_LOADING_FAILED_LABEL;
videoconfig.status_render.type=BACKGROUND_IMAGE_FAIL_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
}
}
/**void yon_gtk_list_store_fill_with_proprietaries(GtkListStore *list)
* [EN]
*/
void yon_gtk_list_store_fill_with_proprietaries(GtkListStore *list){
if(videoconfig.proprietary){
dictionary *dict=NULL;
gtk_list_store_clear(list);
for_dictionaries(dict,videoconfig.proprietary){
GtkTreeIter iter;
int size=0;
config_str str = yon_char_parse((char*)dict->data,&size,";");
gtk_list_store_append(list,&iter);
gtk_list_store_set(list,&iter,1,str[0],2,str[1],3,str[2],4,str[3],5,str[4],-1);
if (strstr(dict->key," installed"))
gtk_list_store_set(list,&iter,0,1,-1);
}
}
}
char *yon_char_remove_brackets(char* source){
if (source){
char *src=yon_char_new(source);
if (src[0]=='\"') yon_char_divide_search(src,"\"",-1);
if (src[strlen(src)-1]=='\"') src=yon_char_divide_search(src,"\"",-1);
return src;
}
return NULL;
}
void yon_monitor_view_dictionary_destroy(void *window){
monitor_window *monitor=(monitor_window*)window;
gtk_widget_destroy(monitor->templateMonitorscreenOverlay);
}
/**void yon_setup_config(char *configcommand)
* [EN]
*/
void yon_setup_config(char *configcommand)
{
videoconfig.monitors=NULL;
if(videoconfig.monitor_visuals)
yon_dictionary_free_all(videoconfig.monitor_visuals,yon_monitor_view_dictionary_destroy);
videoconfig.monitor_visuals=NULL;
videoconfig.autoChooseDrivers=0;
videoconfig.configsize=0;
videoconfig.descreteOnly=0;
videoconfig.failsafeATI=NULL;
videoconfig.failsafenVidia=NULL;
videoconfig.gapfix=0;
videoconfig.loaded_config=NULL;
if(videoconfig.optirun)
free(videoconfig.optirun);
videoconfig.optirun=NULL;
if (videoconfig.primusrun)
free(videoconfig.primusrun);
videoconfig.primusrun=NULL;
if (videoconfig.ports)
for (int i=0;i<videoconfig.portssize;i++)
free(videoconfig.ports[i]);
videoconfig.ports=NULL;
videoconfig.portssize=0;
videoconfig.ports=yon_config_load(get_ports_command,&videoconfig.portssize);
int size = 0;
char *command = configcommand;
dictionary *dct;
for(int i=0; i<videoconfig.portssize;i++)
{
command = yon_char_get_augumented(command, XORG_MONITOR(yon_char_divide_search(yon_char_new(videoconfig.ports[i]),"\n",-1)));
}
videoconfig.configsize=0;
videoconfig.loaded_config = yon_ubl_load_global_config(command, &videoconfig.configsize);
char *param = NULL;
param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,"VGADRV_AUTO");
if (param){
yon_char_divide_search(param,"=",-1);
if (strcmp(param,"NO")!=0)
videoconfig.autoChooseDrivers=1;
}
param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,"FAILSAFENVIDIA");
if (param){
yon_char_divide_search(param,"=",-1);
if (strcmp(param,"")!=0)
videoconfig.failsafenVidia=yon_char_new(param);
}
param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,"FAILSAFEATI");
if (param){
yon_char_divide_search(param,"=",-1);
if (strcmp(param,"")!=0)
videoconfig.failsafeATI=yon_char_new(param);
}
param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,"OPTIRUN");
if (param){
yon_char_divide_search(param,"=",-1);
videoconfig.optirun=yon_char_remove_brackets(yon_char_new(param));
if (strcmp(videoconfig.optirun,"")==0) videoconfig.optirun=NULL;
}
param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,"PRIMUSRUN");
if (param){
yon_char_divide_search(param,"=",-1);
videoconfig.primusrun=yon_char_remove_brackets(yon_char_new(param));
if (strcmp(videoconfig.primusrun,"")==0) videoconfig.primusrun=NULL;
}
for (int i=0;i<videoconfig.portssize;i++){
videoconfig.ports[i] = yon_char_divide_search(videoconfig.ports[i],"\n",-1);
param=yon_config_get_parameter(videoconfig.loaded_config,videoconfig.configsize,XORG_MONITOR(videoconfig.ports[i]));
char *leftover=yon_char_new(param);
yon_char_divide_search(leftover,"=",-1);
if (param&&strcmp(leftover,"")!=0){
videoconfig.monitors = yon_monitor_config_new(videoconfig.ports[i]);
yon_char_divide_search(param,"=",-1);
yon_monitor_config_update(yon_dictionary_get_data(videoconfig.monitors,monitorconfig*),videoconfig.ports[i],param);
}
}
videoconfig.resolutions=yon_config_load(get_resolutions_supportable_command,&videoconfig.resolutionssize);
for (int i=0;i<videoconfig.resolutionssize;i++){
videoconfig.resolutions[i]=yon_char_divide_search(videoconfig.resolutions[i],"\n",-1);
}
}
/** monitor_config yon_monitor_config_new(char *port)
* [EN]
*/
monitor_config yon_monitor_config_new(char *port){
if (port){
monitorconfig *monitor=new(monitorconfig);
monitor->main=0;
monitor->enable=0;
monitor->position=0;
monitor->port=NULL;
monitor->position_port=NULL;
monitor->resolution=NULL;
monitor->resolutionCapabilities=NULL;
monitor->frequency=0;
monitor->rotation=0;
monitor->stringparameters=NULL;
monitor->dpms=0;
monitor->resolution_size=0;
monitor->cvt=0;
monitor->reduced=0;
monitor->gtf=0;
if (videoconfig.monitors)
videoconfig.monitors=yon_dictionary_create_with_data_connected(videoconfig.monitors,port,monitor);
else
videoconfig.monitors=yon_dictionary_create_with_data(port,monitor);
return videoconfig.monitors;
}
}
/**void yon_monitor_config_update(monitorconfig* monitor, char *port, char *config_string)
* [EN]
*/
void yon_monitor_config_update(monitorconfig* monitor, char *port, char *config_string){
if (port&&config_string){
monitor->stringparameters=yon_char_new(config_string);
int size=0;
config_str cnf = yon_char_parse(config_string,&size,",");
if (yon_char_parsed_check_exist(cnf,size,"primary")!=-1)
monitor->main=1;
if (yon_char_parsed_check_exist(cnf,size,"enable")!=-1)
monitor->enable=1;
if (yon_char_parsed_check_exist(cnf,size,"disable")!=-1)
monitor->enable=0;
// if (yon_char_parsed_check_exist(cnf,size,"ignore")==1)
// monitor->enable=0;
if (yon_char_parsed_check_exist(cnf,size,"LeftOf:")!=-1)
monitor->position=1;
if (yon_char_parsed_check_exist(cnf,size,"lo:")!=-1)
monitor->position=1;
if (yon_char_parsed_check_exist(cnf,size,"RightOf:")!=-1)
monitor->position=2;
if (yon_char_parsed_check_exist(cnf,size,"ro:")!=-1)
monitor->position=2;
if (yon_char_parsed_check_exist(cnf,size,"Below:")!=-1)
monitor->position=4;
if (yon_char_parsed_check_exist(cnf,size,"be:")!=-1)
monitor->position=4;
if (yon_char_parsed_check_exist(cnf,size,"Above:")!=-1)
monitor->position=3;
if (yon_char_parsed_check_exist(cnf,size,"ab:")!=-1)
monitor->position=3;
if (yon_char_parsed_check_exist(cnf,size,"rotate:left")!=-1)
monitor->rotation=1;
if (yon_char_parsed_check_exist(cnf,size,"rotate:right")!=-1)
monitor->rotation=2;
if (yon_char_parsed_check_exist(cnf,size,"rotate:invert")!=-1)
monitor->rotation=3;
if (yon_char_parsed_check_exist(cnf,size,"dpms")!=-1)
monitor->dpms=1;
if (yon_char_parsed_check_exist(cnf,size,"nodpms")!=-1)
monitor->dpms=0;
if (yon_char_parsed_check_exist(cnf,size,"cvt")!=-1)
monitor->cvt=1;
if (yon_char_parsed_check_exist(cnf,size,"reduced")!=-1)
monitor->reduced=1;
if (yon_char_parsed_check_exist(cnf,size,"r,")!=-1)
monitor->reduced=1;
if (yon_char_parsed_check_exist(cnf,size,"gtf")!=-1)
monitor->gtf=1;
}
}
char *yon_char_parsed_get_resolution(config_str parsed_string, int size){
char *left=NULL, *right=NULL, *freq=NULL;
for (int i=0;i<size;i++){
right=yon_char_new(parsed_string[i]);
left=yon_char_divide_search(right,"x",1);
if (freq=strstr(left,"x"))
left=yon_char_divide_search(left,"x",-1);
if (left&&right)
if (atoi(left)&&atoi(right))
return parsed_string[i];
}
return NULL;
}
void yon_monitor_view_new(monitor_config monitor){
GtkBuilder *builder = gtk_builder_new_from_file(glade_path);
monitor_window *window = new(monitor_window);
window->templateMonitorscreenOverlay=yon_gtk_builder_get_widget(builder,"templateMonitorscreenOverlay");
window->templateMonitorImage=yon_gtk_builder_get_widget(builder,"templateMonitorImage");
window->templateMonitorInfoBox=yon_gtk_builder_get_widget(builder,"templateMonitorInfoBox");
window->templateMonitorInfoNameLabel=yon_gtk_builder_get_widget(builder,"templateMonitorInfoNameLabel");
window->templateMonitorInfoResolutionLabel=yon_gtk_builder_get_widget(builder,"templateMonitorInfoResolutionLabel");
window->templateMonitorDeleteButton=yon_gtk_builder_get_widget(builder,"templateMonitorDeleteButton");
window->templateMonitorSwitchButton=yon_gtk_builder_get_widget(builder,"templateMonitorSwitchButton");
window->templateMonitorInfoConfigureButton=yon_gtk_builder_get_widget(builder,"templateMonitorInfoConfigureButton");
window->templateMonitorInfoAddButton=yon_gtk_builder_get_widget(builder,"templateMonitorInfoAddButton");
window->config=NULL;
gtk_overlay_add_overlay(GTK_OVERLAY(window->templateMonitorscreenOverlay),window->templateMonitorInfoBox);
if (monitor){
window->config=monitor;
gtk_widget_hide(window->templateMonitorInfoAddButton);
g_signal_connect(G_OBJECT(window->templateMonitorInfoConfigureButton), "clicked", G_CALLBACK(on_monitor_configure), window);
if (videoconfig.monitor_visuals) videoconfig.monitor_visuals = yon_dictionary_create_with_data_connected(videoconfig.monitor_visuals, window->config->key,window);
else videoconfig.monitor_visuals = yon_dictionary_create_with_data(window->config->key,window);
g_signal_connect(G_OBJECT(window->templateMonitorDeleteButton), "clicked", G_CALLBACK(on_monitor_delete), videoconfig.monitor_visuals);
g_signal_connect(G_OBJECT(window->templateMonitorSwitchButton), "clicked", G_CALLBACK(on_monitor_switch), window);
} else {
gtk_widget_show(window->templateMonitorInfoAddButton);
gtk_widget_hide(window->templateMonitorDeleteButton);
gtk_widget_hide(window->templateMonitorSwitchButton);
gtk_widget_hide(window->templateMonitorInfoConfigureButton);
g_signal_connect(G_OBJECT(window->templateMonitorInfoAddButton), "clicked", G_CALLBACK(on_monitor_add), window);
if (videoconfig.monitor_visuals) videoconfig.monitor_visuals = yon_dictionary_create_with_data_connected(videoconfig.monitor_visuals, "GENERIC",window);
else videoconfig.monitor_visuals = yon_dictionary_create_with_data("GENERIC",window);
}
}
void yon_monitor_set_resolutions(){
dictionary *dact=NULL;
int size_connected=0;
config_str connected_ports = yon_config_load(get_resolution_ports_command,&size_connected);
int resolutions_size=0;
config_str resolutions = yon_config_load(get_resolutions_command,&resolutions_size);
for (int i=0;i<size_connected;i++){
int a=atoi(yon_char_divide_search(connected_ports[i],":",-1));
int *cur_pos=new(int);
memcpy(cur_pos,&a,sizeof(int));
connected_ports[i]=yon_char_divide_search(connected_ports[i],"\n",-1);
connected_ports[i]=yon_char_divide_search(connected_ports[i]," ",-1);
yon_dictionary_add_or_create_if_exists_with_data(dact,connected_ports[i],cur_pos);
config_str resol=new(char*);
resolution_supported *supported=new(resolution_supported);
supported->line=resol;
supported->size=0;
yon_dictionary_add_or_create_if_exists_with_data(videoconfig.supported_resolutions,connected_ports[i],supported);
}
config_str final=NULL;
for(int i=0;i<resolutions_size;i++){
int cur_pos=atoi(yon_char_divide_search(resolutions[i],":",-1));
dictionary *dct=NULL;
char *port_for_res=NULL;
int equals=0;
for_dictionaries (dct,dact){
if (cur_pos==*((int*)dct->data)){
equals=1;
port_for_res=NULL;
}
if (cur_pos>*((int*)dct->data)&&equals==0)
port_for_res=yon_char_new(dct->key);
}
if(port_for_res){
dct=yon_dictionary_find(&videoconfig.supported_resolutions,port_for_res);
resolution_supported *sup=yon_dictionary_get_data(dct,resolution_supported*);
sup->size++;
sup->line=realloc(sup->line,sizeof(char*)*sup->size);
sup->line[sup->size-1]=yon_char_new(yon_char_divide_search(resolutions[i],"\n",-1));
}
}
}
void yon_adapter_window_setup(widgets_dict *widgets){
int size=0;
gtk_overlay_add_overlay(GTK_OVERLAY(widgets->InformationOverlay),widgets->InformationCompanyLogoImage);
config_str rtn=yon_config_load(get_adapter_info,&size);
char *desc = yon_config_get_parameter(rtn,size,"description");
yon_char_divide_search(desc,"=",-1);
char *product = yon_config_get_parameter(rtn,size,"product");
yon_char_divide_search(product,"=",-1);
char *vendor = yon_config_get_parameter(rtn,size,"vendor");
yon_char_divide_search(vendor,"=",-1);
char *driver_use = yon_config_get_parameter(rtn,size,"Kernel_driver_in_use");
yon_char_divide_search(driver_use,"=",-1);
char *driver_all = yon_config_get_parameter(rtn,size,"Kernel_modules");
yon_char_divide_search(driver_all,"=",-1);
char *final_text = yon_char_unite("<span size=\"12pt\"><span weight='bold' color='#1a5fb4'>",DESCRIPTION_LABEL,":</span> ",_(desc),
"\n<span weight='bold' color='#1a5fb4'>",VENDOR_LABEL,":</span> ",vendor,
"\n<span weight='bold' color='#1a5fb4'>",MODEL_LABEL,":</span> ",product,
"\n<span weight='bold' color='#1a5fb4'>",USED_KERNEL_DRIVER_LABEL,":</span> ",driver_use,
"\n<span weight='bold' color='#1a5fb4'>",AVALIABLE_KERNEL_DRIVERS_LABEL,":</span> ",driver_all,"</span>",NULL);
gtk_label_set_markup(GTK_LABEL(gtk_builder_get_object(widgets->builder,"InformationLabel")),final_text);
if (strstr(vendor,"Intel")){
GtkIconTheme *icthm=gtk_icon_theme_get_default();
gtk_image_set_from_pixbuf(GTK_IMAGE(widgets->InformationCompanyLogoImage),gtk_icon_info_load_icon(gtk_icon_theme_lookup_icon_for_scale(icthm, "com.ublinux.ubl-settings-video.intel-logo",64,1,GTK_ICON_LOOKUP_FORCE_SVG),NULL));
}
else if (strstr(vendor,"NVidia")){
GtkIconTheme *icthm=gtk_icon_theme_get_default();
gtk_image_set_from_pixbuf(GTK_IMAGE(widgets->InformationCompanyLogoImage),gtk_icon_info_load_icon(gtk_icon_theme_lookup_icon_for_scale(icthm, "com.ublinux.ubl-settings-video.nvidia-logo",64,1,GTK_ICON_LOOKUP_FORCE_SVG),NULL));
}
else if (strstr(vendor,"AMD")){
GtkIconTheme *icthm=gtk_icon_theme_get_default();
gtk_image_set_from_pixbuf(GTK_IMAGE(widgets->InformationCompanyLogoImage),gtk_icon_info_load_icon(gtk_icon_theme_lookup_icon_for_scale(icthm, "com.ublinux.ubl-settings-video.amd-logo",64,1,GTK_ICON_LOOKUP_FORCE_SVG),NULL));
}
else {
gtk_widget_destroy(widgets->InformationCompanyLogoImage);
}
}
/** void yon_setup_widgets(widgets_dict *widgets)
* [EN]
* Sets up every element on main window
* [RU]
*
* */
void yon_setup_widgets(widgets_dict *widgets)
{
widgets->builder = gtk_builder_new_from_file(glade_path);
widgets->appsPackWindow = yon_gtk_builder_get_widget(widgets->builder, "appsPackWindow");
widgets->appsPackBox = yon_gtk_builder_get_widget(widgets->builder, "appsPackBox");
widgets->MainWindow = yon_gtk_builder_get_widget(widgets->builder, "MainWindow");
widgets->headBox = yon_gtk_builder_get_widget(widgets->builder, "headBox");
widgets->headInfoLabel = yon_gtk_builder_get_widget(widgets->builder, "headInfoLabel");
widgets->mainPlugBox = yon_gtk_builder_get_widget(widgets->builder, "mainPlugBox");
widgets->mainErrorBox = yon_gtk_builder_get_widget(widgets->builder, "mainErrorBox");
widgets->mainHeadOverlay = yon_gtk_builder_get_widget(widgets->builder, "mainHeadOverlay");
widgets->extraOptirunChooseAppsButton = yon_gtk_builder_get_widget(widgets->builder, "extraOptirunChooseAppsButton");
widgets->extraPrimusunChooseAppsButton = yon_gtk_builder_get_widget(widgets->builder, "extraPrimusunChooseAppsButton");
widgets->mainHeadBackgroundImage = yon_gtk_builder_get_widget(widgets->builder, "mainHeadBackgroundImage");
widgets->mainDriverAutomaticallyChooseCheck = yon_gtk_builder_get_widget(widgets->builder, "mainDriverAutomaticallyChooseCheck");
widgets->mainDriverFailsafeNvidiaLabel = yon_gtk_builder_get_widget(widgets->builder, "mainDriverFailsafeNvidiaLabel");
widgets->mainDriverFailsafeAMDLabel = yon_gtk_builder_get_widget(widgets->builder, "mainDriverFailsafeAMDLabel");
widgets->mainExtraFixGapCombo = yon_gtk_builder_get_widget(widgets->builder, "mainExtraFixGapCombo");
widgets->mainDriverFailsafeNvidiaCombo = yon_gtk_builder_get_widget(widgets->builder, "mainDriverFailsafeNvidiaCombo");
widgets->mainDriverFailsafeAMDCombo = yon_gtk_builder_get_widget(widgets->builder, "mainDriverFailsafeAMDCombo");
widgets->mainDriverFrameLabel = yon_gtk_builder_get_widget(widgets->builder, "mainDriverFrameLabel");
widgets->monitorConfigurationMethodLabel = yon_gtk_builder_get_widget(widgets->builder, "monitorConfigurationMethodLabel");
widgets->monitorConfigurationMethodCombo = yon_gtk_builder_get_widget(widgets->builder, "monitorConfigurationMethodCombo");
widgets->mainMonitorVisualConfigurationBox = yon_gtk_builder_get_widget(widgets->builder, "mainMonitorVisualConfigurationBox");
widgets->mainMonitorConfigurationBox = yon_gtk_builder_get_widget(widgets->builder, "mainMonitorConfigurationBox");
widgets->mainMonitorConfigurationFrameLabel = yon_gtk_builder_get_widget(widgets->builder, "mainMonitorConfigurationFrameLabel");
widgets->mainHybridGraphicsDiscreteLabel = yon_gtk_builder_get_widget(widgets->builder, "mainHybridGraphicsDiscreteLabel");
widgets->mainHybridGraphicsDiscreteCheck = yon_gtk_builder_get_widget(widgets->builder, "mainHybridGraphicsDiscreteCheck");
widgets->mainHybridGraphicsFrameLabel = yon_gtk_builder_get_widget(widgets->builder, "mainHybridGraphicsFrameLabel");
widgets->mainExtraLaunchOptirunCheck = yon_gtk_builder_get_widget(widgets->builder, "mainExtraLaunchOptirunCheck");
widgets->mainExtraLaunchPrismusunCheck = yon_gtk_builder_get_widget(widgets->builder, "mainExtraLaunchPrismusunCheck");
widgets->mainExtraFixGapLabel = yon_gtk_builder_get_widget(widgets->builder, "mainExtraFixGapLabel");
widgets->mainExtraLaunchOptirunEntry = yon_gtk_builder_get_widget(widgets->builder, "mainExtraLaunchOptirunEntry");
widgets->mainExtraLaunchPrismusunEntry = yon_gtk_builder_get_widget(widgets->builder, "mainExtraLaunchPrismusunEntry");
widgets->mainExtraFixGapLabelCombo = yon_gtk_builder_get_widget(widgets->builder, "mainExtraFixGapLabelCombo");
widgets->mainExtraLaunchThroughButton = yon_gtk_builder_get_widget(widgets->builder, "mainExtraLaunchThroughButton");
widgets->mainExtraFrameLabel = yon_gtk_builder_get_widget(widgets->builder, "mainExtraFrameLabel");
widgets->mainHeaderTitleLabel = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderTitleLabel");
widgets->mainHeaderLoadButton = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderLoadButton");
widgets->mainHeaderConfigLoadLabel = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderConfigLoadLabel");
widgets->mainHeaderSaveConfigurationLabel = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSaveConfigurationLabel");
widgets->mainHeaderSaveButton = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSaveButton");
widgets->mainHeaderSettingsButton = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSettingsButton");
widgets->mainHeaderLoadGlobalMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderLoadGlobalMenuItem");
widgets->mainHeaderLoadLocalMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderLoadLocalMenuItem");
widgets->mainHeaderSaveGlobalLocalMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSaveGlobalLocalMenuItem");
widgets->mainHeaderSaveGlobalMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSaveGlobalMenuItem");
widgets->mainHeaderSaveLocalMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSaveLocalMenuItem");
widgets->mainHeaderSettingsDocumentationMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSettingsDocumentationMenuItem");
widgets->mainHeaderSettingsAboutMenuItem = yon_gtk_builder_get_widget(widgets->builder, "mainHeaderSettingsAboutMenuItem");
widgets->mainStatusBox = yon_gtk_builder_get_widget(widgets->builder, "mainStatusBox");
widgets->mainStatusIcon = yon_gtk_builder_get_widget(widgets->builder, "mainStatusIcon");
widgets->mainStatusLabel = yon_gtk_builder_get_widget(widgets->builder, "mainStatusLabel");
widgets->templateMonitorConfigurationBox = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationBox");
widgets->templateMonitorConfigurationMonitorLabel = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationMonitorLabel");
widgets->templateMonitorConfigurationResolutionLabel = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationResolutionLabel");
widgets->templateMonitorConfigurationResolutionCombo = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationResolutionCombo");
widgets->templateMonitorConfigurationFrequencyLabel = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationFrequencyLabel");
widgets->templateMonitorConfigurationFrequencyCombo = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationFrequencyCombo");
widgets->templateMonitorConfigurationRotationLabel = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationRotationLabel");
widgets->templateMonitorConfigurationRotationCombo = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationRotationCombo");
widgets->templateMonitorConfigurationMainRadio = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationMainRadio");
widgets->templateMonitorConfigurationParameterLineCheck = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationParameterLineCheck");
widgets->templateMonitorConfigurationParameterLineEntry = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationParameterLineEntry");
widgets->templateMonitorConfigurationDoNotSwitchOffLabel = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationDoNotSwitchOffLabel");
widgets->templateMonitorConfigurationDoNotSwitchOffCheck = yon_gtk_builder_get_widget(widgets->builder, "templateMonitorConfigurationDoNotSwitchOffCheck");
widgets->PlugBox = yon_gtk_builder_get_widget(widgets->builder, "mainPlugBox");
widgets->PlugSaveBox = yon_gtk_builder_get_widget(widgets->builder, "plugLoadButton");
widgets->PlugLoadBox = yon_gtk_builder_get_widget(widgets->builder, "plugSaveButton");
widgets->proprietaryTreeView = yon_gtk_builder_get_widget(widgets->builder, "proprietaryTreeView");
widgets->proprietaryInfoButton = yon_gtk_builder_get_widget(widgets->builder, "proprietaryInfoButton");
widgets->proprietaryDeleteButton = yon_gtk_builder_get_widget(widgets->builder, "proprietaryDeleteButton");
widgets->proprietaryInstallButton = yon_gtk_builder_get_widget(widgets->builder, "proprietaryInstallButton");
widgets->proprietaryTreeSelection = GTK_TREE_SELECTION(gtk_builder_get_object(widgets->builder, "proprietaryTreeSelection"));
widgets->driversTreeView = yon_gtk_builder_get_widget(widgets->builder, "driversTreeView");
widgets->driversInfoButton = yon_gtk_builder_get_widget(widgets->builder, "driversInfoButton");
widgets->driversDeleteButton = yon_gtk_builder_get_widget(widgets->builder, "driversDeleteButton");
widgets->driversInstallButton = yon_gtk_builder_get_widget(widgets->builder, "driversInstallButton");
widgets->TerminalOverlay = yon_gtk_builder_get_widget(widgets->builder, "TerminalOverlay");
widgets->MenusTab = yon_gtk_builder_get_widget(widgets->builder, "MenusTab");
widgets->driversTreeSelection = GTK_TREE_SELECTION(gtk_builder_get_object(widgets->builder, "driversTreeSelection"));
widgets->proprietartInstalledColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "proprietartInstalledColumn"));
widgets->ProprietaryPackageColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "ProprietaryPackageColumn"));
widgets->ProprietaryDriverColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "ProprietaryDriverColumn"));
widgets->ProprietaryDescriptionColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "ProprietaryDescriptionColumn"));
widgets->ProprietarySupportedColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "ProprietarySupportedColumn"));
widgets->DriverModulesTab = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "DriverModulesTab"));
widgets->DriversTab = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "DriversTab"));
widgets->MainTabLabel = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "MainTabLabel"));
widgets->DriversTabLabel = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "DriversTabLabel"));
widgets->InformationTabLabel = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "InformationTabLabel"));
widgets->InformationFrameLabel = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "InformationFrameLabel"));
widgets->InformationOverlay = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "InformationOverlay"));
widgets->InformationCompanyLogoImage = GTK_WIDGET(gtk_builder_get_object(widgets->builder, "InformationCompanyLogoImage"));
widgets->driverInstalledColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "driverInstalledColumn"));
widgets->driverPackageColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "driverPackageColumn"));
widgets->driverDriverColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "driverDriverColumn"));
widgets->driverDescriptionColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "driverDescriptionColumn"));
widgets->driverSupportedColumn = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(widgets->builder, "driverSupportedColumn"));
gtk_window_set_title(GTK_WINDOW(widgets->MainWindow),TITLE_LABEL);
videoconfig.list = GTK_LIST_STORE(gtk_builder_get_object(widgets-> builder, "liststore6"));
gtk_tree_view_set_model(GTK_TREE_VIEW(widgets->proprietaryTreeView),GTK_TREE_MODEL(videoconfig.list));
g_signal_connect(G_OBJECT(widgets->MenusTab), "switch-page", G_CALLBACK(on_proprietary_get), widgets);
g_signal_connect(G_OBJECT(widgets->proprietaryDeleteButton), "clicked", G_CALLBACK(on_driver_pack_delete), widgets);
g_signal_connect(G_OBJECT(widgets->proprietaryInstallButton), "clicked", G_CALLBACK(on_driver_pack_install), widgets);
g_signal_connect(G_OBJECT(widgets->proprietaryInfoButton), "clicked", G_CALLBACK(on_driver_pack_info), widgets);
g_signal_connect(G_OBJECT(widgets->driversDeleteButton), "clicked", G_CALLBACK(on_driver_delete), widgets);
g_signal_connect(G_OBJECT(widgets->driversInstallButton), "clicked", G_CALLBACK(on_driver_install), widgets);
g_signal_connect(G_OBJECT(widgets->driversInfoButton), "clicked", G_CALLBACK(on_driver_info), widgets);
g_signal_connect(G_OBJECT(widgets->mainDriverAutomaticallyChooseCheck), "toggled", G_CALLBACK(on_auto_choose_drivers), widgets);
// g_signal_connect(G_OBJECT(widgets->mainHybridGraphicsDiscreteCheck), "toggled", G_CALLBACK(on_sensitive_change), widgets);
g_signal_connect(G_OBJECT(widgets->mainExtraLaunchOptirunCheck), "toggled", G_CALLBACK(on_sensitive_change), widgets->mainExtraLaunchOptirunEntry);
g_signal_connect(G_OBJECT(widgets->mainExtraLaunchPrismusunCheck), "toggled", G_CALLBACK(on_sensitive_change), widgets->mainExtraLaunchPrismusunEntry);
g_signal_connect(G_OBJECT(widgets->mainExtraLaunchOptirunCheck), "toggled", G_CALLBACK(on_sensitive_change), widgets->extraOptirunChooseAppsButton);
g_signal_connect(G_OBJECT(widgets->mainExtraLaunchPrismusunCheck), "toggled", G_CALLBACK(on_sensitive_change), widgets->extraPrimusunChooseAppsButton);
g_signal_connect(G_OBJECT(widgets->MainWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
// g_signal_connect(G_OBJECT(widgets->extraOptirunChooseAppsButton), "clicked", G_CALLBACK(on_apps_chooser_open), widgets);
// g_signal_connect(G_OBJECT(widgets->extraPrimusunChooseAppsButton), "clicked", G_CALLBACK(on_apps_chooser_open), widgets);
g_signal_connect(G_OBJECT(widgets->mainHeaderSettingsAboutMenuItem), "activate", G_CALLBACK(on_about), NULL);
g_signal_connect(G_OBJECT(widgets->mainHeaderSettingsDocumentationMenuItem), "activate", G_CALLBACK(on_about), NULL);
g_signal_connect(G_OBJECT(widgets->mainHeaderLoadGlobalMenuItem), "activate", G_CALLBACK(on_configuration_load_global), widgets);
g_signal_connect(G_OBJECT(widgets->mainHeaderLoadLocalMenuItem), "activate", G_CALLBACK(on_configuration_load_local), widgets);
g_signal_connect(G_OBJECT(widgets->mainHeaderSaveGlobalLocalMenuItem), "activate", G_CALLBACK(on_configuration_save_local_global), widgets);
g_signal_connect(G_OBJECT(widgets->mainHeaderSaveGlobalMenuItem), "activate", G_CALLBACK(on_configuration_save_global), widgets);
g_signal_connect(G_OBJECT(widgets->mainHeaderSaveLocalMenuItem), "activate", G_CALLBACK(on_configuration_save_local), widgets);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo), OFF_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeNvidiaCombo), FBDEV_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo), OFF_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainDriverFailsafeAMDCombo), FBDEV_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainExtraFixGapCombo), GAP_FIX_1_LABEL);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widgets->mainExtraFixGapCombo), GAP_FIX_2_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->headInfoLabel), HEADER_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->mainDriverFailsafeNvidiaLabel), FAILSAFE_NVIDIA_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->mainDriverFailsafeAMDLabel), FAILSAFE_ATI_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->mainDriverFrameLabel), DRIVER_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->mainMonitorConfigurationFrameLabel), MONITOR_CONFIGURATION_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->mainHybridGraphicsFrameLabel), HYBRID_GRAPHICS_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->mainExtraFixGapLabel), FIX_GAP_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->mainExtraFrameLabel), EXTRA_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->mainHeaderTitleLabel), TITLE_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->mainHeaderConfigLoadLabel), LOAD_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->mainHeaderSaveConfigurationLabel), SAVE_LABEL);
gtk_button_set_label(GTK_BUTTON(widgets->mainHybridGraphicsDiscreteCheck), ON_LABEL);
gtk_button_set_label(GTK_BUTTON(widgets->mainDriverAutomaticallyChooseCheck), AUTO_CHOOSE_DRIVERS_LABEL);
gtk_button_set_label(GTK_BUTTON(widgets->mainExtraLaunchOptirunCheck), LAUNCH_OPTIRUN_LABEL);
gtk_button_set_label(GTK_BUTTON(widgets->mainExtraLaunchPrismusunCheck), LAUNCH_PRIMUSRUN_LABEL);
gtk_button_set_label(GTK_BUTTON(widgets->mainHybridGraphicsDiscreteCheck), DISCRETE_ONLY_LABEL);
gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderLoadGlobalMenuItem), LOAD_GLOBAL_LABEL);
gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderLoadLocalMenuItem), LOAD_LOCAL_LABEL);
gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSaveGlobalLocalMenuItem), SAVE_GLOBAL_LOCAL_LABEL);
gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSaveGlobalMenuItem), SAVE_GLOBAL_LABEL);
gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSaveLocalMenuItem), SAVE_LOCAL_LABEL);
gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSettingsDocumentationMenuItem), DOCUMENTATION_LABEL);
gtk_menu_item_set_label(GTK_MENU_ITEM(widgets->mainHeaderSettingsAboutMenuItem), ABOUT_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->DriverModulesTab), DRIVER_MODULES_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->DriversTab), DRIVERS_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->MainTabLabel), MAIN_SETTINGS_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->DriversTabLabel), DRIVERS_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->InformationTabLabel), INFORMATION_LABEL);
gtk_label_set_text(GTK_LABEL(widgets->InformationFrameLabel), DEVICES_DRIVERS_LABEL);
gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), INSTALLED_LABEL);
gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), PACKAGE_LABEL);
gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), SUPPORTED_LABEL);
gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDriverColumn), DRIVER_LABEL);
gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(widgets->ProprietaryDescriptionColumn), DESCRIPTION_LABEL);
yon_ubl_header_setup(widgets->mainHeadOverlay, widgets->headBox, widgets->mainHeadBackgroundImage, banner_path);
yon_monitor_view_setup(widgets->mainMonitorVisualConfigurationBox);
videoconfig.status_render.icon=widgets->mainStatusIcon;
videoconfig.status_render.label=widgets->mainStatusLabel;
videoconfig.status_render.box=widgets->mainStatusBox;
if (videoconfig.lock_load_global==1)
gtk_widget_set_sensitive(widgets->mainHeaderLoadGlobalMenuItem,0);
if (videoconfig.lock_save_global==1)
gtk_widget_set_sensitive(widgets->mainHeaderSaveGlobalMenuItem,0);
if (videoconfig.lock_save_local==1)
gtk_widget_set_sensitive(widgets->mainHeaderSaveLocalMenuItem,0);
if (videoconfig.lock_save_global==1||videoconfig.lock_save_local==1)
gtk_widget_set_sensitive(widgets->mainHeaderSaveGlobalLocalMenuItem,0);
}
int main(int argc, char *argv[])
{
{
int show_help=0;
videoconfig.socket_id=-1;
videoconfig.save_socket_id=-1;
videoconfig.load_socket_id=-1;
videoconfig.lock_help=-1;
videoconfig.lock_load_global=-1;
videoconfig.lock_save_global=-1;
videoconfig.lock_save_local=-1;
local = setlocale(LC_ALL, "");
textdomain(LocaleName);
int option_index=0;
struct option long_options[] = {
{"help", 0, 0, 'h'},
{"version", 0, 0, 'V'},
{"lock-help", 0,0, 1},
// {"lock-settings", 0,0, -16},
{"lock-save", 0,0, 2},
{"lock-save-local", 0,0, 3},
{"lock-save-global", 0,0, 4},
{"lock-load-global", 0,0, 5},
{"socket-id", 1, 0, 's'},
{"socket-ext-id", 1,0, 'e'},
{"socket-trd-id", 1,0, 't'},
{ NULL, 0, NULL, 0 }
};
for (int i=0;i<argc;i++){
int argument=getopt_long(argc,argv,"hVvs:e:t:",long_options,&option_index);
switch(argument){
case 'h':
show_help=1;
break;
case 'v':
case 'V':
printf("%s\n",VERSION_LABEL);
exit(0);
break;
case 's':
if(optarg)
videoconfig.socket_id=atoi(optarg);
break;
case 'e':
if(optarg)
videoconfig.load_socket_id=atoi(optarg);
break;
case 't':
if(optarg)
videoconfig.save_socket_id=atoi(optarg);
break;
case 1:
videoconfig.lock_help=1;
break;
// case -16:
// break;
case 2:
videoconfig.lock_save_local=1;
videoconfig.lock_save_global=1;
break;
case 3:
videoconfig.lock_save_local=1;
break;
case 4:
videoconfig.lock_save_global=1;
break;
case 5:
videoconfig.lock_load_global=1;
break;
}
}
if (show_help==1&&videoconfig.lock_help==-1){
printf("%s\n",HELP_LABEL);
exit(0);
}
}
if (getuid()!=0){
system("/usr/bin/pkexec ubl-settings-video");
return 0;
} else {
gtk_init(&argc, &argv);
GError error;
yon_setup_config(load_drivers_local_command);
widgets_dict widgets;
yon_setup_widgets(&widgets);
// yon_gtk_list_store_fill_with_proprietaries(videoconfig.list);
// yon_gtk_list_store_fill_with_proprietaries(videoconfig.modulelist);
gtk_widget_show(widgets.MainWindow);
// yon_fill_ui(&widgets);
videoconfig.status_render.text_to_render=LOCAL_LOAD_SUCCESS;
videoconfig.status_render.type=BACKGROUND_IMAGE_SUCCESS_TYPE;
yon_ubl_status_box_render(&videoconfig.status_render);
on_config_fill_interface(&widgets);
yon_monitor_set_resolutions();
yon_adapter_window_setup(&widgets);
GtkCssProvider *css = gtk_css_provider_new();
gtk_css_provider_load_from_path(css, CssPath, NULL);
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(),
GTK_STYLE_PROVIDER(css),
-1);
yon_monitor_view_update();
yon_ubl_setup_sockets(widgets.PlugBox,widgets.PlugLoadBox,widgets.PlugSaveBox,videoconfig.socket_id,videoconfig.load_socket_id,videoconfig.save_socket_id);
gtk_main();
return 0;
}
}
Reference in new issue View Git Blame Copy Permalink