#include "ubl-settings-usergroups.h" 
 
config main_config; 
 
//functions 
 
int yon_load_proceed(YON_CONFIG_TYPE type){
	yon_config_load_register(YON_CONFIG_DEFAULT,"users","DEFAULTPASSWD DEFAULTROOTPASSWD USERGROUPS DEFAULTUSER HASHPASSWD ADDADM",NULL);
    yon_config_load_register_no_cleaning(type,"users","DEFAULTPASSWD DEFAULTROOTPASSWD DEFAULTUSER HASHPASSWD USERGROUPS ADDADM USERADD[*] USERSHADOW[*] GROUPADD[*]","[system]","SYSTEMBOOT_STATEMODE","[save]","SAVE_ROOTCOPY_CHANGES",NULL);
    if (type!=YON_CONFIG_GLOBAL){
		yon_config_load_register_no_cleaning(YON_CONFIG_GLOBAL,"users","DEFAULTPASSWD DEFAULTROOTPASSWD",NULL);
	}
	if (type==YON_CONFIG_LOCAL){
		int size;
		config_str passwords = yon_config_load(get_passwords_command,&size);
		for (int i=0;i<size;i++){
			char *key, *value;
			if (yon_config_parse_parameter(passwords[i],&key, &value)){
				int parsed_size;
				char *local_value = yon_config_get_by_key(key);
				config_str parsed = yon_char_parse(value,&parsed_size,":");
				if (strstr(key,"USERADD[")&&local_value){
					if (parsed_size>5){
						char *temp = yon_char_append(local_value,parsed[5]);
						free(local_value);
						local_value=temp;
						yon_config_set(key,yon_char_new(local_value));
						yon_config_set_status(key,0);

					}

				} else if (strstr(key,"GROUPADD[")&&local_value){
					if (parsed_size>4){
						char *temp = yon_char_append(local_value,parsed[4]);
						free(local_value);
						local_value=temp;
						yon_config_set(key,yon_char_new(local_value));
						yon_config_set_status(key,0);

					}
					
				}
				yon_char_parsed_free(parsed,parsed_size);
				free(key);
				free(value);
			}
		}
		return 1;
	}
	
    
}

void yon_interface_update(main_window *widgets){
	gtk_list_store_clear(widgets->UsersList);
	gtk_list_store_clear(widgets->GroupsList);
	int size;
	GtkTreeIter iter;
	char *def_groups = yon_config_get_by_key("USERGROUPS");
		config_str users = yon_config_get_all_by_key("USERADD",&size);
		if (users){
			for (int i=0;i<size;i++){
				gtk_list_store_append(widgets->UsersList,&iter);
				int parameters_size;
				config_str parameters = yon_char_parse(users[i],&parameters_size,":");
				free(yon_char_divide(parameters[0],7));
				char *login = NULL;
				if (strstr(parameters[0],"\"")){
					login = yon_char_divide_search(parameters[0],"\"",-1);
					login[strlen(login)-2]='\0';
				} else {
					login = yon_char_divide_search(parameters[0],"=",-1);
					login[strlen(login)-1]='\0';
				}
				if (parameters_size>1&&!strcmp(parameters[1],"x")) parameters[1]=AUTOMATICALLY_LABEL;
				if (parameters_size>2&&!strcmp(parameters[2],"x")) parameters[2]=login;
				char *pars = "";
				if (parameters_size>5&&strcmp(parameters[5],"x")&&strcmp(parameters[5],"")){
					
					if (!check_is_password_hash(parameters[5])){
						pars = ENCRYPTED_LABEL;
					} else {
						pars = UNENCRYPTED_LABEL;

					}
				} else {
					pars = DEFAULT_USER_LABEL;
					
				}
				gtk_list_store_set(widgets->UsersList,&iter,
				2,login,
				3,parameters_size>0?parameters[0]:"",
				1,parameters_size>1&&!yon_char_is_empty(parameters[1])?parameters[1]:AUTOMATICALLY_LABEL,
				4,parameters_size>2&&!yon_char_is_empty(parameters[2])?parameters[2]:login,
				5,parameters_size>3?!strcmp(parameters[3],"x")||!strcmp(parameters[3],"")?def_groups:parameters[3]:def_groups,
				6,parameters_size>4?!strcmp(parameters[3],"x")?"":parameters[4]:"",
				7,pars,
				-1);
				if(parameters)
				free(parameters);
			}
			free(users);
		}
		config_str groups = yon_config_get_all_by_key("GROUPADD",&size);
		if (groups){
			for (int i=0;i<size;i++){
				gtk_list_store_append(widgets->GroupsList,&iter);
				int parameters_size;
				config_str parameters = yon_char_parse(groups[i],&parameters_size,":");
				free(yon_char_divide(parameters[0],8));
				char *login;
				if (strstr(parameters[0],"\"")){
					login = yon_char_divide_search(parameters[0],"\"",-1);
					login[strlen(login)-2]='\0';
				} else {
					login = yon_char_divide_search(parameters[0],"=",-1);
					login[strlen(login)-1]='\0';
				}
				if (!strcmp(parameters[1],"x")) parameters[1]=AUTOMATICALLY_LABEL;
				gtk_list_store_set(widgets->GroupsList,&iter,
				1,login,
				0,parameters_size>1?parameters[1]:"",
				2,parameters_size>0?parameters[0]:"",
				3,parameters_size>2?parameters[2]:"",
				4,parameters_size>3?ENCRYPTED_LABEL:DEFAULT_USER_LABEL,
				-1);
				if(parameters)
				free(parameters);
				
			}
		}
	if (main_config.groups_size>0){
		yon_char_parsed_free(main_config.groups,main_config.groups_size);
		main_config.groups = yon_file_open(groups_path,&main_config.groups_size);
	}
	if (main_config.users_size>0){
		yon_char_parsed_free(main_config.users,main_config.users_size);
		main_config.users = yon_file_open(users_path,&main_config.users_size);
	}
}

void on_save_window_close_update(GtkWidget *self, main_window *widgets){
	yon_interface_update(widgets);
}

void on_config_local_load(GtkWidget *self, main_window *widgets){
	yon_load_proceed(YON_CONFIG_LOCAL);
	textdomain(template_ui_LocaleName);
	yon_ubl_status_box_render(LOCAL_LOAD_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE); 
	textdomain(LocaleName);
	main_config.load_mode=1;
	yon_interface_update(widgets);
}

void on_config_global_load(GtkWidget *self, main_window *widgets){
	yon_load_proceed(YON_CONFIG_GLOBAL);
	textdomain(template_ui_LocaleName);
	yon_ubl_status_box_render(GLOBAL_LOAD_SUCCESS_LABEL,BACKGROUND_IMAGE_SUCCESS_TYPE);
	textdomain(LocaleName);
	main_config.load_mode=0;
	yon_interface_update(widgets);
}
 
void yon_samba_sync_proceed(){
if (main_config.sync_users){
	for (int i=0;i<main_config.sync_size;i++){
		int size;
		config_str parsed = yon_char_parse(main_config.sync_users[i],&size,":");
		if (!yon_char_is_empty(parsed[1])){
		
		if (system (samba_sync_password_command(parsed[0],parsed[1]))){};
		} else {
		if (system ( samba_sync_command(parsed[0]))){};

		}

		yon_char_parsed_free(parsed,size);
	}
}
}

void yon_accept_changes(){
	char *remove_homes = "";
	for (int i=0;i<main_config.homes_size;i++){
		remove_homes = yon_char_unite(remove_homes,yon_char_is_empty(remove_homes)?"":",",main_config.remove_homes[i],NULL);
	}
	if (!yon_char_is_empty(remove_homes)){
		if (system(remove_home_dirs_command(remove_homes))){};
	}
}

void yon_hide_passwords(template_saving_window *window){
	GtkTreeModel *model = GTK_TREE_MODEL(window->list);
	GtkTreeIter iter;
	int valid = gtk_tree_model_get_iter_first(model,&iter);
	for (;valid;valid = gtk_tree_model_iter_next(model,&iter)){
		char *name;
		char *old_value;
		char *new_value;
		gtk_tree_model_get(model,&iter,1,&name,2,&old_value,3,&new_value,-1);
		if (strstr(name,"USERADD[")){
			char *old=NULL;
			char *newv=NULL;
			int size = 0;
			if (!yon_char_is_empty(new_value)){
				config_str parsed = NULL;
				parsed = yon_char_parse(new_value,&size,":");
				if (size>5&&!yon_char_is_empty(parsed[5])&&strcmp(parsed[5],"x")&&parsed[5][0]!='%'&&parsed[5][1]!='%'){
					free(new_value);
					free(parsed[5]);
					parsed[5]=yon_char_new("*******");
					new_value = yon_char_parsed_to_string(parsed,size,":");
				} else if (size>5&&!yon_char_is_empty(parsed[5])&&strcmp(parsed[5],"x")) {
					free(new_value);
					free(yon_char_divide(parsed[5],1));
					new_value = yon_char_parsed_to_string(parsed,size,":");
				}
				if (parsed){
					yon_char_parsed_free(parsed,size);
				}
			}
			if(!yon_char_is_empty(old_value)){
				old=yon_char_unite("<s>",old_value,"</s>",NULL);
			}
			if(!yon_char_is_empty(new_value)){
				newv=new_value;
			}
			char *new_string = yon_char_unite(!yon_char_is_empty(old)?old:"","\n",!yon_char_is_empty(newv)?newv:"",NULL);
			gtk_list_store_set(window->list,&iter,7,new_string,-1);

		} else if (strstr(name,"GROUPADD[")){
			char *old=NULL;
			char *newv=NULL;
			int size = 0;
			if (new_value){
				config_str parsed = yon_char_parse(new_value,&size,":");
				free(new_value);
				if (size>4&&!yon_char_is_empty(parsed[4])&&strcmp(parsed[4],"x")&&parsed[4][0]!='%'&&parsed[4][1]!='%'){
					free(parsed[4]);
					parsed[4]=yon_char_new("*******");
				}
				new_value = yon_char_parsed_to_string(parsed,size,":");
			}
			if(!yon_char_is_empty(old_value)){
				old=yon_char_unite("<s>",old_value,"</s>",NULL);
			}
			if(!yon_char_is_empty(new_value)){
				newv=new_value;
			}
			char *new_string = yon_char_unite(!yon_char_is_empty(old)?old:"","\n",!yon_char_is_empty(newv)?newv:"",NULL);
			gtk_list_store_set(window->list,&iter,7,new_string,-1);
			
			
		} else if (strstr(name,"DEFAULTPASSWD")){
			char *old=NULL;
			char *newv=NULL;
			if (!yon_char_is_empty(new_value)&&strlen(new_value)>2&&new_value[0]=='%'&&new_value[1]=='%'){
				free(yon_char_divide(new_value,1));
				newv=new_value;
			} else if (!yon_char_is_empty(new_value)&&new_value[0]=='$') {
				newv=new_value;
			}else if (!yon_char_is_empty(new_value)){
				newv="*******";
			}
			if (!yon_char_is_empty(old_value)){
				old = yon_char_unite("<s>",old_value,"</s>",NULL);
			}
			char *new_string = yon_char_unite(!yon_char_is_empty(old)?old:"","\n",!yon_char_is_empty(newv)?newv:"",NULL);
			gtk_list_store_set(window->list,&iter,7,new_string,-1);
			
		} else if (strstr(name,"DEFAULTROOTPASSWD")){
			char *old=NULL;
			char *newv=NULL;
			if (!yon_char_is_empty(new_value)&&strlen(new_value)>2&&new_value[0]=='%'&&new_value[1]=='%'){
				free(yon_char_divide(new_value,1));
				newv=new_value;
			} else if (!yon_char_is_empty(new_value)&&new_value[0]=='$') {
				newv=new_value;
			}else if (!yon_char_is_empty(new_value)){
				newv="*******";
			}
			if (!yon_char_is_empty(old_value)){
				old = yon_char_unite("<s>",old_value,"</s>",NULL);
			}
			char *new_string = yon_char_unite(!yon_char_is_empty(old)?old:"","\n",!yon_char_is_empty(newv)?newv:"",NULL);
			gtk_list_store_set(window->list,&iter,7,new_string,-1);
			
		}
	}
}

void on_config_save(GtkWidget *self, main_window *widgets){
	yon_accept_changes();
	yon_samba_sync_proceed();
	template_saving_window *window = yon_save_proceed(NULL,YON_CONFIG_BOTH,"users", "DEFAULTPASSWD DEFAULTROOTPASSWD DEFAULTUSER HASHPASSWD USERGROUPS ADDADM USERADD[*] USERSHADOW[*] GROUPADD[*]",NULL);
	if (window){
		yon_hide_passwords(window);
		g_signal_connect(G_OBJECT(window->Window),"destroy",G_CALLBACK(on_save_window_close_update),widgets);
	}
}

void on_config_global_save(){
	yon_accept_changes();
	yon_samba_sync_proceed();
	template_saving_window *window = yon_save_proceed("global",YON_CONFIG_GLOBAL,"users", "DEFAULTPASSWD DEFAULTROOTPASSWD DEFAULTUSER HASHPASSWD USERGROUPS ADDADM USERADD[*] USERSHADOW[*] GROUPADD[*]",NULL);
	if (window) yon_hide_passwords(window);

}

void on_config_local_save(GtkWidget *self, main_window *widgets){
	int size;
	config_str keys = yon_config_get_all_by_key("USERADD[",&size);
	int passw_size;
	config_str passwords = NULL;
	for (int i=0;i<size;i++){
		int parsed_size;
		char *key,*value;
		yon_config_parse_parameter(keys[i],&key,&value);
		config_str parsed = yon_char_parse(value,&parsed_size,":");
		if (parsed_size>5&&!yon_char_is_empty(parsed[5])){
			yon_char_parsed_add_or_create_if_exists(passwords,&passw_size,yon_char_new(parsed[5]));
			parsed = yon_char_parsed_rip(parsed,&parsed_size,5);
			char *final_string = yon_char_parsed_to_string(parsed,parsed_size,":");
			char *temp = yon_char_append(final_string,":");
			free(final_string);
			final_string=temp;
			yon_config_set(key,final_string);
		}
		free(key);
		free(value);
	}
	yon_accept_changes();
	yon_samba_sync_proceed();
	template_saving_window *window = yon_save_proceed("system",YON_CONFIG_LOCAL,"users", "DEFAULTPASSWD DEFAULTROOTPASSWD DEFAULTUSER HASHPASSWD USERGROUPS ADDADM USERADD[*] USERSHADOW[*] GROUPADD[*]",NULL);
	if (window){
		yon_hide_passwords(window);
		g_signal_connect(G_OBJECT(window->Window),"destroy",G_CALLBACK(on_save_window_close_update),widgets);
	}
	for (int i=0;i<size;i++){
		char *key,*value;
		yon_config_parse_parameter(keys[i],&key,&value);
		yon_config_set(key,value);
	}
}

void on_saving_settings_save(GtkWidget *self, yon_savasettings_window *window){
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->SambaCheck))){
		if (!yon_config_append("SAVE_ROOTCOPY_CHANGES","/var/lib/samba",",")){
			yon_config_register("SAVE_ROOTCOPY_CHANGES","[save]","/var/lib/samba");
		}
	} else {
		yon_config_remove_element("SAVE_ROOTCOPY_CHANGES","/var/lib/samba",",");
	}
	on_subwindow_close(self);
}

void yon_samba_sync_add(char *user, char*password){
	int sync_place = yon_char_parsed_check_exist(main_config.sync_users,main_config.sync_size,yon_char_append(user,":"));
	if (sync_place==-1){
		yon_char_parsed_add_or_create_if_exists(main_config.sync_users,&main_config.sync_size,yon_char_unite(user,":",password,NULL));
	}
}

void yon_samba_sync_remove(char *user){
	int sync_place = yon_char_parsed_check_exist(main_config.sync_users,main_config.sync_size,yon_char_append(user,":"));
	if (sync_place>-1){
		config_str temp = yon_char_parsed_rip(main_config.sync_users,&main_config.sync_size,sync_place);
		free(main_config.sync_users);
		main_config.sync_users = temp;
	}

}

