master #121

Merged
asmeron merged 9 commits from YanTheKaller/ubl-settings-video:master into master 5 months ago

@ -298,7 +298,7 @@ msgid "Package"
msgstr ""
#: source/ubl-strings.h:61
msgid "Supported Devices"
msgid "Supported devices"
msgstr ""
#: source/ubl-strings.h:62
@ -569,39 +569,43 @@ msgstr ""
msgid "Devices and Drivers"
msgstr ""
#: source/ubl-strings.h:152
#: source/ubl-strings.h:151
msgid "Unlock the pacman package manager database"
msgstr ""
#: source/ubl-strings.h:153
msgid "Database files must be updated"
msgstr ""
#: source/ubl-strings.h:154
#: source/ubl-strings.h:155
msgid "Warning: Couldn't find any supported kernel version"
msgstr ""
#: source/ubl-strings.h:156
#: source/ubl-strings.h:157
msgid "Default (All installed)"
msgstr ""
#: source/ubl-strings.h:157
#: source/ubl-strings.h:158
msgid "Driver installation has failed"
msgstr ""
#: source/ubl-strings.h:158
#: source/ubl-strings.h:159
msgid "Operation has failed"
msgstr ""
#: source/ubl-strings.h:160
#: source/ubl-strings.h:161
msgid "Are you sure want to install driver "
msgstr ""
#: source/ubl-strings.h:161
#: source/ubl-strings.h:162
msgid "Are you sure want to remove driver "
msgstr ""
#: source/ubl-strings.h:162
#: source/ubl-strings.h:163
msgid "Attention!"
msgstr ""
#: source/ubl-strings.h:162
#: source/ubl-strings.h:163
msgid ""
"If you work in sandbox mode, you must install the package with the module!"
msgstr ""

@ -300,7 +300,7 @@ msgid "Package"
msgstr "Пакет"
#: source/ubl-strings.h:61
msgid "Supported Devices"
msgid "Supported devices"
msgstr "Поддерживаемые устройства"
#: source/ubl-strings.h:62
@ -576,43 +576,47 @@ msgstr "Модули драйвера"
msgid "Devices and Drivers"
msgstr "Устройства и драйвера"
#: source/ubl-strings.h:152
#: source/ubl-strings.h:151
msgid "Unlock the pacman package manager database"
msgstr "Разблокировать базу данных пакетного менеджера pacman"
#: source/ubl-strings.h:153
msgid "Database files must be updated"
msgstr "Базы данных репозитория должны быть обновлены"
#: source/ubl-strings.h:154
#: source/ubl-strings.h:155
msgid "Warning: Couldn't find any supported kernel version"
msgstr "Предупреждение: Поддерживаемые версии ядра не найдены"
#: source/ubl-strings.h:156
#: source/ubl-strings.h:157
msgid "Default (All installed)"
msgstr "По умолчанию (все установленные)"
#: source/ubl-strings.h:157
#: source/ubl-strings.h:158
msgid "Driver installation has failed"
msgstr "Установка драйвера завершена с ошибкой"
#: source/ubl-strings.h:158
#: source/ubl-strings.h:159
msgid "Operation has failed"
msgstr "Операция завершена с ошибкой"
#: source/ubl-strings.h:160
#: source/ubl-strings.h:161
msgid "Are you sure want to install driver "
msgstr "Вы уверены, что хотите установить драйвер "
#: source/ubl-strings.h:161
#: source/ubl-strings.h:162
msgid "Are you sure want to remove driver "
msgstr "Вы уверены, что хотите удалить драйвер "
#: source/ubl-strings.h:162
#: source/ubl-strings.h:163
msgid "Attention!"
msgstr "Внимание!"
#: source/ubl-strings.h:162
#: source/ubl-strings.h:163
msgid ""
"If you work in sandbox mode, you must install the package with the module!"
msgstr ""
"Если вы работаете в режиме песочницы необходимо установить пакет с модулем!"
msgid "Driver modules"
msgstr "Модули драйвера"
#~ msgid "Driver modules"
#~ msgstr "Модули драйвера"

@ -89,6 +89,7 @@ set(SOURCE_FILES
ubl-settings-video.c
ubl-settings-video-driver.c
ubl-settings-video-install.c
ubl-settings-video-monitor.c
ubl-settings-video.h
ubl-strings.h
)

