Applications
/
ubl-settings-resourcequota
7
0
Fork 2
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Частично готова версия 2.0

Browse Source
pull/4/head
Igor Belitskiy 2 years ago
parent 3f8aab0c58
commit 708ecfc1ea
8 changed files with 730 additions and 711 deletions
Show Stats Download Patch File Download Diff File

108
source/ubl-settings-resourcequota.c
Unescape View File

@ -498,7 +498,7 @@ void get_param_io_limit(char** arr_values, int index_start, int size, int index_
index_n2--;
array_limit_size = philos_int_append(array_limit_size, &index_n2, -2);
if (strstr(key_find, "IOReadBandwidthMax")!=NULL) {
main_config.i_o_limit_read = yon_remalloc(main_config.i_o_limit_read, (index_n1 + 1) * sizeof(int));
main_config.i_o_limit_read = yon_remalloc(main_config.i_o_limit_read, (index_n1 + 1) * sizeof(int*));
main_config.i_o_limit_read_size = yon_remalloc(main_config.i_o_limit_read_size, (index_n1 + 1) * sizeof(int*));
main_config.disk = yon_remalloc(main_config.disk, (index_n1 + 1) * sizeof(char**));
philos_array_int_copy(&main_config.i_o_limit_read[index_n1], &array_limit);
@ -506,7 +506,7 @@ void get_param_io_limit(char** arr_values, int index_start, int size, int index_
yon_char_parsed_copy(&main_config.disk[index_n1], &array_disk);
}
else {
main_config.i_o_limit_write = yon_remalloc(main_config.i_o_limit_write, (index_n1 + 1) * sizeof(int));
main_config.i_o_limit_write = yon_remalloc(main_config.i_o_limit_write, (index_n1 + 1) * sizeof(int*));
main_config.i_o_limit_write_size = yon_remalloc(main_config.i_o_limit_write_size, (index_n1 + 1) * sizeof(int*));
main_config.disk = yon_remalloc(main_config.disk, (index_n1 + 1) * sizeof(char**));
philos_array_int_copy(&main_config.i_o_limit_write[index_n1], &array_limit);
@ -520,7 +520,6 @@ void get_param_io_limit(char** arr_values, int index_start, int size, int index_
}
void set_size_memory_integer(char* str_find, int** array_data, int index) {
if (strstr(str_find, " ")) {
yon_char_divide_search(str_find, " ", -1);
}
@ -531,11 +530,11 @@ void set_size_memory_integer(char* str_find, int** array_data, int index) {
}
}
if (strstr(str_find, "-")==NULL) {
// Todo: Баг
puts(str_find);
printf("%d\n", strlen(str_find));
*array_data = philos_int_append(*array_data, &index, atoi(str_find));
}
else {
*array_data = philos_int_append(*array_data, &index, -1);
}
}
@ -654,14 +653,14 @@ void tree_view_add(int index) {
main_config.cpu_limit = philos_int_append(main_config.cpu_limit, &main_config.size_tree_view, add_get_limit_cpu());
main_config.size_tree_view--;
main_config.i_o_limit_read = yon_remalloc(main_config.i_o_limit_read, (main_config.size_tree_view + 1) * sizeof(int));
main_config.i_o_limit_read = yon_remalloc(main_config.i_o_limit_read, (main_config.size_tree_view + 1) * sizeof(int*));
main_config.i_o_limit_read_size = yon_remalloc(main_config.i_o_limit_read_size, (main_config.size_tree_view + 1) * sizeof(int*));
main_config.disk = yon_remalloc(main_config.disk, (main_config.size_tree_view + 1) * sizeof(char**));
philos_array_int_copy(&main_config.i_o_limit_read[main_config.size_tree_view], add_get_read_device());
philos_array_int_copy(&main_config.i_o_limit_read_size[main_config.size_tree_view], add_get_read_device_size_pow());
yon_char_parsed_copy(&main_config.disk[main_config.size_tree_view], add_get_select_device());
main_config.i_o_limit_write = yon_remalloc(main_config.i_o_limit_write, (main_config.size_tree_view + 1) * sizeof(int));
main_config.i_o_limit_write = yon_remalloc(main_config.i_o_limit_write, (main_config.size_tree_view + 1) * sizeof(int*));
main_config.i_o_limit_write_size = yon_remalloc(main_config.i_o_limit_write_size, (main_config.size_tree_view + 1) * sizeof(int*));
main_config.disk = yon_remalloc(main_config.disk, (main_config.size_tree_view + 1) * sizeof(char**));
philos_array_int_copy(&main_config.i_o_limit_write[main_config.size_tree_view], add_get_write_device());
@ -718,21 +717,34 @@ char* format_io_limit_in_tree_view(config_str* disk, int** i_o_limit, int** i_o_
int index_to_n2 = 0;
char* str = "";
while (1) {
if (i_o_limit == NULL) {break;}
if (i_o_limit[index]!= NULL) {
if (i_o_limit[index][index_to_n2] != -2) {
if (index_to_n2!=0) {
if (!strstr(str, "-")) {
char* num_and_pow_size = philos_format_cfg_str_size_memory(" ", i_o_limit[index][index_to_n2] , i_o_limit_size[index][index_to_n2]);
if (!strstr(num_and_pow_size, "-")) {
str = yon_char_unite(str, ",",
disk[index][index_to_n2], " ",
philos_format_cfg_str_size_memory(" ", i_o_limit[index][index_to_n2] , i_o_limit_size[index][index_to_n2]), NULL);
num_and_pow_size, NULL);
}
free(num_and_pow_size);
}
}
else if (strstr(disk[index][index_to_n2], "-")){
str = yon_char_unite(str, ",", NULL);
}
else {
if (!strstr(str, "-")) {
char* num_and_pow_size = philos_format_cfg_str_size_memory(" ", i_o_limit[index][index_to_n2], i_o_limit_size[index][index_to_n2]);
if (!strstr(num_and_pow_size, "-")) {
str = yon_char_unite(str,
disk[index][index_to_n2], " ",
philos_format_cfg_str_size_memory(" ", i_o_limit[index][index_to_n2], i_o_limit_size[index][index_to_n2]), NULL);
num_and_pow_size, NULL);
}
free(num_and_pow_size);
}
}
index_to_n2++;
}
@ -746,10 +758,8 @@ char* format_io_limit_in_tree_view(config_str* disk, int** i_o_limit, int** i_o_
}
if (str == NULL) {
str = (char*)malloc(sizeof(char*)*2);
str[0] = '-';
str[1] = '\0';
if (strlen(str)==0) {
return yon_char_new("-");
}
return str;
}
@ -872,7 +882,7 @@ void main_event(main_window *widgets) {
}
void wrapper_add_show(GtkWidget *self) {
add_show(NULL, glade_path);
g_signal_connect(G_OBJECT(get_widget_add()->btnSaveAddSave), "clicked", G_CALLBACK(main_add_btn_save), NULL);
g_signal_connect(G_OBJECT(get_widget_add()->btnSaveTempSave), "clicked", G_CALLBACK(main_add_btn_save), NULL);
}
void main_add_btn_save() {
tree_view_add(main_config.size_tree_view);
@ -901,7 +911,7 @@ void wrapper_edit_show() {
edit_init_windows();
edit_set_limit_swap(main_config.swap[index], main_config.swap_size[index]);
edit_event(get_widget_edit());
g_signal_connect(G_OBJECT(get_widget_edit()->btnSaveEditSave), "clicked", G_CALLBACK(main_edit_btn_save), NULL);
g_signal_connect(G_OBJECT(get_widget_edit()->btnSaveTempSave), "clicked", G_CALLBACK(main_edit_btn_save), NULL);
edit_init_windows();
}
}
@ -1018,49 +1028,85 @@ char* save_format_key(int index) {
}
char* save_format_value(int index) {
char* value = NULL;
char* value = "";
char split_simvol[2] = {0};
split_simvol[0] = 0;
split_simvol[1] = 0;
if (main_config.soft_raw_limit[index]==0) {
value = yon_char_unite(philos_format_cfg_str_size_memory("MemoryHigh=", main_config.soft_raw_limit[index],main_config.soft_raw_limit_size[index]),NULL);
char* value1 = yon_char_unite(philos_format_cfg_str_size_memory("MemoryHigh=", main_config.soft_raw_limit[index],main_config.soft_raw_limit_size[index]),NULL);
if (strstr(value1,"-")) {
free(value1);
}
else {
value = yon_char_new(value1);
free(value1);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
}
if (main_config.hard_raw_limit[index]==0) {
value = yon_char_unite(value ,split_simvol, philos_format_cfg_str_size_memory("MemoryMax=", main_config.hard_raw_limit[index],main_config.hard_raw_limit_size[index]), NULL);
char* value1 = yon_char_unite(value ,split_simvol, philos_format_cfg_str_size_memory("MemoryMax=", main_config.hard_raw_limit[index],main_config.hard_raw_limit_size[index]), NULL);
if (strstr(value1,"-")) {
free(value1);
}
else {
value = yon_char_new(value1);
free(value1);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
}
if (main_config.swap[index]==0) {
value = yon_char_unite(value ,split_simvol, philos_format_cfg_str_size_memory("MemorySwapMax=", main_config.swap[index],main_config.swap_size[index]), NULL);
char* value1 = yon_char_unite(value ,split_simvol, philos_format_cfg_str_size_memory("MemorySwapMax=", main_config.swap[index],main_config.swap_size[index]), NULL);
if (strstr(value1,"-")) {
free(value1);
}
else {
value = yon_char_new(value1);
free(value1);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
}
if (main_config.cpu_limit[index]==0) {
value = yon_char_unite(value ,split_simvol,"CPUQuota=", main_config.cpu_limit[index], NULL);
char* value1 = yon_char_unite(value ,split_simvol,"CPUQuota=", main_config.cpu_limit[index], NULL);
if (strstr(value1,"-")) {
free(value1);
}
else {
value = yon_char_new(value1);
free(value1);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
value = add_io_str_format_ubconfig(value, "IOReadBandwidthMax", main_config.i_o_limit_read, main_config.disk, index);
value = add_io_str_format_ubconfig(value, "IOWriteBandwidthMax", main_config.i_o_limit_write, main_config.disk, index);
}
value = add_io_str_format_ubconfig(value, "IOReadBandwidthMax", main_config.i_o_limit_read, main_config.i_o_limit_read_size, main_config.disk, index);
value = add_io_str_format_ubconfig(value, "IOWriteBandwidthMax", main_config.i_o_limit_write, main_config.i_o_limit_write_size, main_config.disk, index);
return value;
}
char* add_io_str_format_ubconfig(char* cmd_io, char* key, int** i_o_limit, char*** disk, int index) {
char* add_io_str_format_ubconfig(char* cmd_io, char* key, int** i_o_limit, int** i_o_limit_size, char*** disk, int index) {
char split_simvol[2] = {0};
if (i_o_limit != NULL) {
if (i_o_limit) {
if (i_o_limit[index] != NULL) {
if (i_o_limit[index] != NULL) {
for (int i = 0;i_o_limit[index][i] != -2; i++) {
if (i==0) {
cmd_io = yon_char_unite(cmd_io, ",", key, "=");
if (i==0 && strlen(cmd_io) == 0) {
cmd_io = yon_char_unite(cmd_io, ",", key, "=", NULL);
}
if (cmd_io == NULL) {
cmd_io = yon_char_new("");
}
int read_limit = i_o_limit[index][i];
char* read_limit_disk = disk[index][i];
cmd_io = yon_char_unite(cmd_io, split_simvol, read_limit_disk, " ", yon_char_from_int(read_limit));
char* read_disk = disk[index][i];
int read_limit_size = i_o_limit_size[index][i];
if (read_limit >= 0 && read_disk && read_limit_size >= 0) {
char* num_and_pow_size = philos_format_cfg_str_size_memory("",read_limit, read_limit_size);
cmd_io = yon_char_unite(cmd_io, split_simvol, read_disk, " ",num_and_pow_size, NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
}
}
}
}
@ -1112,7 +1158,7 @@ char* template_format_str_set_save(dictionary* load_cfg, char* source_set_cmd) {
key = yon_char_new(save_format_key(index));
value = yon_char_new(save_format_value(index));
if (key != NULL && value != NULL) {
cmd = yon_char_unite(cmd, " " , key, "=" , value, NULL);
cmd = yon_char_unite(cmd, " " , key, "=\"" , value, "\"\n", NULL);
flag_save = 1;
}
if (key != NULL) {

4
source/ubl-settings-resourcequota.h
Unescape View File

@ -43,7 +43,7 @@
#define CMD_GET_GROUP "cut -d: -f1 /etc/group"
typedef char *string;
string version_application = "1.2-42-g505929e";
string version_application = "1.2-43-g3f8aab0";
static char *local;
@ -218,5 +218,5 @@ char* template_format_str_remove_save(dictionary* load_cfg, char* source_remove_
char* template_format_str_set_save(dictionary* load_cfg, char* source_set_cmd);
char* save_format_key(int index);
void get_param_io_limit(char** arr_values, int index_start, int size, int index_n1, char *key_find);
char* add_io_str_format_ubconfig(char* cmd_io, char* key, int** i_o_limit, char*** disk_read, int index);
char* add_io_str_format_ubconfig(char* cmd_io, char* key, int** i_o_limit, int** i_o_limit_size, char*** disk_read, int index);
char* format_io_limit_in_tree_view(config_str* disk, int** i_o_limit, int** i_o_limit_size, int index);

331
source/ubl-utils.c
Unescape View File

@ -671,10 +671,10 @@ void philos_split_size_memory(char* str_value, int* size, char* pow_memory) {
}
char* philos_format_cfg_str_size_memory(char* str_key, int value, int pow_size_memory) {
char* str_value = yon_char_from_int(value);
if (value == 0) {
return "-";
if (value == -1 || pow_size_memory == -3) {
return yon_char_new("-");
}
char* str_value = yon_char_from_int(value);
str_value = yon_char_divide_search(str_value, " ", -1);
if (pow_size_memory==0) {
return yon_char_unite(str_key, str_value, "K" ,NULL);
@ -884,12 +884,18 @@ void yon_int_array_append(int **source, int append){
void philos_array_int_copy(int** source, int** copy) {
int * new_int = g_malloc0(sizeof(int)*2);
new_int[0] = (*copy)[0];
if ((*copy)[0] == -2) {
yon_int_array_append(&new_int,(*copy)[0]);
}
else {
new_int[1] = -2;
int i = 2;
for (i=1;(*copy)[i]!=-2;i++) {
yon_int_array_append(&new_int,(*copy)[i]);
}
}
*source=new_int;
}
// parsing functions
@ -1125,7 +1131,326 @@ char** philos_pars_terminal_systemd_cgls(char* CMD_GET_SLICE_SERVICE, char* str_
}
return array_data;
}
char* philos_pard_array_add_cmd(char* cmd, temp_config* _config, char* key, int* array_io, int* array_io_pow_size) {
char* split_simvol = g_malloc0(sizeof(char)*2);
int flag_format = 0;
char* cmd_old = yon_char_new(cmd);
if (_config->disk && _config->size && array_io && array_io_pow_size) {
int index_find = 0;
for (int index = 0; index < _config->size; index++) {
if (index==0) {
if (strlen(cmd)>1) {
cmd = yon_char_unite(cmd, ",", key, NULL);
}
else {
cmd = yon_char_unite(cmd, key, NULL);
}
}
if (array_io_pow_size[index] != -1 && array_io[index]!=-2 && array_io[index]!=-1) {
char* num_and_pow_size = philos_format_cfg_str_size_memory(" ", array_io[index], array_io_pow_size[index]);
cmd = yon_char_unite(cmd,
split_simvol,
_config->disk[index],
num_and_pow_size, NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
flag_format = 1;
free(num_and_pow_size);
}
}
}
free(split_simvol);
if (flag_format) {
return cmd;
}
else {
return cmd_old;
}
}
int philos_check_activ_disk(temp_set_window *widgets, temp_config* _config) {
char* disk = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->cbtTempDevice));
disk = yon_char_divide_search(disk," ", -1);
int bool_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead));
int bool_write = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite));
if (disk == NULL || _config->size == 0) {
return 0;
}
return 1;
}
void philos_temp_generate_cmd(temp_set_window *widgets, temp_config* _config) {
char* str_cmd = "";
char* split_simvol = g_malloc0(sizeof(char)*2);
int size_bite = 0;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chkSoftRestrictionTemp))) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spiSevereRestrictionTemp));
str_cmd = yon_char_unite(str_cmd,
"MemoryHigh=",
yon_char_from_int(size_bite),
philos_str_size_pow_byte(widgets->cmSevereRestrictionTemp), NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chkSevereRestrictionTemp))) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinSevereRestrictionTemp));
str_cmd = yon_char_unite(str_cmd, split_simvol,
"MemoryMax=",
yon_char_from_int(size_bite),
philos_str_size_pow_byte(widgets->cmbSevereRestrictionTemp), NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chkPaddingFLTemp))) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinPaddingFLTemp));
str_cmd = yon_char_unite(str_cmd, split_simvol,
"MemorySwapMax=",
yon_char_from_int(size_bite),
philos_str_size_pow_byte(widgets->cmbPaddingFLTemp), NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chkCPULimitTemp))) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinCPULimitTemp));
str_cmd = yon_char_unite(str_cmd, split_simvol,
"CPUQuota=",
yon_char_from_int(size_bite),
"%", NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempDevice))!=-1) {
if (_config->size!=0) {
str_cmd = philos_pard_array_add_cmd(str_cmd, _config, "IOReadBandwidthMax=", _config->i_o_limit_read, _config->i_o_limit_read_size);
str_cmd = philos_pard_array_add_cmd(str_cmd, _config, "IOWriteBandwidthMax=", _config->i_o_limit_write, _config->i_o_limit_write_size);
}
}
gtk_entry_set_text(GTK_ENTRY(widgets->entryTempCmd), str_cmd);
free(split_simvol);
}
void philos_temp_del_disk(temp_set_window *widgets, temp_config* _config) {
char* disk = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->cbtTempDevice));
disk = yon_char_divide_search(disk, " ", -1);
int bool_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead));
int bool_write = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite));
if (philos_check_activ_disk(widgets, _config) == 0) {
return;
}
if (_config->disk && _config->size) {
int index_find = -1;
for (int index = 0; index < _config->size; index++) {
char* disk_cfg = _config->disk[index];
if (strstr(disk_cfg, disk) != NULL) {
index_find = index;
break;
}
}
if ((bool_read == 0 && bool_write == 0 && index_find != -1)) {
_config->disk = yon_char_parsed_shrink(_config->disk,&_config->size, index_find);
_config->size++;
_config->i_o_limit_read_size = remove_element_int_array(_config->i_o_limit_read_size,&_config->size, index_find);
_config->size++;
_config->i_o_limit_write_size = remove_element_int_array(_config->i_o_limit_write_size,&_config->size, index_find);
_config->size++;
_config->i_o_limit_read = remove_element_int_array(_config->i_o_limit_read,&_config->size, index_find);
_config->size++;
_config->i_o_limit_write = remove_element_int_array(_config->i_o_limit_write,&_config->size, index_find);
}
}
}
void philos_temp_config_init(temp_config* _config) {
if (_config->size != 0) {
philos_free_string_array(&_config->disk, _config->size);
philos_free_int_array(&_config->i_o_limit_read, _config->size);
philos_free_int_array(&_config->i_o_limit_read_size, _config->size);
philos_free_int_array(&_config->i_o_limit_write, _config->size);
philos_free_int_array(&_config->i_o_limit_write_size, _config->size);
}
_config->disk = NULL;
_config->i_o_limit_read = NULL;
_config->i_o_limit_write = NULL;
_config->i_o_limit_read_size = NULL;
_config->i_o_limit_write_size = NULL;
_config->size = 0;
}
// flag_check_array = 0 READ
// flag_check_array = 1 WRITE
void philos_update_device_to_entry(temp_set_window *widgets, temp_config* _config, int flag_check_array) {
int disk_id = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempDevice));
char* disk = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->cbtTempDevice));
disk = yon_char_divide_search(disk, " ", -1);
if (disk_id != -1) {
int index_find = -1;
for (int index = 0; index < _config->size; index++) {
char* disk_cfg = _config->disk[index];
if (strstr(disk_cfg, disk) != NULL) {
index_find = index;
break;
}
}
printf("%d\n", index_find);
if (index_find != -1) {
printf("%d\n", _config->i_o_limit_read[index_find]);
if (flag_check_array==0) {
if (_config->i_o_limit_read[index_find]==-2 || _config->i_o_limit_read[index_find]==-1) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->spinTempRead), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->cbtTempRead), 0);
}
else {
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->spinTempRead), _config->i_o_limit_read[index_find]);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead), 1);
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->cbtTempRead), _config->i_o_limit_read_size[index_find]);
}
}
else if (flag_check_array==1) {
if (_config->i_o_limit_write[index_find]==-2 || _config->i_o_limit_write[index_find]==-1) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->spinTempWrite), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->cbtTempWrite), 0);
}
else {
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->spinTempWrite), _config->i_o_limit_write[index_find]);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite), 1);
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->cbtTempWrite), _config->i_o_limit_write_size[index_find]);
}
}
else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->spinTempWrite), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->cbtTempWrite), 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->spinTempRead), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->cbtTempRead), 0);
}
}
else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->spinTempWrite), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->cbtTempWrite), 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->spinTempRead), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->cbtTempRead), 0);
}
}
else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->spinTempWrite), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->cbtTempWrite), 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widgets->spinTempRead), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->cbtTempRead), 0);
}
}
void philos_temp_add_disk(temp_set_window *widgets, temp_config* _config){
char* disk = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->cbtTempDevice));
disk = yon_char_divide_search(disk, " ", -1);
int disk_id = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempDevice));
int bool_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead));
int bool_write = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite));
if (disk_id >= 0 && _config->size !=0) {
int index_find = -1;
for (int index = 0; index < _config->size; index++) {
char* disk_cfg = _config->disk[index];
if (strstr(disk_cfg, disk) != NULL) {
index_find = index;
break;
}
}
if (index_find == -1) {
// Добавление
_config->disk = yon_char_parsed_append(_config->disk,&_config->size, disk);
_config->size--;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead))) {
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&_config->size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempRead)));
_config->size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&_config->size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempRead)));
_config->size--;
}
else {
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&_config->size,-1);
_config->size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&_config->size,-1);
_config->size--;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite))) {
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&_config->size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempWrite)));
_config->size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&_config->size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempWrite)));
_config->size--;
}
else {
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&_config->size,-1);
_config->size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&_config->size,-1);
_config->size--;
}
_config->size++;
}
else {
// Редактирование
//_config->disk[index_find] = yon_char_new(disk);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead))) {
_config->i_o_limit_read_size[index_find] =(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempRead));
_config->i_o_limit_read[index_find] = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempRead));
}
else {
_config->i_o_limit_read_size[index_find] = -1;
_config->i_o_limit_read[index_find] = -1;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite))) {
_config->i_o_limit_write_size[index_find] = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempWrite));
_config->i_o_limit_write[index_find] = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempWrite));
}
else {
_config->i_o_limit_write_size[index_find] = -1;
_config->i_o_limit_write[index_find] = -1;
}
}
}
else {
if (bool_read == 1 || bool_write == 1) {
_config->disk = yon_char_parsed_append(_config->disk,&_config->size, disk);
_config->size--;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead))) {
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&_config->size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempRead)));
_config->size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&_config->size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempRead)));
_config->size--;
}
else {
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&_config->size,-1);
_config->size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&_config->size,-1);
_config->size--;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite))) {
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&_config->size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempWrite)));
_config->size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&_config->size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempWrite)));
_config->size--;
}
else {
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&_config->size,-1);
_config->size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&_config->size,-1);
_config->size--;
}
_config->size++;
}
else {
}
}
}
int yon_launch_app(char *name)
{
char *path = name;

58
source/ubl-utils.h
Unescape View File

@ -53,7 +53,51 @@ typedef struct
int *exitcode;
} thread_output;
typedef struct {
char** disk;
int* i_o_limit_read;
int* i_o_limit_write;
int* i_o_limit_read_size;
int* i_o_limit_write_size;
int size;
} temp_config;
typedef struct {
GtkWidget* Window;
GtkWidget* btnSaveTempSave;
GtkWidget* btnTempCancel;
GtkWidget* entryTempCmd;
GtkWidget* chbTempRead;
GtkWidget* spinTempRead;
GtkWidget* cbtTempRead;
GtkWidget* chbTempWrite;
GtkWidget* spinTempWrite;
GtkWidget* cbtTempWrite;
GtkWidget* chkSoftRestrictionTemp;
GtkWidget* spiSevereRestrictionTemp;
GtkWidget* cmSevereRestrictionTemp;
GtkWidget* chkSevereRestrictionTemp;
GtkWidget* spinSevereRestrictionTemp;
GtkWidget* cmbSevereRestrictionTemp;
GtkWidget* chkPaddingFLTemp;
GtkWidget* spinPaddingFLTemp;
GtkWidget* cmbPaddingFLTemp;
GtkWidget* chkCPULimitTemp;
GtkWidget* spinCPULimitTemp;
GtkWidget* lblCPULimitTemp;
GtkWidget* cbtTempDevice;
GtkWidget* cbxTempQuotaObj;
GtkWidget* cbxTempQuotaLevel2;
GtkWidget* boxBlockGui;
} temp_set_window;
typedef struct dictionary
{
char *key;
@ -205,6 +249,20 @@ char *yon_config_make_save_parameter_with_multiple_arguments(char *parameter_str
char** philos_pars_terminal_systemd_cgls(char* CMD_GET_SLICE_SERVICE, char* str_find, int* size_array_data);
char* philos_pard_array_add_cmd(char* cmd, temp_config* _config, char* key, int* array_io, int* array_io_pow_size);
int philos_check_activ_disk(temp_set_window *widgets, temp_config* _config);
void philos_temp_generate_cmd(temp_set_window *widgets, temp_config* _config);
void philos_update_device_to_entry(temp_set_window *widgets, temp_config* _config, int flag_check_array);
void philos_temp_config_init(temp_config* _config);
void philos_temp_add_disk(temp_set_window *widgets, temp_config* _config);
void philos_temp_del_disk(temp_set_window *widgets, temp_config* _config);
int yon_launch_app(char *name);
int yon_launch_app_with_arguments(char *name, char *args);

523
source/view_add.c
Unescape View File

@ -1,374 +1,116 @@
#include "view_add.h"
#include "ubl-utils.h"
add_window *add_widgets = NULL;
add_config obj_add_config;
temp_set_window *add_widgets = NULL;
temp_config obj_add_config;
add_config* get_add_config() {
temp_config* get_add_config() {
return &obj_add_config;
}
add_window *add_setup_window(char* glade_path) {
temp_set_window *add_setup_window(char* glade_path) {
if (add_widgets == NULL) {
add_widgets = malloc(sizeof(add_window));
add_widgets = malloc(sizeof(temp_set_window));
GtkBuilder *builder = gtk_builder_new_from_file(glade_path);
add_widgets->Window = yon_gtk_builder_get_widget(builder,"wndQuotasAdding");
add_widgets->btnSaveAddSave = yon_gtk_builder_get_widget(builder,"btnSaveAddSave");
add_widgets->btnAddCancel = yon_gtk_builder_get_widget(builder,"btnAddCancel");
add_widgets->entryAddCmd = yon_gtk_builder_get_widget(builder,"entryAddCmd");
add_widgets->cbxAddQuotaObj = yon_gtk_builder_get_widget(builder,"cbxAddQuotaObj");
add_widgets->cbxAddQuotaLevel2 = yon_gtk_builder_get_widget(builder,"cbxAddQuotaLevel2");
add_widgets->cbtAddDevice = yon_gtk_builder_get_widget(builder,"cbtAddDevice");
add_widgets->lblCPULimitAdd = yon_gtk_builder_get_widget(builder,"lblCPULimitAdd");
add_widgets->spinCPULimitAdd = yon_gtk_builder_get_widget(builder,"spinCPULimitAdd");
add_widgets->chkCPULimitAdd = yon_gtk_builder_get_widget(builder,"chkCPULimitAdd");
add_widgets->chkPaddingFLAdd = yon_gtk_builder_get_widget(builder,"chkPaddingFLAdd");
add_widgets->spinPaddingFLAdd = yon_gtk_builder_get_widget(builder,"spinPaddingFLAdd");
add_widgets->cmbPaddingFLAdd = yon_gtk_builder_get_widget(builder,"cmbPaddingFLAdd");
add_widgets->chkSevereRestrictionAdd = yon_gtk_builder_get_widget(builder,"chkSevereRestrictionAdd");
add_widgets->spinSevereRestrictionAdd = yon_gtk_builder_get_widget(builder,"spinSevereRestrictionAdd");
add_widgets->cmbSevereRestrictionAdd = yon_gtk_builder_get_widget(builder,"cmbSevereRestrictionAdd");
add_widgets->chkSoftRestrictionAdd = yon_gtk_builder_get_widget(builder,"chkSoftRestrictionAdd");
add_widgets->spiSevereRestrictionAdd = yon_gtk_builder_get_widget(builder,"spiSevereRestrictionAdd");
add_widgets->cmSevereRestrictionAdd = yon_gtk_builder_get_widget(builder,"cmSevereRestrictionAdd");
add_widgets->chbAddRead = yon_gtk_builder_get_widget(builder,"chbAddRead");
add_widgets->spinAddRead = yon_gtk_builder_get_widget(builder,"spinAddRead");
add_widgets->cbtAddRead = yon_gtk_builder_get_widget(builder,"cbtAddRead");
add_widgets->spinAddWrite = yon_gtk_builder_get_widget(builder,"spinAddWrite");
add_widgets->chbAddWrite = yon_gtk_builder_get_widget(builder,"chbAddWrite");
add_widgets->cbtAddWrite = yon_gtk_builder_get_widget(builder,"cbtAddWrite");
add_widgets->btnSaveTempSave = yon_gtk_builder_get_widget(builder,"btnSaveAddSave");
add_widgets->btnTempCancel = yon_gtk_builder_get_widget(builder,"btnAddCancel");
add_widgets->entryTempCmd = yon_gtk_builder_get_widget(builder,"entryAddCmd");
add_widgets->cbxTempQuotaObj = yon_gtk_builder_get_widget(builder,"cbxAddQuotaObj");
add_widgets->cbxTempQuotaLevel2 = yon_gtk_builder_get_widget(builder,"cbxAddQuotaLevel2");
add_widgets->cbtTempDevice = yon_gtk_builder_get_widget(builder,"cbtAddDevice");
add_widgets->lblCPULimitTemp = yon_gtk_builder_get_widget(builder,"lblCPULimitAdd");
add_widgets->spinCPULimitTemp = yon_gtk_builder_get_widget(builder,"spinCPULimitAdd");
add_widgets->chkCPULimitTemp = yon_gtk_builder_get_widget(builder,"chkCPULimitAdd");
add_widgets->chkPaddingFLTemp = yon_gtk_builder_get_widget(builder,"chkPaddingFLAdd");
add_widgets->spinPaddingFLTemp = yon_gtk_builder_get_widget(builder,"spinPaddingFLAdd");
add_widgets->cmbPaddingFLTemp = yon_gtk_builder_get_widget(builder,"cmbPaddingFLAdd");
add_widgets->chkSevereRestrictionTemp = yon_gtk_builder_get_widget(builder,"chkSevereRestrictionAdd");
add_widgets->spinSevereRestrictionTemp = yon_gtk_builder_get_widget(builder,"spinSevereRestrictionAdd");
add_widgets->cmbSevereRestrictionTemp = yon_gtk_builder_get_widget(builder,"cmbSevereRestrictionAdd");
add_widgets->chkSoftRestrictionTemp = yon_gtk_builder_get_widget(builder,"chkSoftRestrictionAdd");
add_widgets->spiSevereRestrictionTemp = yon_gtk_builder_get_widget(builder,"spiSevereRestrictionAdd");
add_widgets->cmSevereRestrictionTemp = yon_gtk_builder_get_widget(builder,"cmSevereRestrictionAdd");
add_widgets->chbTempRead = yon_gtk_builder_get_widget(builder,"chbAddRead");
add_widgets->spinTempRead = yon_gtk_builder_get_widget(builder,"spinAddRead");
add_widgets->cbtTempRead = yon_gtk_builder_get_widget(builder,"cbtAddRead");
add_widgets->spinTempWrite = yon_gtk_builder_get_widget(builder,"spinAddWrite");
add_widgets->chbTempWrite = yon_gtk_builder_get_widget(builder,"chbAddWrite");
add_widgets->cbtTempWrite = yon_gtk_builder_get_widget(builder,"cbtAddWrite");
add_widgets->boxBlockGui = yon_gtk_builder_get_widget(builder,"boxBlockGui");
device_fill_disk(add_widgets->cbtAddDevice);
device_fill_disk(add_widgets->cbtTempDevice);
add_event(add_widgets);
add_init_windows();
add_localization(add_widgets);
add_config_init();
philos_temp_config_init(&obj_add_config);
}
return add_widgets;
}
// flag_check_array = 0 READ
// flag_check_array = 1 WRITE
void update_device_to_entry(GtkWidget *combo_box, GtkWidget *combo_box_size, GtkWidget *check_button, GtkWidget *spin, int flag_check_array) {
int disk_id = gtk_combo_box_get_active(GTK_COMBO_BOX(combo_box));
char* disk = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(add_widgets->cbtAddDevice));
disk = yon_char_divide_search(disk, " ", -1);
if (disk_id != -1) {
int index_find = -1;
for (int index = 0; index < obj_add_config.size; index++) {
char* disk_cfg = obj_add_config.disk[index];
if (strstr(disk_cfg, disk) != NULL) {
index_find = index;
break;
}
}
if (index_find != -1) {
if (flag_check_array==0) {
if (obj_add_config.i_o_limit_read[index_find]==-2) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box_size), 0);
}
else {
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), obj_add_config.i_o_limit_read[index_find]);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), 1);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box_size), obj_add_config.i_o_limit_read_size[index_find]);
}
}
else if (flag_check_array==1) {
if (obj_add_config.i_o_limit_write[index_find]==-2) {
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box_size), 0);
}
else {
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), obj_add_config.i_o_limit_write[index_find]);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), 1);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box_size), obj_add_config.i_o_limit_write_size[index_find]);
}
}
else {
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box_size), 0);
}
}
else {
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box_size), 0);
}
}
else {
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button), 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box_size), 0);
}
}
void add_config_init() {
if (obj_add_config.size != 0) {
philos_free_string_array(&obj_add_config.disk, obj_add_config.size);
philos_free_int_array(&obj_add_config.i_o_limit_read, obj_add_config.size);
philos_free_int_array(&obj_add_config.i_o_limit_read_size, obj_add_config.size);
philos_free_int_array(&obj_add_config.i_o_limit_write, obj_add_config.size);
philos_free_int_array(&obj_add_config.i_o_limit_write_size, obj_add_config.size);
}
obj_add_config.disk = NULL;
obj_add_config.i_o_limit_read = NULL;
obj_add_config.i_o_limit_write = NULL;
obj_add_config.i_o_limit_read_size = NULL;
obj_add_config.i_o_limit_write_size = NULL;
obj_add_config.size = 0;
}
void add_init_windows() {
if (gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbxAddQuotaLevel2)) != -1) {
if (gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbxTempQuotaLevel2)) != -1) {
gtk_widget_set_sensitive(add_widgets->boxBlockGui, 1);
gtk_widget_set_sensitive(add_widgets->btnSaveAddSave, 1);
philos_set_active_widgets(add_widgets->chkSoftRestrictionAdd, add_widgets->spiSevereRestrictionAdd, add_widgets->cmSevereRestrictionAdd, 0 , CMD_RAW);
philos_set_active_widgets(add_widgets->chkSevereRestrictionAdd, add_widgets->spinSevereRestrictionAdd, add_widgets->cmbSevereRestrictionAdd,0 , CMD_RAW);
philos_set_active_widgets(add_widgets->chkPaddingFLAdd, add_widgets->spinPaddingFLAdd, add_widgets->cmbPaddingFLAdd,0 , CMD_SWAP);
philos_set_active_widgets(add_widgets->chkCPULimitAdd, add_widgets->spinCPULimitAdd, add_widgets->lblCPULimitAdd,1 , CMD_CPU);
philos_set_active_widgets_device_io(add_widgets->cbtAddDevice,add_widgets->chbAddWrite, add_widgets->spinAddWrite, add_widgets->cbtAddWrite);
philos_set_active_widgets_device_io(add_widgets->cbtAddDevice,add_widgets->chbAddRead, add_widgets->spinAddRead, add_widgets->cbtAddRead);
add_generate_cmd();
gtk_widget_set_sensitive(add_widgets->btnSaveTempSave, 1);
philos_set_active_widgets(add_widgets->chkSoftRestrictionTemp, add_widgets->spiSevereRestrictionTemp, add_widgets->cmSevereRestrictionTemp, 0 , CMD_RAW);
philos_set_active_widgets(add_widgets->chkSevereRestrictionTemp, add_widgets->spinSevereRestrictionTemp, add_widgets->cmbSevereRestrictionTemp,0 , CMD_RAW);
philos_set_active_widgets(add_widgets->chkPaddingFLTemp, add_widgets->spinPaddingFLTemp, add_widgets->cmbPaddingFLTemp,0 , CMD_SWAP);
philos_set_active_widgets(add_widgets->chkCPULimitTemp, add_widgets->spinCPULimitTemp, add_widgets->lblCPULimitTemp,1 , CMD_CPU);
philos_set_active_widgets_device_io(add_widgets->cbtTempDevice,add_widgets->chbTempWrite, add_widgets->spinTempWrite, add_widgets->cbtTempWrite);
philos_set_active_widgets_device_io(add_widgets->cbtTempDevice,add_widgets->chbTempRead, add_widgets->spinTempRead, add_widgets->cbtTempRead);
}
else {
gtk_widget_set_sensitive(add_widgets->boxBlockGui, 0);
gtk_widget_set_sensitive(add_widgets->btnSaveAddSave, 0);
add_generate_cmd();
}
}
int check_activ_disk() {
char* disk = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(add_widgets->cbtAddDevice));
disk = yon_char_divide_search(disk," ", -1);
int bool_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddRead));
int bool_write = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddWrite));
if (disk == NULL || obj_add_config.size == 0) {
return 0;
}
return 1;
}
void add_del_disk() {
char* disk = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(add_widgets->cbtAddDevice));
disk = yon_char_divide_search(disk, " ", -1);
int bool_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddRead));
int bool_write = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddWrite));
if (check_activ_disk() == 0) {
return;
}
if (obj_add_config.disk && obj_add_config.size) {
int index_find = -1;
printf("%d\n", obj_add_config.size);
for (int index = 0; index < obj_add_config.size; index++) {
char* disk_cfg = obj_add_config.disk[index];
if (strstr(disk_cfg, disk) != NULL) {
index_find = index;
break;
}
}
if ((bool_read == 0 && bool_write == 0 && index_find != -1)) {
obj_add_config.disk = yon_char_parsed_shrink(obj_add_config.disk,&obj_add_config.size, index_find);
obj_add_config.size++;
obj_add_config.i_o_limit_read_size = remove_element_int_array(obj_add_config.i_o_limit_read_size,&obj_add_config.size, index_find);
obj_add_config.size++;
obj_add_config.i_o_limit_write_size = remove_element_int_array(obj_add_config.i_o_limit_write_size,&obj_add_config.size, index_find);
obj_add_config.size++;
obj_add_config.i_o_limit_read = remove_element_int_array(obj_add_config.i_o_limit_read,&obj_add_config.size, index_find);
obj_add_config.size++;
obj_add_config.i_o_limit_write = remove_element_int_array(obj_add_config.i_o_limit_write,&obj_add_config.size, index_find);
}
}
}
char* pard_array_add_cmd(char* cmd, char* key, int* array_io, int* array_io_pow_size) {
char* split_simvol = g_malloc0(sizeof(char)*2);
int flag_format = 0;
char* cmd_old = yon_char_new(cmd);
if (obj_add_config.disk && obj_add_config.size && array_io && array_io_pow_size) {
int index_find = 0;
printf("\n%i\n", obj_add_config.size);
for (int index = 0; index < obj_add_config.size; index++) {
if (index==0) {
if (strlen(cmd)>1) {
cmd = yon_char_unite(cmd, ",", key, NULL);
}
else {
cmd = yon_char_unite(cmd, key, NULL);
}
}
if (array_io_pow_size[index] != -1) {
cmd = yon_char_unite(cmd,
split_simvol,
obj_add_config.disk[index],
philos_format_cfg_str_size_memory(" ", array_io[index], array_io_pow_size[index]), NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
flag_format = 1;
}
}
}
free(split_simvol);
if (flag_format) {
return cmd;
}
else {
return cmd_old;
}
}
void add_disk_all(){
char* disk = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(add_widgets->cbtAddDevice));
disk = yon_char_divide_search(disk, " ", -1);
int disk_id = gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbtAddDevice));
int bool_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddRead));
int bool_write = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddWrite));
if (disk_id >= 0 && obj_add_config.size !=0) {
int index_find = -1;
for (int index = 0; index < obj_add_config.size; index++) {
char* disk_cfg = obj_add_config.disk[index];
if (strstr(disk_cfg, disk) != NULL) {
index_find = index;
break;
}
}
if (index_find == -1) {
// Добавление
obj_add_config.disk = yon_char_parsed_append(obj_add_config.disk,&obj_add_config.size, disk);
obj_add_config.size--;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddRead))) {
obj_add_config.i_o_limit_read_size = philos_int_append(obj_add_config.i_o_limit_read_size,&obj_add_config.size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbtAddRead)));
obj_add_config.size--;
obj_add_config.i_o_limit_read = philos_int_append(obj_add_config.i_o_limit_read,&obj_add_config.size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinAddRead)));
obj_add_config.size--;
}
else {
obj_add_config.i_o_limit_read_size = philos_int_append(obj_add_config.i_o_limit_read_size,&obj_add_config.size,-1);
obj_add_config.size--;
obj_add_config.i_o_limit_read = philos_int_append(obj_add_config.i_o_limit_read,&obj_add_config.size,-1);
obj_add_config.size--;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddWrite))) {
obj_add_config.i_o_limit_write_size = philos_int_append(obj_add_config.i_o_limit_write_size,&obj_add_config.size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbtAddWrite)));
obj_add_config.size--;
obj_add_config.i_o_limit_write = philos_int_append(obj_add_config.i_o_limit_write,&obj_add_config.size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinAddWrite)));
obj_add_config.size--;
}
else {
obj_add_config.i_o_limit_write_size = philos_int_append(obj_add_config.i_o_limit_write_size,&obj_add_config.size,-1);
obj_add_config.size--;
obj_add_config.i_o_limit_write = philos_int_append(obj_add_config.i_o_limit_write,&obj_add_config.size,-1);
obj_add_config.size--;
}
obj_add_config.size++;
}
else {
// Редактирование
//obj_add_config.disk[index_find] = yon_char_new(disk);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddRead))) {
obj_add_config.i_o_limit_read_size[index_find] =(int)gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbtAddRead));
obj_add_config.i_o_limit_read[index_find] = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinAddRead));
}
else {
obj_add_config.i_o_limit_read_size[index_find] = -1;
obj_add_config.i_o_limit_read[index_find] = -1;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddWrite))) {
obj_add_config.i_o_limit_write_size[index_find] = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbtAddWrite));
obj_add_config.i_o_limit_write[index_find] = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinAddWrite));
}
else {
obj_add_config.i_o_limit_write_size[index_find] = -1;
obj_add_config.i_o_limit_write[index_find] = -1;
}
}
}
else {
if (bool_read == 1 || bool_write == 1) {
obj_add_config.disk = yon_char_parsed_append(obj_add_config.disk,&obj_add_config.size, disk);
obj_add_config.size--;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddRead))) {
obj_add_config.i_o_limit_read_size = philos_int_append(obj_add_config.i_o_limit_read_size,&obj_add_config.size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbtAddRead)));
obj_add_config.size--;
obj_add_config.i_o_limit_read = philos_int_append(obj_add_config.i_o_limit_read,&obj_add_config.size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinAddRead)));
obj_add_config.size--;
}
else {
obj_add_config.i_o_limit_read_size = philos_int_append(obj_add_config.i_o_limit_read_size,&obj_add_config.size,-1);
obj_add_config.size--;
obj_add_config.i_o_limit_read = philos_int_append(obj_add_config.i_o_limit_read,&obj_add_config.size,-1);
obj_add_config.size--;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chbAddWrite))) {
obj_add_config.i_o_limit_write_size = philos_int_append(obj_add_config.i_o_limit_write_size,&obj_add_config.size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbtAddWrite)));
obj_add_config.size--;
obj_add_config.i_o_limit_write = philos_int_append(obj_add_config.i_o_limit_write,&obj_add_config.size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinAddWrite)));
obj_add_config.size--;
}
else {
obj_add_config.i_o_limit_write_size = philos_int_append(obj_add_config.i_o_limit_write_size,&obj_add_config.size,-1);
obj_add_config.size--;
obj_add_config.i_o_limit_write = philos_int_append(obj_add_config.i_o_limit_write,&obj_add_config.size,-1);
obj_add_config.size--;
}
obj_add_config.size++;
}
else {
}
gtk_widget_set_sensitive(add_widgets->btnSaveTempSave, 0);
}
philos_temp_generate_cmd(add_widgets, &obj_add_config);
}
void event_check_io_device() {
philos_set_active_widgets_device_io(add_widgets->cbtAddDevice,add_widgets->chbAddWrite, add_widgets->spinAddWrite, add_widgets->cbtAddWrite);
philos_set_active_widgets_device_io(add_widgets->cbtAddDevice,add_widgets->chbAddRead, add_widgets->spinAddRead, add_widgets->cbtAddRead);
add_disk_all();
add_del_disk();
philos_set_active_widgets_device_io(add_widgets->cbtTempDevice,add_widgets->chbTempWrite, add_widgets->spinTempWrite, add_widgets->cbtTempWrite);
philos_set_active_widgets_device_io(add_widgets->cbtTempDevice,add_widgets->chbTempRead, add_widgets->spinTempRead, add_widgets->cbtTempRead);
philos_temp_add_disk(add_widgets, &obj_add_config);
philos_temp_del_disk(add_widgets, &obj_add_config);
add_init_windows();
}
void combo_box_device() {
update_device_to_entry(add_widgets->cbtAddDevice,add_widgets->cbtAddRead, add_widgets->chbAddRead, add_widgets->spinAddRead, 0);
update_device_to_entry(add_widgets->cbtAddDevice,add_widgets->cbtAddWrite, add_widgets->chbAddWrite, add_widgets->spinAddWrite, 1);
philos_update_device_to_entry(add_widgets, &obj_add_config, 0);
philos_update_device_to_entry(add_widgets, &obj_add_config, 1);
}
void add_event(add_window *widgets) {
g_signal_connect(G_OBJECT(widgets->btnAddCancel),"clicked",G_CALLBACK(add_on_destroy_subwindow),NULL);
void add_event(temp_set_window *widgets) {
g_signal_connect(G_OBJECT(widgets->btnTempCancel),"clicked",G_CALLBACK(add_on_destroy_subwindow),NULL);
g_signal_connect(G_OBJECT(widgets->Window), "destroy", G_CALLBACK(add_destroy), NULL);
g_signal_connect(G_OBJECT(widgets->chkSoftRestrictionAdd), "toggled", G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkSevereRestrictionAdd), "toggled", G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkPaddingFLAdd), "toggled", G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkCPULimitAdd), "toggled", G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chbAddRead), "toggled", G_CALLBACK(event_check_io_device), NULL);
g_signal_connect(G_OBJECT(widgets->chbAddWrite), "toggled", G_CALLBACK(event_check_io_device), NULL);
g_signal_connect(G_OBJECT(widgets->cbxAddQuotaObj),"changed",G_CALLBACK(add_update_combo_box), NULL);
g_signal_connect(G_OBJECT(widgets->cbxAddQuotaLevel2),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spiSevereRestrictionAdd),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinSevereRestrictionAdd),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinPaddingFLAdd),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinCPULimitAdd),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinAddRead),"changed",G_CALLBACK(event_check_io_device), NULL);
g_signal_connect(G_OBJECT(widgets->spinAddWrite),"changed",G_CALLBACK(event_check_io_device), NULL);
g_signal_connect(G_OBJECT(widgets->cmSevereRestrictionAdd),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->cmbSevereRestrictionAdd),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->cmbPaddingFLAdd),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->cbtAddRead),"changed",G_CALLBACK(event_check_io_device), NULL);
g_signal_connect(G_OBJECT(widgets->cbtAddWrite),"changed",G_CALLBACK(event_check_io_device), NULL);
g_signal_connect(G_OBJECT(widgets->cbtAddDevice),"changed",G_CALLBACK(combo_box_device), NULL);
g_signal_connect(G_OBJECT(widgets->chkSoftRestrictionTemp), "toggled", G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkSevereRestrictionTemp), "toggled", G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkPaddingFLTemp), "toggled", G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkCPULimitTemp), "toggled", G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->cbxTempQuotaObj),"changed",G_CALLBACK(add_update_combo_box), NULL);
g_signal_connect(G_OBJECT(widgets->cbxTempQuotaLevel2),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spiSevereRestrictionTemp),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinSevereRestrictionTemp),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinPaddingFLTemp),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinCPULimitTemp),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->cmSevereRestrictionTemp),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->cmbSevereRestrictionTemp),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->cmbPaddingFLTemp),"changed",G_CALLBACK(add_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->cbtTempDevice),"changed",G_CALLBACK(combo_box_device), NULL);
g_signal_connect(G_OBJECT(widgets->cbtTempRead),"changed",G_CALLBACK(event_check_io_device), NULL);
g_signal_connect(G_OBJECT(widgets->cbtTempWrite),"changed",G_CALLBACK(event_check_io_device), NULL);
g_signal_connect(G_OBJECT(widgets->spinTempRead),"changed",G_CALLBACK(event_check_io_device), NULL);
g_signal_connect(G_OBJECT(widgets->spinTempWrite),"changed",G_CALLBACK(event_check_io_device), NULL);
g_signal_connect(G_OBJECT(widgets->chbTempRead), "toggled", G_CALLBACK(event_check_io_device), NULL);
g_signal_connect(G_OBJECT(widgets->chbTempWrite), "toggled", G_CALLBACK(event_check_io_device), NULL);
}
@ -383,7 +125,7 @@ void add_destroy(GtkWidget *self) {
add_widgets = NULL;
}
void add_localization(add_window *widgets) {
void add_localization(temp_set_window *widgets) {
}
@ -393,7 +135,7 @@ void add_on_destroy_subwindow(GtkWidget *self) {
}
add_window *get_widget_add() {
temp_set_window *get_widget_add() {
return add_widgets;
}
@ -412,7 +154,7 @@ void add_show(GtkWidget *self, char* glade_path) {
}
char* add_get_select_device_to_level_2() {
char* text = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(add_widgets->cbxAddQuotaLevel2));
char* text = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(add_widgets->cbxTempQuotaLevel2));
if (text != NULL) {
return text;
}
@ -451,43 +193,65 @@ char*** add_get_select_device() {
}
int add_get_soft_size() {
return gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cmSevereRestrictionAdd));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chkSoftRestrictionTemp))) {
return gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cmSevereRestrictionTemp));
}
else {
return -3;
}
}
int add_get_hard_size() {
return gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cmbSevereRestrictionAdd));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chkSevereRestrictionTemp))) {
return gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cmbSevereRestrictionTemp));
}
else {
return -3;
}
}
int add_get_limit_cpu_size() {
return -1;
}
int add_get_limit_swap_size() {
return gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cmbPaddingFLAdd));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chkPaddingFLTemp))) {
return gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cmbPaddingFLTemp));
}
else {
return -3;
}
}
int add_get_quota_object_size() {
return gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbxAddQuotaObj));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chkPaddingFLTemp))) {
return gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbxTempQuotaObj));
}
else {
return -3;
}
}
int add_get_soft() {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spiSevereRestrictionAdd));
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spiSevereRestrictionTemp));
}
int add_get_hard() {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinSevereRestrictionAdd));
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinSevereRestrictionTemp));
}
int add_get_limit_cpu() {
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chkCPULimitAdd))) {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinCPULimitAdd));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chkCPULimitTemp))) {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinCPULimitTemp));
}
else {
return 0;
return -3;
}
}
int add_get_limit_swap() {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinPaddingFLAdd));
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinPaddingFLTemp));
}
char* add_get_quota_object() {
return gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(add_widgets->cbxAddQuotaObj));
return gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(add_widgets->cbxTempQuotaObj));
}
void add_update_combo_box() {
int menu_id = gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbxAddQuotaObj));
int menu_id = gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbxTempQuotaObj));
char* cmd = NULL;
config_str fill_cmb_2 = NULL;
int size = 0;
@ -508,60 +272,9 @@ void add_update_combo_box() {
philos_array_string_remove_char(&fill_cmb_2, "\n", size);
}
if (menu_id >= 0) {
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(add_widgets->cbxAddQuotaLevel2));
philos_fill_combo_box_text(add_widgets->cbxAddQuotaLevel2, fill_cmb_2, size);
gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(add_widgets->cbxTempQuotaLevel2));
philos_fill_combo_box_text(add_widgets->cbxTempQuotaLevel2, fill_cmb_2, size);
// yon_terminal_integrated_launch(widgets->vteProcesses, cmd, NULL, NULL);
}
}
void add_generate_cmd() {
char* str_cmd = "";
char* split_simvol = g_malloc0(sizeof(char)*2);
int size_bite = 0;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chkSoftRestrictionAdd))) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spiSevereRestrictionAdd));
str_cmd = yon_char_unite(str_cmd,
"MemoryHigh=",
yon_char_from_int(size_bite),
philos_str_size_pow_byte(add_widgets->cmSevereRestrictionAdd), NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chkSevereRestrictionAdd))) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinSevereRestrictionAdd));
str_cmd = yon_char_unite(str_cmd, split_simvol,
"MemoryMax=",
yon_char_from_int(size_bite),
philos_str_size_pow_byte(add_widgets->cmbSevereRestrictionAdd), NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chkPaddingFLAdd))) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinPaddingFLAdd));
str_cmd = yon_char_unite(str_cmd, split_simvol,
"MemorySwapMax=",
yon_char_from_int(size_bite),
philos_str_size_pow_byte(add_widgets->cmbPaddingFLAdd), NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_widgets->chkCPULimitAdd))) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(add_widgets->spinCPULimitAdd));
str_cmd = yon_char_unite(str_cmd, split_simvol,
"CPUQuota=",
yon_char_from_int(size_bite),
"%", NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_combo_box_get_active(GTK_COMBO_BOX(add_widgets->cbtAddDevice))!=-1) {
if (obj_add_config.size!=0) {
str_cmd = pard_array_add_cmd(str_cmd, "IOReadBandwidthMax=", obj_add_config.i_o_limit_read, obj_add_config.i_o_limit_read_size);
str_cmd = pard_array_add_cmd(str_cmd, "IOWriteBandwidthMax=", obj_add_config.i_o_limit_write, obj_add_config.i_o_limit_write_size);
}
}
gtk_entry_set_text(GTK_ENTRY(add_widgets->entryAddCmd), str_cmd);
free(split_simvol);
}