int yon_samba_sync_get(char *user){
	int sync_place = yon_char_parsed_check_exist(main_config.sync_users,main_config.sync_size,yon_char_append(user,":"));
	if (sync_place>-1){
		if (!main_config.sync_users)
			return 0;
		int active = main_config.sync_users[sync_place][strlen(main_config.sync_users[sync_place])-1]==':'? 1:2;
		return active;
	}
	return 0;
}

void on_delete_confirmation_delete_home_check(GtkCellRenderer *self, char *path, yon_confirmation_window *window){
	GtkTreeIter iter;
	gboolean status;
	gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->list),&iter,path);
	gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,3,&status,-1);
	gtk_list_store_set(window->list,&iter,3,!status,-1);

}

void on_delete_confirmation_delete_check(GtkCellRenderer *self, char *path, yon_confirmation_window *window){
	GtkTreeIter iter;
	gboolean status;
	gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->list),&iter,path);
	gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,0,&status,-1);
	gtk_list_store_set(window->list,&iter,0,!status,-1);

}

void yon_delete_confirmation_save(GtkWidget *self, dictionary *dict){
	GtkTreeIter iter,itar;
	main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
	yon_confirmation_window *window = yon_dictionary_get_data(dict->first->next,yon_confirmation_window*);
	int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(widgets->UsersList),&iter);
	for (;valid;valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(widgets->UsersList),&iter)){
		char *name;
		gtk_tree_model_get(GTK_TREE_MODEL(widgets->UsersList),&iter,2,&name,-1);
		int valid2 = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->list),&itar);
		for (;valid2;valid2 = gtk_tree_model_iter_next(GTK_TREE_MODEL(window->list),&itar)){
			char *name_check;
			int status,delete;
			gtk_tree_model_get(GTK_TREE_MODEL(window->list),&itar,0,&delete,1,&name_check,3,&status,-1);
			if (!strcmp(name,name_check)&&delete){
				gtk_list_store_remove(widgets->UsersList,&iter);
				yon_config_remove_by_key(USERADD(name));
				yon_config_remove_by_key(USERSHADOW(name));
				gtk_tree_model_get_iter_first(GTK_TREE_MODEL(widgets->UsersList),&iter);
				if (status){
					if (yon_char_parsed_check_exist(main_config.remove_homes,main_config.homes_size,name)==-1){
						yon_char_parsed_add_or_create_if_exists(main_config.remove_homes,&main_config.homes_size,name);
					}
				}
			}
		}
	}
		char *name;
		if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(widgets->UsersList),&iter)){
			gtk_tree_model_get(GTK_TREE_MODEL(widgets->UsersList),&iter,2,&name,-1);
			int valid2 = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->list),&itar);
			for (;valid2;valid2 = gtk_tree_model_iter_next(GTK_TREE_MODEL(window->list),&itar)){
				char *name_check;
				int status,delete;
				gtk_tree_model_get(GTK_TREE_MODEL(window->list),&itar,0,&delete,1,&name_check,3,&status,-1);
				if (!strcmp(name,name_check)&&delete){
					gtk_list_store_remove(widgets->UsersList,&iter);
					yon_config_remove_by_key(USERADD(name));
					yon_config_remove_by_key(USERSHADOW(name));
					gtk_tree_model_get_iter_first(GTK_TREE_MODEL(widgets->UsersList),&iter);
					if (status){
						if (yon_char_parsed_check_exist(main_config.remove_homes,main_config.homes_size,name)==-1){
							yon_char_parsed_add_or_create_if_exists(main_config.remove_homes,&main_config.homes_size,name);
						}
					}
				}
			}
		}
	on_subwindow_close(self);
}

yon_confirmation_window *yon_delete_confirmation_new(){
	yon_confirmation_window *window = malloc(sizeof(yon_confirmation_window));
	GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_ubl_settings_usergroups_confirmation);
	window->Window = yon_gtk_builder_get_widget(builder,"Window");
	window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
	window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
	window->AcceptButton = yon_gtk_builder_get_widget(builder,"AcceptButton");
	window->DeletionTree = yon_gtk_builder_get_widget(builder,"DeletionTree");
	window->DeleteCell = GTK_CELL_RENDERER(gtk_builder_get_object(builder,"DeleteCell"));
	window->DeleteHomeCell = GTK_CELL_RENDERER(gtk_builder_get_object(builder,"DeleteHomeCell"));
	window->list = GTK_LIST_STORE(gtk_builder_get_object(builder,"liststore1"));
	gtk_window_set_title(GTK_WINDOW(window->Window),DELETE_CONFIRMATION_TITLE_LABEL);
	g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
	g_signal_connect(G_OBJECT(window->DeleteCell),"toggled",G_CALLBACK(on_delete_confirmation_delete_check),window);
	g_signal_connect(G_OBJECT(window->DeleteHomeCell),"toggled",G_CALLBACK(on_delete_confirmation_delete_home_check),window);
	yon_window_config_custom_window_setup(GTK_WINDOW(window->Window),"DeleteConfirmationWindow");
	return window;
}

void yon_delete_confirmation_open(main_window *widgets){
	yon_confirmation_window *window = yon_delete_confirmation_new();
	gtk_window_set_transient_for(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->Window));
	GtkTreeIter iter,itar;
	dictionary *dict = NULL;
	yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
	yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
	g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(yon_delete_confirmation_save),dict);
	GtkTreeModel *model = GTK_TREE_MODEL(widgets->UsersList);
	GList *list = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->UsersTree)),&model);
	int chosen_size=0;
	config_str chosen = NULL;
	for (int i=0;i<g_list_length(list);i++){
		char *current;
		gtk_tree_model_get_iter(model,&iter,(GtkTreePath*)g_list_nth_data(list,i));
		gtk_tree_model_get(model,&iter,2,&current,-1);
		yon_char_parsed_add_or_create_if_exists(chosen,&chosen_size,current);
	}
	int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(widgets->UsersList),&iter);
	for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(widgets->UsersList),&iter)){
		char *name,*username,*parameters,*homedir=NULL;
		gtk_tree_model_get(GTK_TREE_MODEL(widgets->UsersList),&iter,2,&name,3,&username,6,&parameters,-1);
		int found = yon_char_parsed_check_exist(main_config.users,main_config.users_size,yon_char_append(name,":"));
		
		if (found>-1){
			int parsed_size;
			config_str parsed = yon_char_parse(main_config.users[found],&parsed_size,":");
			if (parsed_size>5&&!yon_char_is_empty(parsed[5])&&strcmp(parsed[5],"x")){

				homedir = yon_char_new(parsed[5]);
			}
			yon_char_parsed_free(parsed,parsed_size);
		}
		int status=0;
		if (homedir) status=1;
		gtk_list_store_append(window->list,&itar);
		gtk_list_store_set(window->list,&itar,0,yon_char_parsed_check_exist(chosen,chosen_size,name)>-1?1:0,1,name,2,homedir,3,0,4,status,5,username,-1);
		free(name);
		free(username);
		free(parameters);
		free(homedir);
	}
	gtk_widget_show(window->Window);
}

yon_savasettings_window *yon_saving_settings_new(){
	GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_ubl_settings_usergroups_savesettings);
	yon_savasettings_window *window = malloc(sizeof(yon_savasettings_window));
	window->Window = yon_gtk_builder_get_widget(builder,"Window");
	window->CancelButton = yon_gtk_builder_get_widget(builder,"CancelButton");
	window->AcceptButton = yon_gtk_builder_get_widget(builder,"AcceptButton");
	window->SambaCheck = yon_gtk_builder_get_widget(builder,"SambaSaveCheck");
	window->StatusBox = yon_gtk_builder_get_widget(builder,"StatusBox");
	g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
	gtk_widget_show(window->Window);
	yon_window_config_custom_window_setup(GTK_WINDOW(window->Window),"savingSettingsWindow");
	gtk_window_set_title(GTK_WINDOW(window->Window),SAVESETTINGS_TITLE_LABEL);
	char *string = yon_config_get_by_key("SAVE_ROOTCOPY_CHANGES");
	if (!yon_char_is_empty(string)&&strstr(string,"/var/lib/samba")){
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->SambaCheck),1);
	}
	yon_ubl_status_box_spawn_infinite(GTK_CONTAINER(window->StatusBox),"savemode",SYSTEM_SAVEMODE_LABEL,BACKGROUND_IMAGE_INFO_TYPE);
	return window;
}

void on_saving_settings_open(GtkWidget *self, main_window *widgets){
	yon_savasettings_window *window = yon_saving_settings_new();
	gtk_window_set_transient_for(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->Window));
	g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_saving_settings_save),window);
}

void on_password_combo_changed(GtkComboBox *self, GtkWidget *target){
	gtk_widget_set_sensitive(target,gtk_combo_box_get_active(self)>1);
}

 
void on_filechooser_open(GtkWidget *self, GtkEntry *output_target){
	GtkWidget *dialog = gtk_file_chooser_dialog_new(FILECHOOSER_TITLE_LABEL,NULL,GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,CANCEL_LABEL,GTK_RESPONSE_CANCEL,ACCEPT_LABEL,GTK_RESPONSE_ACCEPT,NULL);
	int responce = gtk_dialog_run(GTK_DIALOG(dialog));
	if (responce==GTK_RESPONSE_ACCEPT){
		char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
		gtk_entry_set_text(output_target,filename);
	}
	on_subwindow_close(dialog);

}

void on_groups_save(GtkWidget *self, dictionary *dict){
	ubl_settings_usergroups_group_window *window = yon_dictionary_get_data(dict->first,ubl_settings_usergroups_group_window*);
	GtkEntry *output = yon_dictionary_get_data(dict->first->next,GtkEntry*);
	GtkTreeIter iter;
	GtkTreeModel *model = GTK_TREE_MODEL(window->list);
	if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(window->GroupsTree)),&model,&iter)){
		char *name;
		gtk_tree_model_get(model,&iter,1,&name,-1);
		gtk_entry_set_text(output,name);
		free(name);
	}
	on_subwindow_close(self);
}

void on_groups_clicked(GtkWidget *self, GtkEntry *output_target){
	ubl_settings_usergroups_group_window *window = yon_ubl_settings_usergroups_group_new();
	gtk_window_set_title(GTK_WINDOW(window->GroupsWindow),MAIN_GROUP_LABEL);
	gtk_label_set_text(GTK_LABEL(window->HeaderLabel),MAIN_GROUP_LABEL);
	GtkTreeIter iter, itar;
	int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(main_config.groups_list),&iter);
	for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(main_config.groups_list),&iter)){
		char *groupname;
		gtk_tree_model_get(GTK_TREE_MODEL(main_config.groups_list),&iter,1,&groupname,-1);
		gtk_list_store_append(window->list,&itar);
		gtk_list_store_set(window->list,&itar,1,groupname,-1);
		free(groupname);
	}
	gtk_tree_view_column_set_visible(gtk_tree_view_get_column(GTK_TREE_VIEW(window->GroupsTree),0),0);
	gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(window->GroupsTree)),GTK_SELECTION_SINGLE);
	dictionary *dict = NULL;
	yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
	yon_dictionary_add_or_create_if_exists_with_data(dict,"output",output_target);
	
    g_signal_connect(G_OBJECT(window->GroupsOkButton),"clicked",G_CALLBACK(on_groups_save),dict);
    gtk_widget_show(window->GroupsWindow);

}

void on_groups_multiple_save(GtkWidget *self, dictionary *dict){
	ubl_settings_usergroups_group_window *window = yon_dictionary_get_data(dict->first,ubl_settings_usergroups_group_window*);
	GtkEntry *output = yon_dictionary_get_data(dict->first->next,GtkEntry*);
	GtkTreeIter iter;
	int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->list),&iter);
	char *full_groups="";
	for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->list),&iter)){
		char *name;
		int status;
		gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,0,&status,1,&name,-1);
		if (status){
			char *extend_groups = yon_char_unite(full_groups,!yon_char_is_empty(full_groups)?",":"",name,NULL);
			if (!yon_char_is_empty(full_groups))
				free(full_groups);
			full_groups=extend_groups;
		}
	}
	gtk_entry_set_text(output,full_groups);
	on_subwindow_close(self);
}

void on_groups_multiple_clicked(GtkWidget *self, GtkEntry *output_target){
	ubl_settings_usergroups_group_window *window = yon_ubl_settings_usergroups_group_new();
	gtk_window_set_title(GTK_WINDOW(window->GroupsWindow),ADDITIONAL_GROUPS_TITLE_LABEL);
	gtk_label_set_text(GTK_LABEL(window->HeaderLabel),ADDITIONAL_GROUPS_TITLE_LABEL);
	GtkTreeIter iter, itar;
	char *output = (char*)gtk_entry_get_text(output_target);
	int size=0;
	config_str parsed=NULL;
	if (!yon_char_is_empty(output)){
		parsed = yon_char_parse(output,&size,",");
	}
	int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(main_config.groups_list),&iter);
	for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(main_config.groups_list),&iter)){
		char *groupname;
		gtk_tree_model_get(GTK_TREE_MODEL(main_config.groups_list),&iter,1,&groupname,-1);
		gtk_list_store_append(window->list,&itar);
		gtk_list_store_set(window->list,&itar,1,groupname,-1);
		free(groupname);
	}
	valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->list),&iter);
	for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->list),&iter)){
		char *groupname;
		gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,1,&groupname,-1);
		if (parsed){
			if (yon_char_parsed_check_exist(parsed,size,groupname)>-1){
				gtk_list_store_set(window->list,&iter,0,1,-1);
			}
		}
	}
	dictionary *dict = NULL;
	yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
	yon_dictionary_add_or_create_if_exists_with_data(dict,"output",output_target);
    g_signal_connect(G_OBJECT(window->GroupsOkButton),"clicked",G_CALLBACK(on_groups_multiple_save),dict);
    gtk_widget_show(window->GroupsWindow);

}

void on_passwords_encrypt(){
	int pid = fork();
	if (!pid){
		exit(system(encrypt_passwords_command));
	}
}

void on_password_change(GtkWidget *self, dictionary *entry_dict){//
	GtkComboBox *combo = yon_dictionary_get_data(entry_dict->first,GtkComboBox*);
	GtkEntry *output_target = yon_dictionary_get_data(entry_dict->first->next,GtkEntry*);
	ubl_settings_usergroups_password_window *window = yon_ubl_settings_usergroups_password_new();
	dictionary *dict = NULL;
	char *password = (char*)gtk_entry_get_text(output_target);
	if (!yon_char_is_empty(password)){
		if (main_config.load_mode==0){
			password = yon_char_new(password);
			if (!check_is_password_hash(password)){
				gtk_entry_set_text(GTK_ENTRY(window->PasswordHashEntry),password);
			} else {
					gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->NoEncriptionCheck),1);
				gtk_entry_set_text(GTK_ENTRY(window->PasswordEntry),password);
			}
		}
	}
	yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
	yon_dictionary_add_or_create_if_exists_with_data(dict,"target",output_target);
    g_signal_connect(G_OBJECT(window->UserOkButton),"clicked",G_CALLBACK(on_password_accept),dict);
	g_signal_connect(G_OBJECT(window->UserCancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
	gtk_window_set_transient_for(GTK_WINDOW(window->CreateGroupWindow),GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(output_target))));
    gtk_widget_show(window->CreateGroupWindow);

}

void on_additional_settings_clicked(GtkWidget *self, GtkEntry *output_target){
	ubl_settings_usergroups_additional_settings_window *window = yon_ubl_settings_usergroups_additional_settings_new();
    g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
    gtk_widget_show(window->Window);

}

void on_expiration_clicked(GtkWidget *self, ubl_settings_usergroups_user_window *window){
	gtk_popover_popup(GTK_POPOVER(window->CalendarPopup));
}