@ -65,6 +65,232 @@ void on_link_activate(GtkWidget *, char*, driver_struct *driver){
on_devices_info_clicked(NULL,driver);
}
void on_pacman_db_unlock(void){
yon_launch(pacman_unlock_database_command);
yon_ubl_status_box_render(yon_char_get_localised_from_lib(SUCCESS_LABEL),BACKGROUND_IMAGE_SUCCESS_TYPE);
}
void on_terminal_done(GtkWidget *, int , main_window *widgets){
vte_terminal_feed_child(VTE_TERMINAL(widgets->InstallTerminal),"^C",2);
}
void on_terminal_more(GtkWidget *, main_window *widgets){
int active = gtk_revealer_get_child_revealed(GTK_REVEALER(widgets->TerminalMoreRevieler));
if (active ==1) active = 0;
else active=1;
gtk_revealer_set_reveal_child(GTK_REVEALER(widgets->TerminalMoreRevieler),active);
}
gboolean on_command_execute_success(GtkWidget *self,gint status,main_window *widgets){
yon_install_buttons_set_sensitive(widgets,1);
vte_terminal_set_input_enabled(VTE_TERMINAL(self),0);
g_mutex_lock(&main_config.progress_mutex);
main_config.progress_active=0;
g_mutex_unlock(&main_config.progress_mutex);
if (!status){
if (gtk_widget_get_visible(widgets->TerminalPaned)){
on_terminal_revealer_open(NULL,widgets);
}
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 {
if (!gtk_widget_get_visible(widgets->TerminalPaned)){
on_terminal_revealer_open(NULL,widgets);
}
yon_ubl_status_box_render(yon_char_get_localised_from_lib(FAIL_LABEL),BACKGROUND_IMAGE_FAIL_TYPE);
}
while(gtk_events_pending()) gtk_main_iteration();
on_terminal_done(self,0,widgets);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(widgets->TerminalInfoLabel),0);
return G_SOURCE_REMOVE;
}
gboolean on_terminal_check_progress(main_window *widgets){
g_mutex_lock(&main_config.progress_mutex);
if (!main_config.progress_active){
g_mutex_unlock(&main_config.progress_mutex);
return G_SOURCE_REMOVE;
}
gtk_progress_bar_pulse(GTK_PROGRESS_BAR(widgets->TerminalInfoLabel));
g_mutex_unlock(&main_config.progress_mutex);
return G_SOURCE_CONTINUE;
}
void on_command_cancel(GtkWidget *,main_window *widgets){
g_mutex_lock(&main_config.progress_mutex);
main_config.progress_active=0;
g_mutex_unlock(&main_config.progress_mutex);
on_terminal_done(NULL,0,widgets);
yon_launch(pacman_unlock_database_command);
}
void on_driver_pack_selection_change(GtkWidget *, GtkListBoxRow *selection, main_window *widgets){
if (selection){
driver_struct *driver = g_object_get_data(G_OBJECT(selection),"driver_struct");
if (driver->supported_devices_avaliable){
gtk_widget_set_sensitive(widgets->SupportedDevicesButton,1);
} else {
gtk_widget_set_sensitive(widgets->SupportedDevicesButton,0);
}
gtk_widget_set_sensitive(widgets->AboutModuleButton,1);
gtk_widget_set_sensitive(widgets->AboutPackageButton,1);
} else {
gtk_widget_set_sensitive(widgets->SupportedDevicesButton,0);
gtk_widget_set_sensitive(widgets->AboutModuleButton,0);
gtk_widget_set_sensitive(widgets->AboutPackageButton,0);
}
}
gpointer yon_driver_info_launch(void *command){
if (!system((char*)command)){
yon_ubl_status_box_render_thread(yon_char_get_localised_from_lib(SUCCESS_LABEL),BACKGROUND_IMAGE_SUCCESS_TYPE);
} else {
yon_ubl_status_box_render_thread(yon_char_get_localised_from_lib(FAIL_LABEL),BACKGROUND_IMAGE_SUCCESS_TYPE);
}
return NULL;
}
void on_driver_pack_info(GtkWidget *, main_window *widgets){
GtkWidget *selection = GTK_WIDGET(gtk_list_box_get_selected_row(GTK_LIST_BOX(widgets->DriversList)));
if (selection){
driver_struct *driver = g_object_get_data(G_OBJECT(selection),"driver_struct");
yon_ubl_status_box_render(yon_char_get_localised_from_lib(INFO_PROCESS_LABEL),BACKGROUND_IMAGE_INFO_TYPE);
char *command = get_info_proprietary_command(driver->package);
g_thread_new("info_thread",yon_driver_info_launch,(void*)command);
} else {
yon_ubl_status_box_render(PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
void on_driver_module_info(GtkWidget *, main_window *widgets){
GtkWidget *selection = GTK_WIDGET(gtk_list_box_get_selected_row(GTK_LIST_BOX(widgets->DriversList)));
if (selection){
driver_struct *driver = g_object_get_data(G_OBJECT(selection),"driver_struct");
yon_ubl_status_box_render(yon_char_get_localised_from_lib(INFO_PROCESS_LABEL),BACKGROUND_IMAGE_INFO_TYPE);
char *command = get_info_proprietary_command(driver->module);
g_thread_new("info_thread",yon_driver_info_launch,(void*)command);
} else {
yon_ubl_status_box_render(PROPRIETARY_NOTHING_SELECTED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
}
}
gboolean yon_filter_func(GtkTreeModel* model,GtkTreeIter* iter,main_window *widgets){
const char *target = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->KernelsCombo));
char *cur;
gtk_tree_model_get(model,iter,2,&cur,-1);
if (!yon_char_is_empty(cur)&&!yon_char_is_empty(target)&&!strcmp(cur,target))return 1;
return 0;
}
void on_kernel_filter_changed(GtkWidget *self, main_window *widgets){
const char *active = gtk_combo_box_get_active_id(GTK_COMBO_BOX(self));
if (!yon_char_is_empty(active)){
GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->DriversList));
for (GList *iter = list; iter; iter=iter->next){
driver_struct *driver = g_object_get_data(G_OBJECT(iter->data),"driver_struct");
if (!strcmp(driver->kernel,active)){
gtk_widget_show(GTK_WIDGET(iter->data));
} else {
gtk_widget_hide(GTK_WIDGET(iter->data));
}
}
g_list_free(list);
} else {
GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->DriversList));
for (GList *iter = list; iter; iter=iter->next){
gtk_widget_show(GTK_WIDGET(iter->data));
}
g_list_free(list);
}
}
gboolean yon_proprietary_clear(main_window *widgets){
GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->DriversList));
GList *iter = NULL;
for (iter = list; iter; iter=iter->next){
driver_struct *driver = g_object_get_data(G_OBJECT(iter->data),"driver_struct");
free(driver->name);
free(driver->module);
free(driver->package);
free(driver->kernel);
free(driver->description);
free(driver->devices);
gtk_widget_destroy(GTK_WIDGET(iter->data));
}
return G_SOURCE_REMOVE;
}
void yon_drivers_resize(main_window *widgets){
GList *list = gtk_container_get_children(GTK_CONTAINER(widgets->DriversList));
GList *iter;
int module_width=0;
int package_width=0;
int kernel_width=0;
int driver_width=0;
int description_width=0;
gtk_widget_get_preferred_width(widgets->InstalledModuleLabel,&module_width,NULL);
gtk_widget_get_preferred_width(widgets->InstalledPackageLabel,&package_width,NULL);
gtk_widget_get_preferred_width(widgets->KernelLabel,&kernel_width,NULL);
gtk_widget_get_preferred_width(widgets->DriverLabel,&driver_width,NULL);
gtk_widget_get_preferred_width(widgets->DescriptionLabel,NULL,&description_width);
for (iter = list;iter;iter=iter->next){
driver_struct *data = g_object_get_data(G_OBJECT(iter->data),"driver_struct");
gtk_widget_realize(data->ModuleInstalledCheck);
gtk_widget_realize(data->PackageInstalledCheck);
gtk_widget_realize(data->KernelLabel);
gtk_widget_realize(data->DriverLabel);
gtk_widget_realize(data->DescriptionLabel);
gtk_widget_realize(data->DevicesBox);
int temp_width = 0;
gtk_widget_get_preferred_width(data->ModuleInstalledCheck,&temp_width,NULL);
if (temp_width > module_width) module_width=temp_width;
gtk_widget_get_preferred_width(data->PackageInstalledCheck,&temp_width,NULL);
if (temp_width > package_width) package_width=temp_width;
gtk_widget_get_preferred_width(data->KernelLabel,&temp_width,NULL);
if (temp_width > kernel_width) kernel_width=temp_width;
gtk_widget_get_preferred_width(data->DriverLabel,&temp_width,NULL);
if (temp_width > driver_width) driver_width=temp_width;
gtk_widget_get_preferred_width(data->DescriptionLabel,NULL,&temp_width);
if (temp_width > description_width) description_width=temp_width;
}
if (module_width||package_width||kernel_width||driver_width||description_width){
for (iter = list;iter;iter=iter->next){
driver_struct *data = g_object_get_data(G_OBJECT(iter->data),"driver_struct");
if (module_width)
gtk_widget_set_size_request(gtk_widget_get_parent(data->ModuleInstalledCheck),module_width,-1);
if (package_width)
gtk_widget_set_size_request(gtk_widget_get_parent(data->PackageInstalledCheck),package_width,-1);
if (kernel_width)
gtk_widget_set_size_request(gtk_widget_get_parent(data->KernelLabel),kernel_width,-1);
if (driver_width)
gtk_widget_set_size_request(gtk_widget_get_parent(data->DriverLabel),driver_width,-1);
if (description_width)
gtk_widget_set_size_request(gtk_widget_get_parent(data->DescriptionLabel),description_width,-1);
}
g_list_free(list);
if (module_width) gtk_widget_set_size_request(widgets->InstalledModuleLabel,module_width,-1);
if (package_width) gtk_widget_set_size_request(widgets->InstalledPackageLabel,package_width,-1);
if (kernel_width) gtk_widget_set_size_request(widgets->KernelLabel,kernel_width,-1);
if (driver_width) gtk_widget_set_size_request(widgets->DriverLabel,driver_width,-1);
if (description_width) gtk_widget_set_size_request(widgets->DescriptionLabel,description_width,-1);
}
}
gboolean yon_proprietary_set(main_window *widgets){
gtk_widget_set_sensitive(widgets->LoadDriversButton,1);
return G_SOURCE_REMOVE;
}
gboolean yon_proprietary_append_kernels(struct proprietary_kernel_append_struct *append){
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(append->widgets->KernelsCombo),append->kernel,append->kernel);
free(append->kernel);
free(append);
return G_SOURCE_REMOVE;
}
driver_struct *yon_driver_struct_new(){
driver_struct *driver = new(driver_struct);

@ -71,13 +71,16 @@ void on_install_activate(GtkWidget *self, main_window *widgets){
yon_install_buttons_set_sensitive(widgets,0);
yon_terminal_integrated_start(widgets->InstallTerminal,command);
// g_signal_connect(G_OBJECT(widgets->InstallTerminal),"contents-changed",G_CALLBACK(on_terminal_check_progress),widgets);
if (!gtk_widget_get_visible(widgets->TerminalPaned)){
on_terminal_revealer_open(NULL,widgets);
}
g_timeout_add(500,(GSourceFunc)on_terminal_check_progress,widgets);
}
void on_install_check(GtkWidget *self,gint ,driver_struct *driver){
main_window *widgets = g_object_get_data(G_OBJECT(self),"widgets");
yon_packages_update_package(driver->package);
yon_packages_update_package(driver->module);
yon_packages_update();
yon_driver_struct_update(widgets,driver);
g_signal_handlers_disconnect_by_func(G_OBJECT(self),G_CALLBACK(on_install_check),driver);
}

@ -0,0 +1,490 @@
#include "ubl-settings-video.h"
/**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_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->ManualCheck))){
if (!gtk_combo_box_get_active(GTK_COMBO_BOX(window->PortCombo))){
yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),MISSING_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
yon_ubl_status_highlight_incorrect(window->PortCombo);
return;
}
target = (char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->PortCombo));
} else {
target = (char*)gtk_entry_get_text(GTK_ENTRY(window->PortEntry));
if (yon_char_is_empty(target)){
yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),MISSING_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
yon_ubl_status_highlight_incorrect(window->PortEntry);
return;
}
}
main_display = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->MainCheck));
char *res_str = yon_char_new(gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->ResolutionCombo)));
if (!yon_char_is_empty(res_str)){
frequency = gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->FrequencyCombo));
resolution = yon_char_unite(res_str,!yon_char_is_empty(frequency)?"x":NULL,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);
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);
gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->FrequencyCombo),parsed[i]);
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 yon_monitor_port_manual(GtkToggleButton *self,monitor_edit_window *monitors){
if (gtk_toggle_button_get_active(self)){
gtk_widget_show(monitors->PortEntry);
gtk_widget_hide(monitors->PortCombo);
} else {
gtk_widget_show(monitors->PortCombo);
gtk_widget_hide(monitors->PortEntry);
}
}
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;
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 = NULL;
port_name = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->PortCombo));
if (yon_char_is_empty(port_name)){
port_name = (char*)gtk_entry_get_text(GTK_ENTRY(window->PortEntry));
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->UnsupportedCheck))){
for (int i=main_config.resolutions_size-1;i>0;i--){
int size;
config_str parsed = yon_char_parse(main_config.resolutions_sorted[i],&size,";");
if (!yon_char_is_empty(parsed[0])){
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->ResolutionCombo),parsed[0],g_hash_table_lookup(main_config.resolutions,parsed[0]));
}
yon_char_parsed_free(parsed,size);
}
} else {
char *resolutions = g_hash_table_lookup(main_config.ports_table,port_name);
int size;
config_str parsed =yon_char_parse(resolutions,&size,",");
for (int i=0;i<size;i++){
char *cur_resolution = g_hash_table_lookup(main_config.resolutions,parsed[i]);
if (!yon_char_is_empty(cur_resolution))
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->ResolutionCombo),parsed[i],cur_resolution);
}
}
GList *list = g_hash_table_get_keys(main_config.ports_table);
GList *iter = list;
for (;iter;iter=iter->next){
if (strcmp(port_name,iter->data)){
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->PositionPortCombo),iter->data);
}
}
}
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 = yon_gtk_builder_get_widget(builder, "MainWindow");
monitors->StatusBox = yon_gtk_builder_get_widget(builder, "StatusBox");
monitors->HeadLabel = yon_gtk_builder_get_widget(builder, "HeadLabel");
monitors->EnableConfigurationBox = yon_gtk_builder_get_widget(builder, "EnableConfigurationBox");
monitors->InterfaceConfigurationBox = yon_gtk_builder_get_widget(builder, "InterfaceConfigurationBox");
monitors->EnableCheck = yon_gtk_builder_get_widget(builder, "EnableCheck");
monitors->ManualCheck = yon_gtk_builder_get_widget(builder, "ManualCheck");
monitors->PortCombo = yon_gtk_builder_get_widget(builder, "PortCombo");
monitors->PortEntry = yon_gtk_builder_get_widget(builder, "PortEntry");
monitors->MainCheck = yon_gtk_builder_get_widget(builder, "MainCheck");
monitors->ResolutionCombo = yon_gtk_builder_get_widget(builder, "ResolutionCombo");
monitors->UnsupportedCheck = yon_gtk_builder_get_widget(builder, "UnsupportedCheck");
monitors->FrequencyCombo = yon_gtk_builder_get_widget(builder, "FrequencyCombo");
monitors->RotationCombo = yon_gtk_builder_get_widget(builder, "RotationCombo");
monitors->PositionPosCombo = yon_gtk_builder_get_widget(builder, "PositionPosCombo");
monitors->PositionPortCombo = yon_gtk_builder_get_widget(builder, "PositionPortCombo");
monitors->DoNotSwitchOffCheck = yon_gtk_builder_get_widget(builder, "DoNotSwitchOffCheck");
monitors->ModelineCVTCheck = yon_gtk_builder_get_widget(builder, "ModelineCVTCheck");
monitors->UseCVTReducedCheck = yon_gtk_builder_get_widget(builder, "UseCVTReducedCheck");
monitors->ModelineGTFCheck = yon_gtk_builder_get_widget(builder, "ModelineGTFCheck");
monitors->ParameterLineCheck = yon_gtk_builder_get_widget(builder, "ParameterLineCheck");
monitors->ParameterLineEntry = yon_gtk_builder_get_widget(builder, "ParameterLineEntry");
monitors->CancelButton = yon_gtk_builder_get_widget(builder, "CancelButton");
monitors->SaveButton = yon_gtk_builder_get_widget(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);
yon_gtk_entry_block_restricted_symbols(GTK_ENTRY(monitors->PortEntry));
g_signal_connect(G_OBJECT(monitors->ManualCheck),"toggled",G_CALLBACK(yon_monitor_port_manual),monitors);
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';
}
guint ports_size;
config_str ports = (config_str)g_hash_table_get_keys_as_array(main_config.ports_table,&ports_size);
for (guint i=0;i<ports_size;i++){
int found = yon_char_parsed_check_exist(config_ports,config_size,ports[i]);
if (found==-1||(!yon_char_is_empty(target)&&!strcmp(target,ports[i]))||yon_config_get_status(XORG_MONITOR(ports[i]))==-1){
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(monitors->PortCombo),ports[i],ports[i]);
}
}
if (gtk_combo_box_get_active(GTK_COMBO_BOX(monitors->PortCombo))){
for (guint i=0;i<g_hash_table_size(main_config.ports_table);i++){
if (strcmp(ports[i],gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(monitors->PortCombo))))
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(monitors->PositionPortCombo),ports[i],ports[i]);
}
}
if (!yon_char_is_empty(target)&&g_hash_table_contains(main_config.ports_table,target)){
gtk_widget_set_sensitive(monitors->PortCombo,0);
gtk_widget_set_sensitive(monitors->ManualCheck,0);
gtk_combo_box_set_active_id(GTK_COMBO_BOX(monitors->PortCombo),target);
char *config_string = yon_config_get_by_key(XORG_MONITOR(target));
if (!yon_char_is_empty(config_string)){
yon_monitor_parse(monitors,config_string);
}
} else if (!yon_char_is_empty(target)){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(monitors->ManualCheck),1);
gtk_entry_set_text(GTK_ENTRY(monitors->PortEntry),target);
}
on_port_chosen_changed(NULL,monitors);
char *resolutions = NULL;
if (!yon_char_is_empty(target)){
resolutions = g_hash_table_lookup(main_config.ports_table,target);
}
if (yon_char_is_empty(resolutions)&&!yon_char_is_empty(target)){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(monitors->UnsupportedCheck),1);
}
while(gtk_events_pending()) gtk_main_iteration();
char *parameter = config(XORG_MONITOR(target));
{
int size;
config_str parsed = yon_char_parse(parameter,&size,",");
if (size){
char *current = yon_char_new(parsed[0]);
char *resolution = NULL;
if (g_regex_match_simple("^\\d+x\\d+x\\d+",current,0,0)){
int last = yon_char_find_last(current,'x');
resolution = yon_char_divide(current,last);
gtk_combo_box_set_active_id(GTK_COMBO_BOX(monitors->FrequencyCombo),current);
} else if (g_regex_match_simple("^\\d+x\\d+",current,0,0)){
resolution = current;
}
if (!yon_char_is_empty(target)&&!yon_char_is_empty(resolutions)&&!strstr(resolutions,resolution)){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(monitors->UnsupportedCheck),1);
while(gtk_events_pending()) gtk_main_iteration();
}
gtk_combo_box_set_active_id(GTK_COMBO_BOX(monitors->ResolutionCombo),resolution);
}
}
gtk_widget_show(monitors->MainWindow);
}
}
void yon_monitor_view_dictionary_destroy(void *window){
monitor_data *monitor=(monitor_data*)window;
gtk_widget_destroy(monitor->ScreenOverlay);
}
/**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)));
yon_char_remove_last_symbol(current,']');
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);
}
}
}
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");
window->target_port=NULL;
window->target_resolution=NULL;
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;
}

File diff suppressed because it is too large Load Diff

@ -43,6 +43,32 @@
#define get_ports_command "xrandr |grep -E '.*connected' |cut -d' ' -f1"
#define get_resolutions_and_ports_command "xrandr | awk '\n\
/^Screen / { next }\n\
/^[A-Z]/ {\n\
if (port != \"\") {\n\
print port \":\" (res ? res : \"\")\n\
}\n\
port = $1\n\
res = \"\"\n\
connected = ($2 == \"connected\")\n\
next\n\
}\n\
/^[[:space:]]+[0-9]+x[0-9]+/ && connected {\n\
split($1, parts, \"+\")\n\
mode = parts[1]\n\
if (!(mode in seen)) {\n\
seen[mode] = 1\n\
res = res ? res \",\" mode : mode\n\
}\n\
}\n\
END {\n\
if (port != \"\") {\n\
print port \":\" (res ? res : \"\")\n\
}\n\
}\
'"
#define get_resolutions_command "xrandr |grep -noP \"\\d+x+\\d+\""
#define get_resolution_ports_command "xrandr |grep -nwP \"connected\" |grep -oE \"[-0-9a-zA-Z:]{1,} connected\" |grep -oE \"[-0-9a-zA-Z:]{1,} \""
@ -58,6 +84,8 @@
#define yon_check_database_command "pacman -Sqs >/dev/null"
#define pacman_unlock_database_command "rm -f /var/lib/pacman/db.lck"
#define yon_get_kernels_installed "find /usr/lib/modules/ -maxdepth 2 -type f -iname \"pkgbase\" -exec cat {} + 2>/dev/null"
#define icon_devices_path "com.ublinux.libublsettingsui-gtk3.database-symbolic"
@ -133,6 +161,9 @@ typedef struct
{
template_window_fields
GtkWidget *MainBox;
GtkWidget *MainOverlay;
GtkWidget *MainSpinner;
GtkWidget *AutoDriverCombo;
GtkWidget *FreeDriverCombo;
GtkWidget *FailsafeNvidiaCombo;
@ -183,6 +214,7 @@ typedef struct
GtkWidget *DriverLabel;
GtkWidget *DescriptionLabel;
GtkWidget *DevicesLabel;
GtkWidget *UnlockPacmanButton;
GtkWidget *MoreButton;
GtkWidget *CancelButton;
@ -212,17 +244,16 @@ typedef struct
monitor_view monitor_visuals;
monitor_config monitors;
proprietary_config proprietary;
dictionary *supported_resolutions;
GHashTable *ports_table;
char *failsafenVidia;
char *failsafeATI;
int descreteOnly;
char *optirun;
char *primusrun;
int gapfix;
config_str ports;
int portssize;
config_str resolutions;
int resolutionssize;
GHashTable *resolutions;
int resolutions_size;
config_str resolutions_sorted;
render_data status_render;
dictionary *monitor_output_layers;
@ -300,6 +331,8 @@ typedef struct
GtkWidget *InterfaceConfigurationBox;
GtkWidget *EnableCheck;
GtkWidget *PortCombo;
GtkWidget *ManualCheck;
GtkWidget *PortEntry;
GtkWidget *MainCheck;
GtkWidget *ResolutionCombo;
GtkWidget *UnsupportedCheck;
@ -327,6 +360,8 @@ typedef struct {
GtkWidget *SwitchButton;
GtkWidget *ConfigureButton;
GtkWidget *AddButton;
char *target_port;
char *target_resolution;
} monitor_data;
typedef struct
@ -374,9 +409,6 @@ void on_module_install_activate(GtkCellRendererToggle* self,gchar* path,main_win
gboolean yon_filter_func(GtkTreeModel* model,GtkTreeIter* iter,main_window *widgets);
void on_kernel_filter_changed(GtkWidget *self, main_window *widgets);
void on_port_chosen_changed(GtkWidget *self, monitor_edit_window *window);
void on_sensitive_change(GtkWidget *self, GtkWidget *toggle);
void on_sensitive_change_reversed(GtkWidget *self, GtkWidget *toggle);
void on_auto_choose_drivers(GtkWidget *self, main_window *widgets);
void on_resolutions_unsupported_show(GtkToggleButton *self, monitor_edit_window *window);
void yon_interface_save();
void yon_interface_update();
@ -407,7 +439,6 @@ void config_init();
void yon_proprietary_local_get(main_window *widgets);
gboolean yon_proprietary_append_kernels(struct proprietary_kernel_append_struct *append);
gboolean yon_proprietary_append(driver_struct *target);
gboolean yon_proprietary_clear(main_window *widgets);
gboolean on_command_execute_success(GtkWidget *,gint status,main_window *widgets);
void on_gapfix_changed(GtkWidget*self, main_window *widgets);
@ -428,5 +459,17 @@ void on_devices_button_clicked(GtkWidget *, main_window *widgets);
int check_rmb_menu(void *data);
void on_install_check(GtkWidget *self,gint status,driver_struct *driver);
void yon_install_buttons_set_sensitive(main_window *widgets,int state);
void on_pacman_db_unlock(void);
char *yon_auto_driver_default(char *target);
char *yon_free_driver_default(char *target);
char *yon_failsafe_driver_default(char *target);
char *yon_ati_driver_default(char *target);
char *yon_switch_display_off_default(char *target);
char *yon_scaling_default(char *target);
char *yon_discrete_default(char *target);
char *yon_optirun_default(char *target);
char *yon_primusrun_default(char *target);
void yon_all_resolutions_update();
void yon_monitor_port_manual(GtkToggleButton *self,monitor_edit_window *monitors);
#endif

@ -58,7 +58,7 @@
#define INSTALLED_LABEL _("Installed")
#define INSTALLED_LOW_LABEL _("installed")
#define PACKAGE_LABEL _("Package")
#define SUPPORTED_LABEL _("Supported Devices")
#define SUPPORTED_LABEL _("Supported devices")
#define MODULE_INFO_LABEL _("Module information")
#define PACKAGE_INFO_LABEL _("Package information")
@ -148,6 +148,7 @@
#define DISCRETE_ONLY_LABEL _("discrete video only (AMD/ATI):")
#define DRIVER_MODULES_LABEL _("Driver Modules")
#define DEVICES_AND_DRIVERS_LABEL _("Devices and Drivers")
#define PACMAN_UNLOCK_TOOLTIP_LABEL _("Unlock the pacman package manager database")
#define DATABASE_UNACCESSIBLE_LABEL _("Database files must be updated")

@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated with glade 3.40.0 -->
<!-- Generated with glade 3.38.2 -->
<interface domain="ubl-settings-video">
<requires lib="gtk+" version="3.24"/>
<!-- interface-css-provider-path ubl-settings-video.css -->
@ -69,7 +69,7 @@
</packing>
</child>
<child>
<object class="GtkCheckButton" id="EnableCheck1">
<object class="GtkCheckButton" id="ManualCheck">
<property name="label" translatable="yes">Manual port</property>
<property name="visible">True</property>
<property name="can-focus">True</property>
@ -234,8 +234,8 @@
<property name="active">0</property>
<items>
<item translatable="yes">Default</item>
<item translatable="yes">60</item>
<item translatable="yes">75</item>
<item id="60" translatable="yes">60</item>
<item id="75" translatable="yes">75</item>
</items>
</object>
<packing>

@ -7,6 +7,8 @@
<property name="width-request">500</property>
<property name="height-request">350</property>
<property name="can-focus">False</property>
<property name="default-width">800</property>
<property name="default-height">550</property>
<property name="icon-name">com.ublinux.ubl-settings-video</property>
<child>
<object class="GtkBox">

@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated with glade 3.40.0 -->
<!-- Generated with glade 3.38.2 -->
<interface>
<requires lib="gtk+" version="3.24"/>
<object class="GtkOverlay" id="ScreenOverlay">
@ -55,15 +55,17 @@
<property name="valign">start</property>
<property name="margin-left">3</property>
<property name="margin-right">3</property>
<property name="margin-start">3</property>
<property name="margin-end">3</property>
<property name="margin-start">5</property>
<property name="margin-end">5</property>
<property name="margin-top">10</property>
<property name="margin-bottom">20</property>
<property name="orientation">vertical</property>
<property name="spacing">5</property>
<child>
<object class="GtkLabel" id="NameLabel">
<property name="visible">True</property>
<property name="can-focus">False</property>
<property name="ellipsize">end</property>
<property name="single-line-mode">True</property>
<attributes>
<attribute name="weight" value="bold"/>
@ -82,10 +84,7 @@
<object class="GtkLabel" id="ResoulutionLabel">
<property name="visible">True</property>
<property name="can-focus">False</property>
<property name="margin-left">5</property>
<property name="margin-right">5</property>
<property name="margin-start">5</property>
<property name="margin-end">5</property>
<property name="ellipsize">end</property>
<property name="single-line-mode">True</property>
<attributes>
<attribute name="weight" value="bold"/>
@ -104,9 +103,7 @@
<object class="GtkBox">
<property name="visible">True</property>
<property name="can-focus">False</property>
<property name="margin-start">7</property>
<property name="margin-end">7</property>
<property name="margin-top">15</property>
<property name="spacing">5</property>
<child>
<object class="GtkButton" id="DeleteButton">
<property name="visible">True</property>

File diff suppressed because it is too large Load Diff
Loading…
Cancel
Save