58
source/view_add.h
Unescape View File

@ -21,57 +21,12 @@
static char* CMD_GET_GROUP;
static char* CMD_GET_SLICE_SERVICE;
typedef struct {
config_str disk;
int* i_o_limit_read;
int* i_o_limit_write;
int* i_o_limit_read_size;
int* i_o_limit_write_size;
int size;
} add_config;
// Переменные
typedef struct {
GtkWidget* Window;
GtkWidget* btnSaveAddSave;
GtkWidget* btnAddCancel;
GtkWidget* entryAddCmd;
GtkWidget* chbAddRead;
GtkWidget* spinAddRead;
GtkWidget* cbtAddRead;
GtkWidget* chbAddWrite;
GtkWidget* spinAddWrite;
GtkWidget* cbtAddWrite;
GtkWidget* chkSoftRestrictionAdd;
GtkWidget* spiSevereRestrictionAdd;
GtkWidget* cmSevereRestrictionAdd;
GtkWidget* chkSevereRestrictionAdd;
GtkWidget* spinSevereRestrictionAdd;
GtkWidget* cmbSevereRestrictionAdd;
GtkWidget* chkPaddingFLAdd;
GtkWidget* spinPaddingFLAdd;
GtkWidget* cmbPaddingFLAdd;
GtkWidget* chkCPULimitAdd;
GtkWidget* spinCPULimitAdd;
GtkWidget* lblCPULimitAdd;
GtkWidget* cbtAddDevice;
GtkWidget* cbxAddQuotaObj;
GtkWidget* cbxAddQuotaLevel2;
GtkWidget* boxBlockGui;
} add_window;
// Функции
add_window *add_setup_window(char* glade_path);
void add_event(add_window *widgets);
void add_localization(add_window *widgets);
temp_set_window *add_setup_window(char* glade_path);
void add_event(temp_set_window *widgets);
void add_localization(temp_set_window *widgets);
void add_on_destroy_subwindow(GtkWidget *self);
add_window *get_widget_add();
temp_set_window *get_widget_add();
void add_show(GtkWidget *self, char* glade_path);
void add_destroy(GtkWidget *self);
void add_set_active_widgets(GtkWidget *check, GtkWidget *spin, GtkWidget *combo, int flag_cpu, char* cmd);
@ -93,13 +48,10 @@ int add_get_hard_size();
int add_get_limit_cpu_size();
int add_get_limit_swap_size();
int add_get_quota_object_size();
add_config* get_add_config();
void add_config_init();
void add_disk_all();
temp_config* get_add_config();
void add_set_active_widgets_device_io(GtkWidget *check, GtkWidget *spin, GtkWidget *combo);
void add_get_cmd_group(char* cmd_get_group);
char* add_get_select_device_to_level_2();
void add_generate_cmd();
void add_get_systemd_cgls(char* cmd_systemd_cgls);
void add_set_spin_adjustment(GtkWidget *check, GtkWidget *spin, GtkWidget *combo, size_t value);
#endif