// standard functions 
 
 void on_additional_settings_save(GtkWidget *self, ubl_settings_usergroups_additional_settings_window *window){
	const char *default_user = (char*)gtk_entry_get_text(GTK_ENTRY(window->DefaultUserNameEntry));
	if (!yon_char_is_empty(default_user)){
		yon_config_register("DEFAULTUSER","users",yon_char_new((char*)default_user));
	} else {
		yon_config_remove_by_key("DEFAULTUSER");
	}
	char *default_password = gtk_combo_box_get_active(GTK_COMBO_BOX(window->DefaultPasswordCombo))>1? (char*)gtk_entry_get_text(GTK_ENTRY(window->DefaultPasswordEntry)):NULL;
	if (!yon_char_is_empty(default_password)){
		yon_config_register("DEFAULTPASSWD","users",default_password);
	} else {
		yon_config_remove_by_key("DEFAULTPASSWD");
	}
	char *root_password = gtk_combo_box_get_active(GTK_COMBO_BOX(window->RootPasswordCombo)) > 1 ? (char*)gtk_entry_get_text(GTK_ENTRY(window->RootPasswordEntry)) : NULL;
	if (!yon_char_is_empty(root_password)){
		yon_config_register("DEFAULTROOTPASSWD","users",root_password);
	} else {
		yon_config_remove_by_key("DEFAULTROOTPASSWD");
	}
	int user_k_admin = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->DefaultUserAdministratorCheck));
	if (user_k_admin){
		yon_config_register("ADDADM","users","yes");
	} else {
		yon_config_register("ADDADM","users","no");
	}
	if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->PasswordHashCombo))!=0){
		char *hash = (char*)gtk_combo_box_get_active_id(GTK_COMBO_BOX(window->PasswordHashCombo));
		if (!yon_char_is_empty(hash)){
			yon_config_register("HASHPASSWD","users",hash);
		}
	}else {
		yon_config_remove_by_key("HASHPASSWD");
	}
 }

 void on_hash_changed(GtkWidget *self, ubl_settings_usergroups_additional_settings_window *window){

	int hash_size=0;
	config_str hash_algos = yon_file_open(hash_list_path,&hash_size);
	for (int i=1;i<hash_size;i++){
			if (hash_algos[i][strlen(hash_algos[i])-1]=='\n') hash_algos[i][strlen(hash_algos[i])-1]='\0';
			int parsed_size;
			config_str parsed = yon_char_parse(hash_algos[i],&parsed_size,";");
			gtk_widget_set_tooltip_text(window->PasswordHashCombo,parsed[1]);
			yon_char_parsed_free(parsed,parsed_size);
	}
	yon_char_parsed_free(hash_algos,hash_size);
 }

ubl_settings_usergroups_additional_settings_window *yon_ubl_settings_usergroups_additional_settings_new(){
	ubl_settings_usergroups_additional_settings_window *window = malloc(sizeof(ubl_settings_usergroups_additional_settings_window));
	GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_ubl_settings_usergroups_additional_settings);
	window->Window=yon_gtk_builder_get_widget(builder,"Window");
	window->StatusBox=yon_gtk_builder_get_widget(builder,"StatusBox");
	window->DefaultUserNameEntry=yon_gtk_builder_get_widget(builder,"DefaultUserNameEntry");
	window->DefaultUserAdministratorCheck=yon_gtk_builder_get_widget(builder,"DefaultUserAdministratorCheck");
	window->DefaultPasswordCombo=yon_gtk_builder_get_widget(builder,"DefaultPasswordCombo");
	window->DefaultPasswordEntry=yon_gtk_builder_get_widget(builder,"DefaultPasswordEntry");
	window->DefaultPasswordButton=yon_gtk_builder_get_widget(builder,"DefaultPasswordButton");
	window->RootPasswordCombo=yon_gtk_builder_get_widget(builder,"RootPasswordCombo");
	window->RootPasswordEntry=yon_gtk_builder_get_widget(builder,"RootPasswordEntry");
	window->RootPasswordButton=yon_gtk_builder_get_widget(builder,"RootPasswordButton");
	window->PasswordHashCombo=yon_gtk_builder_get_widget(builder,"PasswordHashCombo");
	window->EncryptAllPasswordsButton=yon_gtk_builder_get_widget(builder,"EncryptAllPasswordsButton");
	window->CancelButton=yon_gtk_builder_get_widget(builder,"CancelButton");
	window->AcceptButton=yon_gtk_builder_get_widget(builder,"AcceptButton");

	yon_window_config_custom_window_setup(GTK_WINDOW(window->Window),"AdditionalSettingsWindow");
	gtk_window_set_title(GTK_WINDOW(window->Window),ADDITIONAL_SETTINGS_TITLE_LABEL);

	int hash_size=0;
	config_str hash_algos = yon_file_open(hash_list_path,&hash_size);
	if (main_config.hash_default_id==-1){
		int size;
		config_str ret = yon_config_load(get_default_hash_command,&size);
		if (size>0){
			char *hash = ret[0];
			if (hash[strlen(hash)-1]=='\n') hash[strlen(hash)-1]='\0';
			for (int i=0;i<hash_size;i++){
				if (hash_algos[i][0]!='!'){
					if (hash_algos[i][strlen(hash_algos[i])-1]=='\n') hash_algos[i][strlen(hash_algos[i])-1]='\0';
					int parsed_size;
					config_str parsed = yon_char_parse(hash_algos[i],&parsed_size,";");
					if (!strcmp(hash,parsed[0])){
						char *def_settings = yon_char_new(parsed[1]);
						char *def = yon_char_divide_search(def_settings," ",-1);
						free(def_settings);
						gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->PasswordHashCombo),yon_char_unite(DEFAULT_USER_LABEL," (",def,")",NULL));
					}
				}
			}
		}
	}
	for (int i=1;i<hash_size;i++){
		if (hash_algos[i][0]!='!'){
			if (hash_algos[i][strlen(hash_algos[i])-1]=='\n') hash_algos[i][strlen(hash_algos[i])-1]='\0';
			int parsed_size;
			config_str parsed = yon_char_parse(hash_algos[i],&parsed_size,";");
			gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(window->PasswordHashCombo),parsed[0],parsed[1]);
			gtk_widget_set_tooltip_text(window->PasswordHashCombo,parsed[1]);
			yon_char_parsed_free(parsed,parsed_size);
		}
	}
	yon_char_parsed_free(hash_algos,hash_size);
	gtk_combo_box_set_active(GTK_COMBO_BOX(window->PasswordHashCombo),0);
	char *default_user = yon_config_get_by_key("DEFAULTUSER");
	if (!yon_char_is_empty(default_user))
		gtk_entry_set_text(GTK_ENTRY(window->DefaultUserNameEntry),default_user);


	g_signal_connect(G_OBJECT(window->RootPasswordCombo),"changed",G_CALLBACK(on_password_combo_changed),window->RootPasswordButton);
	g_signal_connect(G_OBJECT(window->DefaultPasswordCombo),"changed",G_CALLBACK(on_password_combo_changed),window->DefaultPasswordButton);
	char *default_password = yon_config_get_by_key("DEFAULTPASSWD");
	if (!yon_char_is_empty(default_password)){
		gtk_entry_set_text(GTK_ENTRY(window->DefaultPasswordEntry),default_password);
		if(!yon_config_check_ignore("DEFAULTPASSWD"))
			gtk_combo_box_set_active(GTK_COMBO_BOX(window->DefaultPasswordCombo),2);
	}
	char *root_password = yon_config_get_by_key("DEFAULTROOTPASSWD");
	if (!yon_char_is_empty(root_password)){
		gtk_entry_set_text(GTK_ENTRY(window->RootPasswordEntry),root_password);
		if(!yon_config_check_ignore("DEFAULTROOTPASSWD"))
			gtk_combo_box_set_active(GTK_COMBO_BOX(window->RootPasswordCombo),2);
	}
	char *is_k_admin = yon_config_get_by_key("ADDADM");
	if (!yon_char_is_empty(is_k_admin))
		if (!strcmp(is_k_admin,"yes"))
			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->DefaultUserAdministratorCheck),1);
	char *hash = yon_config_get_by_key("HASHPASSWD");
	if (!yon_char_is_empty(hash)){
		gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->PasswordHashCombo),hash);
	}

	g_signal_connect(G_OBJECT(window->CancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
	g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_additional_settings_save),window);
	dictionary *default_dict=NULL;
	yon_dictionary_add_or_create_if_exists_with_data(default_dict,"combo",window->DefaultPasswordCombo);
	yon_dictionary_add_or_create_if_exists_with_data(default_dict,"entry",window->DefaultPasswordEntry);

	dictionary *root_dict=NULL;
	yon_dictionary_add_or_create_if_exists_with_data(root_dict,"combo",window->RootPasswordCombo);
	yon_dictionary_add_or_create_if_exists_with_data(root_dict,"entry",window->RootPasswordEntry);
	g_signal_connect(G_OBJECT(window->DefaultPasswordButton),"clicked",G_CALLBACK(on_password_change),default_dict);
	g_signal_connect(G_OBJECT(window->RootPasswordButton),"clicked",G_CALLBACK(on_password_change),root_dict);
	dialog_confirmation_data *data=malloc(sizeof(dialog_confirmation_data));
	data->function=on_passwords_encrypt;
	data->action_text = ENCRYPT_SURE_LABEL;
	data->data=NULL;
	g_signal_connect(G_OBJECT(window->EncryptAllPasswordsButton),"clicked",G_CALLBACK(yon_confirmation_dialog_call),data);

	g_signal_connect(G_OBJECT(window->PasswordHashCombo),"changed",G_CALLBACK(on_hash_changed),window);

return window;
}

void on_ubl_settings_usergroups_additional_settings_open(GtkWidget *self, main_window *widgets){
    ubl_settings_usergroups_additional_settings_window *window = yon_ubl_settings_usergroups_additional_settings_new();
    g_signal_connect(G_OBJECT(window->AcceptButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
    
    gtk_window_set_transient_for(GTK_WINDOW(window->Window),GTK_WINDOW(widgets->Window));
    gtk_widget_show(window->Window);

}

void on_user_choose(GtkWidget *self, GtkEntry *target){
	ubl_settings_usergroups_group_window *window = yon_ubl_settings_usergroups_group_new();
	gtk_label_set_text(GTK_LABEL(window->HeaderLabel),GROUP_USERS_TITLE_LABEL);
			gtk_label_set_text(GTK_LABEL(window->HeaderLabel),GROUP_USERS_TITLE_LABEL);
	GtkTreeIter iter, itar;
	char *output = (char*)gtk_entry_get_text(target);
	int size=0;
	config_str parsed=NULL;
	if (!yon_char_is_empty(output)){
		parsed = yon_char_parse(output,&size,",");
	}
	int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(main_config.users_list),&iter);
	for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(main_config.users_list),&iter)){
		char *groupname;
		gtk_tree_model_get(GTK_TREE_MODEL(main_config.users_list),&iter,2,&groupname,-1);
		gtk_list_store_append(window->list,&itar);
		gtk_list_store_set(window->list,&itar,1,groupname,-1);
		free(groupname);
	}
	valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->list),&iter);
	for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->list),&iter)){
		char *groupname;
		gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,1,&groupname,-1);
		if (parsed){
			if (yon_char_parsed_check_exist(parsed,size,groupname)>-1){
				gtk_list_store_set(window->list,&iter,0,1,-1);
			}
		}
	}
	gtk_list_store_new(2,G_TYPE_BOOLEAN,G_TYPE_STRING);
	dictionary *dict = NULL;
	yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
	yon_dictionary_add_or_create_if_exists_with_data(dict,"output",target);
    g_signal_connect(G_OBJECT(window->GroupsOkButton),"clicked",G_CALLBACK(on_groups_multiple_save),dict);
    gtk_widget_show(window->GroupsWindow);
}

void on_GID_update(GtkWidget *self, ubl_settings_usergroups_group_creation_window *window){
	if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userUIDAutoCheck))){
	int config_size=0;
		int final_size=0;
		config_str config_groups = yon_config_get_all_by_key("GROUPADD",&config_size);
		yon_char_parsed_prepend_strings(config_groups,config_size,":");
		config_str final = yon_char_parsed_merge(main_config.groups,main_config.groups_size,config_groups,config_size,&final_size);
		long prev_busy=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->SystemGroupCheck))?0:main_config.MINGID;
	for (int i=0;i<final_size;i++){
		int parsed_size;
		config_str parsed = yon_char_parse(final[i],&parsed_size,":");

		if (atol(parsed[2])>=main_config.MINGID||gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->SystemGroupCheck))){
			if (atol(parsed[2])>main_config.MAXGID||gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->SystemGroupCheck)))
				break;
			if (atol(parsed[2])==prev_busy+1)
				prev_busy=atol(parsed[2]);
			else {
				yon_char_parsed_free(parsed, parsed_size);
				break;
			}
		}
		yon_char_parsed_free(parsed, parsed_size);
	}
		gtk_entry_set_text(GTK_ENTRY(window->userUIDEntry),yon_char_from_long(prev_busy+1));
	} else {
		gtk_entry_set_text(GTK_ENTRY(window->userUIDEntry),"");
	}
}

void on_group_save(GtkWidget *self, dictionary *dict){
	main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
	ubl_settings_usergroups_group_creation_window *window = yon_dictionary_get_data(dict->first->next,ubl_settings_usergroups_group_creation_window*);
	char *final_string = NULL;
	char *group_name = NULL;
	char *group_users = NULL;
	char *gid = NULL;
	char *non_unique = NULL;
	char *gsystem = NULL;
	char *admins = NULL;
	char *password = NULL;
	int gid_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userUIDAutoCheck));
	if (gid_active){
		gid="x";
	} else {
		gid = (char*)gtk_entry_get_text(GTK_ENTRY(window->userUIDEntry));
		if (yon_char_is_empty(gid)){
			yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
			yon_ubl_status_highlight_incorrect(window->userUIDEntry);
			return;
		}
	}
	
	group_name = (char*)gtk_entry_get_text(GTK_ENTRY(window->userLoginEntry));
	if (group_name[0]>'0'&&group_name[0]<'9'){
			yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),GROUP_BEGINS_WITH_DIGIT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
			yon_ubl_status_highlight_incorrect(window->userLoginEntry);
			return;
	}
	if (yon_char_is_empty(group_name)){
			yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
			yon_ubl_status_highlight_incorrect(window->userLoginEntry);
			return;
	}
	
	group_users = (char*)gtk_entry_get_text(GTK_ENTRY(window->userGroupsEntry));
	if (yon_char_is_empty(group_users)){
			yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
			yon_ubl_status_highlight_incorrect(window->userGroupsEntry);
			return;
	}
	
	admins = (char*)gtk_entry_get_text(GTK_ENTRY(window->AdminGroupsEntry));
	int non_unique_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->UnuniqueGIDCheck));
	if(non_unique_active){
		non_unique=" --non-unique";
	} else non_unique="";
	
	int gsystem_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->SystemGroupCheck));
	if(gsystem_active){
		gsystem=" --system";
	} else gsystem="";
	
	int shutdown_sync_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->GroupaddShutdownCheck));
	if (shutdown_sync_active){
		yon_config_register(GROUPADD_SYNC(group_name),"users","shutdown");
	} else {
		yon_config_remove_by_key(GROUPADD_SYNC(group_name));
	}

	password = (char*)gtk_entry_get_text(GTK_ENTRY(window->PasswordEntry));
	final_string = yon_char_unite(yon_char_return_if_exist(group_users,"x"),
	":",yon_char_return_if_exist(gid,"x"),
	":",yon_char_return_if_exist(non_unique,""),
	yon_char_return_if_exist(gsystem,""),
	":",yon_char_return_if_exist(admins,"x"),
	":",yon_char_return_if_exist(password,"x"),
	NULL);
	yon_config_register(GROUPADD(group_name),"users",final_string);
	GtkTreeIter iter;
	GtkTreeModel *model = GTK_TREE_MODEL(widgets->GroupsList);
	if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->GroupsTree)),&model,&iter))
		gtk_list_store_append(widgets->GroupsList,&iter);
	gtk_list_store_set(widgets->GroupsList,&iter,0,strcmp(gid,"x")?gid:AUTOMATICALLY_LABEL,1,group_name,2,group_users,3,yon_char_append(non_unique,gsystem),4,gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->PasswordCombo)),-1);
	on_subwindow_close(self);
}

void on_system_parameter_changed(GtkWidget *self, ubl_settings_usergroups_group_creation_window *window){

	char *non_unique = NULL;
	char *gsystem = NULL;
	
	int non_unique_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->UnuniqueGIDCheck));
	if(non_unique_active){
		non_unique="--non-unique";
	} else non_unique="";

	int gsystem_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->SystemGroupCheck));
	if(gsystem_active){
		gsystem="--system";
	} else gsystem="";

	char *final_str = yon_char_unite(
		yon_char_return_if_exist(non_unique,""),
		!yon_char_is_empty(non_unique)?" ":"",
		yon_char_return_if_exist(gsystem,"")
	);
	gtk_entry_set_text(GTK_ENTRY(window->groupExtraOptionsEntry),final_str);
	free(final_str);
}

ubl_settings_usergroups_group_creation_window *yon_ubl_settings_usergroups_group_creation_new(){
	ubl_settings_usergroups_group_creation_window *window = malloc(sizeof(ubl_settings_usergroups_group_creation_window));
	GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_ubl_settings_usergroups_group_creation);
	window->CreateGroupWindow=yon_gtk_builder_get_widget(builder,"CreateGroupWindow");
	window->StatusBox=yon_gtk_builder_get_widget(builder,"StatusBox");
	window->userUIDAutoCheck=yon_gtk_builder_get_widget(builder,"GIDAutoCheck");
	window->userUIDEntry=yon_gtk_builder_get_widget(builder,"userUIDEntry");
	window->userLoginEntry=yon_gtk_builder_get_widget(builder,"userLoginEntry");
	window->userGroupsEntry=yon_gtk_builder_get_widget(builder,"userGroupsEntry");
	window->UserAdditionalGroupsButton=yon_gtk_builder_get_widget(builder,"AdditionalGroupsButton");
	window->UserCancelButton=yon_gtk_builder_get_widget(builder,"UserCancelButton");
	window->UserOkButton=yon_gtk_builder_get_widget(builder,"UserOkButton");
	window->AdditionalGroupsButton=yon_gtk_builder_get_widget(builder,"AdditionalGroupsButton");
	window->UnuniqueGIDCheck=yon_gtk_builder_get_widget(builder,"UnuniqueGIDCheck");
	window->SystemGroupCheck=yon_gtk_builder_get_widget(builder,"SystemGroupCheck");
	window->PasswordCombo=yon_gtk_builder_get_widget(builder,"PasswordCombo");
	window->PasswordEntry=yon_gtk_builder_get_widget(builder,"PasswordEntry");
	window->ChangePasswordButton=yon_gtk_builder_get_widget(builder,"ChangePasswordButton");
	window->userTitleNameLabel=yon_gtk_builder_get_widget(builder,"userTitleNameLabel");
	window->AdminGroupsEntry=yon_gtk_builder_get_widget(builder,"AdminGroupsEntry");
	window->AdminGroupsButton=yon_gtk_builder_get_widget(builder,"AdminGroupsButton");
	window->GroupaddShutdownCheck=yon_gtk_builder_get_widget(builder,"GroupaddShutdownCheck");
	window->groupExtraOptionsEntry=yon_gtk_builder_get_widget(builder,"groupExtraOptionsEntry");

	gtk_window_set_title(GTK_WINDOW(window->CreateGroupWindow),GROUPS_TITLE_LABEL);

		on_GID_update(NULL,window);
	dictionary *entry_dict=NULL;
	yon_dictionary_add_or_create_if_exists_with_data(entry_dict,"combo",window->PasswordCombo);
	yon_dictionary_add_or_create_if_exists_with_data(entry_dict,"entry",window->PasswordEntry);
	yon_window_config_custom_window_setup(GTK_WINDOW(window->CreateGroupWindow),"GroupAddWindow");
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"clicked",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button_inversed),window->userUIDEntry);
	g_signal_connect(G_OBJECT(window->ChangePasswordButton),"clicked",G_CALLBACK(on_password_change),entry_dict);
	g_signal_connect(G_OBJECT(window->PasswordCombo),"changed",G_CALLBACK(on_password_combo_changed),window->ChangePasswordButton);
	g_signal_connect(G_OBJECT(window->UserCancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
	g_signal_connect(G_OBJECT(window->UserAdditionalGroupsButton),"clicked",G_CALLBACK(on_user_choose),window->userGroupsEntry);
	g_signal_connect(G_OBJECT(window->AdminGroupsButton),"clicked",G_CALLBACK(on_user_choose),window->AdminGroupsEntry);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(on_GID_update),window);
	g_signal_connect(G_OBJECT(window->SystemGroupCheck),"toggled",G_CALLBACK(on_GID_update),window);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(yon_gtk_toggle_button_set_inactive_from_toggle_button),window->SystemGroupCheck);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button),window->SystemGroupCheck);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(yon_gtk_toggle_button_set_inactive_from_toggle_button_inversed),window->UnuniqueGIDCheck);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button_inversed),window->UnuniqueGIDCheck);
	g_signal_connect(G_OBJECT(window->UnuniqueGIDCheck),"toggled",G_CALLBACK(on_system_parameter_changed),window);
	g_signal_connect(G_OBJECT(window->SystemGroupCheck),"toggled",G_CALLBACK(on_system_parameter_changed),window);
return window;
}

void on_group_clicked(GtkCellRenderer *self, char *path, ubl_settings_usergroups_group_window *window){
	GtkTreeIter iter;
	gboolean status;
	gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(window->list),&iter,path);
	gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,0,&status,-1);
	gtk_list_store_set(window->list,&iter,0,!status,-1);
}

ubl_settings_usergroups_group_window *yon_ubl_settings_usergroups_group_new(){
	ubl_settings_usergroups_group_window *window = malloc(sizeof(ubl_settings_usergroups_group_window));
	GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_ubl_settings_usergroups_group);
	window->GroupsWindow=yon_gtk_builder_get_widget(builder,"GroupsWindow");
	window->GroupsTree=yon_gtk_builder_get_widget(builder,"GroupsTree");
	window->GroupsCancelButton=yon_gtk_builder_get_widget(builder,"GroupsCancelButton");
	window->GroupsOkButton=yon_gtk_builder_get_widget(builder,"GroupsOkButton");
	window->HeaderLabel=yon_gtk_builder_get_widget(builder,"HeaderLabel");
	window->StatusCell = GTK_CELL_RENDERER(gtk_builder_get_object(builder,"StatusCell"));
	window->list = gtk_list_store_new(2,G_TYPE_BOOLEAN,G_TYPE_STRING);

	yon_window_config_custom_window_setup(GTK_WINDOW(window->GroupsWindow),"GroupWindow");
	gtk_window_set_title(GTK_WINDOW(window->GroupsWindow),GROUPS_TITLE_LABEL);
	g_signal_connect(G_OBJECT(window->StatusCell),"toggled",G_CALLBACK(on_group_clicked),window);
	GtkTreeIter iter;
	gtk_tree_view_set_model(GTK_TREE_VIEW(window->GroupsTree),GTK_TREE_MODEL(window->list));
	for (int i=0;i<main_config.groups_size;i++){
		char *group_record = yon_char_new(main_config.groups[i]);
		char *group_name = yon_char_divide_search(group_record,":",-1);
		gtk_list_store_append(window->list,&iter);
		gtk_list_store_set(window->list,&iter,0,0,1,group_name,-1);
	}


	g_signal_connect(G_OBJECT(window->GroupsCancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
return window;
}

void on_standard_groups_accept(GtkWidget *self, ubl_settings_usergroups_group_window *window){
	GtkTreeIter iter;
	GtkTreeModel *model = GTK_TREE_MODEL(window->list);
	int valid = gtk_tree_model_get_iter_first(model,&iter);
	char *standard_groups="";
	for (;valid;valid=gtk_tree_model_iter_next(model,&iter)){
		int status;
		char *group;
		gtk_tree_model_get(model,&iter,0,&status,1,&group,-1);
		if (status){
			char *extend_groups = yon_char_unite(standard_groups,!yon_char_is_empty(standard_groups)?",":"",group,NULL);
			if (!yon_char_is_empty(standard_groups)) 
				free(standard_groups);
			standard_groups=extend_groups;
		}
	}
	yon_config_register("USERGROUPS","users",standard_groups);
	on_subwindow_close(self);
}

void on_standard_groups_open(GtkWidget *self, main_window *widgets){
    ubl_settings_usergroups_group_window *window = yon_ubl_settings_usergroups_group_new();
	gtk_window_set_title(GTK_WINDOW(window->GroupsWindow),DEFAULT_GROUPS_TITLE_LABEL);
	gtk_label_set_text(GTK_LABEL(window->HeaderLabel),DEFAULT_GROUPS_TITLE_LABEL);
	GtkTreeIter iter, itar;
	int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(main_config.groups_list),&iter);
	for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(main_config.groups_list),&iter)){
		char *groupname;
		gtk_tree_model_get(GTK_TREE_MODEL(main_config.groups_list),&iter,1,&groupname,-1);
		gtk_list_store_append(window->list,&itar);
		gtk_list_store_set(window->list,&itar,1,groupname,-1);
		free(groupname);
	}
    g_signal_connect(G_OBJECT(window->GroupsOkButton),"clicked",G_CALLBACK(on_standard_groups_accept),window);
    gtk_window_set_transient_for(GTK_WINDOW(window->GroupsWindow),GTK_WINDOW(widgets->Window));
	char *groups = yon_config_get_by_key("USERGROUPS");
	if (!yon_char_is_empty(groups)){
		GtkTreeIter iter;
		int size;
		config_str standard_groups = yon_char_parse(groups,&size,",");
		int valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(window->list),&iter);
		for (;valid;valid=gtk_tree_model_iter_next(GTK_TREE_MODEL(window->list),&iter)){
			char *cur_name;
			gtk_tree_model_get(GTK_TREE_MODEL(window->list),&iter,1,&cur_name,-1);
			for (int i=0;i<size;i++){
				if (!strcmp(standard_groups[i],cur_name)){
					gtk_list_store_set(window->list,&iter,0,1,-1);
				}
			}
			free(cur_name);
		}
	}
    gtk_widget_show(window->GroupsWindow);
}

void on_password_show_hide(GtkEntry *self, GtkEntryIconPosition icon_pos,  GdkEvent* event){
	if (icon_pos == GTK_ENTRY_ICON_SECONDARY){
		int visible = gtk_entry_get_visibility(self);
		if (!visible){
			gtk_entry_set_visibility(self,1);
		} else {
			gtk_entry_set_visibility(self,0);
			gtk_entry_set_invisible_char(self,'*');
		}
	}
}

void on_password_changed(GtkEntry *self, ubl_settings_usergroups_password_window *window){
	char *self_text = (char*)gtk_entry_get_text(GTK_ENTRY(window->PasswordEntry));
	char *pair_text = (char*)gtk_entry_get_text(GTK_ENTRY(window->RepeatPasswordEntry));
	if ((!yon_char_is_empty(self_text)&&!yon_char_is_empty(pair_text))&&strcmp(self_text,pair_text)){
		yon_ubl_status_box_spawn_infinite(GTK_CONTAINER(window->StatusBox),"password_mismatch",PASSWORD_MISMATCH_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
	} else if (strlen(self_text)<main_config.password_min_length){
		yon_ubl_status_box_spawn_infinite(GTK_CONTAINER(window->StatusBox),"password_short",PASSWORD_SHORT_LABEL(yon_char_from_int(main_config.password_min_length)),BACKGROUND_IMAGE_FAIL_TYPE);
	} else {
		yon_ubl_status_box_despawn_infinite(GTK_CONTAINER(window->StatusBox));
	}
}

void on_password_accept(GtkWidget *self, dictionary *dict){
	ubl_settings_usergroups_password_window *window = yon_dictionary_get_data(dict->first,ubl_settings_usergroups_password_window*);
	GtkEntry *entry = yon_dictionary_get_data(dict->first->next,GtkEntry*);
	char *password = (char*)gtk_entry_get_text(GTK_ENTRY(window->PasswordEntry));
	if (yon_char_is_empty(password)){
		char *pasted_hash = (char*)gtk_entry_get_text(GTK_ENTRY(window->PasswordHashEntry));
		if (!yon_char_is_empty(pasted_hash)){
				gtk_entry_set_text(entry,pasted_hash);
		}
	} else {
		
		if (yon_char_is_empty(password)){
			yon_ubl_status_box_spawn_infinite(GTK_CONTAINER(window->StatusBox),"password_empty",EMPTY_IMPORTANT_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
			return;
		} else if (password[0]=='%'&&password[1]=='%'){
			yon_ubl_status_box_spawn_infinite(GTK_CONTAINER(window->StatusBox),"password_wrong",EMPTY_IMPORTANT_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
			return;
		}
		if (strlen(password)<main_config.password_min_length){
			yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),PASSWORD_SHORT_LABEL(yon_char_from_int(main_config.password_min_length)),5,BACKGROUND_IMAGE_FAIL_TYPE);
			return;
		}
		char *password_check = (char*)gtk_entry_get_text(GTK_ENTRY(window->RepeatPasswordEntry));
		if (!strcmp(password,password_check)){
			if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->NoEncriptionCheck))){
				char *pasw=yon_char_append("%%",password);
				password=pasw;
			}
				gtk_entry_set_text(GTK_ENTRY(entry),password);
		} else {
			yon_ubl_status_box_spawn_infinite(GTK_CONTAINER(window->StatusBox),"password_mismatch",PASSWORD_MISMATCH_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
			return;
		}
	}
	on_subwindow_close(self);
}