283
source/view_edit.c
Unescape View File

@ -1,48 +1,49 @@
#include "view_edit.h"
edit_window *edit_widgets = NULL;
edit_config obj_edit_config;
temp_set_window *edit_widgets = NULL;
temp_config obj_edit_config;
edit_config* get_edit_config() {
temp_config* get_edit_config() {
return &obj_edit_config;
}
edit_window *edit_setup_window(char* glade_path){
temp_set_window *edit_setup_window(char* glade_path){
if (edit_widgets == NULL) {
edit_widgets = malloc(sizeof(edit_window));
edit_widgets = malloc(sizeof(temp_set_window));
GtkBuilder *builder = gtk_builder_new_from_file(glade_path);
edit_widgets->Window = yon_gtk_builder_get_widget(builder,"wndQuotasEdit");
edit_widgets->btnEditCancel = yon_gtk_builder_get_widget(builder,"btnEditCancel");
edit_widgets->btnSaveEditSave = yon_gtk_builder_get_widget(builder,"btnSaveEditSave");
edit_widgets->btnTempCancel = yon_gtk_builder_get_widget(builder,"btnEditCancel");
edit_widgets->btnSaveTempSave = yon_gtk_builder_get_widget(builder,"btnSaveEditSave");
edit_widgets->cbtEditDevice = yon_gtk_builder_get_widget(builder,"cbtEditDevice");
edit_widgets->lblCPULimitEdit = yon_gtk_builder_get_widget(builder,"lblCPULimitEdit");
edit_widgets->spinCPULimitEdit = yon_gtk_builder_get_widget(builder,"spinCPULimitEdit");
edit_widgets->chkCPULimitEdit = yon_gtk_builder_get_widget(builder,"chkCPULimitEdit");
edit_widgets->cbtTempDevice = yon_gtk_builder_get_widget(builder,"cbtEditDevice");
edit_widgets->lblCPULimitTemp = yon_gtk_builder_get_widget(builder,"lblCPULimitEdit");
edit_widgets->spinCPULimitTemp = yon_gtk_builder_get_widget(builder,"spinCPULimitEdit");
edit_widgets->chkCPULimitTemp = yon_gtk_builder_get_widget(builder,"chkCPULimitEdit");
edit_widgets->chkPaddingFLEdit = yon_gtk_builder_get_widget(builder,"chkPaddingFLEdit");
edit_widgets->spinPaddingFLEdit = yon_gtk_builder_get_widget(builder,"spinPaddingFLEdit");
edit_widgets->cmbPaddingFLEdit = yon_gtk_builder_get_widget(builder,"cmbPaddingFLEdit");
edit_widgets->chkPaddingFLTemp = yon_gtk_builder_get_widget(builder,"chkPaddingFLEdit");
edit_widgets->spinPaddingFLTemp = yon_gtk_builder_get_widget(builder,"spinPaddingFLEdit");
edit_widgets->cmbPaddingFLTemp = yon_gtk_builder_get_widget(builder,"cmbPaddingFLEdit");
edit_widgets->chkSevereRestrictionEdit = yon_gtk_builder_get_widget(builder,"chkSevereRestrictionEdit");
edit_widgets->spinSevereRestrictionEdit = yon_gtk_builder_get_widget(builder,"spinSevereRestrictionEdit");
edit_widgets->cmbSevereRestrictionEdit = yon_gtk_builder_get_widget(builder,"cmbSevereRestrictionEdit");
edit_widgets->chkSevereRestrictionTemp = yon_gtk_builder_get_widget(builder,"chkSevereRestrictionEdit");
edit_widgets->spinSevereRestrictionTemp = yon_gtk_builder_get_widget(builder,"spinSevereRestrictionEdit");
edit_widgets->cmbSevereRestrictionTemp = yon_gtk_builder_get_widget(builder,"cmbSevereRestrictionEdit");
edit_widgets->chkSoftRestrictionEdit = yon_gtk_builder_get_widget(builder,"chkSoftRestrictionEdit");
edit_widgets->spiSevereRestrictionEdit = yon_gtk_builder_get_widget(builder,"spiSevereRestrictionEdit");
edit_widgets->cmSevereRestrictionEdit = yon_gtk_builder_get_widget(builder,"cmSevereRestrictionEdit");
edit_widgets->chkSoftRestrictionTemp = yon_gtk_builder_get_widget(builder,"chkSoftRestrictionEdit");
edit_widgets->spiSevereRestrictionTemp = yon_gtk_builder_get_widget(builder,"spiSevereRestrictionEdit");
edit_widgets->cmSevereRestrictionTemp = yon_gtk_builder_get_widget(builder,"cmSevereRestrictionEdit");
edit_widgets->chbEditRead = yon_gtk_builder_get_widget(builder,"chbEditRead");
edit_widgets->spinEditRead = yon_gtk_builder_get_widget(builder,"spinEditRead");
edit_widgets->cbtEditRead = yon_gtk_builder_get_widget(builder,"cbtEditRead");
edit_widgets->chbTempRead = yon_gtk_builder_get_widget(builder,"chbEditRead");
edit_widgets->spinTempRead = yon_gtk_builder_get_widget(builder,"spinEditRead");
edit_widgets->cbtTempRead = yon_gtk_builder_get_widget(builder,"cbtEditRead");
edit_widgets->spinEditWrite = yon_gtk_builder_get_widget(builder,"spinEditWrite");
edit_widgets->chbEditWrite = yon_gtk_builder_get_widget(builder,"chbEditWrite");
edit_widgets->cbtEditWrite = yon_gtk_builder_get_widget(builder,"cbtEditWrite");
edit_widgets->entryEditCmd = yon_gtk_builder_get_widget(builder,"entryEditCmd");
edit_widgets->spinTempWrite = yon_gtk_builder_get_widget(builder,"spinEditWrite");
edit_widgets->chbTempWrite = yon_gtk_builder_get_widget(builder,"chbEditWrite");
edit_widgets->cbtTempWrite = yon_gtk_builder_get_widget(builder,"cbtEditWrite");
edit_widgets->entryTempCmd = yon_gtk_builder_get_widget(builder,"entryEditCmd");
edit_config_init();
device_fill_disk(edit_widgets->cbtEditDevice);
device_fill_disk(edit_widgets->cbtTempDevice);
// edit_event(edit_widgets);
edit_localization(edit_widgets);
philos_temp_config_init(&obj_edit_config);
}
return edit_widgets;
}
@ -61,35 +62,35 @@ void edit_config_init() {
obj_edit_config.i_o_limit_write_size = NULL;
obj_edit_config.size = 0;
}
void edit_event(edit_window *widgets) {
g_signal_connect(G_OBJECT(widgets->btnEditCancel),"clicked",G_CALLBACK(edit_on_hide_subwindow),NULL);
void edit_event(temp_set_window *widgets) {
g_signal_connect(G_OBJECT(widgets->btnTempCancel),"clicked",G_CALLBACK(edit_on_hide_subwindow),NULL);
g_signal_connect(G_OBJECT(widgets->Window), "destroy", G_CALLBACK(edit_destroy), NULL);
g_signal_connect(G_OBJECT(widgets->chkSoftRestrictionEdit), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkSevereRestrictionEdit), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkPaddingFLEdit), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkCPULimitEdit), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chbEditRead), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chbEditWrite), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkSoftRestrictionTemp), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkSevereRestrictionTemp), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkPaddingFLTemp), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chkCPULimitTemp), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chbTempRead), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->chbTempWrite), "toggled", G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spiSevereRestrictionEdit),"value-changed",G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinSevereRestrictionEdit),"value-changed",G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinPaddingFLEdit),"value-changed",G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinCPULimitEdit),"value-changed",G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinEditRead),"value-changed",G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinEditWrite),"value-changed",G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->cmSevereRestrictionEdit),"changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), widgets->spiSevereRestrictionEdit);
g_signal_connect(G_OBJECT(widgets->cmbSevereRestrictionEdit),"changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), widgets->spinSevereRestrictionEdit);
g_signal_connect(G_OBJECT(widgets->cmbPaddingFLEdit),"changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), widgets->spinPaddingFLEdit);
g_signal_connect(G_OBJECT(widgets->cbtEditRead),"changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), widgets->spinEditRead);
g_signal_connect(G_OBJECT(widgets->cbtEditWrite),"changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), widgets->spinEditWrite);
g_signal_connect(G_OBJECT(widgets->cbtEditDevice),"changed",G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spiSevereRestrictionTemp),"value-changed",G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinSevereRestrictionTemp),"value-changed",G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinPaddingFLTemp),"value-changed",G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinCPULimitTemp),"value-changed",G_CALLBACK(edit_init_windows), NULL);
g_signal_connect(G_OBJECT(widgets->spinTempRead),"value-changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), NULL);
g_signal_connect(G_OBJECT(widgets->spinTempWrite),"value-changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), NULL);
g_signal_connect(G_OBJECT(widgets->cmSevereRestrictionTemp),"changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), widgets->spiSevereRestrictionTemp);
g_signal_connect(G_OBJECT(widgets->cmbSevereRestrictionTemp),"changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), widgets->spinSevereRestrictionTemp);
g_signal_connect(G_OBJECT(widgets->cmbPaddingFLTemp),"changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), widgets->spinPaddingFLTemp);
g_signal_connect(G_OBJECT(widgets->cbtTempRead),"changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), widgets->spinTempRead);
g_signal_connect(G_OBJECT(widgets->cbtTempWrite),"changed",G_CALLBACK(wrapper_edit_init_windows_size_memory), widgets->spinTempWrite);
g_signal_connect(G_OBJECT(widgets->cbtTempDevice),"changed",G_CALLBACK(combo_box_device_edit), NULL);
}
void edit_destroy(GtkWidget *self) {
edit_widgets = NULL;
}
void edit_localization(edit_window *widgets) {
void edit_localization(temp_set_window *widgets) {
}
@ -98,7 +99,7 @@ void edit_on_hide_subwindow(GtkWidget *self) {
edit_widgets = NULL;
}
edit_window *get_widget_edit() {
temp_set_window *get_widget_edit() {
return edit_widgets;
}
@ -116,30 +117,64 @@ void wrapper_edit_init_windows_size_memory(GtkWidget *spin) {
if (spin != NULL) {
// gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 0);
}
philos_set_active_widgets_device_io(edit_widgets->cbtTempDevice,edit_widgets->chbTempWrite, edit_widgets->spinTempWrite, edit_widgets->cbtTempWrite);
philos_set_active_widgets_device_io(edit_widgets->cbtTempDevice,edit_widgets->chbTempRead, edit_widgets->spinTempRead, edit_widgets->cbtTempRead);
philos_temp_add_disk(edit_widgets, &obj_edit_config);
philos_temp_del_disk(edit_widgets, &obj_edit_config);
edit_init_windows();
}
void edit_init_windows() {
philos_set_active_widgets(edit_widgets->chkSoftRestrictionEdit, edit_widgets->spiSevereRestrictionEdit, edit_widgets->cmSevereRestrictionEdit,0 ,CMD_RAW);
philos_set_active_widgets(edit_widgets->chkSevereRestrictionEdit, edit_widgets->spinSevereRestrictionEdit, edit_widgets->cmbSevereRestrictionEdit,0 , CMD_RAW);
philos_set_active_widgets(edit_widgets->chkPaddingFLEdit, edit_widgets->spinPaddingFLEdit, edit_widgets->cmbPaddingFLEdit,0 , CMD_SWAP);
philos_set_active_widgets(edit_widgets->chkCPULimitEdit, edit_widgets->spinCPULimitEdit, edit_widgets->lblCPULimitEdit,1 ,CMD_CPU);
philos_set_active_widgets_device_io(edit_widgets->cbtEditDevice,edit_widgets->chbEditWrite, edit_widgets->spinEditWrite, edit_widgets->cbtEditWrite);
philos_set_active_widgets_device_io(edit_widgets->cbtEditDevice,edit_widgets->chbEditRead, edit_widgets->spinEditRead, edit_widgets->cbtEditRead);
edit_generate_cmd();
philos_set_active_widgets(edit_widgets->chkSoftRestrictionTemp, edit_widgets->spiSevereRestrictionTemp, edit_widgets->cmSevereRestrictionTemp,0 ,CMD_RAW);
philos_set_active_widgets(edit_widgets->chkSevereRestrictionTemp, edit_widgets->spinSevereRestrictionTemp, edit_widgets->cmbSevereRestrictionTemp,0 , CMD_RAW);
philos_set_active_widgets(edit_widgets->chkPaddingFLTemp, edit_widgets->spinPaddingFLTemp, edit_widgets->cmbPaddingFLTemp,0 , CMD_SWAP);
philos_set_active_widgets(edit_widgets->chkCPULimitTemp, edit_widgets->spinCPULimitTemp, edit_widgets->lblCPULimitTemp,1 ,CMD_CPU);
philos_set_active_widgets_device_io(edit_widgets->cbtTempDevice,edit_widgets->chbTempWrite, edit_widgets->spinTempWrite, edit_widgets->cbtTempWrite);
philos_set_active_widgets_device_io(edit_widgets->cbtTempDevice,edit_widgets->chbTempRead, edit_widgets->spinTempRead, edit_widgets->cbtTempRead);
philos_temp_generate_cmd(edit_widgets, &obj_edit_config);
}
void combo_box_device_edit() {
philos_update_device_to_entry(edit_widgets, &obj_edit_config, 0);
philos_update_device_to_entry(edit_widgets, &obj_edit_config, 1);
}
int edit_get_soft_size() {
return gtk_combo_box_get_active(GTK_COMBO_BOX(edit_widgets->cmSevereRestrictionEdit));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chkSoftRestrictionTemp))) {
return gtk_combo_box_get_active(GTK_COMBO_BOX(edit_widgets->cmSevereRestrictionTemp));
}
else {
return -3;
}
}
int edit_get_hard_size() {
return gtk_combo_box_get_active(GTK_COMBO_BOX(edit_widgets->cmbSevereRestrictionEdit));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chkSevereRestrictionTemp))) {
return gtk_combo_box_get_active(GTK_COMBO_BOX(edit_widgets->cmbSevereRestrictionTemp));
}
else {
return -3;
}
}
int edit_get_limit_cpu_size() {
return -1;
}
int edit_get_limit_swap_size() {
return gtk_combo_box_get_active(GTK_COMBO_BOX(edit_widgets->cmbPaddingFLEdit));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chkPaddingFLTemp))) {
return gtk_combo_box_get_active(GTK_COMBO_BOX(edit_widgets->cmbPaddingFLTemp));
}
else {
return -3;
}
}
int edit_get_quota_object_size() {
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chkPaddingFLTemp))) {
return gtk_combo_box_get_active(GTK_COMBO_BOX(edit_widgets->cbxTempQuotaObj));
}
else {
return -3;
}
}
int** edit_get_read_device() {
@ -171,21 +206,21 @@ char*** edit_get_select_device() {
return &obj_edit_config.disk;
}
int edit_get_soft() {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spiSevereRestrictionEdit));
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spiSevereRestrictionTemp));
}
int edit_get_hard() {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinSevereRestrictionEdit));
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinSevereRestrictionTemp));
}
int edit_get_limit_cpu() {
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chkCPULimitEdit))) {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinCPULimitEdit));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chkCPULimitTemp))) {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinCPULimitTemp));
}
else {
return 0;
}
}
int edit_get_limit_swap() {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinPaddingFLEdit));
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinPaddingFLTemp));
}
// =================================================================
@ -196,8 +231,8 @@ void edit_set_select_device(char*** str_value) {
if ((*str_value)[0] == NULL) {
return;
}
int index = yon_gtk_combo_box_text_find(edit_widgets->cbtEditDevice, (*str_value)[0]);
gtk_combo_box_set_active(GTK_COMBO_BOX(edit_widgets->cbtEditDevice), index);
int index = yon_gtk_combo_box_text_find(edit_widgets->cbtTempDevice, (*str_value)[0]);
gtk_combo_box_set_active(GTK_COMBO_BOX(edit_widgets->cbtTempDevice), index);
@ -209,11 +244,11 @@ void edit_set_read_device(int* str_value, int* pow_mem) {
if (str_value[0] == -2 || pow_mem[0] == -2) {
return;
}
edit_temp_set(str_value[0],pow_mem[0], edit_widgets->chbEditRead,
edit_widgets->spinEditRead,
edit_widgets->cbtEditRead);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(edit_widgets->chbEditRead), 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(edit_widgets->chbEditWrite), 1);
edit_temp_set(str_value[0],pow_mem[0], edit_widgets->chbTempRead,
edit_widgets->spinTempRead,
edit_widgets->cbtTempRead);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(edit_widgets->chbTempRead), 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(edit_widgets->chbTempWrite), 1);
}
void edit_set_write_device(int* str_value, int* pow_mem) {
if (str_value == NULL || pow_mem == NULL) {
@ -223,41 +258,42 @@ void edit_set_write_device(int* str_value, int* pow_mem) {
return;
}
else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(edit_widgets->chbEditWrite), 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(edit_widgets->chbTempWrite), 1);
}
edit_temp_set(str_value[0],pow_mem[0], edit_widgets->chbEditWrite,
edit_widgets->spinEditWrite,
edit_widgets->cbtEditWrite);
edit_temp_set(str_value[0],pow_mem[0], edit_widgets->chbTempWrite,
edit_widgets->spinTempWrite,
edit_widgets->cbtTempWrite);
}
void edit_set_soft(int value, int pow_mem) {
edit_temp_set(value,pow_mem, edit_widgets->chkSoftRestrictionEdit,
edit_widgets->spiSevereRestrictionEdit,
edit_widgets->cmSevereRestrictionEdit);
edit_temp_set(value,pow_mem, edit_widgets->chkSoftRestrictionTemp,
edit_widgets->spiSevereRestrictionTemp,
edit_widgets->cmSevereRestrictionTemp);
}
void edit_set_hard(int value, int pow_mem) {
edit_temp_set(value,pow_mem, edit_widgets->chkSevereRestrictionEdit,
edit_widgets->spinSevereRestrictionEdit,
edit_widgets->cmbSevereRestrictionEdit);
edit_temp_set(value,pow_mem, edit_widgets->chkSevereRestrictionTemp,
edit_widgets->spinSevereRestrictionTemp,
edit_widgets->cmbSevereRestrictionTemp);
}
void edit_set_limit_cpu(int value, int pow_mem) {
edit_temp_set(value,pow_mem, edit_widgets->chkCPULimitEdit,
edit_widgets->spinCPULimitEdit,
edit_temp_set(value,pow_mem, edit_widgets->chkCPULimitTemp,
edit_widgets->spinCPULimitTemp,
NULL);
}
void edit_set_limit_swap(int value, int pow_mem) {
edit_temp_set(value,pow_mem, edit_widgets->chkPaddingFLEdit,
edit_widgets->spinPaddingFLEdit,
edit_widgets->cmbPaddingFLEdit);
edit_temp_set(value,pow_mem, edit_widgets->chkPaddingFLTemp,
edit_widgets->spinPaddingFLTemp,
edit_widgets->cmbPaddingFLTemp);
}
void edit_temp_set(int value, int pow_mem, GtkWidget* cheek, GtkWidget* spin, GtkWidget* combo_box_text) {
char* search = "-";
char* mem_size_pow = yon_char_from_int(value);
if (strstr(mem_size_pow, search) == 0) {
if (strstr(mem_size_pow, search) == 0 && pow_mem!=-3 && pow_mem>=-1) {
int value = atoi(yon_char_divide_search(mem_size_pow, " ", -1));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), value);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cheek), 1);
if (combo_box_text != NULL) {
// Todo: add code
printf("%d", pow_mem);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box_text), pow_mem);
}
}
@ -265,75 +301,4 @@ void edit_temp_set(int value, int pow_mem, GtkWidget* cheek, GtkWidget* spin, Gt
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cheek), 0);
}
}
void edit_generate_cmd() {
char* str_cmd = " ";
char* split_simvol = g_malloc0(sizeof(char)*2);
int size_bite = 0;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chkSoftRestrictionEdit))) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spiSevereRestrictionEdit));
str_cmd = yon_char_unite(str_cmd,
"MemoryHigh=",
yon_char_from_int(size_bite),
philos_str_size_pow_byte(edit_widgets->cmSevereRestrictionEdit), NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chkSevereRestrictionEdit))) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinSevereRestrictionEdit));
str_cmd = yon_char_unite(str_cmd, split_simvol,
"MemoryMax=",
yon_char_from_int(size_bite),
philos_str_size_pow_byte(edit_widgets->cmbSevereRestrictionEdit), NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chkPaddingFLEdit))) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinPaddingFLEdit));
str_cmd = yon_char_unite(str_cmd, split_simvol,
"MemorySwapMax=",
yon_char_from_int(size_bite),
philos_str_size_pow_byte(edit_widgets->cmbPaddingFLEdit), NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chkCPULimitEdit))) {
size_bite = (int)gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinCPULimitEdit));
str_cmd = yon_char_unite(str_cmd, split_simvol,
"CPUQuota=",
yon_char_from_int(size_bite),
"%", NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chbEditRead))) {
int menu_id = gtk_combo_box_get_active(GTK_COMBO_BOX(edit_widgets->cbtEditDevice));
if (menu_id != -1) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinEditRead));
str_cmd = yon_char_unite(str_cmd, split_simvol,
"IOReadBandwidthMax=\"",
get_device_cfg()->name_disk[menu_id],
" ",
yon_char_from_int(size_bite),
philos_str_size_pow_byte(edit_widgets->cbtEditRead),"\"", NULL);
}
split_simvol[0] = ',';
split_simvol[1] = '\0';
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(edit_widgets->chbEditWrite))) {
int menu_id = gtk_combo_box_get_active(GTK_COMBO_BOX(edit_widgets->cbtEditDevice));
if (menu_id != -1) {
size_bite = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinEditWrite));
str_cmd = yon_char_unite(str_cmd, split_simvol,
"IOWriteBandwidthMax=\"",
get_device_cfg()->name_disk[menu_id],
" ",
yon_char_from_int(size_bite),
philos_str_size_pow_byte(edit_widgets->cbtEditWrite),"\"", NULL);
}
}
gtk_entry_set_text(GTK_ENTRY(edit_widgets->entryEditCmd), str_cmd);
free(split_simvol);
}