ubl_settings_usergroups_password_window *yon_ubl_settings_usergroups_password_new(){
	ubl_settings_usergroups_password_window *window = malloc(sizeof(ubl_settings_usergroups_password_window));
	GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_ubl_settings_usergroups_password);
	window->CreateGroupWindow=yon_gtk_builder_get_widget(builder,"CreateGroupWindow");
	window->StatusBox=yon_gtk_builder_get_widget(builder,"StatusBox");
	window->PasswordEntry=yon_gtk_builder_get_widget(builder,"PasswordEntry");
	window->RepeatPasswordEntry=yon_gtk_builder_get_widget(builder,"RepeatPasswordEntry");
	window->PasswordHashEntry=yon_gtk_builder_get_widget(builder,"PasswordHashEntry");
	window->HashBox=yon_gtk_builder_get_widget(builder,"HashBox");
	window->PasswordBox=yon_gtk_builder_get_widget(builder,"PasswordBox");
	window->NoEncriptionCheck=yon_gtk_builder_get_widget(builder,"NoEncriptionCheck");

	window->UserCancelButton=yon_gtk_builder_get_widget(builder,"UserCancelButton");
	window->UserOkButton=yon_gtk_builder_get_widget(builder,"UserOkButton");

	yon_window_config_custom_window_setup(GTK_WINDOW(window->CreateGroupWindow),"PasswordWindow");
	g_signal_connect(G_OBJECT(window->UserCancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
	g_signal_connect(G_OBJECT(window->PasswordEntry),"icon-press",G_CALLBACK(on_password_show_hide),NULL);
	g_signal_connect(G_OBJECT(window->RepeatPasswordEntry),"icon-press",G_CALLBACK(on_password_show_hide),NULL);
	g_signal_connect(G_OBJECT(window->PasswordHashEntry),"icon-press",G_CALLBACK(on_password_show_hide),NULL);
	g_signal_connect(G_OBJECT(window->PasswordEntry),"changed",G_CALLBACK(on_password_changed),window);
	g_signal_connect(G_OBJECT(window->RepeatPasswordEntry),"changed",G_CALLBACK(on_password_changed),window);
	gtk_window_set_title(GTK_WINDOW(window->CreateGroupWindow),PASSWORD_TITLE_LABEL);
	
return window;
}

void yon_system_load(ubl_settings_usergroups_system_window *window){
	gtk_list_store_clear(window->liststore1);
	gtk_list_store_clear(window->liststore2);
	GtkTreeIter iter;
	for (int i=0;i<main_config.groups_size;i++){
		int parsed_size;
		if (main_config.groups[i][strlen(main_config.groups[i])-1]=='\n') main_config.groups[i][strlen(main_config.groups[i])-1]='\0';
		config_str parsed = yon_char_parse(main_config.groups[i],&parsed_size,":");
		if (atoi(parsed[2])>=main_config.MINGID&&atoi(parsed[2])<=main_config.MAXGID||window->show_all==1){
			gtk_list_store_append(window->liststore2,&iter);
			gtk_list_store_set(window->liststore2,&iter,0,atol(parsed[2]),1,parsed[0],2,parsed[3],-1);
		}
	}
	for (int i=0;i<main_config.users_size;i++){
		int parsed_size;
		config_str parsed = yon_char_parse(main_config.users[i],&parsed_size,":");
		if ((atoi(parsed[2])>=main_config.MINUID&&atoi(parsed[2])<=main_config.MAXUID)||window->show_all==1){
			char *groups_string="";
			char *main_group_name="";
			for (int j=0;j<main_config.groups_size;j++){
				int parsed_gr_size;
				config_str parsed_group = yon_char_parse(main_config.groups[j],&parsed_gr_size,":");
				if (atol(parsed[2])==atol(parsed_group[2])){
					main_group_name=yon_char_new(parsed_group[0]);
				}
				if (strstr(parsed_group[3],parsed[0])){
					groups_string = yon_char_unite(groups_string,!yon_char_is_empty(groups_string)?",":"",parsed_group[0],NULL);
				}
				yon_char_parsed_free(parsed_group,parsed_gr_size);
			}
			gtk_list_store_append(window->liststore1,&iter);
			gtk_list_store_set(window->liststore1,&iter,1,atol(parsed[2]),2,parsed[0],3,parsed[0],4,main_group_name,5,groups_string,6,parsed[5],-1);
		}
		yon_char_parsed_free(parsed,parsed_size);
	}
	int shadow_size;
	config_str shadow = yon_file_open(shadow_path,&shadow_size);
	for (int i=0;i<shadow_size;i++){
		if (shadow[i][strlen(shadow[i])-1]=='\n') shadow[i][strlen(shadow[i])-1]='\0';
		int parsed_size=0;
		config_str parsed = yon_char_parse(shadow[i],&parsed_size,":");
		if (yon_gtk_list_store_find_text(window->liststore1,&iter,3,parsed[0])){
			GDateTime *date = g_date_time_new_from_unix_local(atol(parsed[2]));
			char *date_string;
				date_string = g_date_time_format(date,"%Y-%m-%d");
			
			gtk_list_store_set(window->liststore1,&iter,8,parsed_size>2?date_string:"",9,parsed_size>7?parsed[7]:"",10,parsed_size>3?parsed[3]:"",11,parsed_size>4?parsed[4]:"",12,parsed_size>5?parsed[5]:"",13,parsed_size>2?parsed[6]:"",-1);
		}
	}
}

void on_mode_changed(GtkWidget *self, ubl_settings_usergroups_system_window *window){
	if (window->show_all==0){
		window->show_all=1;
		gtk_style_context_add_class(gtk_widget_get_style_context(window->ToggleAllButton),"chosenOutline");
	} else {
		window->show_all=0;
		gtk_style_context_remove_class(gtk_widget_get_style_context(window->ToggleAllButton),"chosenOutline");
	}
	yon_system_load(window);
}

void on_system_update(GtkWidget *self, ubl_settings_usergroups_system_window *window){
	
	main_config.groups = yon_file_open(groups_path,&main_config.groups_size);
	main_config.users = yon_file_open(users_path,&main_config.users_size);
	int login_size;
	config_str login_defs = yon_file_open(uid_path,&login_size);
	for (int i=0;i<login_size;i++){
		if (login_defs[i][0]!='#'){
			char *copy = yon_char_new(login_defs[i]);
			char *divided = yon_char_divide(copy,7);
			if (divided){
				if (!strcmp(divided,"UID_MAX")){
					main_config.MAXUID = atol(strstr(login_defs[i],"\t"));
				}
				else if (!strcmp(divided,"UID_MIN")){
					main_config.MINUID = atol(strstr(login_defs[i],"\t"));
				}
				else if (!strcmp(divided,"GID_MAX")){
					main_config.MAXGID = atol(strstr(login_defs[i],"\t"));
				}
				else if (!strcmp(divided,"GID_MIN")){
					main_config.MINGID = atol(strstr(login_defs[i],"\t"));
				}
			}
		}
	}
	yon_char_parsed_free(login_defs,login_size);
	yon_system_load(window);
}

ubl_settings_usergroups_system_window *yon_ubl_settings_usergroups_system_new(){
	ubl_settings_usergroups_system_window *window = malloc(sizeof(ubl_settings_usergroups_system_window));
	GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_ubl_settings_usergroups_system);
	window->liststore1=GTK_LIST_STORE(gtk_builder_get_object(builder,"liststore1"));
	window->liststore2=GTK_LIST_STORE(gtk_builder_get_object(builder,"liststore2"));
	window->MonitorWindow=yon_gtk_builder_get_widget(builder,"MonitorWindow");
	window->ToggleAllButton=yon_gtk_builder_get_widget(builder,"ToggleAllButton");
	window->UpdateButton=yon_gtk_builder_get_widget(builder,"UpdateButton");
	window->SystemTree = yon_gtk_builder_get_widget(builder,"SystemTree");
	window->show_all=0;
	yon_window_config_custom_window_setup(GTK_WINDOW(window->MonitorWindow),"InspectorWindow");
	yon_gtk_tree_view_minimal_fixed_size_set_full(GTK_TREE_VIEW(window->SystemTree));
	GList *list = gtk_tree_view_get_columns(GTK_TREE_VIEW(window->SystemTree));
	for (int i=0;i<g_list_length(list);i++){
		yon_window_config_add_listener((GtkWidget*)g_list_nth_data(list,i),yon_char_append("UserColumn",yon_char_from_int(i)),"fixed-width",YON_TYPE_INT);
	}
	g_list_free(list);
	gtk_window_set_title(GTK_WINDOW(window->MonitorWindow),INSPECTOR_TITLE_LABEL);

	g_signal_connect(G_OBJECT(window->ToggleAllButton),"clicked",G_CALLBACK(on_mode_changed),window);
	g_signal_connect(G_OBJECT(window->UpdateButton),"clicked",G_CALLBACK(on_system_update),window);

	yon_system_load(window);
return window;
}

void on_settings_usergroups_system_open(GtkWidget *self, main_window *widgets){
    ubl_settings_usergroups_system_window *window = yon_ubl_settings_usergroups_system_new();
    gtk_window_set_transient_for(GTK_WINDOW(window->MonitorWindow),GTK_WINDOW(widgets->Window));
    gtk_widget_show(window->MonitorWindow);
}







void on_user_shell_changed(GtkWidget *self, ubl_settings_usergroups_user_window *window){
	const char *current = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->userShellCombo));
	if (!yon_char_is_empty(current)&&!strcmp(current,SET_LABEL)){
		if(gtk_combo_box_get_active(GTK_COMBO_BOX(window->userShellCombo))>1){
			gtk_widget_set_sensitive(window->userShellEntry,1);
		} else {
			gtk_widget_set_sensitive(window->userShellEntry,0);
			}
	} else {
		gtk_widget_set_sensitive(window->userShellEntry,0);
	}
}

void on_UID_update(GtkWidget *self, ubl_settings_usergroups_user_window *window){
	if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userUIDAutoCheck))){
		int config_size=0;
		int final_size=0;
		config_str config_users = yon_config_get_all_by_key("USERADD[",&config_size);
		yon_char_parsed_prepend_strings(config_users,config_size,":");
		config_str final = yon_char_parsed_merge(main_config.users,main_config.users_size,config_users,config_size,&final_size);
		long prev_busy=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userCreateSystemCheck))?0:main_config.MINGID;
	for (int i=0;i<final_size;i++){
		int parsed_size;
		config_str parsed = yon_char_parse(final[i],&parsed_size,":");

		if (atol(parsed[2])>=main_config.MINUID||gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userCreateSystemCheck))){
			if (atol(parsed[2])>main_config.MAXUID||gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userCreateSystemCheck)))
				break;
			if (atol(parsed[2])==prev_busy+1)
				prev_busy=atol(parsed[2]);
			else {
				yon_char_parsed_free(parsed, parsed_size);
				break;
			}
		}
		yon_char_parsed_free(parsed, parsed_size);
	}
		gtk_entry_set_text(GTK_ENTRY(window->userUIDEntry),yon_char_from_long(prev_busy+1));
	} else {
		gtk_entry_set_text(GTK_ENTRY(window->userUIDEntry),"");
	}
}

void on_user_login_update(GtkWidget *self, ubl_settings_usergroups_user_window *window){
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userGroupsCheck))){
		gtk_entry_set_text(GTK_ENTRY(window->userGroupsEntry),gtk_entry_get_text(GTK_ENTRY(window->userLoginEntry)));
	} else {
		gtk_entry_set_text(GTK_ENTRY(window->userGroupsEntry),"");
	}
	if (gtk_combo_box_get_active(GTK_COMBO_BOX(window->userHomeCombo))==0){
		char *homepath = yon_char_append("/home/",(char*)gtk_entry_get_text(GTK_ENTRY(window->userLoginEntry)));
		gtk_entry_set_text(GTK_ENTRY(window->userHomeEntry),homepath);
		free(homepath);
	}
}

void on_user_save(GtkWidget *self, dictionary *dict){
	main_window *widgets = yon_dictionary_get_data(dict->first,main_window*);
	ubl_settings_usergroups_user_window *window = yon_dictionary_get_data(dict->first->next,ubl_settings_usergroups_user_window*);
	char *final_user="";
	char *uid_string = NULL;
	char *password = NULL;
	char *login = NULL;
	char *username = NULL;
	char *main_group = NULL;
	char *no_user_group=NULL;
	char *additional_groups = NULL;
	char *password_changed_date = NULL;
	char *password_expiration_date = NULL;
	char *password_change_interval_minimum = NULL;
	char *password_change_interval_maximum = NULL;
	char *warning_days = NULL;
	char *no_activity_days = NULL;
	char *force_at_next_login = NULL;
	char *user_shell = NULL;
	char *user_home = NULL;
	char *create_system_user = NULL;
	char *create_ununique = NULL;
	char *do_not_check = NULL;
	int samba_sync = 0;
	int samba_password_sync = 0;
	char *deactivate = NULL;
	char *extra_options = NULL;
	char *useradd_boot = "";
	char *useradd_shutdown = "";
	char *usershadow_boot = "";
	char *usershadow_shutdown = "";
	

	int uid_auto_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userUIDAutoCheck));
	if (uid_auto_active){
		uid_string="";
	} else {
		uid_string = (char*)gtk_entry_get_text(GTK_ENTRY(window->userUIDEntry));
		if (yon_char_is_empty(uid_string)){
			yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
			yon_ubl_status_highlight_incorrect(window->userUIDEntry);
			return;
		} 
	}

	int do_not_check_actve = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userDontCheckCheck));
	if (do_not_check_actve)
		do_not_check = " --badnames";

	login = (char*)gtk_entry_get_text(GTK_ENTRY(window->userLoginEntry));
	if (login[0]>'0'&&login[0]<'9'&&!do_not_check_actve){
			yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),USER_BEGINS_WITH_DIGIT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
			yon_ubl_status_highlight_incorrect(window->userLoginEntry);
			return;
	}
	if (yon_char_is_empty(login)){
			yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
			yon_ubl_status_highlight_incorrect(window->userLoginEntry);
			return;
	}

	int password_active = gtk_combo_box_get_active(GTK_COMBO_BOX(window->userPasswordCombo));
	if (password_active > 1){
		password = (char*)gtk_entry_get_text(GTK_ENTRY(window->userPasswordEntry));
		if (yon_char_is_empty(password)){
				yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
				yon_ubl_status_highlight_incorrect(window->userPasswordEntry);
				return;
		}
	} else {
		password="";
	}

	username = (char*)gtk_entry_get_text(GTK_ENTRY(window->userUserNameEntry));
	if (yon_char_is_empty(username)){
		username="";
	}

	int main_group_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userGroupsCheck));
	if (!main_group_active){
		main_group = (char*)gtk_entry_get_text(GTK_ENTRY(window->userGroupsEntry));
		if (yon_char_is_empty(main_group)){
				no_user_group="--no-user-group";
		}
	} else {
		main_group = "";
	}

	additional_groups = (char*)gtk_entry_get_text(GTK_ENTRY(window->userAdditionalGroupsEntry));
	char *default_groups = yon_config_get_by_key("USERGROUPS");
	if (!yon_char_is_empty(default_groups)&&!strcmp(default_groups,additional_groups)){
		additional_groups="";
	}
	long password_change_interval_minimum_active = gtk_spin_button_get_value(GTK_SPIN_BUTTON(window->userPasswordChangeDelayMinimumSpin));
	if (password_change_interval_minimum_active>0){
		password_change_interval_minimum = yon_char_from_long(password_change_interval_minimum_active);
	} else password_change_interval_minimum = 0;

	long password_change_interval_maximum_active = gtk_spin_button_get_value(GTK_SPIN_BUTTON(window->userPasswordChangeDelayMaximumSpin));
	if (password_change_interval_minimum_active>0){
		password_change_interval_maximum = yon_char_from_long(password_change_interval_maximum_active);
	} else password_change_interval_maximum = 0;

	
	long password_interval_maximum = gtk_spin_button_get_value(GTK_SPIN_BUTTON(window->userPasswordChangeDelayMaximumSpin));
	
	password_expiration_date = (char*)gtk_entry_get_text(GTK_ENTRY(window->userPasswordExpirationEntry));
	if (!yon_char_is_empty(password_expiration_date)){
		password_expiration_date = window->expiration_unix;
	}
		
	warning_days = yon_char_from_long(gtk_spin_button_get_value(GTK_SPIN_BUTTON(window->userWarningSpin)));

	int no_activity_days_active = gtk_spin_button_get_value(GTK_SPIN_BUTTON(window->userActivitySpin));
	if (no_activity_days_active>0){
		no_activity_days = yon_char_from_long(no_activity_days_active);
	}

	int force_at_next_login_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userForceChangeCheck));
	if (force_at_next_login_active){

	}

	int user_shell_active = gtk_combo_box_get_active(GTK_COMBO_BOX(window->userShellCombo));
	if (user_shell_active>0){
		user_shell = yon_char_unite(" --shell ",(char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->userShellCombo)),NULL);
		if (!strcmp(user_shell,SET_LABEL)){
			user_shell = yon_char_unite(" --shell ",(char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->userShellCombo)),NULL);
		} 
	} else user_shell="";

	int user_home_active = gtk_combo_box_get_active(GTK_COMBO_BOX(window->userHomeCombo));
	if (user_home_active==2){
		user_home=yon_char_unite("--home-dir ",(char*)gtk_entry_get_text(GTK_ENTRY(window->userHomeEntry)),NULL);
	} else if (user_home_active==0){
		user_home=yon_char_unite("--home-dir ",main_config.default_home,"/",login,NULL);
	} else if (user_home_active==1){
		user_home="--no-create-home";
	} else user_home = "";

	int system_user_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userCreateSystemCheck));
	if (system_user_active)
		create_system_user = " --system";

	int create_ununique_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userCreateUnuniqueCheck));
	if (create_ununique_active)
		create_ununique = " --non-unique";

	samba_sync = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBACheck));
	samba_password_sync = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBAPasswordCheck));
	if (samba_sync){
		if (yon_samba_sync_get(login)==2)
			yon_samba_sync_remove(login);
		yon_samba_sync_add(login,NULL);
	} else if (samba_password_sync){
		if (yon_samba_sync_get(login)==1)
			yon_samba_sync_remove(login);
		yon_samba_sync_add(login,password);
	} else {
		yon_samba_sync_remove(login);
	}

	int deactivate_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userDeactivatedCheck));
	if (deactivate_active);

	extra_options=(char*)gtk_entry_get_text(GTK_ENTRY(window->userExtraOptionsEntry));

	if (!window->old_password||window->old_password&&strcmp(window->old_password,password)){
		time_t t = time(NULL);
		struct tm tm = *localtime(&t);
		password_changed_date = yon_char_unite(yon_char_from_int(1900+tm.tm_year),"-",yon_char_from_int(tm.tm_mon+1),"-",yon_char_from_int(tm.tm_mday),NULL);
	}

	int useradd_boot_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->UseraddBootCheck));
	if (useradd_boot_active){
		useradd_boot = "boot";
	}

	int useradd_shutdown_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->UseraddShutdownCheck));
	if (useradd_shutdown_active){
		useradd_shutdown = "shutdown";
	}

	int usershadow_boot_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->UsershadowBootCheck));
	if (usershadow_boot_active){
		usershadow_boot = "boot";
	}

	int usershadow_shutdown_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->UsershadowShutdownCheck));
	if (usershadow_shutdown_active){
		usershadow_shutdown = "shutdown";
	}


	char *useradd_sync_string = NULL;
	useradd_sync_string = yon_char_unite(useradd_boot,!yon_char_is_empty(useradd_boot)?",":"",useradd_shutdown,NULL);
	char *usershadow_sync_string = NULL;
	usershadow_sync_string = yon_char_unite(usershadow_boot,!yon_char_is_empty(usershadow_boot)?",":"",usershadow_shutdown,NULL);
	char *shadow_string = NULL;
	shadow_string = yon_char_unite(yon_char_return_if_exist(password_changed_date,""),
	":",yon_char_return_if_exist(password_change_interval_minimum,""),
	":",yon_char_return_if_exist(password_change_interval_maximum,""),
	":",yon_char_return_if_exist(warning_days,""),
	":",yon_char_return_if_exist(no_activity_days,""),
	":",yon_char_return_if_exist(password_expiration_date,""),
	NULL);

	final_user = yon_char_unite(yon_char_return_if_exist(username,"x"),
	":",yon_char_return_if_exist(uid_string,"x"),
	":",yon_char_return_if_exist(main_group,"x"),
	":",yon_char_return_if_exist(additional_groups,"x"),
	":",yon_char_return_if_exist(extra_options,""),
	":",yon_char_return_if_exist(password,""),
	NULL);
	
	yon_config_register(USERADD(login),"users",final_user);
	if (!yon_char_is_empty(window->old_username)&&strcmp(window->old_username,login)){
		yon_config_remove_by_key(USERADD(window->old_username));
	}
	yon_config_register(USERSHADOW(login),"users",shadow_string);
	if (!yon_char_is_empty(window->old_username)&&strcmp(window->old_username,login)){
		yon_config_remove_by_key(USERSHADOW(window->old_username));
	}
	int home_delete = yon_char_parsed_check_exist(main_config.remove_homes,main_config.homes_size,login);
	if (home_delete>-1){
		yon_char_parsed_rip(main_config.remove_homes,&main_config.homes_size,home_delete);
	}

	if (!yon_char_is_empty(useradd_sync_string)){
		yon_config_register(USERADD_SYNC(login),"users",useradd_sync_string);
		if (!yon_char_is_empty(window->old_username)&&strcmp(window->old_username,login)){
			yon_config_remove_by_key(USERADD_SYNC(window->old_username));
		}
	}

	if (!yon_char_is_empty(usershadow_sync_string)){
		yon_config_register(USERSHADOW_SYNC(login),"users",usershadow_sync_string);
		if (!yon_char_is_empty(window->old_username)&&strcmp(window->old_username,login)){
			yon_config_remove_by_key(USERSHADOW_SYNC(window->old_username));
		}
	}
	GtkTreeIter iter;
	GtkTreeModel *model = GTK_TREE_MODEL(widgets->UsersList);
	char *password_status=NULL;
	if (password_active==0) password_status = DEFAULT_USER_LABEL;
	else if (password_active==1) password_status = NO_PASSWORD_LABEL;
	else if (password[0]=='%'&&password[1]=='%') password_status = UNENCRYPTED_LABEL;
	else password_status = ENCRYPTED_LABEL;
	if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->UsersTree)),&model,&iter))
		gtk_list_store_append(widgets->UsersList,&iter);
	gtk_list_store_set(widgets->UsersList,&iter,
	1,yon_char_return_if_exist(uid_string,AUTOMATICALLY_LABEL),
	2,yon_char_return_if_exist(login,""),
	3,yon_char_return_if_exist(username,""),
	4,yon_char_return_if_exist(main_group,login),
	5,yon_char_return_if_exist(additional_groups,yon_config_get_by_key("USERGROUPS")),
	6,yon_char_unite(yon_char_return_if_exist(user_home,""),yon_char_return_if_exist(user_shell,""),yon_char_return_if_exist(create_system_user,""),yon_char_return_if_exist(create_ununique,""),yon_char_return_if_exist(do_not_check,""),NULL),
	7,password_status,
	-1);
	on_subwindow_close(self);
}

void on_toggle_button_set_active_from_combo_box(GtkComboBox *self,ubl_settings_usergroups_user_window *window){
	char *passw = (char*)gtk_entry_get_text(GTK_ENTRY(window->userPasswordEntry));
	if (gtk_combo_box_get_active(self)<=1||(passw[0]=='$')){
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBACheck),0);
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBAPasswordCheck),0);
		gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBAPasswordCheck),0);
	}else {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBACheck),0);
		gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBACheck),1);
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBAPasswordCheck),0);
		gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBAPasswordCheck),1);

	}
}

void on_password_user_changed(GtkComboBox *self,ubl_settings_usergroups_user_window *window){
	char *passw = (char*)gtk_entry_get_text(GTK_ENTRY(window->userPasswordEntry));
	if ((passw[0]=='$')){
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBACheck),0);
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBAPasswordCheck),0);
		gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBAPasswordCheck),0);
	} else {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBACheck),0);
		gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBACheck),1);
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBAPasswordCheck),0);
		gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBAPasswordCheck),1);

	}
}

void on_toggle_button_set_active_from_toggle_button_inversed(GtkToggleButton *self, ubl_settings_usergroups_user_window *window){
	char *passw = (char*)gtk_entry_get_text(GTK_ENTRY(window->userPasswordEntry));
	if ((passw[0]!='$')&&gtk_combo_box_get_active(GTK_COMBO_BOX(window->userPasswordCombo))>1){
		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBACheck))){
			gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBAPasswordCheck),0);
		} else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBAPasswordCheck))){
			gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBACheck),0);

		} else {
			gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBACheck),1);
			gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBAPasswordCheck),1);
		}
	} else {
		gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBACheck),1);
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBAPasswordCheck),0);
		gtk_widget_set_sensitive(GTK_WIDGET(window->userSyncSAMBAPasswordCheck),0);

	}
}

void on_date_selected(GtkWidget *self, ubl_settings_usergroups_user_window *window){
	int year=0, month=0, day=0;
	gtk_calendar_get_date(GTK_CALENDAR(window->ExpirationCalendar),&year,&month,&day);
	GDateTime *date = g_date_time_new_local(year,month,day,23,59,59);
	char *date_string = g_date_time_format(date,"%Y-%m-%d");
	gtk_entry_set_text(GTK_ENTRY(window->userPasswordExpirationEntry), date_string);
	window->expiration_unix=date_string;
}

void on_parameter_changed(GtkWidget *self,ubl_settings_usergroups_user_window *window){
	char *user_shell=NULL;
	char *user_home=NULL;
	char *login=NULL;
	char *create_system_user=NULL;
	char *create_ununique=NULL;
	char *do_not_check=NULL;
	char *main_group=NULL;
	char *no_user_group=NULL;

	int do_not_check_actve = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userDontCheckCheck));
	if (do_not_check_actve)
		do_not_check = "--badnames";

	login = (char*)gtk_entry_get_text(GTK_ENTRY(window->userLoginEntry));
	if (login[0]>'0'&&login[0]<'9'&&!do_not_check_actve){
			yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),USER_BEGINS_WITH_DIGIT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
			yon_ubl_status_highlight_incorrect(window->userLoginEntry);
			return;
	}
	if (yon_char_is_empty(login)){
			yon_ubl_status_box_spawn(GTK_CONTAINER(window->StatusBox),EMPTY_IMPORTANT_LABEL,5,BACKGROUND_IMAGE_FAIL_TYPE);
			yon_ubl_status_highlight_incorrect(window->userLoginEntry);
			return;
	}

	int user_shell_active = gtk_combo_box_get_active(GTK_COMBO_BOX(window->userShellCombo));
	if (user_shell_active>0){
		user_shell = yon_char_unite(" --shell ",(char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->userShellCombo)),NULL);
		if (!strcmp(user_shell,SET_LABEL)){
			user_shell = yon_char_unite(" --shell ",(char*)gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(window->userShellCombo)),NULL);
		} 
	} else user_shell="";

	int user_home_active = gtk_combo_box_get_active(GTK_COMBO_BOX(window->userHomeCombo));
	if (user_home_active==2){
		user_home=yon_char_unite("--home-dir ",(char*)gtk_entry_get_text(GTK_ENTRY(window->userHomeEntry)),NULL);
	} else if (user_home_active==0){
		user_home=yon_char_unite("--home-dir ",main_config.default_home,"/",login,NULL);
	} else if (user_home_active==1){
		user_home="--no-create-home";
	} else user_home = "";

	int system_user_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userCreateSystemCheck));
	if (system_user_active)
		create_system_user = " --system";

	int create_ununique_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userCreateUnuniqueCheck));
	if (create_ununique_active)
		create_ununique = " --non-unique";
	int main_group_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->userGroupsCheck));
	if (!main_group_active){
		main_group = (char*)gtk_entry_get_text(GTK_ENTRY(window->userGroupsEntry));
		if (yon_char_is_empty(main_group)){
				no_user_group="--no-user-group";
		}
	} else {
		main_group = "";
	}
	char *final_string = yon_char_unite(yon_char_return_if_exist(user_home,""),
	yon_char_return_if_exist(user_shell,""),
	!yon_char_is_empty(user_shell)?" ":"",
	yon_char_return_if_exist(create_system_user,""),
	!yon_char_is_empty(create_system_user)?" ":"",
	yon_char_return_if_exist(create_ununique,""),
	!yon_char_is_empty(create_ununique)?" ":"",
	yon_char_return_if_exist(do_not_check,""),
	!yon_char_is_empty(do_not_check)?" ":"",
	yon_char_return_if_exist(no_user_group,""),
	NULL);
	gtk_entry_set_text(GTK_ENTRY(window->userExtraOptionsEntry),final_string);
	free(final_string);
}