52
source/view_edit.h
Unescape View File

@ -16,53 +16,14 @@
#define CMD_CPU "lscpu | grep \"CPU(s):\" |grep -oE \"[0-9]{1,}\""
#define CMD_SWAP "grep '^Swap' /proc/meminfo | grep \"SwapTotal\" |grep -oE \"[0-9]{1,}\""
#define CMD_RAW "cat /proc/meminfo | grep \"MemTotal\" |grep -oE \"[0-9]{1,}\""
// Переменные
typedef struct {
config_str disk;
int* i_o_limit_read;
int* i_o_limit_write;
int* i_o_limit_read_size;
int* i_o_limit_write_size;
int size;
} edit_config;
typedef struct {
GtkWidget* Window;
GtkWidget* btnSaveEditSave;
GtkWidget* btnEditCancel;
GtkWidget* entryEditCmd;
GtkWidget* chbEditRead;
GtkWidget* spinEditRead;
GtkWidget* cbtEditRead;
GtkWidget* chbEditWrite;
GtkWidget* spinEditWrite;
GtkWidget* cbtEditWrite;
GtkWidget* chkSoftRestrictionEdit;
GtkWidget* spiSevereRestrictionEdit;
GtkWidget* cmSevereRestrictionEdit;
GtkWidget* chkSevereRestrictionEdit;
GtkWidget* spinSevereRestrictionEdit;
GtkWidget* cmbSevereRestrictionEdit;
GtkWidget* chkPaddingFLEdit;
GtkWidget* spinPaddingFLEdit;
GtkWidget* cmbPaddingFLEdit;
GtkWidget* chkCPULimitEdit;
GtkWidget* spinCPULimitEdit;
GtkWidget* lblCPULimitEdit;
GtkWidget* cbtEditDevice;
} edit_window;
// Функции
edit_window *edit_setup_window(char* glade_path);
void edit_event(edit_window *widgets);
void edit_localization(edit_window *widgets);
temp_set_window *edit_setup_window(char* glade_path);
void edit_event(temp_set_window *widgets);
void edit_localization(temp_set_window *widgets);
void edit_on_hide_subwindow(GtkWidget *self);
edit_window *get_widget_edit();
temp_set_window *get_widget_edit();
void combo_box_device_edit();
void edit_show(GtkWidget *self, char* glade_path);
void edit_destroy(GtkWidget *self);
void edit_init_windows();
@ -75,7 +36,6 @@ int edit_get_soft();
int edit_get_hard();
int edit_get_limit_cpu();
int edit_get_limit_swap();
void edit_generate_cmd();
void wrapper_edit_show();
void edit_set_select_device(char*** str_value);
void edit_set_read_device(int* str_value, int* pow_mem);
@ -93,7 +53,7 @@ int edit_get_hard_size();
int edit_get_limit_cpu_size();
int edit_get_limit_swap_size();
void edit_config_init();
edit_config* get_edit_config();
temp_config* get_edit_config();
void edit_set_active_widgets_device_io(GtkWidget *check, GtkWidget *spin, GtkWidget *combo);
void edit_set_spin_adjustment(GtkWidget *check, GtkWidget *spin, GtkWidget *combo, size_t value);
#endif
Write Preview
Loading…
Cancel
Save