ubl_settings_usergroups_user_window *yon_ubl_settings_usergroups_user_new(){
	ubl_settings_usergroups_user_window *window = malloc(sizeof(ubl_settings_usergroups_user_window));
	GtkBuilder *builder = gtk_builder_new_from_resource(glade_path_ubl_settings_usergroups_user);
	window->CreateUserWindow=yon_gtk_builder_get_widget(builder,"CreateUserWindow");
	window->StatusBox=yon_gtk_builder_get_widget(builder,"StatusBox");
	window->userUIDAutoCheck=yon_gtk_builder_get_widget(builder,"userUIDAutoCheck");
	window->userUIDEntry=yon_gtk_builder_get_widget(builder,"userUIDEntry");
	window->userLoginEntry=yon_gtk_builder_get_widget(builder,"userLoginEntry");
	window->userPasswordCombo=yon_gtk_builder_get_widget(builder,"userPasswordCombo");
	window->userPasswordEntry=yon_gtk_builder_get_widget(builder,"userPasswordEntry");
	window->userPasswordButton=yon_gtk_builder_get_widget(builder,"userPasswordButton");
	window->userUserNameEntry=yon_gtk_builder_get_widget(builder,"userUserNameEntry");
	window->userGroupsCheck=yon_gtk_builder_get_widget(builder,"userGroupsCheck");
	window->userGroupsEntry=yon_gtk_builder_get_widget(builder,"userGroupsEntry");
	window->UserGroupsButton=yon_gtk_builder_get_widget(builder,"UserGroupsButton");
	window->userAdditionalGroupsEntry=yon_gtk_builder_get_widget(builder,"userAdditionalGroupsEntry");
	window->userAdditionalGroupsButton=yon_gtk_builder_get_widget(builder,"userAdditionalGroupsButton");
	window->userPasswordChangedEntry=yon_gtk_builder_get_widget(builder,"userPasswordChangedEntry");
	window->userPasswordExpirationEntry=yon_gtk_builder_get_widget(builder,"userPasswordExpirationEntry");
	window->userPasswordExpirationButton=yon_gtk_builder_get_widget(builder,"userPasswordExpirationButton");
	window->userPasswordChangeDelayMinimumSpin=yon_gtk_builder_get_widget(builder,"userPasswordChangeDelayMinimumSpin");
	window->userPasswordChangeDelayMaximumSpin=yon_gtk_builder_get_widget(builder,"userPasswordChangeDelayMaximumSpin");
	window->userWarningSpin=yon_gtk_builder_get_widget(builder,"userWarningSpin");
	window->userActivitySpin=yon_gtk_builder_get_widget(builder,"userActivitySpin");
	window->userForceChangeCheck=yon_gtk_builder_get_widget(builder,"userForceChangeCheck");
	window->userShellCombo=yon_gtk_builder_get_widget(builder,"userShellCombo");
	window->userShellEntry=yon_gtk_builder_get_widget(builder,"userShellEntry");
	window->userHomeCombo=yon_gtk_builder_get_widget(builder,"userHomeCombo");
	window->userHomeEntry=yon_gtk_builder_get_widget(builder,"userHomeEntry");
	window->userHomeButton=yon_gtk_builder_get_widget(builder,"userHomeButton");
	window->userCreateSystemCheck=yon_gtk_builder_get_widget(builder,"userCreateSystemCheck");
	window->userCreateUnuniqueCheck=yon_gtk_builder_get_widget(builder,"userCreateUnuniqueCheck");
	window->userDontCheckCheck=yon_gtk_builder_get_widget(builder,"userDontCheckCheck");
	window->userSyncSAMBACheck=yon_gtk_builder_get_widget(builder,"userSyncSAMBACheck");
	window->userSyncSAMBAPasswordCheck=yon_gtk_builder_get_widget(builder,"userSyncSAMBAPasswordCheck");
	window->userDeactivatedCheck=yon_gtk_builder_get_widget(builder,"userDeactivatedCheck");
	window->userExtraOptionsEntry=yon_gtk_builder_get_widget(builder,"userExtraOptionsEntry");
	window->UserCancelButton=yon_gtk_builder_get_widget(builder,"UserCancelButton");
	window->UserOkButton=yon_gtk_builder_get_widget(builder,"UserOkButton");
	window->CalendarPopup=yon_gtk_builder_get_widget(builder,"CalendarPopover");
	window->UseraddBootCheck=yon_gtk_builder_get_widget(builder,"UseraddBootCheck");
	window->ExpirationCalendar=yon_gtk_builder_get_widget(builder,"ExpirationCalendar");
	window->UseraddShutdownCheck=yon_gtk_builder_get_widget(builder,"UseraddShutdownCheck");
	window->UsershadowBootCheck=yon_gtk_builder_get_widget(builder,"UsershadowBootCheck");
	window->UsershadowShutdownCheck=yon_gtk_builder_get_widget(builder,"UsershadowShutdownCheck");
	window->userTitleNameLabel=yon_gtk_builder_get_widget(builder,"userTitleNameLabel");
	window->expiration_unix=NULL;

	on_UID_update(NULL,window);
	int shell_size=0;
	config_str shells = yon_file_open(shell_list_path,&shell_size);
	for (int i=1;i<shell_size;i++){
		if (shells[i][0]!='!'){
			if (shells[i][strlen(shells[i])-1]=='\n') shells[i][strlen(shells[i])-1]='\0';
			int parsed_size=0;
			config_str parsed = yon_char_parse(shells[i],&parsed_size,";");
			gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->userShellCombo),parsed[0]);
			yon_char_parsed_free(parsed,parsed_size);
		}
	}
	gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(window->userShellCombo),SET_LABEL);
	yon_char_parsed_free(shells,shell_size);
	gtk_combo_box_set_active(GTK_COMBO_BOX(window->userShellCombo),0);
	window->old_password=NULL;
	window->old_username=NULL;
	dictionary *entry_dict = NULL;
	yon_window_config_custom_window_setup(GTK_WINDOW(window->CreateUserWindow),"UserWindow");
	yon_dictionary_add_or_create_if_exists_with_data(entry_dict,"combo",window->userPasswordCombo);
	yon_dictionary_add_or_create_if_exists_with_data(entry_dict,"entry",window->userPasswordEntry);
	char *password = yon_config_get_by_key(USERADD((char*)gtk_entry_get_text(GTK_ENTRY(window->userLoginEntry))));
	g_signal_connect(G_OBJECT(window->UserCancelButton),"clicked",G_CALLBACK(on_subwindow_close),NULL);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button_inversed),window->userUIDEntry);
	g_signal_connect(G_OBJECT(window->userHomeButton),"clicked",G_CALLBACK(on_filechooser_open),window->userHomeEntry);
	g_signal_connect(G_OBJECT(window->UserGroupsButton),"clicked",G_CALLBACK(on_groups_clicked),window->userGroupsEntry);
	g_signal_connect(G_OBJECT(window->userPasswordButton),"clicked",G_CALLBACK(on_password_change),entry_dict);
	g_signal_connect(G_OBJECT(window->userAdditionalGroupsButton),"clicked",G_CALLBACK(on_groups_multiple_clicked),window->userAdditionalGroupsEntry);
	g_signal_connect(G_OBJECT(window->userPasswordExpirationButton),"clicked",G_CALLBACK(on_expiration_clicked),window);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button_inversed),window->userUIDEntry);
	g_signal_connect(G_OBJECT(window->userHomeCombo),"changed",G_CALLBACK(on_password_combo_changed),window->userHomeEntry);
	g_signal_connect(G_OBJECT(window->userHomeCombo),"changed",G_CALLBACK(on_password_combo_changed),window->userHomeButton);
	g_signal_connect(G_OBJECT(window->userPasswordCombo),"changed",G_CALLBACK(on_password_combo_changed),window->userPasswordButton);
	g_signal_connect(G_OBJECT(window->userGroupsCheck),"toggled",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button_inversed),window->userGroupsEntry);
	g_signal_connect(G_OBJECT(window->userGroupsCheck),"toggled",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button_inversed),window->UserGroupsButton);
	g_signal_connect(G_OBJECT(window->userShellCombo),"changed",G_CALLBACK(on_user_shell_changed),window);
	g_signal_connect(G_OBJECT(window->ExpirationCalendar),"day-selected",G_CALLBACK(on_date_selected),window);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(on_UID_update),window);
	g_signal_connect(G_OBJECT(window->userCreateSystemCheck),"toggled",G_CALLBACK(on_UID_update),window);
	g_signal_connect(G_OBJECT(window->userGroupsCheck),"toggled",G_CALLBACK(on_user_login_update),window);
	g_signal_connect(G_OBJECT(window->userLoginEntry),"changed",G_CALLBACK(on_user_login_update),window);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button),window->userCreateSystemCheck);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(yon_gtk_toggle_button_set_inactive_from_toggle_button),window->userCreateSystemCheck);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button_inversed),window->userCreateUnuniqueCheck);
	g_signal_connect(G_OBJECT(window->userUIDAutoCheck),"toggled",G_CALLBACK(yon_gtk_toggle_button_set_inactive_from_toggle_button_inversed),window->userCreateUnuniqueCheck);
	g_signal_connect(G_OBJECT(window->userSyncSAMBACheck),"toggled",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button_inversed),window->userSyncSAMBAPasswordCheck);
	g_signal_connect(G_OBJECT(window->userSyncSAMBAPasswordCheck),"toggled",G_CALLBACK(yon_gtk_widget_set_sensitive_from_toggle_button_inversed),window->userSyncSAMBACheck);
	g_signal_connect(G_OBJECT(window->userSyncSAMBACheck),"toggled",G_CALLBACK(on_toggle_button_set_active_from_toggle_button_inversed),window);
	g_signal_connect(G_OBJECT(window->userSyncSAMBAPasswordCheck),"toggled",G_CALLBACK(on_toggle_button_set_active_from_toggle_button_inversed),window);
	g_signal_connect(G_OBJECT(window->userPasswordCombo),"changed",G_CALLBACK(on_toggle_button_set_active_from_combo_box),window);
	g_signal_connect(G_OBJECT(window->userPasswordCombo),"changed",G_CALLBACK(on_toggle_button_set_active_from_combo_box),window);
	g_signal_connect(G_OBJECT(window->userPasswordEntry),"changed",G_CALLBACK(on_password_user_changed),window);
	g_signal_connect(G_OBJECT(window->userHomeEntry),"changed",G_CALLBACK(on_parameter_changed),window);
	g_signal_connect(G_OBJECT(window->userHomeCombo),"changed",G_CALLBACK(on_parameter_changed),window);
	g_signal_connect(G_OBJECT(window->userShellCombo),"changed",G_CALLBACK(on_parameter_changed),window);
	g_signal_connect(G_OBJECT(window->userShellEntry),"changed",G_CALLBACK(on_parameter_changed),window);
	g_signal_connect(G_OBJECT(window->userCreateSystemCheck),"toggled",G_CALLBACK(on_parameter_changed),window);
	g_signal_connect(G_OBJECT(window->userCreateUnuniqueCheck),"toggled",G_CALLBACK(on_parameter_changed),window);
	g_signal_connect(G_OBJECT(window->userDontCheckCheck),"toggled",G_CALLBACK(on_parameter_changed),window);
	g_signal_connect(G_OBJECT(window->userGroupsCheck),"toggled",G_CALLBACK(on_parameter_changed),window);
	g_signal_connect(G_OBJECT(window->userGroupsEntry),"changed",G_CALLBACK(on_parameter_changed),window);
return window;
}

void on_main_add(GtkWidget *self, main_window *widgets){
	GtkTreeModel *model;
	GtkWidget *cur_tree;
	GtkTreeIter iter;
	if (gtk_notebook_get_current_page(GTK_NOTEBOOK(widgets->MainNotebook))==0){
		model = GTK_TREE_MODEL(widgets->UsersList);
		gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->UsersTree)));
			ubl_settings_usergroups_user_window *window = yon_ubl_settings_usergroups_user_new();
			gtk_window_set_title(GTK_WINDOW(window->CreateUserWindow),ADD_USER_TITLE_LABEL);
			gtk_label_set_text(GTK_LABEL(window->userTitleNameLabel),ADD_USER_TITLE_LABEL);
			char *default_groups = yon_config_get_by_key("USERGROUPS");
			gtk_entry_set_text(GTK_ENTRY(window->userAdditionalGroupsEntry), default_groups);
			dictionary *dict = NULL;
			yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
			yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
			g_signal_connect(G_OBJECT(window->UserOkButton),"clicked",G_CALLBACK(on_user_save),dict);
			
			gtk_window_set_transient_for(GTK_WINDOW(window->CreateUserWindow),GTK_WINDOW(widgets->Window));
			gtk_widget_show(window->CreateUserWindow);
	} else {
		model = GTK_TREE_MODEL(widgets->GroupsList);
		gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->GroupsTree)));
			ubl_settings_usergroups_group_creation_window *window = yon_ubl_settings_usergroups_group_creation_new();
			gtk_window_set_title(GTK_WINDOW(window->CreateGroupWindow),ADD_GROUP_TITLE_LABEL);
			gtk_label_set_text(GTK_LABEL(window->userTitleNameLabel),ADD_GROUP_TITLE_LABEL);
			dictionary *dict = NULL;
			yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
			yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
			g_signal_connect(G_OBJECT(window->UserOkButton),"clicked",G_CALLBACK(on_group_save),dict);
			
			gtk_window_set_transient_for(GTK_WINDOW(window->CreateGroupWindow),GTK_WINDOW(widgets->Window));
			gtk_widget_show(window->CreateGroupWindow);
	}

}

void on_main_edit(GtkWidget *self, main_window *widgets){
	GtkTreeModel *model;
	GtkWidget *cur_tree;
	GtkTreeIter iter;
	if (gtk_notebook_get_current_page(GTK_NOTEBOOK(widgets->MainNotebook))==0){
		model = GTK_TREE_MODEL(widgets->UsersList);
		if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->UsersTree)),&model,&iter)){
			ubl_settings_usergroups_user_window *window = yon_ubl_settings_usergroups_user_new();
			gtk_window_set_title(GTK_WINDOW(window->CreateUserWindow),CONFIGURE_USER_TITLE_LABEL);
			gtk_label_set_text(GTK_LABEL(window->userTitleNameLabel),CONFIGURE_USER_TITLE_LABEL);
			dictionary *dict = NULL;
			yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
			yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
			g_signal_connect(G_OBJECT(window->UserOkButton),"clicked",G_CALLBACK(on_user_save),dict);
			char *name;
			gtk_tree_model_get(GTK_TREE_MODEL(widgets->UsersList),&iter,2,&name,-1);
			char *parameter_string = yon_config_get_by_key(USERADD(name));
			int parsed_size=0;
			if (parameter_string){
				if (parameter_string[0]=='\"') yon_char_divide(parameter_string,0);
				if (parameter_string[strlen(parameter_string)-1]=='\"') parameter_string[strlen(parameter_string)-1]='\0';
				config_str parameters = yon_char_parse(parameter_string,&parsed_size,":");
				gtk_entry_set_text(GTK_ENTRY(window->userLoginEntry), name);
				gtk_entry_set_text(GTK_ENTRY(window->userGroupsEntry), name);
				gtk_entry_set_text(GTK_ENTRY(window->userUserNameEntry), parsed_size>0?parameters[0]:"");
				window->old_username=name;
				if (parsed_size>1){
					if (strcmp(parameters[1],"x")){
						gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userUIDAutoCheck),0);
						gtk_entry_set_text(GTK_ENTRY(window->userUIDEntry), parsed_size>1?parameters[1]:"");
					}
				}
				if (parsed_size>2){
					if (!strcmp(parameters[2],"x"))
						gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userGroupsCheck),1);
					else
						gtk_entry_set_text(GTK_ENTRY(window->userGroupsEntry), parsed_size>2?parameters[2]:"");
				}
				if (parsed_size>3){
					if (strcmp(parameters[3],"x")){
						gtk_entry_set_text(GTK_ENTRY(window->userAdditionalGroupsEntry), parameters[3]);
					} else {
						char *default_groups = yon_config_get_by_key("USERGROUPS");
						gtk_entry_set_text(GTK_ENTRY(window->userAdditionalGroupsEntry), default_groups);
					}
					
				}
				if (parsed_size>4&&!yon_char_is_empty(parameters[4])){
					int params_size;
					config_str parameters_substring = yon_char_parse(parameters[4],&params_size," ");
					for (int i=0;i<params_size;i++){
						if (!strcmp(parameters_substring[i],"--home-dir")){
							gtk_entry_set_text(GTK_ENTRY(window->userHomeEntry),parameters_substring[i+1]);
							gtk_combo_box_set_active(GTK_COMBO_BOX(window->userHomeCombo),2);
							i++;
						} else if (!strcmp(parameters_substring[i],"--shell")||!strcmp(parameters_substring[i],"-s")){
							int active = yon_gtk_combo_box_text_find(window->userShellCombo,parameters_substring[i+1]);
							if (!active){
								gtk_entry_set_text(GTK_ENTRY(window->userShellEntry),parameters_substring[i+1]);
								gtk_combo_box_set_active_id(GTK_COMBO_BOX(window->userShellCombo),"Set");
							}
							i++;
							
						}else if (!strcmp(parameters_substring[i],"--system")||!strcmp(parameters_substring[i],"-r")){
							gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userCreateSystemCheck),1);
						}else if (!strcmp(parameters_substring[i],"--no-create-home")||!strcmp(parameters_substring[i],"-M")){
							gtk_combo_box_set_active(GTK_COMBO_BOX(window->userHomeCombo),2);
						}else if (!strcmp(parameters_substring[i],"--no-user-group")||!strcmp(parameters_substring[i],"-N")){
							// gtk
							gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userGroupsCheck),0);
							gtk_entry_set_text(GTK_ENTRY(window->userGroupsEntry),"");
						}else if (!strcmp(parameters_substring[i],"--non-unique")||!strcmp(parameters_substring[i],"-o")){
							gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userCreateUnuniqueCheck),1);
						}else if (!strcmp(parameters_substring[i],"--badnames")){
							gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userDontCheckCheck),1);
						}
					}
					// gtk_entry_set_text(GTK_ENTRY(window->), parsed_size>4?parameters[4]:"");
				}
				window->old_password=parameters[5];
					if (strcmp(parameters[5],"x")&&strcmp(parameters[5],"")){
						gtk_entry_set_text(GTK_ENTRY(window->userPasswordEntry),parameters[5]);
						gtk_combo_box_set_active(GTK_COMBO_BOX(window->userPasswordCombo),2);
					}
				
				int samba_sync = yon_samba_sync_get(name);
				if (samba_sync==1){
					gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBACheck),1);
				} else if (samba_sync==2){
					gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userSyncSAMBAPasswordCheck),1);
				} 
				free(parameters);
				parameters=yon_char_parse(yon_config_get_by_key(USERSHADOW(name)),&parsed_size,":");
				gtk_entry_set_text(GTK_ENTRY(window->userPasswordChangedEntry),parsed_size>0?parameters[0]:"");
				gtk_spin_button_set_value(GTK_SPIN_BUTTON(window->userPasswordChangeDelayMinimumSpin),atol(parsed_size>1?parameters[1]:"0"));
				gtk_spin_button_set_value(GTK_SPIN_BUTTON(window->userPasswordChangeDelayMaximumSpin),atol(parsed_size>2?parameters[2]:"0"));
				gtk_spin_button_set_value(GTK_SPIN_BUTTON(window->userWarningSpin),atol(parsed_size>3?parameters[3]:"0"));
				gtk_spin_button_set_value(GTK_SPIN_BUTTON(window->userActivitySpin),atol(parsed_size>4?parameters[4]:"0"));
				if (parsed_size>5&&!yon_char_is_empty(parameters[5])){
					gtk_entry_set_text(GTK_ENTRY(window->userPasswordExpirationEntry),parameters[5]);
				}
				gtk_window_set_transient_for(GTK_WINDOW(window->CreateUserWindow),GTK_WINDOW(widgets->Window));
				gtk_widget_show(window->CreateUserWindow);

				char *useradd_sync = NULL;
				useradd_sync = yon_config_get_by_key(USERADD_SYNC(name));
				if (useradd_sync){
					if (strstr(useradd_sync,"boot")){
						gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->UseraddBootCheck),1);
					}
					if (strstr(useradd_sync,"shutdown")){
						gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->UseraddShutdownCheck),1);
					}
					free(useradd_sync);
				}
				char *usershadow_sync =yon_config_get_by_key(USERSHADOW_SYNC(name));
				if (usershadow_sync){
					if (strstr(usershadow_sync,"boot")){
						gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->UsershadowBootCheck),1);
					}
					if (strstr(usershadow_sync,"shutdown")){
						gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->UsershadowShutdownCheck),1);
					}
					free(usershadow_sync);
				}
			}
			
		}
	} else {
		model = GTK_TREE_MODEL(widgets->GroupsList);
		if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->GroupsTree)),&model,&iter)){
			ubl_settings_usergroups_group_creation_window *window = yon_ubl_settings_usergroups_group_creation_new();
			gtk_window_set_title(GTK_WINDOW(window->CreateGroupWindow),CONFIGURE_GROUP_TITLE_LABEL);
			gtk_label_set_text(GTK_LABEL(window->userTitleNameLabel),CONFIGURE_GROUP_TITLE_LABEL);
			dictionary *dict = NULL;
			yon_dictionary_add_or_create_if_exists_with_data(dict,"widgets",widgets);
			yon_dictionary_add_or_create_if_exists_with_data(dict,"window",window);
			g_signal_connect(G_OBJECT(window->UserOkButton),"clicked",G_CALLBACK(on_group_save),dict);
			char *name;
			gtk_tree_model_get(model,&iter,1,&name,-1);
			char *config_string = yon_config_get_by_key(GROUPADD(name));
			if (!yon_char_is_empty(config_string)){
				if (config_string[0]=='\"') yon_char_divide(config_string,0);
				if (config_string[strlen(config_string)-1]=='\"') config_string[strlen(config_string)-1]='\0';
				int size;
				config_str parsed = yon_char_parse(config_string,&size,":");
				gtk_entry_set_text(GTK_ENTRY(window->userLoginEntry),name);
				if (size>1&&strcmp(parsed[0],"x"))
					gtk_entry_set_text(GTK_ENTRY(window->userGroupsEntry),parsed[0]);
				if (size>1){
					if (!strcmp(parsed[1],"")||!strcmp(parsed[1],"x"))
						gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->userUIDAutoCheck),1);
					else
						gtk_entry_set_text(GTK_ENTRY(window->userUIDEntry),parsed[1]);
				}
				if (size>2&&!yon_char_is_empty(parsed[2])){
					int parsed_size=0;
					config_str substring = yon_char_parse(parsed[2],&parsed_size," ");
					for (int i=0;i<parsed_size;i++){
						if (!yon_char_is_empty(substring[i])){
							if (!strcmp(substring[i],"--non-unique")||!strcmp(substring[i],"-o")){
								gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->UnuniqueGIDCheck),1);
							} else if (!strcmp(substring[i],"--system")||!strcmp(substring[i],"-r")){
								gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->SystemGroupCheck),1);
							}
						}
					}
					free(substring);
				}
				if (size>3){
					if (strcmp(parsed[3],"")&&strcmp(parsed[3],"x")){
						gtk_entry_set_text(GTK_ENTRY(window->AdminGroupsEntry),parsed[3]);
					}
				}
				if (size>4){
					if (strcmp(parsed[4],"")&&strcmp(parsed[4],"x")){
						gtk_entry_set_text(GTK_ENTRY(window->PasswordEntry),parsed[4]);
						gtk_combo_box_set_active(GTK_COMBO_BOX(window->PasswordCombo),2);
					} else {
						gtk_combo_box_set_active(GTK_COMBO_BOX(window->PasswordCombo),1);
					}
				}
				char *sync = yon_config_get_by_key(GROUPADD_SYNC(name));
				if (sync){
					gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(window->GroupaddShutdownCheck),1);
				}
			} else {
				yon_ubl_status_box_render(LOADING_FAILED_LABEL,BACKGROUND_IMAGE_FAIL_TYPE);
			}
			
			gtk_window_set_transient_for(GTK_WINDOW(window->CreateGroupWindow),GTK_WINDOW(widgets->Window));
			gtk_widget_show(window->CreateGroupWindow);
		}
	}

}

void on_main_edit_activate(GtkWidget *self, GtkTreePath *path, GtkTreeViewColumn *column, main_window *widgets){
	on_main_edit(self,widgets);
}

void on_main_delete(GtkWidget *self, main_window *widgets){
	GtkTreeModel *model;
	GtkWidget *cur_tree;
	GtkTreeIter iter;
	dialog_confirmation_data *data=malloc(sizeof(dialog_confirmation_data));
	data->function=NULL;
	data->data=NULL;
	if (gtk_notebook_get_current_page(GTK_NOTEBOOK(widgets->MainNotebook))==0){
		yon_delete_confirmation_open(widgets);
	} else {
		model = GTK_TREE_MODEL(widgets->GroupsList);
		cur_tree=widgets->GroupsTree;
		if(gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(cur_tree)),&model,&iter)){
			char *name;
			gtk_tree_model_get(model,&iter,1,&name,-1);
			data->action_text=DELETE_CONFIRMATION_LABEL("group",name);
			if (yon_confirmation_dialog_call(self,data)==GTK_RESPONSE_ACCEPT){
				yon_config_remove_by_key(GROUPADD(name));
				gtk_list_store_remove(GTK_LIST_STORE(model),&iter);

			}
		}
	}
}

void on_config_update(GtkWidget *self, main_window *widgets){
	if (main_config.load_mode==0){
		on_config_global_load(NULL,widgets);
	} else {
		on_config_local_load(NULL,widgets);
	}
}

 
/**config_init() 
 * [EN] 
 *  
 * [RU] 
 * Функция инициализации всех параметров конфигурации 
*/ 
void config_init(){ 
    main_config.always_open_documentation=0; 
    main_config.socket_id=-1; 
    main_config.save_socket_id=-1; 
    main_config.load_socket_id=-1; 
    main_config.lock_help=0; 
    main_config.lock_load_global=0; 
    main_config.lock_save_global=0; 
    main_config.lock_save_local=0;
	main_config.groups_size=0;
	main_config.users_size=0;
	main_config.load_mode=1;
	main_config.hash_default_id=-1;
	main_config.groups = yon_file_open(groups_path,&main_config.groups_size);
	main_config.users = yon_file_open(users_path,&main_config.users_size);
	main_config.users_list=NULL;
	main_config.groups_list=NULL;
	main_config.password_min_length=6;
	main_config.sync_users = NULL;
	main_config.sync_size=0;
	main_config.homes_size=0;
	main_config.remove_homes=NULL;
	int login_size;
	config_str login_defs = yon_file_open(uid_path,&login_size);
	for (int i=0;i<login_size;i++){
		if (login_defs[i][0]!='#'){
			char *copy = yon_char_new(login_defs[i]);
			char *divided = yon_char_divide(copy,7);
			if (divided){
				if (!strcmp(divided,"UID_MAX")){
					main_config.MAXUID = atol(strstr(login_defs[i],"\t"));
				}
				else if (!strcmp(divided,"UID_MIN")){
					main_config.MINUID = atol(strstr(login_defs[i],"\t"));
				}
				else if (!strcmp(divided,"GID_MAX")){
					main_config.MAXGID = atol(strstr(login_defs[i],"\t"));
				}
				else if (!strcmp(divided,"GID_MIN")){
					main_config.MINGID = atol(strstr(login_defs[i],"\t"));
				}
			}
		}
	}
	yon_char_parsed_free(login_defs,login_size);
	login_defs = yon_file_open(password_limits_path,&login_size);
	for (int i=0;i<login_size;i++){
		if (login_defs[i][0]!='#'){
			char *copy = yon_char_new(login_defs[i]);
			char *divided = yon_char_divide(copy,7);
			if (divided){
				if (!strcmp(divided,"minlen")){
					main_config.password_min_length = atol(strstr(login_defs[i],"\t"));
				}
				// else if (!strcmp(divided,"UID_MIN")){
				// 	main_config.MINUID = atol(strstr(login_defs[i],"\t"));
				// }
			}
		}
	}
	yon_char_parsed_free(login_defs,login_size);
	int size=0;
	main_config.default_home = NULL;
	config_str file_output = yon_file_open(default_home_initiator_path,&size);
	for (int i=0;i<size;i++){
		char *parameter = yon_char_divide_search(file_output[i],"=",-1);
		if (!strcmp(parameter,"HOME")){
			if (file_output[i][strlen(file_output[i])-1]=='\n') file_output[i][strlen(file_output[i])-1]='\0';
			main_config.default_home=yon_char_new(file_output[i]);
		}
		free(parameter);
	}
	// yon_char_parsed_free(file_output,size);
} 

void on_selection_changed(GtkWidget *self, main_window *widgets){
	GtkTreeIter iter;
	if (gtk_notebook_get_current_page(GTK_NOTEBOOK(widgets->MainNotebook))==0){
		GtkTreeModel *model = GTK_TREE_MODEL(widgets->UsersList);
		if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->UsersTree)),&model,&iter)){
			gtk_widget_set_sensitive(widgets->EditButton,1);
		} else {
			gtk_widget_set_sensitive(widgets->EditButton,0);
		}
	} else {
		GtkTreeModel *model = GTK_TREE_MODEL(widgets->GroupsList);
		if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->GroupsTree)),&model,&iter)){
			gtk_widget_set_sensitive(widgets->EditButton,1);
		} else {
			gtk_widget_set_sensitive(widgets->EditButton,0);
		}
	}
}
 
void on_notebook_page_changed(GtkWidget *self, GtkWidget *page, int num, main_window *widgets){
	GtkTreeIter iter;
	if (num==0){
		GtkTreeModel *model = GTK_TREE_MODEL(widgets->UsersList);
		if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->UsersTree)),&model,&iter)){
			gtk_widget_set_sensitive(widgets->EditButton,1);
		} else {
			gtk_widget_set_sensitive(widgets->EditButton,0);
		}
	} else {
		GtkTreeModel *model = GTK_TREE_MODEL(widgets->GroupsList);
		if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(widgets->GroupsTree)),&model,&iter)){
			gtk_widget_set_sensitive(widgets->EditButton,1);
		} else {
			gtk_widget_set_sensitive(widgets->EditButton,0);
		}
	}
}

/**yon_main_window_complete(main_window *widgets) 
 * [EN] 
 *  
 * [RU] 
 * Функция настройки основного окна приложения. [widgets] - структура со стандартным интерфейсом. 
*/ 
main_window *yon_main_window_complete(main_window *widgets){ 
    widgets = yon_remalloc(widgets,sizeof(main_window)); 
    GtkBuilder *builder = gtk_builder_new_from_resource(glade_path); 
    gtk_box_pack_start(GTK_BOX(widgets->InterfaceBox),yon_gtk_builder_get_widget(builder,"PlugBox"),1,1,0); 
    // Custom widgets configuration 
    
	widgets->CacheAlgList=GTK_LIST_STORE(gtk_builder_get_object(builder,"CacheAlgList"));
	widgets->GroupsList=GTK_LIST_STORE(gtk_builder_get_object(builder,"GroupsList"));
	widgets->UsersList=GTK_LIST_STORE(gtk_builder_get_object(builder,"UsersList"));
	widgets->PlugBox=yon_gtk_builder_get_widget(builder,"PlugBox");
	widgets->button1=yon_gtk_builder_get_widget(builder,"button1");
	widgets->button2=yon_gtk_builder_get_widget(builder,"button2");
	widgets->button3=yon_gtk_builder_get_widget(builder,"button3");
	widgets->AddButton=yon_gtk_builder_get_widget(builder,"AddButton");
	widgets->EditButton=yon_gtk_builder_get_widget(builder,"EditButton");
	widgets->DeleteButton=yon_gtk_builder_get_widget(builder,"DeleteButton");
	widgets->UpdateButton=yon_gtk_builder_get_widget(builder,"UpdateButton");
	widgets->UsersTree=yon_gtk_builder_get_widget(builder,"UsersTree");
	widgets->GroupsTree=yon_gtk_builder_get_widget(builder,"GroupsTree");
	widgets->MainNotebook=yon_gtk_builder_get_widget(builder,"MainNotebook");
	widgets->SavingSettingsButton=yon_gtk_builder_get_widget(builder,"SavingSettingsButton");
    
    
	main_config.users_list = widgets->UsersList;
	main_config.groups_list = widgets->GroupsList;

    /* Signal connection | Присоединение сигналов */
    g_signal_connect(G_OBJECT(widgets->AddButton),"clicked",G_CALLBACK(on_main_add),widgets);
    g_signal_connect(G_OBJECT(widgets->EditButton),"clicked",G_CALLBACK(on_main_edit),widgets);
    g_signal_connect(G_OBJECT(widgets->DeleteButton),"clicked",G_CALLBACK(on_main_delete),widgets);
    g_signal_connect(G_OBJECT(widgets->button3),"clicked",G_CALLBACK(on_standard_groups_open),widgets);
    g_signal_connect(G_OBJECT(widgets->button2),"clicked",G_CALLBACK(on_ubl_settings_usergroups_additional_settings_open),widgets);
    g_signal_connect(G_OBJECT(widgets->button1),"clicked",G_CALLBACK(on_settings_usergroups_system_open),widgets);
    g_signal_connect(G_OBJECT(widgets->UpdateButton),"clicked",G_CALLBACK(on_config_update),widgets);
	g_signal_connect(G_OBJECT(widgets->SavingSettingsButton),"clicked",G_CALLBACK(on_saving_settings_open),widgets);
    g_signal_connect(G_OBJECT(widgets->SaveMenuItem),"activate",G_CALLBACK(on_config_save),widgets);
    g_signal_connect(G_OBJECT(widgets->UsersTree),"cursor-changed",G_CALLBACK(on_selection_changed),widgets);
    g_signal_connect(G_OBJECT(widgets->UsersTree),"row-activated",G_CALLBACK(on_main_edit_activate),widgets);
    g_signal_connect(G_OBJECT(widgets->GroupsTree),"cursor-changed",G_CALLBACK(on_selection_changed),widgets);
    g_signal_connect(G_OBJECT(widgets->GroupsTree),"row-activated",G_CALLBACK(on_main_edit_activate),widgets);
    g_signal_connect(G_OBJECT(widgets->MainNotebook),"switch-page",G_CALLBACK(on_notebook_page_changed),widgets);
    g_signal_connect(G_OBJECT(widgets->SaveGlobalMenuItem),"activate",G_CALLBACK(on_config_global_save),widgets);
    g_signal_connect(G_OBJECT(widgets->SaveLocalMenuItem),"activate",G_CALLBACK(on_config_local_save),widgets);

    g_signal_connect(G_OBJECT(widgets->LoadGlobalMenuItem),"activate",G_CALLBACK(on_config_global_load),widgets);
    g_signal_connect(G_OBJECT(widgets->LoadLocalMenuItem),"activate",G_CALLBACK(on_config_local_load),widgets);

	yon_gtk_tree_view_minimal_fixed_size_set_full(GTK_TREE_VIEW(widgets->UsersTree));
	yon_gtk_tree_view_minimal_fixed_size_set_full(GTK_TREE_VIEW(widgets->GroupsTree));
	yon_load_proceed(YON_CONFIG_LOCAL);
	yon_interface_update((main_window*)widgets);
    gtk_widget_realize(GTK_WIDGET(widgets->UsersTree));
	yon_gtk_tree_view_minimal_fixed_size_set_full(GTK_TREE_VIEW(widgets->UsersTree));
    gtk_widget_realize(GTK_WIDGET(widgets->GroupsTree));
	yon_gtk_tree_view_minimal_fixed_size_set_full(GTK_TREE_VIEW(widgets->GroupsTree));
	GList *list = gtk_tree_view_get_columns(GTK_TREE_VIEW(widgets->UsersTree));
	for (int i=0;i<g_list_length(list);i++){
		yon_window_config_add_listener((GtkWidget*)g_list_nth_data(list,i),yon_char_append("UserColumn",yon_char_from_int(i)),"fixed-width",YON_TYPE_INT);
	}
	g_list_free(list);
	list = gtk_tree_view_get_columns(GTK_TREE_VIEW(widgets->GroupsTree));
	for (int i=0;i<g_list_length(list);i++){
		yon_window_config_add_listener((GtkWidget*)g_list_nth_data(list,i),yon_char_append("GroupColumn",yon_char_from_int(i)),"fixed-width",YON_TYPE_INT);
	}
	g_list_free(list);
return widgets;
} 
 
int main(int argc, char *argv[]){ 
    local=setlocale(LC_ALL, "");
    textdomain (LocaleName); 
    config_init();
    yon_ubl_connect_config((_template_config*)&main_config); 
    yon_ubl_window_init(TITLE_LABEL,TITLE_INFO_LABEL,LocaleName,CssPath,LocaleName,version_application,WIKI_LINK);
	config_str unfound = NULL;
	int size=0;
	yon_ubl_setup_arguments(argc,argv,&unfound,&size,NULL);
    gtk_init(&argc,&argv); 
    template_main_window *widgets = yon_ubl_window_setup(); 
    yon_main_window_complete((main_window*)widgets);
	yon_window_config_load(config_path);
    gtk_main();
}