Merge pull request 'master' (#13) from Igor1/ubl-settings-diskquota:master into develop

Reviewed-on: #13
pull/15/head
Dmitry Razumov 2 years ago
commit b80771fed6

@ -24,7 +24,7 @@ all: init build
init:
@echo "Initialize ..."; \
sed -r "s/(version_application = ).*/\1\"$$(grep 'VERSION' ${FILE_VERSION} | cut -d" " -f2)\";/" -i source/ubl-settings-diskquota.cc; \
sed -r "s/(version_application = ).*/\1\"$$(grep 'VERSION' ${FILE_VERSION} | cut -d" " -f2)\";/" -i source/view/ubl-settings-diskquota.cc; \
echo "-- Build path: ${CMAKE_BUILD_DIR}"
depend:

@ -1,13 +1,14 @@
cmake_minimum_required(VERSION 3.7)
find_package(PkgConfig REQUIRED)
project(ubl-settings-diskquota)
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED gtkmm-3.0)
include_directories(${GTK_INCLUDE_DIRS})
link_directories(${GTK_LIBRARY_DIRS})
add_definitions(${GTK_CFLAGS_OTHER})
find_library(WEBKIT_LIBRARIES_FOUND webkit2gtk-4.0 webkit2gtk-web-extension-4.0)
option(WEBKIT_FOUND "No" OFF)
@ -29,30 +30,45 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wall -Wextra -Werror -Wmissin
-fstack-clash-protection -fcf-protection -g")
set(SOURCE_FILES
view/view_edit_project.cc
view/view_edit_project.h
view/view_add_project.cc
view/view_add_project.h
view/view_edit_user_group.h
view/view_edit_user_group.cc
view/view_add_user_group.h
view/view_add_user_group.cc
view/view_edit_user_group.cc
view/view_edit_user_group.h
view/view_filters.cc
view/view_filters.h
view/ubl-settings-diskquota.h
view/ubl-settings-diskquota.cc
view/model/ubconfig_quota.cc
view/model/ubconfig_quota.h
view/model/save.h
view/model/save.cc
view/model/load.h
view/model/load.cc
view/model/my_process.h
view/model/my_process.cc
view/model/util.h
view/model/util.cc
view/ubl-util-standard.h
view/ubl-util-standard.c
view/model/wrapper_load_save.cc
view/model/wrapper_load_save.h
ubl-settings-diskquota-cm.h
ubl-settings-diskquota.h
ubl-settings-diskquota.cc
ubconfig_quotas.h
ubconfig_quotas.cc
system_quotas.h
system_quotas.cc
my_device.h
my_device.cc
view/view_open_browser.cc
view/view_open_browser.h
view/view_about.h
view/view_about.cc
controller.cc
controller.h
main.cc
var.h
project_lib.h
my_type.h
save.h
save.cc
load.h
load.cc
my_process.h
my_process.cc
util.h
util.cc
my_plug.h
my_plug.cc
ubl-util-standard.h
ubl-util-standard.c
main.cc)
my_type.h)
set(LIBRARIES
${GTK_LIBRARIES}

@ -1,46 +0,0 @@
#include "controler.h"
Back_Back::Back_Back() {}
void Back_Back::set_mode(string flag_mode) {
this->flag_mode = flag_mode;
}
void Back_Back::set_partition(string partition) {
this->partition = partition;
}
void Back_Back::set_sys_flag(string sys_flag) {
this->sys_flag = sys_flag;
}
bool Back_Back::wrapper_off_quotas(string quotas_type) {
bool flag_status = false;
quotas_type = this->handler_quotas_type(quotas_type);
if (flag_mode == "system") {
string cmd_hw = "";
string cmd_sw = "";
flag_status = obj_quotas_sys.off_quota(partition, cmd_hw, cmd_sw);
}
else if (flag_mode == "ubconfig") {
flag_status = obj_quotas_ubconfig.off_quota(partition, quotas_type, "disable");
}
return flag_status;
}
bool Back_Back::wrapper_on_quotas(string quotas_type) {
bool flag_status = false;
quotas_type = this->handler_quotas_type(quotas_type);
if (flag_mode == "system") {
string cmd_hw = "";
string cmd_sw = "";
flag_status = obj_quotas_sys.on_quota_hw(partition, cmd_hw, cmd_sw);
flag_status = obj_quotas_sys.wrapper_on_quotas(partition, quotas_type);
}
else if (flag_mode == "ubconfig") {
flag_status = obj_quotas_sys.wrapper_on_quotas(partition, quotas_type, "enable");
flag_status = obj_quotas_ubconfig.format_cmd_quotas();
}
return flag_status;
}
string Back_Back::handler_quotas_type(string quotas_type) {
return quotas_type;
}

@ -1,19 +0,0 @@
#include "system_quotas.h"
#include "ubconfig_quotas.h"
class Back_Back{
public:
string flag_mode;
string partition;
string sys_flag;
Quotas_sys::Quotas_sys obj_quotas_sys = Quotas_sys::Quotas_sys();
Quotas_ubconfig::Quotas_ubconfig obj_quotas_ubconfig = Quotas_ubconfig::Quotas_ubconfig();
public:
Back_Back();
void set_mode(string flag_mode);
void set_partition(string partition);
void set_sys_flag(string sys_flag);
bool wrapper_off_quotas(string quotas_type);
string handler_quotas_type(string quotas_type);
bool wrapper_on_quotas(string quotas_type);
};

@ -1,8 +1,38 @@
#ifndef MY_PLUG_H
#define MY_PLUG_H
#include "controller.h"
#include "my_plug.h"
int socket_ext_id_I = 0;
int socket_trd_id_I = 0;
Controller::Controller(BaseObjectType* obj, Glib::RefPtr<Gtk::Builder> const& builder)
:Gtk::ApplicationWindow(obj), builder{builder} {
this->builder = builder;
this->settings();
}
Controller::Controller(Glib::RefPtr<Gtk::Builder> const& builder) {
this->builder = builder;
this->settings();
}
Controller::~Controller()
{
}
void Controller::settings() {
obj_open_browser->set_obj_about(obj_view_about);
obj_main_window = new MainWindow(builder, obj_open_browser, &socket_ext_id_I, &socket_trd_id_I);
obj_main_window->set_obj_wrapper_load_save(obj_wrapper_load_save);
obj_open_browser->settings();
obj_main_window->set_map_gui(&map_gui_cfg);
obj_main_window->set_map_global(&map_global_cfg);
obj_main_window->set_map_local(&map_system_cfg);
obj_main_window->set_obj_view_filters(&obj_view_filters);
obj_main_window->set_obj_view_edit(&obj_view_edit);
obj_main_window->set_obj_view_add(&obj_view_add);
obj_main_window->set_obj_view_add_project(&obj_view_add_project);
obj_main_window->set_obj_view_edit_project(&obj_view_edit_project);
obj_main_window->settings();
}
CmdArgParser::CmdArgParser(const std::string& p_name, const std::string& p_description, const std::string& p_help)
: Glib::OptionGroup{p_name, p_description, p_help} {
@ -22,17 +52,17 @@ CmdArgParser::CmdArgParser(const std::string& p_name, const std::string& p_descr
add_entry(socketExtId, socket_ext_id_I);
add_entry(socketTrdId, socket_trd_id_I);
}
::Window CmdArgParser::GetSocketID() const{
return m_socketID;
}
SettingsPlug::SettingsPlug(::Window p_socketID, Glib::RefPtr<Gtk::Builder> builder)
:Gtk::Plug{p_socketID} {
MainWindow* wnd = nullptr;
Controller* wnd = nullptr;
builder->get_widget_derived("window", wnd);
builder->get_widget("plugBox", plugBox);
plugBox->get_parent()->remove(*plugBox);
add(*plugBox);
show_all_children();
}
#endif
}

@ -0,0 +1,59 @@
#ifndef CONTROLLER_H
#define CONTROLLER_H
#include "my_type.h"
#include "view/view_open_browser.h"
#include "view/view_about.h"
#include "view/ubl-settings-diskquota.h"
#include "view/model/wrapper_load_save.h"
#include "view/view_filters.h"
#include "view/view_add_user_group.h"
#include "view/view_edit_user_group.h"
#include "view/view_edit_project.h"
#include "view/view_add_project.h"
extern int socket_ext_id_I;
extern int socket_trd_id_I;
class Controller : public Gtk::ApplicationWindow
{
private:
Glib::RefPtr<Gtk::Builder> builder;
map_str_str map_gui_cfg;
map_str_str map_global_cfg;
map_str_str map_system_cfg;
public:
~Controller();
void settings();
View_open_browser* obj_open_browser = new View_open_browser();
View_about* obj_view_about = new View_about();
MainWindow* obj_main_window;
Wrapper_load_save *obj_wrapper_load_save = new Wrapper_load_save();
View_filters obj_view_filters = View_filters();
View_add_user_group obj_view_add = View_add_user_group();
View_edit_user_group obj_view_edit = View_edit_user_group();
View_edit_project obj_view_edit_project = View_edit_project();
View_add_project obj_view_add_project = View_add_project();
Controller(BaseObjectType* obj, Glib::RefPtr<Gtk::Builder> const& builder);
Controller(Glib::RefPtr<Gtk::Builder> const& builder);
};
class CmdArgParser : public Glib::OptionGroup {
public:
CmdArgParser(const std::string& p_name, const std::string& p_description, const std::string& p_help);
::Window GetSocketID() const;
private:
int m_socketID = 0;
};
class SettingsPlug : public Gtk::Plug{
public:
Gtk::Window *window;
SettingsPlug(::Window p_socketID, Glib::RefPtr<Gtk::Builder> builder);
private:
Gtk::Widget *plugBox;
Gtk::Widget *parent;
};
#endif

@ -1,4 +1,5 @@
#include "my_plug.h"
#include "controller.h"
#include "var.h"
void pars_flag(int index_start, int argc, char* argv[]);
@ -44,14 +45,14 @@ int main(int argc, char** argv) {
auto app = Gtk::Application::create(len_argv, argv, "org.gtkmm.example.plug");
auto builder = Gtk::Builder::create_from_file(path_glade);
pars_flag(1, argc, argv);
MainWindow* wnd = nullptr;
builder->get_widget_derived("MainWindow", wnd);
Controller* wnd = nullptr;
builder->get_widget_derived("window", wnd);
auto r = app->run(*wnd);
delete wnd;
return r;
}
}
void pars_flag(int index_start, int argc, char* argv[]) {
string str_argv = "";
for (int i = index_start; i<argc; i++){

@ -1,29 +0,0 @@
#include "my_device.h"
namespace Devices {
map_str_str Parted::get_parted() {
string cmd = "lsblk --fs --raw --output PATH,FSTYPE --exclude 7,11,253";
string response = obj_process_call.call_all_sections(cmd);
vector<string> vec_parted = Utils::split(response, '\n');
map_str_str dict_parted;
string key = "";
string value = "";
if (vec_parted.size()>1) {
vec_parted.erase(vec_parted.begin());
}
for (const string& str_parted : vec_parted) {
key = str_parted.substr(0, str_parted.find(" "));
if (str_parted.find(" ") != string::npos) {
value = str_parted.substr(str_parted.find(" ") + 1, str_parted.length());
if (value.length()>0) {
dict_parted[key] = value;
}
}
}
return dict_parted;
}
}

@ -1,20 +0,0 @@
#ifndef MY_DEVICE_H
#define MY_DEVICE_H
#include "project_lib.h"
#include "my_process.h"
#include "util.h"
#include "my_type.h"
namespace Devices {
class Parted{
protected:
My_Process::My_Process_call obj_process_call = My_Process::My_Process_call();
public:
map_str_str get_parted();
};
}
#endif

@ -1,20 +0,0 @@
#include "project_lib.h"
#include "ubl-settings-diskquota.h"
class CmdArgParser : public Glib::OptionGroup {
public:
CmdArgParser(const std::string& p_name, const std::string& p_description, const std::string& p_help);
::Window GetSocketID() const;
private:
int m_socketID = 0;
};
class SettingsPlug : public Gtk::Plug{
public:
Gtk::Window *window;
SettingsPlug(::Window p_socketID, Glib::RefPtr<Gtk::Builder> builder);
private:
Gtk::Widget *plugBox;
Gtk::Widget *parent;
};

@ -22,5 +22,6 @@
#include <libintl.h>
#include <glibmm/i18n.h>
#include <map>
#include "ubl-util-standard.c"
#include "ubl-settings-diskquota-cm.h"
#endif

@ -1,33 +0,0 @@
#ifndef SAVE_H
#define SAVE_H
#include "my_process.h"
#include "project_lib.h"
namespace Lib_save {
class Save {
private:
std::map <string, string> *map_global;
std::map <string, string> *map_local;
std::map <string, string> *map_gui;
vector<string> vec_errors;
vector<string>* vec_param_names;
My_Process::My_Process_system process = My_Process::My_Process_system();
bool flag_no_save;
public:
void set_data_global(std::map <string, string> &map_global);
void set_data_local(std::map <string, string> &map_local);
void set_data_gui(std::map <string, string> &map_gui);
bool check_save(string flag_save, string key_name);
bool get_state_save();
int get_count_error();
string get_cmd_error();
void save_all(string sections, string str_flag_save);
void save_all_1(string sections, string str_flag_save);
void set_count_error(int count_error);
void set_vec_params(vector<string>& vec_param_names);
void save(string sections, string str_flag_save) ;
vector<string> get_error();
};
}
#endif

@ -1,263 +0,0 @@
#include "system_quotas.h"
#include "my_type.h"
namespace Quotas_sys {
Quotas_sys::Quotas_sys() {
map_hw_or_sw["ext2"] = "hw";
map_hw_or_sw["ext3"] = "hw";
map_hw_or_sw["nfs"] = "sw";
map_hw_or_sw["NFS"] = "sw";
}
void Quotas_sys::set_map_device(map_str_str &map_device) {
this->map_device = &map_device;
this->check_partition_mount();
}
void Quotas_sys::set_map_gui(map_str_str &map_gui) {
map_gui_cfg = &map_gui;
}
void Quotas_sys::check_partition_mount() {
string key = "";
string response = Utils::file_read("/proc/mounts");
for (const auto& iter: (*map_device)) {
key = iter.first;
if (response.find(key) != string::npos) {
disk_mount[key] = true;
}
}
}
string Quotas_sys::wrapper_hw_sw(string partition) {
if ((*map_device).find(partition) != (*map_device).end()) {
string fsystem = (*map_device)[partition];
if ((*map_device).find(fsystem) != (*map_device).end()) {
return map_hw_or_sw[fsystem];
}
}
return "";
}
bool Quotas_sys::check_on_quotas_system(string cmd) {
string response = obj_process_call.call_all_sections(cmd);
if (response.length() > 0) {
return true;
}
else {
return false;
}
}
struct status_quotas Quotas_sys::check_on_quotas_system_2_hw(string params) {
string cmd = "quotaon -ugPvp " + params;
string response = obj_process_call.call_all_sections(cmd);
struct status_quotas status;
if (response.length() > 0 && response.find("Cannot find mountpoint for device ") == string::npos) {
status.status = true;
vector<string> vec_str = Utils::split(response, '\n');
string array_str[3] = {"group", "user", "project"};
for (int index = 0; index < 3; index++) {
string u_g_p = array_str[index];
for (const string& vec_u_g_p : vec_str) {
if (vec_u_g_p.find(u_g_p) != string::npos && vec_u_g_p.find("accounting") != string::npos ) {
if (index == 0) {
status.group = true;
}
else if (index == 1) {
status.user = true;
}
else if (index == 2) {
status.project = true;
}
}
else if (vec_u_g_p.find(u_g_p) != string::npos && vec_u_g_p.find("enforced") != string::npos){
if (index == 0) {
status.group = false;
}
else if (index == 1) {
status.user = false;
}
else if (index == 2) {
status.project = false;
}
}
}
}
}
else {
status.group = false;
status.user = false;
status.project = false;
status.status = false;
}
return status;
}
bool Quotas_sys::wrapper_on_quotas(string partition, string flag_mode) {
// Todo
// Добавить выключение квот в зависимости от диска
cout << partition << "" << flag_mode << endl;
if (disk_mount.find(partition) == disk_mount.end()) {
}
else {
}
return true;
}
bool Quotas_sys::on_quota_hw(string partition, string cmd_hw, string cmd_sw) {
/*
Включить квоты, только для HW ext2,3,4:
Если ФС, уже существует и без HW атрибут квот ext2,3,4
Раздел должен быть отмонтирован
*/
if (this->wrapper_hw_sw(partition) == "hw") {
obj_process_system.call(cmd_hw, "");
obj_process_system.call("ubconfig set config SERVICESSTART+=,quotaon.service", "");
return true;
}
else if (this->wrapper_hw_sw(partition) == "sw") {
obj_process_system.call(cmd_sw, "");
obj_process_system.call("ubconfig set config SERVICESSTART+=,quotaon.service", "");
return true;
}
else{
return false;
}
return false;
}
bool Quotas_sys::on_quota_sw(string partition, int mode) {
/*
Включить квоты, только для SW, другие ФС и сетевые NFS:
У этого исполнения квот отсутствуют проектные квоты prjquota
Раздел должен быть примонтирован
*/
if (map_hw_or_sw.find(partition) != map_hw_or_sw.end()) {
string cmd = "";
if (mode == 0) {
cmd += "mount -vo remount,usrquota " + partition;
cmd += "; quotacheck -ucm " + partition;
cmd += "; quotaon -uv " + partition;
}
else if (mode == 1) {
cmd += "; mount -vo remount,grpquota " + partition;
cmd += "; quotacheck -gcm " + partition;
cmd += "; quotaon -gv " + partition;
}
else if (mode == 2) {
cmd += "; quotaon -ugPv " + partition;
}
else if (mode == 3) {
cmd += "; quotaon -augPv";
}
else {
return false;
}
cmd += "; ubconfig set config SERVICESSTART+=,quotaon.service";
obj_process_system.call(cmd, "");
return true;
}
return false;
}
bool Quotas_sys::off_quota(string partition, string quota_hw, string quota_sw) {
string cmd = "";
if (map_hw_or_sw.find(partition) != map_hw_or_sw.end()) {
if (this->wrapper_hw_sw(partition) == "hw") {
cmd = quota_hw + " " + partition;
obj_process_system.call(cmd, "");
return true;
}
else if (this->wrapper_hw_sw(partition) == "sw") {
cmd = quota_sw + " " + partition;
obj_process_system.call(cmd, "");
return true;
}
}
return false;
}
vector<data_all_quotas> Quotas_sys::pars_data(string cmd) {
string start_pars = "------\n";
string response = obj_process_call.call_all_sections(cmd);
size_t index_start = response.find(start_pars);
string line_pars = "";
struct data_all_quotas struct_data;
vector<data_all_quotas> vec_struct_data;
int index = 0;
int old_index = index;
if (index_start != string::npos) {
response = response.substr(index_start+start_pars.length(), response.length());
vector<int> vec_index_sep = Utils::find_all(response, "\n");
for (size_t i = 0; i < vec_index_sep.size(); i++) {
old_index = index;
index = vec_index_sep[i];
if (index-1 == old_index) {
break;
}
line_pars = response.substr(old_index, index);
struct_data = part_quotas_line(line_pars);
vec_struct_data.push_back(struct_data);
}
}
return vec_struct_data;
}
struct data_all_quotas Quotas_sys::part_quotas_line(string line) {
struct data_all_quotas struct_data;
vector<int> vec_index_sep = Utils::find_all(line, " ");
int old_index = 0;
string buff = "";
int index_data = 0;
for (int& index: vec_index_sep) {
if ((index - old_index) >= 2) {
buff = line.substr(old_index, index - old_index);
cout << buff << endl;
if (index_data == 0) {
struct_data.username = buff;
}
else if (index_data == 1) {
struct_data.status = buff;
}
else if (index_data == 2) {
struct_data.block_used = buff;
}
else if (index_data == 3) {
struct_data.block_soft = buff;
}
else if (index_data == 4) {
struct_data.block_hard = buff;
}
else if (index_data == 5) {
struct_data.block_grace = buff;
}
else if (index_data == 6) {
struct_data.file_used = buff;
}
else if (index_data == 7) {
struct_data.file_soft = buff;
}
else if (index_data == 8) {
struct_data.file_hard = buff;
}
else if (index == 9) {
struct_data.file_grace = buff;
}
index_data += 1;
}
old_index = index;
}
if (index_data != 0) {struct_data.is_validate = true; }
else {struct_data.is_validate = false; }
return struct_data;
}
}

@ -1,35 +0,0 @@
#ifndef SYSTEM_CMD_QUOTAS
#define SYSTEM_CMD_QUOTAS
#include "project_lib.h"
#include "my_type.h"
#include "my_process.h"
#include "util.h"
namespace Quotas_sys {
class Quotas_sys {
public:
map_str_str map_hw_or_sw;
map_str_str* map_device;
map_str_str* map_gui_cfg;
map<string, bool> disk_mount;
My_Process::My_Process_system obj_process_system = My_Process::My_Process_system();
My_Process::My_Process_call obj_process_call = My_Process::My_Process_call();
public:
Quotas_sys();
void set_map_gui(map_str_str &map_gui);
void check_partition_mount();
void format_cmd_quotas_system(struct struct_quotas& _struct_quota);
bool off_quota(string partition, string quota_hw, string quota_sw);
bool check_on_quotas_system(string cmd);
struct status_quotas check_on_quotas_system_2_hw(string params);
bool on_quota_hw(string partition, string cmd_hw, string cmd_sw);
bool on_quota_sw(string partition, int mode);
vector<data_all_quotas> pars_data(string cmd);
void set_map_device(map_str_str &map_device);
string wrapper_hw_sw(string partition);
bool wrapper_on_quotas(string partition, string flag_mode);
protected:
struct data_all_quotas part_quotas_line(string line);
};
}
#endif

@ -1,27 +0,0 @@
#include "ubconfig_quotas.h"
namespace Quotas_ubconfig {
void Quotas_ubconfig::format_cmd_quotas(struct struct_quotas& _struct_quota) {
string key = "DISK_QUOTA[";
key += ":" + _struct_quota.device + "]";
string value = _struct_quota.name + ":" + _struct_quota.cmd;
(*map_gui_cfg)[key] = value;
}
bool Quotas_ubconfig::off_quota(string partition, string quota_type, string state) {
string key = "DISK_QUOTA[" + quota_type + ":" + partition + "]";
string value = "disable";
(*map_gui_cfg)[key] = state;
return true;
}
void Quotas_ubconfig::set_map_gui(map_str_str &map_gui) {
map_gui_cfg = &map_gui;
}
Quotas_ubconfig::Quotas_ubconfig() {
map_hw_or_sw["ext2"] = "hw";
map_hw_or_sw["ext3"] = "hw";
map_hw_or_sw["nfs"] = "sw";
map_hw_or_sw["NFS"] = "sw";
}
}

@ -1,25 +0,0 @@
#ifndef UBCONFIG_QUOTAS
#define UBCONFIG_QUOTAS
#include "project_lib.h"
#include "my_type.h"
#include "my_process.h"
#include "util.h"
namespace Quotas_ubconfig {
class Quotas_ubconfig{
public:
map_str_str map_hw_or_sw;
map_str_str* map_gui_cfg;
My_Process::My_Process_system obj_process_system = My_Process::My_Process_system();
My_Process::My_Process_call obj_process_call = My_Process::My_Process_call();
Quotas_ubconfig();
bool off_quota(string partition, string quota_type, string state);
void format_cmd_quotas(struct struct_quotas& _struct_quota);
void set_map_gui(map_str_str &map_gui);
};
}
#endif

@ -1,915 +0,0 @@
#include "ubl-settings-diskquota.h"
using namespace std;
int socket_ext_id_I = 0;
int socket_trd_id_I = 0;
bool flag_save = false;
bool flag_save_local = false;
bool flag_save_global = false;
bool flag_load_global = false;
bool flag_lock_help = false;
string version_application = "1.0";
MainWindow::MainWindow(BaseObjectType* obj, Glib::RefPtr<Gtk::Builder> const& builder)
: Gtk::ApplicationWindow(obj), builder{builder} {
this->builder = builder;
this->settings();
}
MainWindow::MainWindow(Glib::RefPtr<Gtk::Builder> const& builder) {
this->builder = builder;
this->settings();
}
void MainWindow::settings() {
this->get_builder();
this->lacalization();
this->add_CSS();
this->flag_block_gui();
btnBoxAboutDialog->set_visible(false);
map_device = obj_device.get_parted();
this->filling_device_combo_box_template(groupsDeviceCombo, map_device);
this->filling_device_combo_box_template(usersDeviceCombo, map_device);
this->filling_device_combo_box_template(quotegroupDeviceCombo, map_device);
this->init_tree_view();
this->init_spin_all();
check_limit(quotegroupSizeSoftLimitCheck
,quotegroupSizeSoftLimitSpin
,quotegroupSizeSoftLimitCombo);
check_limit(quotegroupSizeHardLimitCheck
,quotegroupSizeHardLimitSpin
,quotegroupSizeHardLimitCombo);
check_limit(quotegroupFilesSoftLimitCheck
,quotegroupFilesSoftLimitSpin
,quotegroupFilesSoftLimitlabel);
check_limit(quotegroupFilesHardLimitCheck
,quotegroupFilesHardLimitSpin
,quotegroupFilesHarLimitLabel);
obj_quotas_sys.set_map_gui(map_gui_cfg);
obj_quotas_ubconfig.set_map_gui(map_gui_cfg);
#ifdef WEBKIT_FOUND
one = WEBKIT_WEB_VIEW( webkit_web_view_new() );
three = Glib::wrap(GTK_WIDGET(one));
wndWeb->add(*three);
#endif
if (geteuid() == 0) {
this->load_system_cfg();
this->load_global_cfg();
this->event();
}
else {
boxFuncs->set_sensitive(false);
btnSave->set_sensitive(false);
btnLoad->set_sensitive(false);
imgInfo->set_from_icon_name(icon_warning, Gtk::ICON_SIZE_MENU);
info_status_app(info_box_error_css);
lblWarning->set_text(program_as_root);
}
Gtk::Widget *boxWidget;
builder->get_widget("boxColor", boxWidget);
HeadOverlay->add_overlay(*boxWidget);
ubl_make_plugs(boxSave, boxButton, socket_ext_id_I, socket_trd_id_I);
}
void MainWindow::init_spin_all() {
generalGroupsSizeWeeksSpi->set_range(0, 52);
generalGroupsSizeWeeksSpi->set_increments(1.0, 1.0);
generalGroupsSizeWeeksSpi->set_value(0);
generalGroupsFileWeeksSpin->set_range(0, 52);
generalGroupsFileWeeksSpin->set_increments(1.0, 1.0);
generalGroupsFileWeeksSpin->set_value(0);
generalUsersSizWeeksSpin->set_range(0, 52);
generalUsersSizWeeksSpin->set_increments(1.0, 1.0);
generalUsersSizWeeksSpin->set_value(0);
generalUsersFileWeeksSpin->set_range(0, 52);
generalUsersFileWeeksSpin->set_increments(1.0, 1.0);
generalUsersFileWeeksSpin->set_value(0);
generalGroupsSizeDaySpin->set_range(0, 31);
generalGroupsSizeDaySpin->set_increments(1.0, 1.0);
generalGroupsSizeDaySpin->set_value(0);
generalGroupsFilesDaySpin->set_range(0, 31);
generalGroupsFilesDaySpin->set_increments(1.0, 1.0);
generalGroupsFilesDaySpin->set_value(0);
generalUsersSizeDaySpin->set_range(0, 31);
generalUsersSizeDaySpin->set_increments(1.0, 1.0);
generalUsersSizeDaySpin->set_value(0);
generalUsersFilesDaySpin->set_range(0, 31);
generalUsersFilesDaySpin->set_increments(1.0, 1.0);
generalUsersFilesDaySpin->set_value(0);
generalGroupsSizeHourSpin->set_range(0, 23);
generalGroupsSizeHourSpin->set_increments(1.0, 1.0);
generalGroupsSizeHourSpin->set_value(0);
generalGroupsFilesHourSpin->set_range(0, 23);
generalGroupsFilesHourSpin->set_increments(1.0, 1.0);
generalGroupsFilesHourSpin->set_value(0);
generalUsersSizeHourSpin->set_range(0, 23);
generalUsersSizeHourSpin->set_increments(1.0, 1.0);
generalUsersSizeHourSpin->set_value(0);
generalUsersFilesHoursSpin->set_range(0, 23);
generalUsersFilesHoursSpin->set_increments(1.0, 1.0);
generalUsersFilesHoursSpin->set_value(0);
generalGroupsSizeMinuteSpin->set_range(0, 59);
generalGroupsSizeMinuteSpin->set_increments(1.0, 1.0);
generalGroupsSizeMinuteSpin->set_value(0);
generalGroupsFilesMinuteSpin->set_range(0, 59);
generalGroupsFilesMinuteSpin->set_increments(1.0, 1.0);
generalGroupsFilesMinuteSpin->set_value(0);
generalUsersSizeMinuteSpin->set_range(0, 59);
generalUsersSizeMinuteSpin->set_increments(1.0, 1.0);
generalUsersSizeMinuteSpin->set_value(0);
generalUsersFilesMinutesSpin->set_range(0, 59);
generalUsersFilesMinutesSpin->set_increments(1.0, 1.0);
generalUsersFilesMinutesSpin->set_value(0);
}
void MainWindow::init_tree_view() {
this->view_add_columns(*usersQuotasTree);
this->view_add_columns(*groupsQuotasTree);
this->view_add_columns(*ProjectQuotasTree);
this->init_tree_view_general();
}
void MainWindow::init_tree_view_general() {
GeneralQuotasTree->append_column_editable(str_status, m_columnsGeneral.status);
GeneralQuotasTree->append_column(str_quota, m_columnsGeneral.type_quotas);
GeneralQuotasTree->append_column(str_device_project, m_columnsGeneral.device);
GeneralQuotasTree->append_column(str_user, m_columnsGeneral.user);
GeneralQuotasTree->append_column(str_group, m_columnsGeneral.group);
GeneralQuotasTree->append_column(str_projects, m_columnsGeneral.projects);
GeneralQuotasTree->append_column(str_tw_soft_limit, m_columnsGeneral.soft_limit_size);
GeneralQuotasTree->append_column(str_tw_severe_limitation, m_columnsGeneral.hard_limit_size);
GeneralQuotasTree->append_column(str_tw_soft_limit_files, m_columnsGeneral.soft_limit_files);
GeneralQuotasTree->append_column(str_tw_severe_limitation_files, m_columnsGeneral.hard_limit_files);
GeneralQuotasTree->append_column(str_tw_general_deferring_size, m_columnsGeneral.deferring_size);
GeneralQuotasTree->append_column(str_tw_general_deferring_files, m_columnsGeneral.deferring_files);
}
void MainWindow::view_add_columns(Gtk::TreeView &treeView) {
treeView.append_column(str_name, m_columns.name);
treeView.append_column_editable(str_quotas, m_columns.quotas);
treeView.append_column(str_size, m_columns.size);
treeView.append_column(str_tw_soft_limit, m_columns.soft_limit_size);
treeView.append_column(str_tw_severe_limitation, m_columns.hard_limit_size);
treeView.append_column(str_tw_deferring_size, m_columns.deferring_size);
treeView.append_column(str_files, m_columns.files);
treeView.append_column(str_tw_soft_limit_files, m_columns.soft_limit_files);
treeView.append_column(str_tw_severe_limitation_files, m_columns.hard_limit_delay);
treeView.append_column(str_tw_deferring_files, m_columns.deferring_files);
}
void MainWindow::lacalization() {
time_t now = time(0);
tm *ltm = localtime(&now);
unsigned int year = 1900 + ltm->tm_year;
string str_authors = string(copyright) + to_string(year);
aboutWindows->set_copyright(str_authors);
aboutWindows->set_comments(str_setting_user);
aboutWindows->set_website(website);
aboutWindows->set_version(_(version_application.c_str()));
aboutWindows->set_website_label(project_Home_page);
generalTabLabel->set_text(str_general_settings);
GroupsTabLabel->set_text(str_groups);
headerAboutTopic->set_label(_(app_name));
headerTopic->set_label(name_app);
UsersTabLabel->set_text(str_users);
generalGroupsSizeLabel->set_text(str_excess_size_delay);
generalGroupsFilesLabel->set_text(str_excess_files_delay);
generalUsersSizeLabel->set_text(str_excess_size_delay);
generalUsersFilesLabel->set_text(str_excess_files_delay);
generalGroupsSizeWeeksLabel->set_text(str_weeks);
generalGroupsFilesWeeksLabel->set_text(str_weeks);
generalUsersSizeWeeksLabel->set_text(str_weeks);
generalUsersFilesWeeksLabel->set_text(str_weeks);
generalGroupsSizeDaysLabel->set_text(str_days);
generalGroupsFilesDaysLabel->set_text(str_days);
generalUsersSizeDaysLabel->set_text(str_days);
generalUsersFilesDaysLabel->set_text(str_days);
generalGroupsSizeHoursLabel->set_text(str_hours);
generalGroupsFilesHoursLabel->set_text(str_hours);
generalUsersSizeHoursLabel->set_text(str_hours);
generalUsersFilesHoursLabel->set_text(str_hours);
generalGroupsSizeMinutesLabel->set_text(str_minutes);
generalGroupsFilesMinutesLabel->set_text(str_minutes);
generalUsersSizeMinutesLabel->set_text(str_minutes);
generalUsersFilesMinutesLabel->set_text(str_minutes);
lblLoad->set_text(str_load_local);
lblSave->set_text(str_save_local);
groupsDeviceLabel->set_label(str_device);
usersDeviceLabel->set_label(str_device);
headLabel->set_label(str_lb_head);
filtersNameFilterCheckbox->set_label(str_name);
filtersQuotasFilterCheckbox->set_label(str_quotas);
filtersSizeFilterCheckbox->set_label(str_size);
filtersSoftSizeFilterCheckbox->set_label(str_soft_limit_size);
filtersHardSizeFilterCheckbox->set_label(str_hard_limit_size);
filtersHardSizeDelayFilterCheckbox->set_label(str_deferring_hard_limit_size);
filtersHardSizeActivationFilterCheckbox->set_label(str_hard_activation_size);
filtersFilesFilterCheckbox->set_label(str_files);
filtersSoftFilesFilterCheckbox->set_label(str_soft_restriction_files);
filtersHardFilesFilterCheckbox->set_label(str_severe_limitation_files);
filtersHardFilesDelayFilterCheckbox->set_label(str_deferring_limit_files);
filtersHardFilesActivationFilterCheckbox->set_label(str_hard_limit_time);
quotegroupDeviceLabel->set_text(str_device);
quotegroupDiskQuotasLabel->set_text(str_disk_quotas_device);
quotegroupGroupQuotasLabel->set_text(str_group_quotas_device);
quotegroupSizeFrameLabel->set_text(str_size);
quotegroupFilesFrameLabel->set_text(str_files);
quotegroupSizeCurrentlyLabel->set_text(str_currently_using);
quotegroupSizeSoftLimitLabel->set_text(str_soft_limit);
quoteSizeHardLimitLabel->set_text(str_hard_limit);
quoteFilesHardLimitLabel->set_text(str_hard_limit);
quotegroupFilesSoftLimitLabel->set_text(str_soft_limit);
quotegroupFilesCurrentlyLabel->set_text(str_currently_using);
quoteuserDiskQuotasLabel->set_text(str_disk_quotas_device);
quoteuserDeviceLabel->set_text(str_device);
quoteuserGroupQuotasLabel->set_text(str_user_quotas_device);
quoteuserSizeFrameLabel->set_text(str_size);
quoteuserSizeCurrentlyLabel->set_text(str_currently_using);
quoteuserSizeSoftLimitLabel->set_text(str_soft_limit);
quoteuserSizeHardLimitLabel1->set_text(str_hard_limit);
quoteuserFileSystemLabel->set_text(str_file_system);
quoteuserFilesFrameLabel->set_text(str_files);
quoteuserFilesCurrentlyLabel->set_text(str_currently_using_space);
quoteuserFilesSoftLimitLabel->set_text(str_soft_limit);
quoteFilesHardLimitLabel1->set_text(str_hard_limit);
quoteuserFilesHarLimitLabel->set_text(str_files);
quoteuserFilesSoftLimitlabel->set_text(str_files);
quotegroupFileSystemLabel->set_text(str_file_system);
btnLoadGlob->set_label(load_global);
btnLoadLocal->set_label(load_local);
btnAbout->set_label(str_about_1);
btnSynopsis->set_label(str_help);
btnSaveLocalGlob->set_label(save_all);
btnSaveGlob->set_label(save_global);
btnSaveLocal->set_label(save_local);
lblHeadFiltersWindow->set_label(str_filters);
ProjectTabLabel->set_label(str_projects);
usersProjectLabel->set_text(str_device);
lblhelpHeader->set_text(read_documentation_web);
lblhelpText->set_text(redirected_documentation);
btnReadHelp->set_label(read_online);
btnCancelHelp->set_label(cancel);
chkAlwaysOpenHelp->set_label(always_redirect);
lblwebHeaderName->set_label(name_app);
chbMangSystemFile->set_label(str_quotas_mode);
}
void MainWindow::filling_device_combo_box_template(Gtk::ComboBoxText *combo_box, map_str_str &map_device) {
if (map_device.size() != 0) {
for (const auto &device : map_device) {
combo_box->append(device.first.c_str());
}
combo_box->set_active(0);
}
}
void MainWindow::flag_block_gui() {
if (flag_load_global == true) {
btnLoadGlob->set_sensitive(false);
}
if (flag_save_local == true && flag_save_global == true) {
btnSave->set_sensitive(false);
}
if (flag_save == true) {
btnSave->set_sensitive(false);
}
if (flag_save_local == true) {
btnSaveLocal->set_sensitive(false);
btnSaveLocalGlob->set_sensitive(false);
}
if (flag_save_global == true) {
btnSaveGlob->set_sensitive(false);
btnSaveLocalGlob->set_sensitive(false);
}
if (flag_lock_help == true) {
btnSynopsis->set_sensitive(false);
}
}
void MainWindow::entry_combo_box_temp(Gtk::ComboBoxText *combo_box, Gtk::Label *label) {
string text = combo_box->get_active_text();
if (map_device.find(text) != map_device.end()){
label->set_text(map_device[text]);
}
}
void MainWindow::add_CSS() {
Glib::RefPtr<Gtk::CssProvider> cssProvider = Gtk::CssProvider::create();
cssProvider->load_from_path(path_css);
Glib::RefPtr<Gtk::StyleContext> styleContext = Gtk::StyleContext::create();
Glib::RefPtr<Gdk::Screen> screen = Gdk::Screen::get_default();//get default screen
styleContext->add_provider_for_screen(screen, cssProvider, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);//add provider for screen in all application
HeadBackgroundImage->set(path_img_head_background);
Glib::RefPtr<Gtk::StyleContext> headLabel_css = headLabel->get_style_context();
Glib::RefPtr<Gtk::StyleContext> boxButton_css = boxButton->get_style_context();
Glib::RefPtr<Gtk::StyleContext> boxSave_css = boxSave->get_style_context();
Glib::RefPtr<Gtk::StyleContext> headerBar_css = headerBar->get_style_context();
if (socket_trd_id_I == 0 && socket_ext_id_I == 0){
boxButton_css->add_class("bkim_no_plug");
boxSave_css->add_class("bkim_no_plug");
}
headLabel_css->add_class("textHead");
}
/*
void init_treeview_user() {
}
void MainWindow::view_add_data(Gtk::TreeModel::Row &row, Glib::RefPtr<Gtk::ListStore> list_store_m , std::array<std::vector<std::string>, 5> &arr_view , size_t index) {
row = *(list_store_m->append());
bool flag_chb = false;
string name = arr_view[0][index];
row[m_columns.check_button] = flag_chb;
row[m_columns.name] = _(name.c_str());
row[m_columns.description] = _(arr_view[1][index].c_str());
}
*/
void MainWindow::get_builder() {
builder->set_translation_domain(path_app);
builder->get_widget("headerTopic", headerTopic);
builder->get_widget("boxButton", boxButton);
builder->get_widget("boxSave", boxSave);
builder->get_widget("aboutWindows", aboutWindows);
builder->get_widget("HeadOverlay", HeadOverlay);
builder->get_widget("headerBar", headerBar);
builder->get_widget("boxFuncs", boxFuncs);
builder->get_widget("btnLoad", btnLoad);
builder->get_widget("btnSave", btnSave);
builder->get_widget("btnBoxAboutDialog", btnBoxAboutDialog);
builder->get_widget("HeadBackgroundImage", HeadBackgroundImage);
builder->get_widget("imgInfo", imgInfo);
builder->get_widget("lblWarning", lblWarning);
builder->get_widget("boxInfoError", boxInfoError);
builder->get_widget("imgInfo", imgInfo);
builder->get_widget("generalTabLabel", generalTabLabel);
builder->get_widget("GroupsTabLabel", GroupsTabLabel);
builder->get_widget("UsersTabLabel", UsersTabLabel);
builder->get_widget("generalGroupsSizeLabel", generalGroupsSizeLabel);
builder->get_widget("generalGroupsFilesLabel", generalGroupsFilesLabel);
builder->get_widget("generalUsersSizeLabel", generalUsersSizeLabel);
builder->get_widget("generalUsersFilesLabel", generalUsersFilesLabel);
builder->get_widget("generalGroupsSizeWeeksLabel", generalGroupsSizeWeeksLabel);
builder->get_widget("generalGroupsFilesWeeksLabel", generalGroupsFilesWeeksLabel);
builder->get_widget("generalUsersSizeWeeksLabel", generalUsersSizeWeeksLabel);
builder->get_widget("generalUsersFilesWeeksLabel", generalUsersFilesWeeksLabel);
builder->get_widget("generalGroupsSizeDaysLabel", generalGroupsSizeDaysLabel);
builder->get_widget("generalGroupsFilesDaysLabel", generalGroupsFilesDaysLabel);
builder->get_widget("generalUsersSizeDaysLabel", generalUsersSizeDaysLabel);
builder->get_widget("generalUsersFilesDaysLabel", generalUsersFilesDaysLabel);
builder->get_widget("generalGroupsSizeHoursLabel", generalGroupsSizeHoursLabel);
builder->get_widget("generalGroupsFilesHoursLabel", generalGroupsFilesHoursLabel);
builder->get_widget("generalUsersSizeHoursLabel", generalUsersSizeHoursLabel);
builder->get_widget("generalUsersFilesHoursLabel", generalUsersFilesHoursLabel);
builder->get_widget("generalGroupsSizeMinutesLabel", generalGroupsSizeMinutesLabel);
builder->get_widget("generalGroupsFilesMinutesLabel", generalGroupsFilesMinutesLabel);
builder->get_widget("generalUsersSizeMinutesLabel", generalUsersSizeMinutesLabel);
builder->get_widget("generalUsersFilesMinutesLabel", generalUsersFilesMinutesLabel);
builder->get_widget("lblLoad", lblLoad);
builder->get_widget("lblSave", lblSave);
builder->get_widget("btnSettings", btnSettings);
builder->get_widget("btnSettings", btnSettings);
builder->get_widget("groupsDeviceLabel", groupsDeviceLabel);
builder->get_widget("usersDeviceLabel", usersDeviceLabel);
builder->get_widget("headLabel", headLabel);
builder->get_widget("FiltersWindow", FiltersWindow);
builder->get_widget("filtersNameFilterCheckbox", filtersNameFilterCheckbox);
builder->get_widget("filtersQuotasFilterCheckbox", filtersQuotasFilterCheckbox);
builder->get_widget("filtersSizeFilterCheckbox", filtersSizeFilterCheckbox);
builder->get_widget("filtersSoftSizeFilterCheckbox", filtersSoftSizeFilterCheckbox);
builder->get_widget("filtersHardSizeFilterCheckbox", filtersHardSizeFilterCheckbox);
builder->get_widget("filtersHardSizeDelayFilterCheckbox", filtersHardSizeDelayFilterCheckbox);
builder->get_widget("filtersHardSizeActivationFilterCheckbox", filtersHardSizeActivationFilterCheckbox);
builder->get_widget("filtersFilesFilterCheckbox", filtersFilesFilterCheckbox);
builder->get_widget("filtersSoftFilesFilterCheckbox", filtersSoftFilesFilterCheckbox);
builder->get_widget("filtersHardFilesFilterCheckbox", filtersHardFilesFilterCheckbox);
builder->get_widget("filtersHardFilesDelayFilterCheckbox", filtersHardFilesDelayFilterCheckbox);
builder->get_widget("filtersHardFilesActivationFilterCheckbox", filtersHardFilesActivationFilterCheckbox);
builder->get_widget("filtersHardFilesActivationFilterCheckbox", filtersHardFilesActivationFilterCheckbox);
builder->get_widget("btnLoadGlob", btnLoadGlob);
builder->get_widget("btnLoadLocal", btnLoadLocal);
builder->get_widget("btnSynopsis", btnSynopsis);
builder->get_widget("btnAbout", btnAbout);
builder->get_widget("btnSaveLocalGlob", btnSaveLocalGlob);
builder->get_widget("btnSaveGlob", btnSaveGlob);
builder->get_widget("btnSaveLocal", btnSaveLocal);
builder->get_widget("GroupsTabLabel", GroupsTabLabel);
builder->get_widget("groupsQuotasTree", groupsQuotasTree);
builder->get_widget("usersQuotasTree", usersQuotasTree);
builder->get_widget("quotegroupDeviceLabel", quotegroupDeviceLabel);
builder->get_widget("quotegroupFileSystemLabel", quotegroupFileSystemLabel);
builder->get_widget("quotegroupDiskQuotasLabel", quotegroupDiskQuotasLabel);
builder->get_widget("quotegroupGroupQuotasLabel", quotegroupGroupQuotasLabel);
builder->get_widget("quotegroupSizeFrameLabel", quotegroupSizeFrameLabel);
builder->get_widget("quotegroupFilesFrameLabel", quotegroupFilesFrameLabel);
builder->get_widget("quotegroupSizeCurrentlyLabel", quotegroupSizeCurrentlyLabel);
builder->get_widget("quotegroupFilesCurrentlyLabel", quotegroupFilesCurrentlyLabel);
builder->get_widget("quotegroupSizeSoftLimitLabel", quotegroupSizeSoftLimitLabel);
builder->get_widget("quoteSizeHardLimitLabel", quoteSizeHardLimitLabel);
builder->get_widget("quotegroupFilesSoftLimitLabel", quotegroupFilesSoftLimitLabel);
builder->get_widget("quoteFilesHardLimitLabel", quoteFilesHardLimitLabel);
builder->get_widget("quotegroupFilesHarLimitLabel", quotegroupFilesHarLimitLabel);
builder->get_widget("quoteuserDeviceLabel", quoteuserDeviceLabel);
builder->get_widget("quoteuserFileSystemLabel", quoteuserFileSystemLabel);
builder->get_widget("quoteuserDiskQuotasLabel", quoteuserDiskQuotasLabel);
builder->get_widget("quoteuserGroupQuotasLabel", quoteuserGroupQuotasLabel);
builder->get_widget("quoteuserSizeFrameLabel", quoteuserSizeFrameLabel);
builder->get_widget("quoteuserSizeCurrentlyLabel", quoteuserSizeCurrentlyLabel);
builder->get_widget("quoteuserSizeSoftLimitLabel", quoteuserSizeSoftLimitLabel);
builder->get_widget("quoteuserSizeHardLimitLabel1", quoteuserSizeHardLimitLabel1);
builder->get_widget("quoteuserFilesFrameLabel", quoteuserFilesFrameLabel);
builder->get_widget("quoteuserFilesCurrentlyLabel", quoteuserFilesCurrentlyLabel);
builder->get_widget("quoteuserFilesSoftLimitLabel", quoteuserFilesSoftLimitLabel);
builder->get_widget("quoteFilesHardLimitLabel1", quoteFilesHardLimitLabel1);
builder->get_widget("quoteuserFilesHarLimitLabel", quoteuserFilesHarLimitLabel);
builder->get_widget("quoteuserFilesSoftLimitlabel", quoteuserFilesSoftLimitlabel);
builder->get_widget("QuotasEditWindow", QuotasEditWindow);
builder->get_widget("QuotasUserEditWindow", QuotasUserEditWindow);
builder->get_widget("headerAboutTopic", headerAboutTopic);
builder->get_widget("lblHeadQuotasUserEditWindow", lblHeadQuotasUserEditWindow);
builder->get_widget("lblHeadQuotasEditWindow", lblHeadQuotasEditWindow);
builder->get_widget("lblHeadFiltersWindow", lblHeadFiltersWindow);
builder->get_widget("usersDeviceCombo", usersDeviceCombo);
builder->get_widget("GroupsTabLabel", GroupsTabLabel);
builder->get_widget("generalTabLabel", generalTabLabel);
builder->get_widget("groupsDeviceCombo", groupsDeviceCombo);
builder->get_widget("generalGroupsSizeWeeksSpi", generalGroupsSizeWeeksSpi);
builder->get_widget("generalGroupsFileWeeksSpin", generalGroupsFileWeeksSpin);
builder->get_widget("generalGroupsSizeDaySpin", generalGroupsSizeDaySpin);
builder->get_widget("generalGroupsFilesDaySpin", generalGroupsFilesDaySpin);
builder->get_widget("generalGroupsSizeHourSpin", generalGroupsSizeHourSpin);
builder->get_widget("generalGroupsFilesHourSpin", generalGroupsFilesHourSpin);
builder->get_widget("generalGroupsSizeMinuteSpin", generalGroupsSizeMinuteSpin);
builder->get_widget("generalGroupsFilesMinuteSpin", generalGroupsFilesMinuteSpin);
builder->get_widget("generalUsersSizWeeksSpin", generalUsersSizWeeksSpin);
builder->get_widget("generalUsersFileWeeksSpin", generalUsersFileWeeksSpin);
builder->get_widget("generalUsersSizeDaySpin", generalUsersSizeDaySpin);
builder->get_widget("generalUsersFilesDaySpin", generalUsersFilesDaySpin);
builder->get_widget("generalUsersSizeHourSpin", generalUsersSizeHourSpin);
builder->get_widget("generalUsersFilesHoursSpin", generalUsersFilesHoursSpin);
builder->get_widget("generalUsersSizeMinuteSpin", generalUsersSizeMinuteSpin);
builder->get_widget("generalUsersFilesMinutesSpin", generalUsersFilesMinutesSpin);
builder->get_widget("lblEditWndFsys", lblEditWndFsys);
builder->get_widget("quotegroupSizeSoftLimitCheck", quotegroupSizeSoftLimitCheck);
builder->get_widget("quotegroupSizeHardLimitCheck", quotegroupSizeHardLimitCheck);
builder->get_widget("quotegroupFilesSoftLimitCheck", quotegroupFilesSoftLimitCheck);
builder->get_widget("quotegroupFilesHardLimitCheck", quotegroupFilesHardLimitCheck);
builder->get_widget("quotegroupSizeSoftLimitSpin", quotegroupSizeSoftLimitSpin);
builder->get_widget("quotegroupSizeSoftLimitCombo", quotegroupSizeSoftLimitCombo);
builder->get_widget("quotegroupSizeHardLimitSpin", quotegroupSizeHardLimitSpin);
builder->get_widget("quotegroupSizeHardLimitCombo", quotegroupSizeHardLimitCombo);
builder->get_widget("quotegroupFilesSoftLimitSpin", quotegroupFilesSoftLimitSpin);
builder->get_widget("quotegroupFilesSoftLimitlabel", quotegroupFilesSoftLimitlabel);
builder->get_widget("quotegroupFilesHardLimitSpin", quotegroupFilesHardLimitSpin);
builder->get_widget("quotegroupSaveButton", quotegroupSaveButton);
builder->get_widget("quotegroupCancelButton", quotegroupCancelButton);
builder->get_widget("quotegroupDeviceCombo", quotegroupDeviceCombo);
builder->get_widget("GeneralQuotasTree", GeneralQuotasTree);
builder->get_widget("ProjectQuotasTree", ProjectQuotasTree);
builder->get_widget("ProjectTabLabel", ProjectTabLabel);
builder->get_widget("usersProjectLabel", usersProjectLabel);
builder->get_widget("btnFilterProject", btnFilterProject);
builder->get_widget("btnFilterUsers", btnFilterUsers);
builder->get_widget("btnFilterGroups", btnFilterGroups);
#ifdef WEBKIT_FOUND
builder->get_widget("wndWeb", wndWeb);
#endif
builder->get_widget("lblHeadeWndWeb", lblHeadeWndWeb);
builder->get_widget("lblwebHeaderName", lblwebHeaderName);
builder->get_widget("lblhelpText", lblhelpText);
builder->get_widget("lblhelpHeader", lblhelpHeader);
builder->get_widget("chkAlwaysOpenHelp", chkAlwaysOpenHelp);
builder->get_widget("btnReadHelp", btnReadHelp);
builder->get_widget("btnCancelHelp", btnCancelHelp);
builder->get_widget("wndShowWeb", wndShowWeb);
builder->get_widget("chbMangSystemFile", chbMangSystemFile);
builder->get_widget("btnDelGroups", btnDelGroups);
builder->get_widget("btnDelProject", btnDelProject);
builder->get_widget("btnDelUsers", btnDelUsers);
builder->get_widget("btnAddGroups", btnAddGroups);
builder->get_widget("btnAddUsers", btnAddUsers);
builder->get_widget("btnAddProject", btnAddProject);
}
void MainWindow::event() {
btnCancelHelp->signal_clicked().connect([&]() {wndShowWeb->hide();});
chkAlwaysOpenHelp->signal_toggled().connect([&]() {flag_open_browser = true;});
btnReadHelp->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::open_browser));
btnFilterGroups->signal_clicked().connect([&]() {this->groupsFilters_show();});
btnFilterUsers->signal_clicked().connect([&]() {this->groupsFilters_show();});
btnFilterProject->signal_clicked().connect([&]() {this->groupsFilters_show();});
quotegroupSaveButton->signal_clicked().connect([&]() {});
btnLoadGlob->signal_activate().connect([&]() {this->load_global_cfg();});
btnLoadLocal->signal_activate().connect([&]() {this->load_system_cfg();});
btnSynopsis->signal_activate().connect([&]() {this->synopsis_show();});
btnAbout->signal_activate().connect([&]() {aboutWindows->show();});
btnSaveLocalGlob->signal_activate().connect([&]() {this->wrapper_save_all_cfg();});
btnSaveGlob->signal_activate().connect([&]() {this->wrapper_save_global_cfg();});
btnSaveLocal->signal_activate().connect([&]() {this->wrapper_save_system_cfg();});
chbMangSystemFile->signal_toggled().connect([&]() {this->mode_switch_quota();});
quotegroupDeviceCombo->signal_changed().connect([&]() {entry_combo_box_temp(quotegroupDeviceCombo, lblEditWndFsys);});
quotegroupSizeSoftLimitCheck->signal_toggled().connect([&]() {
check_limit(quotegroupSizeSoftLimitCheck
,quotegroupSizeSoftLimitSpin
,quotegroupSizeSoftLimitCombo);
});
quotegroupSizeHardLimitCheck->signal_toggled().connect([&]() {
check_limit(quotegroupSizeHardLimitCheck
,quotegroupSizeHardLimitSpin
,quotegroupSizeHardLimitCombo);
});
quotegroupFilesSoftLimitCheck->signal_toggled().connect([&]() {
check_limit(quotegroupFilesSoftLimitCheck
,quotegroupFilesSoftLimitSpin
,quotegroupFilesSoftLimitlabel);
});
quotegroupFilesHardLimitCheck->signal_toggled().connect([&]() {
check_limit(quotegroupFilesHardLimitCheck
,quotegroupFilesHardLimitSpin
,quotegroupFilesHarLimitLabel);
});
quotegroupCancelButton->signal_clicked().connect([&]() {QuotasEditWindow->hide();});
// QuotasEditWindow->show();
btnDelGroups->signal_clicked().connect(
sigc::bind<Glib::RefPtr<Gtk::ListStore>*, const Gtk::TreeModel::iterator*, bool&> (sigc::mem_fun( *this,
&MainWindow::remove_template), &list_store_groups, &iter_groups, flag_validate_del_groups));
btnDelUsers->signal_clicked().connect(
sigc::bind<Glib::RefPtr<Gtk::ListStore>*, const Gtk::TreeModel::iterator*, bool&> (sigc::mem_fun( *this,
&MainWindow::remove_template), &list_store_users, &iter_users, flag_validate_del_users));
btnDelProject->signal_clicked().connect(
sigc::bind<Glib::RefPtr<Gtk::ListStore>*, const Gtk::TreeModel::iterator*, bool&> (sigc::mem_fun( *this,
&MainWindow::remove_template), &list_store_project, &iter_project, flag_validate_del_project));
btnAddProject->signal_clicked().connect(
sigc::bind<Gtk::TreeModel::Row&, Glib::RefPtr<Gtk::ListStore>, struct tv_g_u_p> (sigc::mem_fun( *this,
&MainWindow::set_add_tv_g_u_p), row, list_store_project, obj_tv_g_u_p));
btnAddUsers->signal_clicked().connect(
sigc::bind<Gtk::TreeModel::Row&, Glib::RefPtr<Gtk::ListStore>, struct tv_g_u_p> (sigc::mem_fun( *this,
&MainWindow::set_add_tv_g_u_p), row, list_store_users, obj_tv_g_u_p));
btnAddGroups->signal_clicked().connect(
sigc::bind<Gtk::TreeModel::Row&, Glib::RefPtr<Gtk::ListStore>, struct tv_g_u_p> (sigc::mem_fun( *this,
&MainWindow::set_add_tv_g_u_p), row, list_store_groups, obj_tv_g_u_p));
}
void MainWindow::remove_template(Glib::RefPtr<Gtk::ListStore>* list_store, const Gtk::TreeModel::iterator* iter, bool& flag_validate_del) {
if (flag_validate_del && (*list_store)->iter_is_valid(*(iter))) {
Gtk::TreeModel::Row row = *(*iter);
if(row) {
string name = row[m_columns.name] + "";
// TODO:
string key = "GRUB_PASSWORD[" + name + "]";
map_gui_cfg[key] = "";
}
(*list_store)->erase((*iter));
flag_validate_del = false;
info_status_app(info_box_ok_css);
imgInfo->set_from_icon_name(icon_checked, Gtk::ICON_SIZE_MENU);
lblWarning->set_text("");
}
flag_validate_del = false;
}
void MainWindow::set_add_tv_g_u_p(Gtk::TreeModel::Row &row, Glib::RefPtr<Gtk::ListStore> list_store, struct tv_g_u_p obj_tv_g_u_p) {
row = *(list_store->append());
row[m_columns.name] = obj_tv_g_u_p.name;
row[m_columns.quotas] = obj_tv_g_u_p.quotas;
row[m_columns.size] = obj_tv_g_u_p.size;
row[m_columns.soft_limit_size] = obj_tv_g_u_p.soft_limit_size;
row[m_columns.hard_limit_size] = obj_tv_g_u_p.hard_limit_size;
row[m_columns.deferring_size] = obj_tv_g_u_p.deferring_size;
row[m_columns.files] = obj_tv_g_u_p.files;
row[m_columns.soft_limit_files] = obj_tv_g_u_p.soft_limit_files;
row[m_columns.hard_limit_delay] = obj_tv_g_u_p.hard_limit_delay;
row[m_columns.deferring_files] = obj_tv_g_u_p.deferring_files;
}
void MainWindow::mode_switch_quota() {
if (chbMangSystemFile->get_active()) {
mode_quota = "filesystem";
}
else {
mode_quota = "ubconfig";
}
}
void MainWindow::wrapper_settings_quotas_temp(string save_user_or_group) {
struct partition_cmd _struct_partition_cmd = this->wrapper_settings_quotas();
string device = _struct_partition_cmd.device;
string cmd = _struct_partition_cmd.cmd;
string type_quotas = save_user_or_group;
string user = "";
struct struct_quotas _struct_quota;
_struct_quota.device = device;
_struct_quota.cmd = cmd;
_struct_quota.type_quotas = type_quotas;
_struct_quota.name = user;
obj_quotas_ubconfig.format_cmd_quotas(_struct_quota);
}
void MainWindow::save_quotegroupSaveButton() {
if (sys_or_ubconfig == "ubconfig") {
if (save_user_or_group == "usrquota") {
this->wrapper_settings_quotas_temp(save_user_or_group);
}
else {
this->wrapper_settings_quotas_temp(save_user_or_group);
}
}
else {
if (save_user_or_group == "usrquota") {
}
else {
}
}
}
struct partition_cmd MainWindow::wrapper_settings_quotas() {
string str_parted = quotegroupDeviceCombo->get_active_text();
string value = "";
if (quotegroupSizeSoftLimitCheck->get_active()) {
value = Utils::format_str_size(quotegroupSizeSoftLimitSpin->get_value(), quotegroupSizeSoftLimitCombo->get_active_row_number());
value += ":";
}
else {
value += "0:";
}
if (quotegroupSizeHardLimitCheck->get_active()) {
value += Utils::format_str_size(quotegroupSizeHardLimitSpin->get_value(), quotegroupSizeHardLimitCombo->get_active_row_number());
value += ":";
}
else {
value += "0:";
}
if (quotegroupFilesSoftLimitCheck->get_active()) {
value += to_string(quotegroupFilesSoftLimitSpin->get_value());
value += ":";
}
else {
value += "0:";
}
if (quotegroupFilesHardLimitCheck->get_active()) {
value += to_string(quotegroupFilesHardLimitSpin->get_value());
value += ":";
}
else {
value += "0:";
}
struct partition_cmd _struct_partition_cmd;
_struct_partition_cmd.device = str_parted;
_struct_partition_cmd.cmd = value;
return _struct_partition_cmd;
}
void MainWindow::groupsFilters_show() {
FiltersWindow->show_all();
}
void MainWindow::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::ComboBoxText *combo_box) {
spin->set_sensitive(check_button->get_active());
combo_box->set_sensitive(check_button->get_active());
}
void MainWindow::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::Label *combo_box) {
spin->set_sensitive(check_button->get_active());
combo_box->set_sensitive(check_button->get_active());
}
void MainWindow::info_status_app(string stule) {
Glib::RefPtr<Gtk::StyleContext> boxInfo = boxInfoError->get_style_context();
boxInfo->remove_class(info_box_ok_css);
boxInfo->remove_class(info_box_error_css);
boxInfo->add_class(stule);
}
void MainWindow::init_dict(string flag_load) {
std::map<std::string, std::string> map_gui_cfg_n;
map_gui_cfg_n[""] = "";
map_gui_cfg = map_gui_cfg_n;
if (flag_load == "global") {
map_global_cfg = map_gui_cfg_n;
}
else if (flag_load == "system") {
map_system_cfg = map_gui_cfg_n;
}
}
bool MainWindow::save_template(string section, string flag_save) {
bool flag_no_save = true;
obj_save.set_data_local(map_system_cfg);
obj_save.set_data_global(map_global_cfg);
obj_save.set_data_gui(map_gui_cfg);
obj_save.set_vec_params(vec_param_names);
obj_save.save(section, flag_save);
vector<string> obj_vec_error = obj_save.get_error();
flag_no_save = obj_save.get_state_save();
return flag_no_save;
}
void MainWindow::wrapper_save_all_cfg() {
this->set_data_cfg();
bool _flag_save_global = this->save_template("boot", "global");;
bool _flag_save_local = this->save_template("boot", "system");
if (_flag_save_global && _flag_save_local) {
this->info_warning_error(5);
}
else {
info_warning_error(4);
}
map_global_cfg = map_gui_cfg;
map_system_cfg = map_gui_cfg;
}
void MainWindow::load_global_cfg() {
this->load_template(&map_global_cfg, "global");
info_warning_error(1);
map_gui_cfg = map_global_cfg;
}
void MainWindow::load_system_cfg() {
this->load_template(&map_system_cfg, "system");
info_warning_error(0);
map_gui_cfg = map_system_cfg;
}
void MainWindow::set_data_cfg() {
// TODO:
// Написать функцию
}
void MainWindow::wrapper_save_global_cfg() {
this->set_data_cfg();
if (this->save_template("boot", "global")) {
this->info_warning_error(5);
}
else {
info_warning_error(3);
}
map_global_cfg = map_gui_cfg;
}
void MainWindow::synopsis_show() {
if (flag_open_browser == true) {
this->open_browser();
}
else {
wndShowWeb->show_all();
}
}
void MainWindow::open_browser() {
#ifdef WEBKIT_FOUND
webkit_web_view_load_uri(one, link_doc);
wndWeb->show_all();
#else
this->template_open_browser();
#endif
}
void MainWindow::template_open_browser() {
string cmd = cmd_xdg + string(_(link_doc)) + " &";
string buf = "";
if (geteuid() == 0) {
string response_user = getlogin();
int size_s = std::snprintf(nullptr, 0, cmd_execute, response_user.c_str(), cmd.c_str()) + 1;
auto size = static_cast<size_t>(size_s);
std::unique_ptr<char[]> buf(new char[ size ]);
std::snprintf( buf.get(), size, cmd_execute, response_user.c_str(), cmd.c_str() );
cmd = std::string( buf.get(), buf.get() + size - 1 );
}
obj_process_system.call(cmd, "");
}
void MainWindow::wrapper_save_system_cfg() {
this->set_data_cfg();
if (this->save_template("boot", "system")) {
this->info_warning_error(5);
}
else {
info_warning_error(2);
}
map_system_cfg = map_gui_cfg;
}
void MainWindow::init_work_tv_g_u_p() {
groupsQuotasTree->remove_all_columns();
ProjectQuotasTree->remove_all_columns();
usersQuotasTree->remove_all_columns();
list_store_groups = Gtk::ListStore::create(m_columns);
list_store_project = Gtk::ListStore::create(m_columns);
list_store_users = Gtk::ListStore::create(m_columns);
groupsQuotasTree->set_model(list_store_groups);
ProjectQuotasTree->set_model(list_store_project);
usersQuotasTree->set_model(list_store_users);
Glib::RefPtr<Gtk::TreeModel> groupsQuotasTreeModel = groupsQuotasTree->get_model();
groupsQuotasTreeModel->signal_row_changed().connect(sigc::bind<Gtk::TreeModel::iterator&, bool&>
(sigc::mem_fun(*this, &MainWindow::remove_line_template), iter_groups, flag_validate_del_groups));
Glib::RefPtr<Gtk::TreeModel> ProjectQuotasTreeModel = ProjectQuotasTree->get_model();
ProjectQuotasTreeModel->signal_row_changed().connect(sigc::bind<Gtk::TreeModel::iterator&, bool&>
(sigc::mem_fun(*this, &MainWindow::remove_line_template), iter_project, flag_validate_del_project));
Glib::RefPtr<Gtk::TreeModel> usersQuotasTreeModel = usersQuotasTree->get_model();
usersQuotasTreeModel->signal_row_changed().connect(sigc::bind<Gtk::TreeModel::iterator&, bool&>
(sigc::mem_fun(*this, &MainWindow::remove_line_template),iter_users, flag_validate_del_users));
this->view_add_columns(*groupsQuotasTree);
this->view_add_columns(*ProjectQuotasTree);
this->view_add_columns(*usersQuotasTree);
}
void MainWindow::load_template(map_str_str* map_temp, string str_load) {
this->init_work_tv_g_u_p();
this->init_dict(str_load);
string sections;
sections = "security";
obj_load.set_sections(sections);
*map_temp = obj_load.get_load_data(*map_temp, str_load);
}
void MainWindow::remove_line_template(const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator& iter, Gtk::TreeModel::iterator& iter_del, bool& flag_del) {
iter_del = iter;
flag_del = true;
}
void MainWindow::info_warning_error(int mess) {
if (obj_load.get_count_error() > 0 || obj_save.get_count_error() > 0) {
info_status_app(info_box_error_css);
imgInfo->set_from_icon_name(icon_warning, Gtk::ICON_SIZE_MENU);
string mess_error = "";
if (mess == 0) {
mess_error = string(local_read_error) + str_cmd_error;
lblWarning->set_text(mess_error);
}
else if (mess == 1) {
mess_error = string(global_read_error) + str_cmd_error;
lblWarning->set_text(mess_error);
}
else if (mess == 2) {
mess_error = string(local_write_error) + str_cmd_error;
lblWarning->set_text(mess_error);
}
else if (mess == 3) {
mess_error = string(global_write_error) + str_cmd_error;
lblWarning->set_text(mess_error);
}
else if (mess == 4) {
mess_error = string(error_save_all) + str_cmd_error;
lblWarning->set_text(mess_error);
}
str_cmd_error = "";
obj_load.set_count_error(0);
obj_save.set_count_error(0);
}
else {
info_status_app(info_box_ok_css);
imgInfo->set_from_icon_name(icon_checked, Gtk::ICON_SIZE_MENU);
if (mess == 0) {
lblWarning->set_text(local_load_ok);
}
else if (mess == 1) {
lblWarning->set_text(global_load_ok);
}
else if (mess == 2) {
lblWarning->set_text(local_ok_written);
}
else if (mess == 3) {
lblWarning->set_text(global_ok_written);
}
else if (mess == 4) {
lblWarning->set_text(successfully_save_all);
}
else if (mess == 5) {
lblWarning->set_text(nothing_save);
}
}
}
MainWindow::~MainWindow() {}
void help() {
string version = string(str_version) + version_application + "\n";
cout << version.c_str();
cout << str_help_h;
}

@ -1,441 +0,0 @@
#ifndef UBL_SETTINGS_QUOTAS_H
#define UBL_SETTINGS_QUOTAS_H
#include "util.h"
#include "load.h"
#include "save.h"
#include "my_process.h"
#include "my_type.h"
#include "my_device.h"
#include "system_quotas.h"
#include "ubconfig_quotas.h"
#include <dlfcn.h>
#include "ubl-settings-diskquota-cm.h"
#ifdef WEBKIT_FOUND
#include <webkit2/webkit2.h>
#endif
#define copyright _("Copyright © UBSoft LLC, 2022 - ")
#define name_app _("ubl-settings-diskquota")
#define website _("https://wiki.ublinux.com")
#define project_Home_page _("Project Home Page")
#define configuring_system_boot _("Configuring system boot parameters")
#define system_boot _("System boot")
#define str_about _("About ubl-settings-diskquota")
#define command_line_parameters _("Command line parameters:")
#define load_default _("Load default:")
#define seconds _("seconds")
#define download_menu _("Download menu")
#define terminal_for_input _("Terminal for input")
#define terminal_for_output _("Terminal for output")
#define boot_selection_menu_timer _("Boot selection menu timer")
#define str_help _("Help")
#define str_about_1 _("About")
#define str_save_local _("Save")
#define str_load_local _("Load")
#define save_all _("Save in global and local configuration")
#define save_local _("Save in local configuration")
#define save_global _("Save in global configuration")
#define load_global _("Load global configuration")
#define load_local _("Load local configuration")
#define read_online _("Read online")
#define cancel _("Cancel")
#define always_redirect _("Always redirect")
#define boot_screen_display_mode _("Boot screen display mode:")
#define no_loading_animation _("No loading animation, full log")
#define boot_menu_user_name _("Boot menu user name:")
#define boot_menu_user_password _("Boot menu user password:")
#define last_successful_upload _("Last successful upload")
#define read_documentation_web _("Would you like to read documentation in the Web?")
#define redirected_documentation _("You will be redirected to documentation site, where user help pages are ""translated and supported by community.")
#define local_read_error _("Local configuration reading error")
#define global_read_error _("Global configuration read error")
#define local_write_error _("Local configuration write error")
#define global_write_error _("Global configuration write error")
#define error_save_all _("Error saved local and global configuration")
#define local_load_ok _("Local configuration downloaded successfully")
#define global_load_ok _("Global configuration downloaded successfully")
#define local_ok_written _("Local configuration successfully written")
#define global_ok_written _("Global configuration successfully written")
#define successfully_save_all _("Successfully saved local and global configuration")
#define nothing_save _("Nothing to save!")
#define program_as_root _("The program must be run as root")
#define str_weeks _("weeks")
#define str_days _("days")
#define str_hours _("hours")
#define str_minutes _("minutes")
#define str_device _("Device:")
#define str_setting_user _("Setting user quotas")
#define str_users _("Users")
#define str_groups _("Groups")
#define str_files _("files")
#define str_hard_limit _("Hard limit")
#define str_file_system _("File system:")
#define str_name _("Name")
#define str_size _("Size")
#define str_quotas_mode _("Direct control of the file system")
#define str_lb_head _("Configuration of disk quotas parameters for system groups and users")
#define str_soft_limit _("Soft limit")
#define str_currently_using _("Currently using:")
#define str_currently_using_space _("Currently using: ")
#define str_filters _("Filters")
#define str_projects _("Projects")
#define str_quotas _("Quotas")
#define str_help_h _("GTK settings disk quota for UBLinux\n" \
"\n" \
"Usage: ubl-settings-diskquota [OPTIONS...]\n" \
"Options:\n" \
" -h, --help\t Show this help\n" \
" -V, --version\t Show package version\n" \
" --lock-help Lock utility help\n" \
" --lock-save Lock saving local and global configuration\n" \
" --lock-save-local Lock save global configuration\n" \
" --lock-save-global Lock load global configuration\n" \
" --lock-load-global Lock load global configuration\n")
#define str_version _("ubl-settings-diskquota version: ")
#define str_user _("User")
#define str_group _("Group")
#define str_device_project _("Device\nProject")
#define str_quota _("Quota type")
#define str_status _("Status")
#define str_excess_size_delay _("Excess size delay period")
#define str_excess_files_delay _("Excess files delay period")
#define str_disk_quotas_device _("Disk quotas for this device:")
#define str_user_quotas_device _("User quotas for this device: ")
#define str_soft_limit_size _("Soft limit (size)")
#define str_tw_soft_limit _("Soft limit\n(size)")
#define str_hard_limit_size _("Hard limit (size)")
#define str_deferring_hard_limit_size _("Deferring a hard limit (size)")
#define str_hard_activation_size _("Hard limit activation time (size)")
#define str_hard_limit_time _("Hard limit (file) activation time")
#define str_group_quotas_device _("Group quotas for this device:")
#define str_general_settings _("General settings")
#define str_tw_severe_limitation _("Severe\nlimitation\n(size)")
#define str_tw_general_deferring_size _("Deferring\n(size)")
#define str_tw_general_deferring_files _("Deferring\n(files)")
#define str_tw_deferring_size _("Deferring\na hard\nlimit\n(files)")
#define str_tw_deferring_files _("Deferring\na hard\nlimit\n(files)")
#define str_tw_soft_limit_files _("Soft limit\n(files)")
#define str_tw_severe_limitation_files _("Severe\nlimitation\n(files)")
#define str_soft_restriction_files _("Soft Restriction (files)")
#define str_severe_limitation_files _("Severe limitation (files)")
#define str_deferring_limit_files _("Deferring a hard limit (files)")
#define info_box_ok_css "boxInfoMessOK"
#define info_box_error_css "boxInfoMessError"
#define icon_checked "com.ublinux.ubl-settings-diskquota.checked"
#define icon_warning "com.ublinux.ubl-settings-diskquota.warning"
#define link_doc "https://wiki.ublinux.com/ru/Программное_обеспечениерограммы_и_утилиты/Все/ubl-settings-diskquota"
#define cmd_xdg "xdg-open "
#define cmd_execute "su -l %s -c \" DISPLAY=$DISPLAY %s \""
#define path_app "/usr/bin/"
#define path_glade "/usr/share/ubl-settings-diskquota/ui/ubl-settings-diskquota.glade"
#define path_css "/usr/share/ubl-settings-diskquota/css/ubl-settings-diskquota.css"
#define app_name "ubl-settings-diskquota"
#define path_resources "/usr/share/ubl-settings-diskquota"
#define path_img_head_background "/usr/share/ubl-settings-diskquota/images/logo-background.png"
#define no_recognized _("Argument not recognized\n")
using namespace std;
extern string version_application;
extern bool flag_save;
extern bool flag_save_local;
extern bool flag_save_global;
extern bool flag_load_global;
extern bool flag_lock_help;
extern int socket_ext_id_I;
extern int socket_trd_id_I;
class MainWindow : public Gtk::ApplicationWindow {
public:
class ModelColumns : public Gtk::TreeModel::ColumnRecord {
public:
ModelColumns() {add(name), add(quotas); add(size),
add(soft_limit_size), add(hard_limit_size); add(deferring_size),
add(files); add(soft_limit_files),
add(hard_limit_delay), add(deferring_files); }
Gtk::TreeModelColumn<Glib::ustring> name;
Gtk::TreeModelColumn<Glib::ustring> quotas;
Gtk::TreeModelColumn<Glib::ustring> size;
Gtk::TreeModelColumn<Glib::ustring> soft_limit_size;
Gtk::TreeModelColumn<Glib::ustring> hard_limit_size;
Gtk::TreeModelColumn<Glib::ustring> deferring_size;
Gtk::TreeModelColumn<Glib::ustring> files;
Gtk::TreeModelColumn<Glib::ustring> soft_limit_files;
Gtk::TreeModelColumn<Glib::ustring> hard_limit_delay;
Gtk::TreeModelColumn<Glib::ustring> deferring_files;
};
class ModelColumnsGeneral : public Gtk::TreeModel::ColumnRecord {
public:
ModelColumnsGeneral() {add(status), add(type_quotas); add(device),
add(user), add(group), add(projects); add(soft_limit_size),
add(hard_limit_size); add(soft_limit_files), add(hard_limit_files), add(deferring_size),
add(deferring_files); }
Gtk::TreeModelColumn<bool> status;
Gtk::TreeModelColumn<Glib::ustring> type_quotas;
Gtk::TreeModelColumn<Glib::ustring> device;
Gtk::TreeModelColumn<Glib::ustring> user;
Gtk::TreeModelColumn<Glib::ustring> group;
Gtk::TreeModelColumn<Glib::ustring> projects;
Gtk::TreeModelColumn<Glib::ustring> soft_limit_size;
Gtk::TreeModelColumn<Glib::ustring> hard_limit_size;
Gtk::TreeModelColumn<Glib::ustring> soft_limit_files;
Gtk::TreeModelColumn<Glib::ustring> hard_limit_files;
Gtk::TreeModelColumn<Glib::ustring> deferring_size;
Gtk::TreeModelColumn<Glib::ustring> deferring_files;
};
ModelColumns m_columns;
ModelColumnsGeneral m_columnsGeneral;
Glib::RefPtr<Gtk::Builder> builder;
template<typename Type>
struct Result{
Type response;
int error;
};
Gtk::Label *headerTopic;
Gtk::AboutDialog *aboutWindows;
Gtk::Overlay *HeadOverlay;
Gtk::HeaderBar *headerBar;
Gtk::Box *boxSave;
Gtk::Box *boxButton;
Gtk::Box *boxFuncs;
Gtk::MenuButton *btnSave;
Gtk::MenuButton *btnLoad;
Gtk::MenuButton *btnSettings;
Gtk::ButtonBox *btnBoxAboutDialog;
Gtk::Image *HeadBackgroundImage;
Gtk::Image *imgInfo;
Gtk::Box *boxInfoError;
Gtk::Label *lblWarning;
Gtk::Label *generalTabLabel;
Gtk::Label *UsersTabLabel;
Gtk::Label *GroupsTabLabel;
Gtk::Label *generalGroupsSizeLabel;
Gtk::Label *generalGroupsFilesLabel;
Gtk::Label *generalUsersSizeLabel;
Gtk::Label *generalUsersFilesLabel;
Gtk::Label *generalGroupsSizeWeeksLabel;
Gtk::Label *generalGroupsFilesWeeksLabel;
Gtk::Label *generalUsersSizeWeeksLabel;
Gtk::Label *generalUsersFilesWeeksLabel;
Gtk::Label *generalGroupsSizeDaysLabel;
Gtk::Label *generalGroupsFilesDaysLabel;
Gtk::Label *generalUsersSizeDaysLabel;
Gtk::Label *generalUsersFilesDaysLabel;
Gtk::Label *generalGroupsSizeHoursLabel;
Gtk::Label *generalGroupsFilesHoursLabel;
Gtk::Label *generalUsersSizeHoursLabel;
Gtk::Label *generalUsersFilesHoursLabel;
Gtk::Label *generalGroupsSizeMinutesLabel;
Gtk::Label *generalGroupsFilesMinutesLabel;
Gtk::Label *generalUsersSizeMinutesLabel;
Gtk::Label *generalUsersFilesMinutesLabel;
Gtk::Label *ProjectTabLabel;
Gtk::Label *usersProjectLabel;
Gtk::Label *lblLoad;
Gtk::Label *lblSave;
Gtk::MenuItem *btnLoadGlob;
Gtk::MenuItem *btnLoadLocal;
Gtk::MenuItem *btnSynopsis;
Gtk::MenuItem *btnAbout;
Gtk::MenuItem *btnSaveLocalGlob;
Gtk::MenuItem *btnSaveGlob;
Gtk::MenuItem *btnSaveLocal;
Gtk::Label *groupsDeviceLabel;
Gtk::Label *usersDeviceLabel;
Gtk::Label *headLabel;
Gtk::Window *FiltersWindow;
Gtk::CheckButton *filtersNameFilterCheckbox;
Gtk::CheckButton *filtersQuotasFilterCheckbox;
Gtk::CheckButton *filtersSizeFilterCheckbox;
Gtk::CheckButton *filtersSoftSizeFilterCheckbox;
Gtk::CheckButton *filtersHardSizeFilterCheckbox;
Gtk::CheckButton *filtersHardSizeDelayFilterCheckbox;
Gtk::CheckButton *filtersHardSizeActivationFilterCheckbox;
Gtk::CheckButton *filtersFilesFilterCheckbox;
Gtk::CheckButton *filtersSoftFilesFilterCheckbox;
Gtk::CheckButton *filtersHardFilesFilterCheckbox;
Gtk::CheckButton *filtersHardFilesDelayFilterCheckbox;
Gtk::CheckButton *filtersHardFilesActivationFilterCheckbox;
Gtk::TreeView *groupsQuotasTree;
Gtk::TreeView *usersQuotasTree;
Gtk::TreeView *ProjectQuotasTree;
Gtk::TreeView *GeneralQuotasTree;
Gtk::Label *quotegroupDeviceLabel;
Gtk::Label *quotegroupFileSystemLabel;
Gtk::Label *quotegroupDiskQuotasLabel;
Gtk::Label *quotegroupGroupQuotasLabel;
Gtk::Label *quotegroupSizeFrameLabel;
Gtk::Label *quotegroupSizeCurrentlyLabel;
Gtk::Label *quoteSizeHardLimitLabel;
Gtk::Label *quotegroupFilesFrameLabel;
Gtk::Label *quotegroupFilesCurrentlyLabel;
Gtk::Label *quotegroupFilesSoftLimitLabel;
Gtk::Label *quoteFilesHardLimitLabel;
Gtk::Label *quotegroupFilesHarLimitLabel;
Gtk::Label *quoteuserDeviceLabel;
Gtk::Label *quoteuserDiskQuotasLabel;
Gtk::Label *quoteuserFileSystemLabel;
Gtk::Label *quoteuserGroupQuotasLabel;
Gtk::Label *quoteuserSizeFrameLabel;
Gtk::Label *quoteuserSizeCurrentlyLabel;
Gtk::Label *quoteuserSizeSoftLimitLabel;
Gtk::Label *quoteuserSizeHardLimitLabel1;
Gtk::Label *quoteuserFilesCurrentlyLabel;
Gtk::Label *quoteuserFilesSoftLimitLabel;
Gtk::Label *quoteFilesHardLimitLabel1;
Gtk::Label *quoteuserFilesHarLimitLabel;
Gtk::Label *quoteuserFilesFrameLabel;
Gtk::Label *quotegroupSizeSoftLimitLabel;
Gtk::Label *quoteuserFilesSoftLimitlabel;
Gtk::Window *QuotasUserEditWindow;
Gtk::Window *QuotasEditWindow;
Gtk::Label *headerAboutTopic;
Gtk::Label *lblHeadQuotasUserEditWindow;
Gtk::Label *lblHeadQuotasEditWindow;
Gtk::Label *lblHeadFiltersWindow;
Gtk::ComboBoxText *usersDeviceCombo;
Gtk::ComboBoxText *groupsDeviceCombo;
Gtk::ComboBoxText *generalDeviceCombo;
Gtk::Label *lblFstypeGroups;
Gtk::SpinButton *generalGroupsSizeWeeksSpi;
Gtk::SpinButton *generalGroupsFileWeeksSpin;
Gtk::SpinButton *generalGroupsSizeDaySpin;
Gtk::SpinButton *generalGroupsFilesDaySpin;
Gtk::SpinButton *generalGroupsSizeHourSpin;
Gtk::SpinButton *generalGroupsFilesHourSpin;
Gtk::SpinButton *generalGroupsSizeMinuteSpin;
Gtk::SpinButton *generalGroupsFilesMinuteSpin;
Gtk::SpinButton *generalUsersSizWeeksSpin;
Gtk::SpinButton *generalUsersFileWeeksSpin;
Gtk::SpinButton *generalUsersSizeDaySpin;
Gtk::SpinButton *generalUsersFilesDaySpin;
Gtk::SpinButton *generalUsersSizeHourSpin;
Gtk::SpinButton *generalUsersFilesHoursSpin;
Gtk::SpinButton *generalUsersSizeMinuteSpin;
Gtk::SpinButton *generalUsersFilesMinutesSpin;
Gtk::Label *lblEditWndFsys;
Gtk::CheckButton *quotegroupSizeSoftLimitCheck;
Gtk::CheckButton *quotegroupSizeHardLimitCheck;
Gtk::CheckButton *quotegroupFilesSoftLimitCheck;
Gtk::CheckButton *quotegroupFilesHardLimitCheck;
Gtk::SpinButton *quotegroupSizeSoftLimitSpin;
Gtk::SpinButton *quotegroupSizeHardLimitSpin;
Gtk::SpinButton *quotegroupFilesSoftLimitSpin;
Gtk::SpinButton *quotegroupFilesHardLimitSpin;
Gtk::Label *quotegroupFilesSoftLimitlabel;
Gtk::ComboBoxText *quotegroupSizeSoftLimitCombo;
Gtk::ComboBoxText *quotegroupSizeHardLimitCombo;
Gtk::Button *quotegroupCancelButton;
Gtk::Button *quotegroupSaveButton;
Gtk::Button *btnFilterGroups;
Gtk::Button *btnFilterUsers;
Gtk::Button *btnFilterProject;
Gtk::ComboBoxText *quotegroupDeviceCombo;
Gtk::Label *lblHeadeWndWeb;
Gtk::Label *lblwebHeaderName;
Gtk::Label *lblhelpText;
Gtk::Label *lblhelpHeader;
Gtk::CheckButton *chkAlwaysOpenHelp;
Gtk::Button *btnReadHelp;
Gtk::Button *btnCancelHelp;
Gtk::Window *wndShowWeb;
Gtk::CheckMenuItem *chbMangSystemFile;
Gtk::Button* btnDelGroups;
Gtk::Button* btnDelProject;
Gtk::Button* btnDelUsers;
Gtk::Button* btnAddGroups;
Gtk::Button* btnAddUsers;
Gtk::Button* btnAddProject;
#ifdef WEBKIT_FOUND
Gtk::Window *wndWeb;
Gtk::Widget *three;
WebKitWebView *one;
#endif
public:
Lib_save::Save obj_save = Lib_save::Save();
Lib_Load::Load obj_load = Lib_Load::Load();
Devices::Parted obj_device = Devices::Parted();
Quotas_sys::Quotas_sys obj_quotas_sys = Quotas_sys::Quotas_sys();
Quotas_ubconfig::Quotas_ubconfig obj_quotas_ubconfig = Quotas_ubconfig::Quotas_ubconfig();
My_Process::My_Process_system obj_process_system = My_Process::My_Process_system();
My_Process::My_Process_call obj_process_call = My_Process::My_Process_call();
map_str_str map_gui_cfg;
map_str_str map_global_cfg;
map_str_str map_system_cfg;
vector<string> vec_param_names;
map_str_str map_device;
string str_cmd_error;
string save_user_or_group;
string sys_or_ubconfig;
string hw_or_sw = "";
bool flag_open_browser = false;
string mode_quota = "ubconfig";
Glib::RefPtr<Gtk::ListStore> list_store_groups;
Glib::RefPtr<Gtk::ListStore> list_store_users;
Glib::RefPtr<Gtk::ListStore> list_store_project;
Gtk::TreeModel::iterator iter_groups;
Gtk::TreeModel::iterator iter_users;
Gtk::TreeModel::iterator iter_project;
bool flag_validate_del_groups = false;
bool flag_validate_del_users = false;
bool flag_validate_del_project = false;
Gtk::TreeModel::Row row;
const struct tv_g_u_p obj_tv_g_u_p {"", "", "", "", "", "", "", "", "",""};
public:
MainWindow(BaseObjectType* obj, Glib::RefPtr<Gtk::Builder> const& builder);
MainWindow(Glib::RefPtr<Gtk::Builder> const& builder);
~MainWindow();
void settings();
void flag_block_gui();
void lacalization();
void add_CSS();
void get_builder();
void event();
void init_work_tv_g_u_p();
void remove_line_template(const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator& iter, Gtk::TreeModel::iterator& iter_del, bool& flag_del);
void remove_template(Glib::RefPtr<Gtk::ListStore>* list_store, const Gtk::TreeModel::iterator* iter, bool& flag_validate_del);
void init_tree_view_general();
void entry_combo_box_temp(Gtk::ComboBoxText *combo_box, Gtk::Label *label);
void synopsis_show();
void info_status_app(string stule);
void groupsFilters_show();
void init_tree_view();
void template_open_browser();
void open_browser();
void set_add_tv_g_u_p(Gtk::TreeModel::Row &row, Glib::RefPtr<Gtk::ListStore> list_store, struct tv_g_u_p obj_tv_g_u_p);
void load_template(map_str_str* map_temp, string str_load);
void info_warning_error(int mess);
void off_quota_system(Gtk::ComboBoxText* combo_box, string quota_type);
void wrapper_save_system_cfg();
void wrapper_save_global_cfg();
void wrapper_save_all_cfg();
void init_dict(string flag_load);
void set_data_cfg();
void mode_switch_quota();
void save_quotegroupSaveButton();
void wrapper_settings_quotas_temp(string save_user_or_group);
void off_quota_ubconfig(Gtk::ComboBoxText* combo_box, string quota_type);
void init_spin_all();
void format_cmd_quotas_system(struct struct_quotas& _struct_quota);
void format_cmd_quotas_ubconfig(struct struct_quotas& _struct_quota);
void load_global_cfg();
void load_system_cfg();
struct partition_cmd wrapper_settings_quotas();
void filling_device_combo_box_template(Gtk::ComboBoxText *combo_box, map_str_str &map_device);
bool save_template(string section, string flag_save);
void view_add_columns(Gtk::TreeView &treeView);
void check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::ComboBoxText *combo_box);
void check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::Label *combo_box);
};
void help();
#endif

@ -0,0 +1,162 @@
#ifndef VAE_H
#define VAE_H
#include "project_lib.h"
using namespace std;
extern string version_application;
#define name_app _("ubl-settings-diskquota")
#define configuring_system_boot _("Configuring system boot parameters")
#define system_boot _("System boot")
#define str_about _("About ubl-settings-diskquota")
#define command_line_parameters _("Command line parameters:")
#define load_default _("Load default:")
#define seconds _("seconds")
#define download_menu _("Download menu")
#define terminal_for_input _("Terminal for input")
#define terminal_for_output _("Terminal for output")
#define boot_selection_menu_timer _("Boot selection menu timer")
#define str_help _("Help")
#define str_about_1 _("About")
#define str_save_local _("Save")
#define str_load_local _("Load")
#define save_all _("Save in global and local configuration")
#define save_local _("Save in local configuration")
#define save_global _("Save in global configuration")
#define load_global _("Load global configuration")
#define load_local _("Load local configuration")
#define read_online _("Read online")
#define cancel _("Cancel")
#define always_redirect _("Always redirect")
#define boot_screen_display_mode _("Boot screen display mode:")
#define no_loading_animation _("No loading animation, full log")
#define boot_menu_user_name _("Boot menu user name:")
#define boot_menu_user_password _("Boot menu user password:")
#define last_successful_upload _("Last successful upload")
#define read_documentation_web _("Would you like to read documentation in the Web?")
#define redirected_documentation _("You will be redirected to documentation website where documentation is\ntranslated and supported by community.")
#define local_read_error _("Local configuration reading error")
#define global_read_error _("Global configuration read error")
#define local_write_error _("Local configuration write error")
#define global_write_error _("Global configuration write error")
#define error_save_all _("Error saved local and global configuration")
#define local_load_ok _("Local configuration downloaded successfully")
#define global_load_ok _("Global configuration downloaded successfully")
#define local_ok_written _("Local configuration successfully written")
#define global_ok_written _("Global configuration successfully written")
#define successfully_save_all _("Successfully saved local and global configuration")
#define nothing_save _("Nothing to save!")
#define program_as_root _("The program must be run as root")
#define str_weeks _("weeks")
#define str_days _("days")
#define str_hours _("hours")
#define str_minutes _("minutes")
#define str_device _("Device:")
#define str_users _("Users")
#define str_groups _("Groups")
#define str_files _("files")
#define str_hard_limit _("Hard limit")
#define str_file_system _("File system:")
#define str_name _("Name")
#define str_size _("Size")
#define str_quotas_mode _("Direct control of the file system")
#define str_lb_head _("Setting user quotas")
#define str_soft_limit _("Soft limit")
#define str_currently_using _("Currently using:")
#define str_currently_using_space _("Currently using: ")
#define str_filters _("Filters")
#define str_quotas _("Quotas")
#define str_help_h _("GTK settings disk quota for UBLinux\n" \
"\n" \
"Usage: ubl-settings-diskquota [OPTIONS...]\n" \
"Options:\n" \
" -h, --help\t Show this help\n" \
" -V, --version\t Show package version\n" \
" --lock-help Lock utility help\n" \
" --lock-save Lock saving local and global configuration\n" \
" --lock-save-local Lock save global configuration\n" \
" --lock-save-global Lock load global configuration\n" \
" --lock-load-global Lock load global configuration\n")
#define str_user _("User")
#define str_group _("Group")
#define str_projects _("Projects")
#define str_user_1 _("User:")
#define str_group_1 _("Group:")
#define str_project_1 _("Projects:")
#define str_device_project _("Device\nProject")
#define str_quota _("Quota type")
#define str_status _("Status")
#define str_excess_size_delay _("Excess size delay period")
#define str_excess_files_delay _("Excess files delay period")
#define str_disk_quotas_device _("Disk quotas for this device:")
#define str_user_quotas_device _("User quotas for this device: ")
#define str_soft_limit_size _("Soft limit (size)")
#define str_tw_soft_limit _("Soft limit\n(size)")
#define str_hard_limit_size _("Hard limit (size)")
#define str_deferring_hard_limit_size _("Deferring a hard limit (size)")
#define str_hard_activation_size _("Hard limit activation time (size)")
#define str_hard_limit_time _("Hard limit (file) activation time")
#define str_group_quotas_device _("Group quotas for this device:")
#define str_general_settings _("General settings")
#define str_tw_severe_limitation _("Severe\nlimitation\n(size)")
#define str_tw_general_deferring_size _("Deferring\n(size)")
#define str_tw_general_deferring_files _("Deferring\n(files)")
#define str_tw_deferring_size _("Deferring\na hard\nlimit\n(files)")
#define str_tw_deferring_files _("Deferring\na hard\nlimit\n(files)")
#define str_tw_soft_limit_files _("Soft limit\n(files)")
#define str_tw_severe_limitation_files _("Severe\nlimitation\n(files)")
#define str_soft_restriction_files _("Soft Restriction (files)")
#define str_severe_limitation_files _("Severe limitation (files)")
#define str_deferring_limit_files _("Deferring a hard limit (files)")
#define info_box_ok_css "boxInfoMessOK"
#define info_box_error_css "boxInfoMessError"
#define icon_checked "com.ublinux.ubl-settings-diskquota.checked"
#define icon_warning "com.ublinux.ubl-settings-diskquota.warning"
#define str_version _("ubl-settings-diskquota version: ")
#define path_app "/usr/bin/"
#define path_glade "/usr/share/ubl-settings-diskquota/ui/ubl-settings-diskquota.glade"
#define path_css "/usr/share/ubl-settings-diskquota/css/ubl-settings-diskquota.css"
#define app_name "ubl-settings-diskquota"
#define path_resources "/usr/share/ubl-settings-diskquota"
#define path_img_head_background "/usr/share/ubl-settings-diskquota/images/logo-background.png"
#define no_recognized _("Argument not recognized\n")
#define str_device _("Device:")
#define str_quota_status _("Quota use status:")
#define str_size _("Size")
#define str_files _("files")
#define str_currently_using _("Currently using:")
#define str_soft_limit _("Soft limit")
#define str_hard_limit _("Hard limit")
#define str_hard_limit _("Hard limit")
#define str_prefix_KB _("Kb")
#define str_prefix_MB _("Mb")
#define str_prefix_GB _("Gb")
#define str_prefix_TB _("Tb")
#define const_link_doc "https://wiki.ublinux.com/ru/Программное_обеспечениерограммы_и_утилиты/Все/ubl-settings-diskquota"
#define cmd_xdg "xdg-open "
#define cmd_execute "su -l %s -c \" DISPLAY=$DISPLAY %s \""
#define str_name _("Name")
#define str_size _("Size")
#define str_filters _("Filters")
#define str_quotas _("Quotas")
#define str_soft_limit_size _("Soft limit (size)")
#define str_hard_limit_size _("Hard limit (size)")
#define str_hard_limit_size_delay _("Hard limit (size) delay")
#define str_soft_limit_files _("Soft limit (files)")
#define copyright _("Copyright © UBSoft LLC, 2022 - ")
#define str_setting_user _("Setting user quotas")
#define website _("https://wiki.ublinux.com")
#define project_Home_page _("Project Home Page")
#endif

@ -1,21 +1,16 @@
#include "load.h"
namespace Lib_Load{
void Load::set_sections(string sections){
this->sections = sections;
}
void Load::set_count_error(int count_error) {
process.set_count_error(count_error);
}
string Load::get_cmd_error() {
return process.get_cmd_error();
}
map<string, string>& Load::get_load_data(std::map <string, string> &map_temp, string str_flag_load) {
string cmd = "";
map<string, string>& Load::get_load_data(std::map <string, string> &map_temp, string cmd) {
string response = "";
string key = "";
string value = "";
cmd = "ubconfig --default --source " + str_flag_load + " get " + this->sections;
response = process.call_all_sections(cmd);
vector<string> vec_str_key_value = Utils::split(response, '\n');
for (const string &param: vec_str_key_value) {
@ -36,4 +31,4 @@ namespace Lib_Load{
return process.get_count_error();
}
}
}

@ -9,7 +9,6 @@ namespace Lib_Load{
string sections;
My_Process::My_Process_call process = My_Process::My_Process_call();
public:
void set_sections(string sections);
int get_count_error();
void set_count_error(int count_error);
string get_cmd_error();

@ -107,93 +107,45 @@ void Save::save(string sections, string str_flag_save) {
}
}
void Save::save_all(string sections, string str_flag_save) {
void Save::save_one_cmd(string cmd1, string cmd_remove, string str_flag_save) {
string key = "";
string value = "";
string cmd_all = "ubconfig --target " + str_flag_save + " set " + sections;
size_t len_start_cmd_all = cmd_all.length();
string str_error = "";
this->flag_no_save = true;
string cmd = "";
string cmd_remove = "";
this->flag_no_save = true;
cmd = cmd1;
string remove = cmd_remove;
for (const auto &key: *vec_param_names) {
if (map_gui->find(key) != map_gui->end()) {
value = (*map_gui)[key];
if (this->check_save(str_flag_save, key)) {
if (value.length() != 0) {
cmd_all += " " + key + "=\"" + value + "\"";
cmd = cmd + key + "=\"" + value + "\" ";
}
else if (value.length() == 0) {
cmd = "ubconfig --target " + str_flag_save + " remove " + sections + " " + key;
}
else {
cmd = "";
}
if (cmd.length() != 0) {
process.call(cmd, "");
this->flag_no_save = false;
str_error = process.get_cmd_error();
if (str_error.length() != 0) {
this->vec_errors.push_back(str_error);
str_error = "";
}
remove = remove + key + " ";
}
}
}
}
if (len_start_cmd_all != cmd_all.length()) {
process.call(cmd, "");
this->flag_no_save = false;
str_error = process.get_cmd_error();
if (str_error.length() != 0) {
this->vec_errors.push_back(str_error);
str_error = "";
}
if (cmd.length() != cmd1.length()) {
this->template_save(cmd);
}
if (cmd_remove.length() != remove.length()) {
this->template_save(remove);
}
}
void Save::save_all_1(string sections, string str_flag_save) {
string key = "";
string value = "";
string cmd_all = "ubconfig --target " + str_flag_save + " set " + sections;
size_t len_start_cmd_all = cmd_all.length();
void Save::template_save(string cmd) {
string str_error = "";
this->flag_no_save = true;
string cmd = "";
string cmd_remove = "";
for (const auto &iter: (*map_gui)) {
value = iter.second;
key = iter.first;
if (this->check_save(str_flag_save, key)) {
if (value.length() != 0) {
cmd_all += " " + key + "=\"" + value + "\"";
}
else if (value.length() == 0) {
cmd = "ubconfig --target " + str_flag_save + " remove " + sections + " " + key;
}
else {
cmd = "";
}
if (cmd.length() != 0) {
process.call(cmd, "");
this->flag_no_save = false;
str_error = process.get_cmd_error();
if (str_error.length() != 0) {
this->vec_errors.push_back(str_error);
str_error = "";
}
}
}
}
if (len_start_cmd_all != cmd_all.length()) {
process.call(cmd, "");
this->flag_no_save = false;
str_error = process.get_cmd_error();
if (str_error.length() != 0) {
this->vec_errors.push_back(str_error);
str_error = "";
}
process.call(cmd, "");
this->flag_no_save = false;
str_error = process.get_cmd_error();
if (str_error.length() != 0) {
this->vec_errors.push_back(str_error);
str_error = "";
}
}
}

@ -0,0 +1,33 @@
#ifndef MY_SAVE_H
#define MY_SAVE_H
#include "my_process.h"
namespace Lib_save {
class Save {
private:
std::map <string, string> *map_global;
std::map <string, string> *map_local;
std::map <string, string> *map_gui;
vector<string> vec_errors;
vector<string>* vec_param_names;
My_Process::My_Process_system process = My_Process::My_Process_system();
bool flag_no_save;
void template_save(string cmd);
public:
void set_data_global(std::map <string, string> &map_global);
void set_data_local(std::map <string, string> &map_local);
void set_data_gui(std::map <string, string> &map_gui);
bool check_save(string flag_save, string key_name);
bool get_state_save();
void save_one_cmd(string cmd1, string cmd_remove, string str_flag_save);
int get_count_error();
string get_cmd_error();
void set_count_error(int count_error);
void set_vec_params(vector<string>& vec_param_names);
void save(string sections, string str_flag_save) ;
vector<string> get_error();
};
}
#endif

@ -0,0 +1,39 @@
#include "ubconfig_quota.h"
Ubconfig_quota::Ubconfig_quota(/* args */)
{
}
Ubconfig_quota::~Ubconfig_quota()
{
}
void Ubconfig_quota::set_map_global(map_str_str* map_global_cfg) {
this->map_global_cfg = map_global_cfg;
}
void Ubconfig_quota::set_map_local(map_str_str* map_system_cfg) {
this->map_system_cfg = map_system_cfg;
}
void Ubconfig_quota::remove_key_to_vec(string key) {
cout << key << endl;
}
void Ubconfig_quota::add_key_to_vec(string key) {
cout << key << endl;
}
void Ubconfig_quota::set_vec_key(vector<string>* vec_param_names) {
this->vec_param_names = vec_param_names;
}
void Ubconfig_quota::format_data() {
}

@ -0,0 +1,58 @@
#ifndef UBCONFIG_QUOTAS_H
#define UBCONFIG_QUOTAS_H
#include "../../my_type.h"
#include "../../project_lib.h"
class Ubconfig_quota
{
private:
map_str_str* map_gui_cfg = NULL;
map_str_str* map_global_cfg = NULL;
map_str_str* map_system_cfg = NULL;
vector<string>* vec_param_names = NULL;
struct Size {
int size_0;
int size_1;
int size_2;
int size_3;
int size_4;
int size_5;
};
struct User {
bool active;
string device;
vector<string> users;
struct Size obj_size;
};
struct Group {
bool active;
string device;
vector<string> groups;
struct Size obj_size;
};
struct Prjquota {
bool active;
string device;
vector<string> prjquota_name;
struct Size obj_size;
};
struct Quotas {
struct User obj_user;
struct Group obj_group;
struct Prjquota obj_prjquota;
};
public:
Ubconfig_quota(/* args */);
~Ubconfig_quota();
void set_map_gui(map_str_str* map_gui_cfg);
void set_map_global(map_str_str* map_global_cfg);
void set_map_local(map_str_str* map_system_cfg);
void set_vec_key(vector<string>* vec_param_names);
void remove_key_to_vec(string key);
void add_key_to_vec(string key);
void format_data();
};
#endif

@ -146,4 +146,83 @@ string file_read(string filename) {
}
return buffer;
}
unsigned short read_uid_min_max(string filename, string search) {
std::string line;
int uid = 0;
string remove_tab = "\t";
string remove_space = " ";
std::ifstream in(filename); // окрываем файл для чтения
if (in.is_open()){
while (getline(in, line)){
try{
if (line.find(search) != string::npos && (line.find("SYS_"+search) == string::npos)) {
Utils::str_remove(line, search);
Utils::str_remove(line, remove_space);
Utils::str_remove(line, remove_tab);
uid = atoi(line.c_str());
}
}
catch (int x) {
if (search == "UID_MIN"){
uid = 1000;
}
else{
uid = 65534;
}
}
}
}
else{
if (search == "UID_MIN") {
uid = 1000;
}
else{
uid = 65534;
}
}
in.close();
return uid;
}
vector<string> pars_users() {
unsigned short uid_min = Utils::read_uid_min_max(file_source_login_min_max, "UID_MIN");
unsigned short uid_max = Utils::read_uid_min_max(file_source_login_min_max, "UID_MAX");
vector<string> vec_user;
while (true) {
errno = 0;
passwd* entry = getpwent();
if (!entry) {
if (errno) {
break;
}
break;
}
if ((entry->pw_uid >= uid_min && entry->pw_uid < uid_max) || entry->pw_uid == 0) {
vec_user.push_back(entry->pw_name);
}
}
endpwent();
return vec_user;
}
vector<string> pars_group() {
vector<string> vec_group;
while (true) {
errno = 0; // so we can distinguish errors from no more entries
passwd* entry = getpwent();
if (!entry) {
if (errno) {
std::cerr << "Error reading password database\n";
break;
}
break;
}
vec_group.push_back(entry->pw_name);
}
endpwent();
return vec_group;
}
}

@ -1,10 +1,11 @@
#ifndef UTIL_H
#define UTIL_H
#include "project_lib.h"
#include "../../project_lib.h"
using namespace std;
namespace Utils {
#define file_source_login_min_max "/etc/login.defs"
template<typename Type>
struct Result{
Type response;
@ -26,5 +27,8 @@ std::vector<std::string> split(std::string text, char delim);
vector <string> pars_users();
int synopsis_show(string str_link);
string file_read(string filename);
unsigned short read_uid_min_max(string filename, string search);
vector<string> pars_users();
vector<string> pars_group();
}
#endif

@ -0,0 +1,133 @@
#include "wrapper_load_save.h"
Wrapper_load_save::Wrapper_load_save(/* args */) {
//obj_quotas_sys.set_map_gui(map_gui_cfg);
//obj_quotas_ubconfig.set_map_gui(map_gui_cfg);
}
Wrapper_load_save::~Wrapper_load_save()
{
}
void Wrapper_load_save::set_map_gui(map_str_str* map_gui_cfg) {
this->map_gui_cfg = map_gui_cfg;
}
void Wrapper_load_save::set_map_global(map_str_str* map_global_cfg) {
this->map_global_cfg = map_global_cfg;
}
void Wrapper_load_save::set_map_local(map_str_str* map_system_cfg) {
this->map_system_cfg = map_system_cfg;
}
void Wrapper_load_save::set_vec_key(vector<string> vec_param_names) {
this->vec_param_names = vec_param_names;
}
int Wrapper_load_save::load_global_cfg() {
this->load_template(map_global_cfg, global_load);
*map_gui_cfg = *map_global_cfg;
return 1;
}
int Wrapper_load_save::load_system_cfg() {
this->load_template(map_system_cfg, system_load);
*map_gui_cfg = *map_system_cfg;
return 0;
}
void Wrapper_load_save::load_template(map_str_str* map_temp, string cmd) {
if (cmd.find("system") != string::npos) {
this->init_dict("system");
}
else {
this->init_dict("global");
}
*map_temp = obj_load.get_load_data(*map_temp, cmd);
}
int Wrapper_load_save::wrapper_save_global_cfg() {
this->set_data_cfg();
if (this->save_template("boot", "global")) {
*map_global_cfg = *map_gui_cfg;
return 5;
}
else {
*map_global_cfg = *map_gui_cfg;
return 3;
}
}
int Wrapper_load_save::wrapper_save_system_cfg() {
this->set_data_cfg();
if (this->save_template("boot", "system")) {
*map_system_cfg = *map_gui_cfg;
return 5;
}
else {
*map_system_cfg = *map_gui_cfg;
return 2;
}
}
int Wrapper_load_save::wrapper_save_all_cfg() {
this->set_data_cfg();
bool _flag_save_global = this->save_template("boot", "global");;
bool _flag_save_local = this->save_template("boot", "system");
if (_flag_save_global && _flag_save_local) {
*map_global_cfg = *map_gui_cfg;
*map_system_cfg = *map_gui_cfg;
return 5;
}
else {
*map_global_cfg = *map_gui_cfg;
*map_system_cfg = *map_gui_cfg;
return 4;
}
}
int Wrapper_load_save::get_error_load() {
return obj_load.get_count_error();
}
int Wrapper_load_save::get_error_save() {
return obj_save.get_count_error();
}
bool Wrapper_load_save::save_template(string section, string flag_save) {
bool flag_no_save = true;
obj_save.set_data_local(*map_system_cfg);
obj_save.set_data_global(*map_global_cfg);
obj_save.set_data_gui(*map_gui_cfg);
obj_save.set_vec_params(vec_param_names);
obj_save.save(section, flag_save);
vector<string> obj_vec_error = obj_save.get_error();
flag_no_save = obj_save.get_state_save();
return flag_no_save;
}
void Wrapper_load_save::init_dict(string flag_load) {
map_str_str map_gui_cfg_n;
map_gui_cfg_n[""] = "";
*map_gui_cfg = map_gui_cfg_n;
if (flag_load == "global") {
*map_global_cfg = *map_gui_cfg;
}
else if (flag_load == "system") {
*map_system_cfg = *map_gui_cfg;
}
}
void Wrapper_load_save::set_data_cfg() {
// TODO:
// Написать функцию
}

@ -0,0 +1,55 @@
#ifndef WRAPPER_LOAD_SAVE_H
#define WRAPPER_LOAD_SAVE_H
#include "../../my_type.h"
#include "../../project_lib.h"
#include "load.h"
#include "save.h"
#include "my_process.h"
#include "util.h"
#define global_load "ubconfig --default --source global get boot"
#define system_load "ubconfig --default --source system get boot"
#define global_save "ubconfig --target global --noexecute set boot "
#define system_save "ubconfig --target system set boot "
#define all_save "ubconfig set boot "
#define all_remove "ubconfig set/remove boot "
#define global_remove "ubconfig --target global --noexecute set/remove boot "
#define system_remove "ubconfig --target system --noexecute set/remove boot "
class Wrapper_load_save {
private:
string str_cmd_error;
private:
map_str_str* map_gui_cfg = NULL;
map_str_str* map_global_cfg = NULL;
map_str_str* map_system_cfg = NULL;
vector<string> vec_param_names;
My_Process::My_Process_system obj_process_system = My_Process::My_Process_system();
My_Process::My_Process_call obj_process_call = My_Process::My_Process_call();
Lib_save::Save obj_save = Lib_save::Save();
Lib_Load::Load obj_load = Lib_Load::Load();
public:
Wrapper_load_save(/* args */);
~Wrapper_load_save();
int load_global_cfg();
int load_system_cfg();
int wrapper_save_system_cfg();
int wrapper_save_global_cfg();
int wrapper_save_all_cfg();
int get_error_load();
int get_error_save();
void set_map_gui(map_str_str* map_gui_cfg);
void set_map_global(map_str_str* map_global_cfg);
void set_map_local(map_str_str* map_system_cfg);
void set_vec_key(vector<string> vec_param_names);
private:
void load_template(map_str_str* map_temp, string cmd);
void init_dict(string flag_load);
void set_data_cfg();
bool save_template(string section, string flag_save);
};
#endif

@ -0,0 +1,637 @@
#ifndef UBL_SETTINGS_DISKQUOTA_H
#define UBL_SETTINGS_DISKQUOTA_H
#include "ubl-settings-diskquota.h"
string version_application = "1.6";
bool flag_save = false;
bool flag_save_local = false;
bool flag_save_global = false;
bool flag_load_global = false;
bool flag_lock_help = false;
MainWindow::MainWindow(Glib::RefPtr<Gtk::Builder> builder, View_open_browser* obj_open_browser, int* socket_ext_id_I, int* socket_trd_id_I) {
this->builder = builder;
this->socket_ext_id_I = socket_ext_id_I;
this->socket_trd_id_I = socket_trd_id_I;
this->set_obj_browser(obj_open_browser);
// this->settings();
}
void MainWindow::set_map_gui(map_str_str* map_gui_cfg) {
this->map_gui_cfg = map_gui_cfg;
obj_wrapper_load_save->set_map_gui(map_gui_cfg);
}
void MainWindow::set_map_global(map_str_str* map_global_cfg) {
this->map_global_cfg = map_global_cfg;
obj_wrapper_load_save->set_map_global(map_global_cfg);
}
void MainWindow::set_map_local(map_str_str* map_system_cfg) {
this->map_system_cfg = map_system_cfg;
obj_wrapper_load_save->set_map_local(map_system_cfg);
}
void MainWindow::set_obj_wrapper_load_save(Wrapper_load_save* obj_wrapper_load_save) {
this->obj_wrapper_load_save = obj_wrapper_load_save;
}
void MainWindow::set_obj_view_filters(View_filters* obj_view_filters) {
this->obj_view_filters = obj_view_filters;
}
void MainWindow::set_obj_view_add(View_add_user_group* obj_view_add) {
this->obj_view_add = obj_view_add;
}
void MainWindow::set_obj_view_edit(View_edit_user_group* obj_view_edit) {
this->obj_view_edit = obj_view_edit;
}
void MainWindow::set_obj_view_add_project(View_add_project* obj_view_add_project) {
this->obj_view_add_project = obj_view_add_project;
}
void MainWindow::set_obj_view_edit_project(View_edit_project* obj_view_edit_project) {
this->obj_view_edit_project = obj_view_edit_project;
}
void MainWindow::settings() {
this->get_builder();
this->lacalization();
Gtk::Widget *boxWidget;
builder->get_widget("boxColor", boxWidget);
HeadOverlay->add_overlay(*boxWidget);
ubl_make_plugs(boxSave, boxButton, (*socket_ext_id_I), (*socket_trd_id_I));
this->add_CSS();
this->flag_block_gui();
this->init_tree_view();
this->init_spin_all();
if (geteuid() == 0) {
this->wrapper_load_system();
this->wrapper_load_global();
this->event();
}
else {
boxFuncs->set_sensitive(false);
btnSave->set_sensitive(false);
btnLoad->set_sensitive(false);
imgInfo->set_from_icon_name(icon_warning, Gtk::ICON_SIZE_MENU);
info_status_app(info_box_error_css);
lblWarning->set_text(program_as_root);
}
}
void MainWindow::set_obj_browser(View_open_browser* obj_open_browser) {
this->obj_open_browser = obj_open_browser;
obj_open_browser->get_about()->set_version(version_application);
}
void MainWindow::init_spin_all() {
generalGroupsSizeWeeksSpi->set_range(0, 52);
generalGroupsSizeWeeksSpi->set_increments(1.0, 1.0);
generalGroupsSizeWeeksSpi->set_value(0);
generalGroupsFileWeeksSpin->set_range(0, 52);
generalGroupsFileWeeksSpin->set_increments(1.0, 1.0);
generalGroupsFileWeeksSpin->set_value(0);
generalUsersSizWeeksSpin->set_range(0, 52);
generalUsersSizWeeksSpin->set_increments(1.0, 1.0);
generalUsersSizWeeksSpin->set_value(0);
generalUsersFileWeeksSpin->set_range(0, 52);
generalUsersFileWeeksSpin->set_increments(1.0, 1.0);
generalUsersFileWeeksSpin->set_value(0);
generalGroupsSizeDaySpin->set_range(0, 31);
generalGroupsSizeDaySpin->set_increments(1.0, 1.0);
generalGroupsSizeDaySpin->set_value(0);
generalGroupsFilesDaySpin->set_range(0, 31);
generalGroupsFilesDaySpin->set_increments(1.0, 1.0);
generalGroupsFilesDaySpin->set_value(0);
generalUsersSizeDaySpin->set_range(0, 31);
generalUsersSizeDaySpin->set_increments(1.0, 1.0);
generalUsersSizeDaySpin->set_value(0);
generalUsersFilesDaySpin->set_range(0, 31);
generalUsersFilesDaySpin->set_increments(1.0, 1.0);
generalUsersFilesDaySpin->set_value(0);
generalGroupsSizeHourSpin->set_range(0, 23);
generalGroupsSizeHourSpin->set_increments(1.0, 1.0);
generalGroupsSizeHourSpin->set_value(0);
generalGroupsFilesHourSpin->set_range(0, 23);
generalGroupsFilesHourSpin->set_increments(1.0, 1.0);
generalGroupsFilesHourSpin->set_value(0);
generalUsersSizeHourSpin->set_range(0, 23);
generalUsersSizeHourSpin->set_increments(1.0, 1.0);
generalUsersSizeHourSpin->set_value(0);
generalUsersFilesHoursSpin->set_range(0, 23);
generalUsersFilesHoursSpin->set_increments(1.0, 1.0);
generalUsersFilesHoursSpin->set_value(0);
generalGroupsSizeMinuteSpin->set_range(0, 59);
generalGroupsSizeMinuteSpin->set_increments(1.0, 1.0);
generalGroupsSizeMinuteSpin->set_value(0);
generalGroupsFilesMinuteSpin->set_range(0, 59);
generalGroupsFilesMinuteSpin->set_increments(1.0, 1.0);
generalGroupsFilesMinuteSpin->set_value(0);
generalUsersSizeMinuteSpin->set_range(0, 59);
generalUsersSizeMinuteSpin->set_increments(1.0, 1.0);
generalUsersSizeMinuteSpin->set_value(0);
generalUsersFilesMinutesSpin->set_range(0, 59);
generalUsersFilesMinutesSpin->set_increments(1.0, 1.0);
generalUsersFilesMinutesSpin->set_value(0);
}
void MainWindow::init_tree_view() {
this->view_add_columns(*usersQuotasTree);
this->view_add_columns(*groupsQuotasTree);
this->view_add_columns(*ProjectQuotasTree);
this->init_tree_view_general();
}
void MainWindow::init_tree_view_general() {
GeneralQuotasTree->append_column_editable(str_status, m_columnsGeneral.status);
GeneralQuotasTree->append_column(str_quota, m_columnsGeneral.type_quotas);
GeneralQuotasTree->append_column(str_device_project, m_columnsGeneral.device);
GeneralQuotasTree->append_column(str_user, m_columnsGeneral.user);
GeneralQuotasTree->append_column(str_group, m_columnsGeneral.group);
GeneralQuotasTree->append_column(str_projects, m_columnsGeneral.projects);
GeneralQuotasTree->append_column(str_tw_soft_limit, m_columnsGeneral.soft_limit_size);
GeneralQuotasTree->append_column(str_tw_severe_limitation, m_columnsGeneral.hard_limit_size);
GeneralQuotasTree->append_column(str_tw_soft_limit_files, m_columnsGeneral.soft_limit_files);
GeneralQuotasTree->append_column(str_tw_severe_limitation_files, m_columnsGeneral.hard_limit_files);
GeneralQuotasTree->append_column(str_tw_general_deferring_size, m_columnsGeneral.deferring_size);
GeneralQuotasTree->append_column(str_tw_general_deferring_files, m_columnsGeneral.deferring_files);
}
void MainWindow::view_add_columns(Gtk::TreeView &treeView) {
treeView.append_column_editable(str_name, m_columns.name);
treeView.append_column_editable(str_quotas, m_columns.quotas);
treeView.append_column(str_size, m_columns.size);
treeView.append_column(str_tw_soft_limit, m_columns.soft_limit_size);
treeView.append_column(str_tw_severe_limitation, m_columns.hard_limit_size);
treeView.append_column(str_tw_deferring_size, m_columns.deferring_size);
treeView.append_column(str_files, m_columns.files);
treeView.append_column(str_tw_soft_limit_files, m_columns.soft_limit_files);
treeView.append_column(str_tw_severe_limitation_files, m_columns.hard_limit_delay);
treeView.append_column(str_tw_deferring_files, m_columns.deferring_files);
}
void MainWindow::lacalization() {
generalTabLabel->set_text(str_general_settings);
GroupsTabLabel->set_text(str_groups);
headerTopic->set_label(name_app);
UsersTabLabel->set_text(str_users);
generalGroupsFilesLabel->set_text(str_excess_files_delay);
generalUsersSizeLabel->set_text(str_excess_size_delay);
generalUsersFilesLabel->set_text(str_excess_files_delay);
generalGroupsSizeWeeksLabel->set_text(str_weeks);
generalGroupsFilesWeeksLabel->set_text(str_weeks);
generalUsersSizeWeeksLabel->set_text(str_weeks);
generalUsersFilesWeeksLabel->set_text(str_weeks);
generalGroupsSizeDaysLabel->set_text(str_days);
generalGroupsFilesDaysLabel->set_text(str_days);
generalUsersSizeDaysLabel->set_text(str_days);
generalUsersFilesDaysLabel->set_text(str_days);
generalGroupsSizeHoursLabel->set_text(str_hours);
generalGroupsFilesHoursLabel->set_text(str_hours);
generalUsersSizeHoursLabel->set_text(str_hours);
generalUsersFilesHoursLabel->set_text(str_hours);
generalGroupsSizeMinutesLabel->set_text(str_minutes);
generalGroupsFilesMinutesLabel->set_text(str_minutes);
generalUsersSizeMinutesLabel->set_text(str_minutes);
generalUsersFilesMinutesLabel->set_text(str_minutes);
lblLoad->set_text(str_load_local);
lblSave->set_text(str_save_local);
groupsDeviceLabel->set_label(str_device);
usersDeviceLabel->set_label(str_device);
headLabel->set_label(str_lb_head);
btnLoadGlob->set_label(load_global);
btnLoadLocal->set_label(load_local);
btnAbout->set_label(str_about_1);
btnSynopsis->set_label(str_help);
btnSaveLocalGlob->set_label(save_all);
btnSaveGlob->set_label(save_global);
btnSaveLocal->set_label(save_local);
ProjectTabLabel->set_label(str_projects);
usersProjectLabel->set_text(str_device);
chbMangSystemFile->set_label(str_quotas_mode);
}
void MainWindow::info_warning_error(int mess, int error_save, int error_load) {
if (error_save > 0 || error_load > 0) {
info_status_app(info_box_error_css);
imgInfo->set_from_icon_name(icon_warning, Gtk::ICON_SIZE_MENU);
string mess_error = "";
if (mess == 0) {
mess_error = string(local_read_error) + str_cmd_error;
lblWarning->set_text(mess_error);
}
else if (mess == 1) {
mess_error = string(global_read_error) + str_cmd_error;
lblWarning->set_text(mess_error);
}
else if (mess == 2) {
mess_error = string(local_write_error) + str_cmd_error;
lblWarning->set_text(mess_error);
}
else if (mess == 3) {
mess_error = string(global_write_error) + str_cmd_error;
lblWarning->set_text(mess_error);
}
else if (mess == 4) {
mess_error = string(error_save_all) + str_cmd_error;
lblWarning->set_text(mess_error);
}
str_cmd_error = "";
}
else {
info_status_app(info_box_ok_css);
imgInfo->set_from_icon_name(icon_checked, Gtk::ICON_SIZE_MENU);
if (mess == 0) {
lblWarning->set_text(local_load_ok);
}
else if (mess == 1) {
lblWarning->set_text(global_load_ok);
}
else if (mess == 2) {
lblWarning->set_text(local_ok_written);
}
else if (mess == 3) {
lblWarning->set_text(global_ok_written);
}
else if (mess == 4) {
lblWarning->set_text(successfully_save_all);
}
else if (mess == 5) {
lblWarning->set_text(nothing_save);
}
}
}
void MainWindow::filling_device_combo_box_template(Gtk::ComboBoxText *combo_box, map_str_str &map_device) {
if (map_device.size() != 0) {
for (const auto &device : map_device) {
combo_box->append(device.first.c_str());
}
combo_box->set_active(0);
}
}
void MainWindow::flag_block_gui() {
if (flag_load_global == true) {
btnLoadGlob->set_sensitive(false);
}
if (flag_save_local == true && flag_save_global == true) {
btnSave->set_sensitive(false);
}
if (flag_save == true) {
btnSave->set_sensitive(false);
}
if (flag_save_local == true) {
btnSaveLocal->set_sensitive(false);
btnSaveLocalGlob->set_sensitive(false);
}
if (flag_save_global == true) {
btnSaveGlob->set_sensitive(false);
btnSaveLocalGlob->set_sensitive(false);
}
if (flag_lock_help == true) {
btnSynopsis->set_sensitive(false);
}
}
/*
void MainWindow::entry_combo_box_temp(Gtk::ComboBoxText *combo_box, Gtk::Label *label) {
string text = combo_box->get_active_text();
if (map_device.find(text) != map_device.end()){
label->set_text(map_device[text]);
}
}
*/
void MainWindow::add_CSS() {
Glib::RefPtr<Gtk::CssProvider> cssProvider = Gtk::CssProvider::create();
cssProvider->load_from_path(path_css);
Glib::RefPtr<Gtk::StyleContext> styleContext = Gtk::StyleContext::create();
Glib::RefPtr<Gdk::Screen> screen = Gdk::Screen::get_default();//get default screen
styleContext->add_provider_for_screen(screen, cssProvider, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);//add provider for screen in all application
HeadBackgroundImage->set(path_img_head_background);
Glib::RefPtr<Gtk::StyleContext> headLabel_css = headLabel->get_style_context();
Glib::RefPtr<Gtk::StyleContext> boxButton_css = boxButton->get_style_context();
Glib::RefPtr<Gtk::StyleContext> boxSave_css = boxSave->get_style_context();
Glib::RefPtr<Gtk::StyleContext> headerBar_css = headerBar->get_style_context();
if ((*socket_trd_id_I) == 0 && (*socket_ext_id_I) == 0){
boxButton_css->add_class("bkim_no_plug");
boxSave_css->add_class("bkim_no_plug");
}
headLabel_css->add_class("textHead");
}
void MainWindow::get_builder() {
builder->set_translation_domain(path_app);
builder->get_widget("headerTopic", headerTopic);
builder->get_widget("boxButton", boxButton);
builder->get_widget("boxSave", boxSave);
builder->get_widget("HeadOverlay", HeadOverlay);
builder->get_widget("headerBar", headerBar);
builder->get_widget("boxFuncs", boxFuncs);
builder->get_widget("btnLoad", btnLoad);
builder->get_widget("btnSave", btnSave);
builder->get_widget("HeadBackgroundImage", HeadBackgroundImage);
builder->get_widget("imgInfo", imgInfo);
builder->get_widget("lblWarning", lblWarning);
builder->get_widget("boxInfoError", boxInfoError);
builder->get_widget("imgInfo", imgInfo);
builder->get_widget("generalTabLabel", generalTabLabel);
builder->get_widget("GroupsTabLabel", GroupsTabLabel);
builder->get_widget("UsersTabLabel", UsersTabLabel);
builder->get_widget("generalGroupsFilesLabel", generalGroupsFilesLabel);
builder->get_widget("generalUsersSizeLabel", generalUsersSizeLabel);
builder->get_widget("generalUsersFilesLabel", generalUsersFilesLabel);
builder->get_widget("generalGroupsSizeWeeksLabel", generalGroupsSizeWeeksLabel);
builder->get_widget("generalGroupsFilesWeeksLabel", generalGroupsFilesWeeksLabel);
builder->get_widget("generalUsersSizeWeeksLabel", generalUsersSizeWeeksLabel);
builder->get_widget("generalUsersFilesWeeksLabel", generalUsersFilesWeeksLabel);
builder->get_widget("generalGroupsSizeDaysLabel", generalGroupsSizeDaysLabel);
builder->get_widget("generalGroupsFilesDaysLabel", generalGroupsFilesDaysLabel);
builder->get_widget("generalUsersSizeDaysLabel", generalUsersSizeDaysLabel);
builder->get_widget("generalUsersFilesDaysLabel", generalUsersFilesDaysLabel);
builder->get_widget("generalGroupsSizeHoursLabel", generalGroupsSizeHoursLabel);
builder->get_widget("generalGroupsFilesHoursLabel", generalGroupsFilesHoursLabel);
builder->get_widget("generalUsersSizeHoursLabel", generalUsersSizeHoursLabel);
builder->get_widget("generalUsersFilesHoursLabel", generalUsersFilesHoursLabel);
builder->get_widget("generalGroupsSizeMinutesLabel", generalGroupsSizeMinutesLabel);
builder->get_widget("generalGroupsFilesMinutesLabel", generalGroupsFilesMinutesLabel);
builder->get_widget("generalUsersSizeMinutesLabel", generalUsersSizeMinutesLabel);
builder->get_widget("generalUsersFilesMinutesLabel", generalUsersFilesMinutesLabel);
builder->get_widget("lblLoad", lblLoad);
builder->get_widget("lblSave", lblSave);
builder->get_widget("btnSettings", btnSettings);
builder->get_widget("groupsDeviceLabel", groupsDeviceLabel);
builder->get_widget("usersDeviceLabel", usersDeviceLabel);
builder->get_widget("headLabel", headLabel);
builder->get_widget("btnLoadGlob", btnLoadGlob);
builder->get_widget("btnLoadLocal", btnLoadLocal);
builder->get_widget("btnSynopsis", btnSynopsis);
builder->get_widget("btnAbout", btnAbout);
builder->get_widget("btnSaveLocalGlob", btnSaveLocalGlob);
builder->get_widget("btnSaveGlob", btnSaveGlob);
builder->get_widget("btnSaveLocal", btnSaveLocal);
builder->get_widget("GroupsTabLabel", GroupsTabLabel);
builder->get_widget("groupsQuotasTree", groupsQuotasTree);
builder->get_widget("usersQuotasTree", usersQuotasTree);
builder->get_widget("usersDeviceCombo", usersDeviceCombo);
builder->get_widget("GroupsTabLabel", GroupsTabLabel);
builder->get_widget("generalTabLabel", generalTabLabel);
builder->get_widget("groupsDeviceCombo", groupsDeviceCombo);
builder->get_widget("generalGroupsSizeWeeksSpi", generalGroupsSizeWeeksSpi);
builder->get_widget("generalGroupsFileWeeksSpin", generalGroupsFileWeeksSpin);
builder->get_widget("generalGroupsSizeDaySpin", generalGroupsSizeDaySpin);
builder->get_widget("generalGroupsFilesDaySpin", generalGroupsFilesDaySpin);
builder->get_widget("generalGroupsSizeHourSpin", generalGroupsSizeHourSpin);
builder->get_widget("generalGroupsFilesHourSpin", generalGroupsFilesHourSpin);
builder->get_widget("generalGroupsSizeMinuteSpin", generalGroupsSizeMinuteSpin);
builder->get_widget("generalGroupsFilesMinuteSpin", generalGroupsFilesMinuteSpin);
builder->get_widget("generalUsersSizWeeksSpin", generalUsersSizWeeksSpin);
builder->get_widget("generalUsersFileWeeksSpin", generalUsersFileWeeksSpin);
builder->get_widget("generalUsersSizeDaySpin", generalUsersSizeDaySpin);
builder->get_widget("generalUsersFilesDaySpin", generalUsersFilesDaySpin);
builder->get_widget("generalUsersSizeHourSpin", generalUsersSizeHourSpin);
builder->get_widget("generalUsersFilesHoursSpin", generalUsersFilesHoursSpin);
builder->get_widget("generalUsersSizeMinuteSpin", generalUsersSizeMinuteSpin);
builder->get_widget("generalUsersFilesMinutesSpin", generalUsersFilesMinutesSpin);
builder->get_widget("GeneralQuotasTree", GeneralQuotasTree);
builder->get_widget("ProjectQuotasTree", ProjectQuotasTree);
builder->get_widget("ProjectTabLabel", ProjectTabLabel);
builder->get_widget("usersProjectLabel", usersProjectLabel);
builder->get_widget("btnFilterProject", btnFilterProject);
builder->get_widget("btnFilterUsers", btnFilterUsers);
builder->get_widget("btnFilterGroups", btnFilterGroups);
builder->get_widget("chbMangSystemFile", chbMangSystemFile);
builder->get_widget("btnDelGroups", btnDelGroups);
builder->get_widget("btnDelProject", btnDelProject);
builder->get_widget("btnDelUsers", btnDelUsers);
builder->get_widget("btnAddGroups", btnAddGroups);
builder->get_widget("btnAddUsers", btnAddUsers);
builder->get_widget("btnAddProject", btnAddProject);
builder->get_widget("btnEditProject", btnEditProject);
builder->get_widget("btnEditUsers", btnEditUsers);
builder->get_widget("btnEditGroups", btnEditGroups);
builder->get_widget("usersProjectCombo", usersProjectCombo);
builder->get_widget("boxResize", boxResize);
builder->get_widget("boxGroupsWeeks", boxGroupsWeeks);
builder->get_widget("boxGroupsDays", boxGroupsDays);
builder->get_widget("boxGroupsHours", boxGroupsHours);
builder->get_widget("boxGroupsMinutes", boxGroupsMinutes);
builder->get_widget("boxUsersWeeks", boxUsersWeeks);
builder->get_widget("boxUsersDays", boxUsersDays);
builder->get_widget("boxUsersHours", boxUsersHours);
builder->get_widget("boxUsersMinutes", boxUsersMinutes);
builder->get_widget("boxProjectWeeks", boxProjectWeeks);
builder->get_widget("boxProjectDays", boxProjectDays);
builder->get_widget("boxProjectHours", boxProjectHours);
builder->get_widget("boxProjectMinutes", boxProjectMinutes);
}
void MainWindow::open_browser() {
obj_open_browser->open_help();
}
void MainWindow::wrapper_save_system() {
int id_mess = obj_wrapper_load_save->wrapper_save_system_cfg();
int error_save = obj_wrapper_load_save->get_error_save();
int error_load = obj_wrapper_load_save->get_error_load();
this->info_warning_error(id_mess, error_save, error_load);
}
void MainWindow::wrapper_save_global() {
int id_mess = obj_wrapper_load_save->wrapper_save_global_cfg();
int error_save = obj_wrapper_load_save->get_error_save();
int error_load = obj_wrapper_load_save->get_error_load();
this->info_warning_error(id_mess, error_save, error_load);
}
void MainWindow::wrapper_save_all() {
int id_mess = obj_wrapper_load_save->wrapper_save_all_cfg();
int error_save = obj_wrapper_load_save->get_error_save();
int error_load = obj_wrapper_load_save->get_error_load();
this->info_warning_error(id_mess, error_save, error_load);
}
void MainWindow::wrapper_load_system() {
int id_mess = obj_wrapper_load_save->load_system_cfg();
int error_save = obj_wrapper_load_save->get_error_save();
int error_load = obj_wrapper_load_save->get_error_load();
this->info_warning_error(id_mess, error_save, error_load);
this->init_work_tv_g_u_p();
}
void MainWindow::wrapper_load_global() {
int id_mess = obj_wrapper_load_save->load_global_cfg();
int error_save = obj_wrapper_load_save->get_error_save();
int error_load = obj_wrapper_load_save->get_error_load();
this->info_warning_error(id_mess, error_save, error_load);
this->init_work_tv_g_u_p();
}
void MainWindow::event() {
boxResize->signal_check_resize().connect(sigc::mem_fun(*this, &MainWindow::resize_widget));
btnFilterGroups->signal_clicked().connect([&]() {this->filters_show();});
btnFilterUsers->signal_clicked().connect([&]() {this->filters_show();});
btnFilterProject->signal_clicked().connect([&]() {this->filters_show();});
btnSynopsis->signal_activate().connect([&]() {this->open_browser();});
btnAbout->signal_activate().connect([&]() {obj_open_browser->get_about()->aboutWindows->show();});
btnSaveLocalGlob->signal_activate().connect([&]() {this->wrapper_save_all();});
btnSaveGlob->signal_activate().connect([&]() {this->wrapper_save_global();});
btnSaveLocal->signal_activate().connect([&]() {this->wrapper_save_system();});
btnLoadGlob->signal_activate().connect([&]() {this->wrapper_load_global();});
btnLoadLocal->signal_activate().connect([&]() {this->wrapper_load_system();});
btnEditGroups->signal_clicked().connect(sigc::bind<string> (sigc::mem_fun( *this,
&MainWindow::edit_quota_show), str_groups));
btnEditUsers->signal_clicked().connect(sigc::bind<string> (sigc::mem_fun( *this,
&MainWindow::edit_quota_show), str_users));
btnEditProject->signal_clicked().connect([&]() {this->edit_quota_project_show();});
chbMangSystemFile->signal_toggled().connect([&]() {this->mode_switch_quota();});
btnDelGroups->signal_clicked().connect(
sigc::bind<Glib::RefPtr<Gtk::ListStore>*, const Gtk::TreeModel::iterator*, bool&> (sigc::mem_fun( *this,
&MainWindow::remove_template), &list_store_groups, &iter_groups, flag_validate_del_groups));
btnDelUsers->signal_clicked().connect(
sigc::bind<Glib::RefPtr<Gtk::ListStore>*, const Gtk::TreeModel::iterator*, bool&> (sigc::mem_fun( *this,
&MainWindow::remove_template), &list_store_users, &iter_users, flag_validate_del_users));
btnDelProject->signal_clicked().connect(
sigc::bind<Glib::RefPtr<Gtk::ListStore>*, const Gtk::TreeModel::iterator*, bool&> (sigc::mem_fun( *this,
&MainWindow::remove_template), &list_store_project, &iter_project, flag_validate_del_project));
btnAddProject->signal_clicked().connect([&]() {this->obj_view_add_project->show();});
btnAddUsers->signal_clicked().connect(
sigc::bind<string,Gtk::TreeView*, Gtk::TreeModel::Row&, Glib::RefPtr<Gtk::ListStore>&, struct tv_g_u_p> (sigc::mem_fun( *this,
&MainWindow::set_add_tv_g_u_p), str_users, usersQuotasTree, row, list_store_users, obj_tv_g_u_p));
btnAddGroups->signal_clicked().connect(
sigc::bind<string,Gtk::TreeView*, Gtk::TreeModel::Row&, Glib::RefPtr<Gtk::ListStore>&, struct tv_g_u_p> (sigc::mem_fun( *this,
&MainWindow::set_add_tv_g_u_p), str_groups, groupsQuotasTree, row, list_store_groups, obj_tv_g_u_p));
}
void MainWindow::resize_widget() {
// boxGroupsWeeks = boxGroupsWeeks(Gtk::ORIENTATION_HORIZONTAL);
}
void MainWindow::add_quota_show(string name) {
obj_view_add->set_label_type_quota(name);
obj_view_add->show();
}
void MainWindow::edit_quota_show(string name) {
obj_view_edit->set_label_type_quota(name);
obj_view_edit->show();
}
void MainWindow::edit_quota_project_show() {
obj_view_edit_project->show();
}
void MainWindow::remove_template(Glib::RefPtr<Gtk::ListStore>* list_store, const Gtk::TreeModel::iterator* iter, bool& flag_validate_del) {
if (flag_validate_del && (*list_store)->iter_is_valid(*(iter))) {
Gtk::TreeModel::Row row = *(*iter);
if(row) {
// string name = row[m_columns.name] + "";
// TODO: : check
// string key = "GRUB_PASSWORD[" + name + "]";
// map_gui_cfg[key] = "";
}
(*list_store)->erase((*iter));
flag_validate_del = false;
info_status_app(info_box_ok_css);
imgInfo->set_from_icon_name(icon_checked, Gtk::ICON_SIZE_MENU);
// lblWarning->set_text("");
}
flag_validate_del = false;
}
void MainWindow::set_add_tv_g_u_p(string name, Gtk::TreeView* tree_view, Gtk::TreeModel::Row &row, Glib::RefPtr<Gtk::ListStore>& list_store, struct tv_g_u_p obj_tv_g_u_p) {
if (this->check_space(tree_view)) {
row = *(list_store->append());
row[m_columns.name] = obj_tv_g_u_p.name;
row[m_columns.quotas] = obj_tv_g_u_p.quotas;
row[m_columns.size] = obj_tv_g_u_p.size;
row[m_columns.soft_limit_size] = obj_tv_g_u_p.soft_limit_size;
row[m_columns.hard_limit_size] = obj_tv_g_u_p.hard_limit_size;
row[m_columns.deferring_size] = obj_tv_g_u_p.deferring_size;
row[m_columns.files] = obj_tv_g_u_p.files;
row[m_columns.soft_limit_files] = obj_tv_g_u_p.soft_limit_files;
row[m_columns.hard_limit_delay] = obj_tv_g_u_p.hard_limit_delay;
row[m_columns.deferring_files] = obj_tv_g_u_p.deferring_files;
this->add_quota_show(name);
}
}
void MainWindow::mode_switch_quota() {
// Todo: check
if (chbMangSystemFile->get_active()) {
mode_quota = "filesystem";
}
else {
mode_quota = "ubconfig";
}
}
void MainWindow::filters_show() {
obj_view_filters->show();
}
bool MainWindow::check_space(Gtk::TreeView* tree_view) {
Glib::RefPtr<Gtk::TreeModel> tree_view_model = tree_view->get_model();
Gtk::TreeModel::Children children = tree_view_model->children();
string name = "";
string quotas = "";
for(Gtk::TreeModel::iterator iter = children.begin(); iter != children.end(); ++iter) {
Gtk::TreeModel::Row row = *iter;
name = row[m_columns.name] + "";
quotas = row[m_columns.quotas] + "";
if (name.length() == 0 || quotas.length() == 0) {
return false;
}
}
return true;
}
void MainWindow::info_status_app(string stule) {
Glib::RefPtr<Gtk::StyleContext> boxInfo = boxInfoError->get_style_context();
boxInfo->remove_class(info_box_ok_css);
boxInfo->remove_class(info_box_error_css);
boxInfo->add_class(stule);
}
void MainWindow::init_work_tv_g_u_p() {
// Todo: remove
groupsQuotasTree->remove_all_columns();
ProjectQuotasTree->remove_all_columns();
usersQuotasTree->remove_all_columns();
list_store_groups = Gtk::ListStore::create(m_columns);
list_store_project = Gtk::ListStore::create(m_columns);
list_store_users = Gtk::ListStore::create(m_columns);
groupsQuotasTree->set_model(list_store_groups);
ProjectQuotasTree->set_model(list_store_project);
usersQuotasTree->set_model(list_store_users);
Glib::RefPtr<Gtk::TreeModel> groupsQuotasTreeModel = groupsQuotasTree->get_model();
groupsQuotasTreeModel->signal_row_changed().connect(sigc::bind<Gtk::TreeModel::iterator&, bool&>
(sigc::mem_fun(*this, &MainWindow::remove_line_template), iter_groups, flag_validate_del_groups));
Glib::RefPtr<Gtk::TreeModel> ProjectQuotasTreeModel = ProjectQuotasTree->get_model();
ProjectQuotasTreeModel->signal_row_changed().connect(sigc::bind<Gtk::TreeModel::iterator&, bool&>
(sigc::mem_fun(*this, &MainWindow::remove_line_template), iter_project, flag_validate_del_project));
Glib::RefPtr<Gtk::TreeModel> usersQuotasTreeModel = usersQuotasTree->get_model();
usersQuotasTreeModel->signal_row_changed().connect(sigc::bind<Gtk::TreeModel::iterator&, bool&>
(sigc::mem_fun(*this, &MainWindow::remove_line_template),iter_users, flag_validate_del_users));
this->view_add_columns(*groupsQuotasTree);
this->view_add_columns(*ProjectQuotasTree);
this->view_add_columns(*usersQuotasTree);
}
void MainWindow::remove_line_template(const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator& iter, Gtk::TreeModel::iterator& iter_del, bool& flag_del) {
iter_del = iter;
flag_del = true;
}
void help() {
string version = string(str_version) + version_application + "\n";
cout << version.c_str();
cout << str_help_h;
}
MainWindow::~MainWindow() {}
#endif

@ -0,0 +1,273 @@
#ifndef UBL_SETTINGS_QUOTAS_H
#define UBL_SETTINGS_QUOTAS_H
#include <dlfcn.h>
#include "view_open_browser.h"
#include "../project_lib.h"
#include "../my_type.h"
#include "ubl-util-standard.c"
#include "../var.h"
#include "model/wrapper_load_save.h"
#include "view_filters.h"
#include "view_add_user_group.h"
#include "view_edit_user_group.h"
#include "view_add_project.h"
#include "view_edit_project.h"
using namespace std;
extern bool flag_save;
extern bool flag_save_local;
extern bool flag_save_global;
extern bool flag_load_global;
extern bool flag_lock_help;
class MainWindow {
public:
class ModelColumns : public Gtk::TreeModel::ColumnRecord {
public:
ModelColumns() {add(name), add(quotas); add(size),
add(soft_limit_size), add(hard_limit_size); add(deferring_size),
add(files); add(soft_limit_files),
add(hard_limit_delay), add(deferring_files); }
Gtk::TreeModelColumn<Glib::ustring> name;
Gtk::TreeModelColumn<Glib::ustring> quotas;
Gtk::TreeModelColumn<Glib::ustring> size;
Gtk::TreeModelColumn<Glib::ustring> soft_limit_size;
Gtk::TreeModelColumn<Glib::ustring> hard_limit_size;
Gtk::TreeModelColumn<Glib::ustring> deferring_size;
Gtk::TreeModelColumn<Glib::ustring> files;
Gtk::TreeModelColumn<Glib::ustring> soft_limit_files;
Gtk::TreeModelColumn<Glib::ustring> hard_limit_delay;
Gtk::TreeModelColumn<Glib::ustring> deferring_files;
};
class ModelColumnsGeneral : public Gtk::TreeModel::ColumnRecord {
public:
ModelColumnsGeneral() {add(status), add(type_quotas); add(device),
add(user), add(group), add(projects); add(soft_limit_size),
add(hard_limit_size); add(soft_limit_files), add(hard_limit_files), add(deferring_size),
add(deferring_files); }
Gtk::TreeModelColumn<bool> status;
Gtk::TreeModelColumn<Glib::ustring> type_quotas;
Gtk::TreeModelColumn<Glib::ustring> device;
Gtk::TreeModelColumn<Glib::ustring> user;
Gtk::TreeModelColumn<Glib::ustring> group;
Gtk::TreeModelColumn<Glib::ustring> projects;
Gtk::TreeModelColumn<Glib::ustring> soft_limit_size;
Gtk::TreeModelColumn<Glib::ustring> hard_limit_size;
Gtk::TreeModelColumn<Glib::ustring> soft_limit_files;
Gtk::TreeModelColumn<Glib::ustring> hard_limit_files;
Gtk::TreeModelColumn<Glib::ustring> deferring_size;
Gtk::TreeModelColumn<Glib::ustring> deferring_files;
};
ModelColumns m_columns;
ModelColumnsGeneral m_columnsGeneral;
Glib::RefPtr<Gtk::Builder> builder;
template<typename Type>
struct Result{
Type response;
int error;
};
Gtk::Label *headerTopic;
Gtk::Overlay *HeadOverlay;
Gtk::HeaderBar *headerBar;
Gtk::Widget *boxSave;
Gtk::Widget *boxButton;
Gtk::Box *boxFuncs;
Gtk::Box* boxResize;
Gtk::MenuButton *btnSave;
Gtk::MenuButton *btnLoad;
Gtk::MenuButton *btnSettings;
Gtk::Image *HeadBackgroundImage;
Gtk::Image *imgInfo;
Gtk::Box *boxInfoError;
Gtk::Label *lblWarning;
Gtk::Label *generalTabLabel;
Gtk::Label *UsersTabLabel;
Gtk::Label *GroupsTabLabel;
Gtk::Label *generalGroupsFilesLabel;
Gtk::Label *generalUsersSizeLabel;
Gtk::Label *generalUsersFilesLabel;
Gtk::Label *generalGroupsSizeWeeksLabel;
Gtk::Label *generalGroupsFilesWeeksLabel;
Gtk::Label *generalUsersSizeWeeksLabel;
Gtk::Label *generalUsersFilesWeeksLabel;
Gtk::Label *generalGroupsSizeDaysLabel;
Gtk::Label *generalGroupsFilesDaysLabel;
Gtk::Label *generalUsersSizeDaysLabel;
Gtk::Label *generalUsersFilesDaysLabel;
Gtk::Label *generalGroupsSizeHoursLabel;
Gtk::Label *generalGroupsFilesHoursLabel;
Gtk::Label *generalUsersSizeHoursLabel;
Gtk::Label *generalUsersFilesHoursLabel;
Gtk::Label *generalGroupsSizeMinutesLabel;
Gtk::Label *generalGroupsFilesMinutesLabel;
Gtk::Label *generalUsersSizeMinutesLabel;
Gtk::Label *generalUsersFilesMinutesLabel;
Gtk::Label *ProjectTabLabel;
Gtk::Label *usersProjectLabel;
Gtk::Label *lblLoad;
Gtk::Label *lblSave;
Gtk::MenuItem *btnLoadGlob;
Gtk::MenuItem *btnLoadLocal;
Gtk::MenuItem *btnSynopsis;
Gtk::MenuItem *btnAbout;
Gtk::MenuItem *btnSaveLocalGlob;
Gtk::MenuItem *btnSaveGlob;
Gtk::MenuItem *btnSaveLocal;
Gtk::Label *groupsDeviceLabel;
Gtk::Label *usersDeviceLabel;
Gtk::Label *headLabel;
Gtk::TreeView *groupsQuotasTree;
Gtk::TreeView *usersQuotasTree;
Gtk::TreeView *ProjectQuotasTree;
Gtk::TreeView *GeneralQuotasTree;
Gtk::Label *quotegroupGroupQuotasLabel;
Gtk::ComboBoxText *usersDeviceCombo;
Gtk::ComboBoxText *groupsDeviceCombo;
Gtk::ComboBoxText *generalDeviceCombo;
Gtk::ComboBoxText *usersProjectCombo;
Gtk::Label *lblFstypeGroups;
Gtk::SpinButton *generalGroupsSizeWeeksSpi;
Gtk::SpinButton *generalGroupsFileWeeksSpin;
Gtk::SpinButton *generalGroupsSizeDaySpin;
Gtk::SpinButton *generalGroupsFilesDaySpin;
Gtk::SpinButton *generalGroupsSizeHourSpin;
Gtk::SpinButton *generalGroupsFilesHourSpin;
Gtk::SpinButton *generalGroupsSizeMinuteSpin;
Gtk::SpinButton *generalGroupsFilesMinuteSpin;
Gtk::SpinButton *generalUsersSizWeeksSpin;
Gtk::SpinButton *generalUsersFileWeeksSpin;
Gtk::SpinButton *generalUsersSizeDaySpin;
Gtk::SpinButton *generalUsersFilesDaySpin;
Gtk::SpinButton *generalUsersSizeHourSpin;
Gtk::SpinButton *generalUsersFilesHoursSpin;
Gtk::SpinButton *generalUsersSizeMinuteSpin;
Gtk::SpinButton *generalUsersFilesMinutesSpin;
Gtk::Button *btnFilterGroups;
Gtk::Button *btnFilterUsers;
Gtk::Button *btnFilterProject;
Gtk::CheckMenuItem *chbMangSystemFile;
Gtk::Button* btnDelGroups;
Gtk::Button* btnDelProject;
Gtk::Button* btnDelUsers;
Gtk::Button* btnAddGroups;
Gtk::Button* btnAddUsers;
Gtk::Button* btnAddProject;
Gtk::Button* btnEditProject;
Gtk::Button* btnEditUsers;
Gtk::Button* btnEditGroups;
Gtk::Box* boxGroupsWeeks;
Gtk::Box* boxGroupsDays;
Gtk::Box* boxGroupsHours;
Gtk::Box* boxGroupsMinutes;
Gtk::Box* boxUsersWeeks;
Gtk::Box* boxUsersDays;
Gtk::Box* boxUsersHours;
Gtk::Box* boxUsersMinutes;
Gtk::Box* boxProjectWeeks;
Gtk::Box* boxProjectDays;
Gtk::Box* boxProjectHours;
Gtk::Box* boxProjectMinutes;
public:
map_str_str* map_gui_cfg = NULL;
map_str_str* map_global_cfg = NULL;
map_str_str* map_system_cfg = NULL;
Wrapper_load_save* obj_wrapper_load_save = NULL;
View_edit_user_group* obj_view_edit = NULL;
View_filters* obj_view_filters = NULL;
View_add_user_group* obj_view_add = NULL;
View_add_project* obj_view_add_project = NULL;
View_edit_project* obj_view_edit_project = NULL;
//Devices::Parted obj_device = Devices::Parted();
//Quotas_sys::Quotas_sys obj_quotas_sys = Quotas_sys::Quotas_sys();
//Quotas_ubconfig::Quotas_ubconfig obj_quotas_ubconfig = Quotas_ubconfig::Quotas_ubconfig();
vector<string> vec_param_names;
map_str_str map_device;
string str_cmd_error;
string save_user_or_group;
string sys_or_ubconfig;
string hw_or_sw = "";
string mode_quota = "ubconfig";
Glib::RefPtr<Gtk::ListStore> list_store_groups;
Glib::RefPtr<Gtk::ListStore> list_store_users;
Glib::RefPtr<Gtk::ListStore> list_store_project;
Gtk::TreeModel::iterator iter_groups;
Gtk::TreeModel::iterator iter_users;
Gtk::TreeModel::iterator iter_project;
bool flag_validate_del_groups = false;
bool flag_validate_del_users = false;
bool flag_validate_del_project = false;
Gtk::TreeModel::Row row;
int* socket_ext_id_I = NULL;
int* socket_trd_id_I = NULL;
View_open_browser* obj_open_browser;
const struct tv_g_u_p obj_tv_g_u_p {"", "", "", "", "", "", "", "", "",""};
public:
// MainWindow(BaseObjectType* obj, Glib::RefPtr<Gtk::Builder> const& builder);
MainWindow(Glib::RefPtr<Gtk::Builder> builder, View_open_browser* obj_open_browser, int* socket_ext_id_I, int* socket_trd_id_I);
~MainWindow();
void settings();
void flag_block_gui();
void lacalization();
void add_CSS();
void resize_widget();
void get_builder();
void event();
void open_browser();
void info_warning_error(int mess, int error_save, int error_load);
void init_work_tv_g_u_p();
void remove_line_template(const Gtk::TreeModel::Path&, const Gtk::TreeModel::iterator& iter, Gtk::TreeModel::iterator& iter_del, bool& flag_del);
void remove_template(Glib::RefPtr<Gtk::ListStore>* list_store, const Gtk::TreeModel::iterator* iter, bool& flag_validate_del);
void init_tree_view_general();
void entry_combo_box_temp(Gtk::ComboBoxText *combo_box, Gtk::Label *label);
void info_status_app(string stule);
void filters_show();
void set_obj_wrapper_load_save(Wrapper_load_save* obj_wrapper_load_save);
void init_tree_view();
void del_columns();
void set_obj_browser(View_open_browser* obj_open_browser);
void set_add_tv_g_u_p(string name, Gtk::TreeView* tree_view, Gtk::TreeModel::Row &row, Glib::RefPtr<Gtk::ListStore>& list_store, struct tv_g_u_p obj_tv_g_u_p);
void off_quota_system(Gtk::ComboBoxText* combo_box, string quota_type);
void mode_switch_quota();
void save_quotegroupSaveButton();
void filling_device_combo_box_template(Gtk::ComboBoxText *combo_box, map_str_str &map_device);
void wrapper_settings_quotas_temp(string save_user_or_group);
void off_quota_ubconfig(Gtk::ComboBoxText* combo_box, string quota_type);
void init_spin_all();
void view_add_columns(Gtk::TreeView &treeView);
void format_cmd_quotas_system(struct struct_quotas& _struct_quota);
void format_cmd_quotas_ubconfig(struct struct_quotas& _struct_quota);
struct partition_cmd wrapper_settings_quotas();
void set_map_gui(map_str_str* map_gui_cfg);
void set_map_global(map_str_str* map_global_cfg);
void set_map_local(map_str_str* map_system_cfg);
void wrapper_load_system();
void wrapper_load_global();
void wrapper_save_all();
void wrapper_save_system();
void wrapper_save_global();
void set_obj_view_filters(View_filters* obj_view_filters);
bool check_space(Gtk::TreeView* tree_view);
void set_obj_view_add(View_add_user_group* obj_view_edit);
void add_quota_show(string name);
void edit_quota_show(string name);
void set_obj_view_edit(View_edit_user_group* obj_view_edit);
void set_obj_view_add_project(View_add_project* obj_view_add_project);
void set_obj_view_edit_project(View_edit_project* obj_view_edit_project);
void edit_quota_project_show();
};
void wrapper_help_show(GtkWidget *self, char* link, gpointer user_data);
void help();
#endif

@ -0,0 +1,47 @@
#include "view_about.h"
View_about::View_about() {
builder = Gtk::Builder::create_from_file(path_glade);
this->settings();
}
View_about::~View_about() {
}
void View_about::lacalization() {
time_t now = time(0);
tm *ltm = localtime(&now);
unsigned int year = 1900 + ltm->tm_year;
string str_authors = string(copyright) + to_string(year);
aboutWindows->set_copyright(str_authors);
aboutWindows->set_comments(str_setting_user);
aboutWindows->set_website(website);
aboutWindows->set_version(_(version_application.c_str()));
aboutWindows->set_website_label(project_Home_page);
headerAboutTopic->set_label(_(app_name));
}
void View_about::set_version(string version_application) {
version_application = version_application;
}
void View_about::show() {
aboutWindows->show();
}
void View_about::get_builder() {
builder->get_widget("btnBoxAboutDialog", btnBoxAboutDialog);
builder->get_widget("aboutWindows", aboutWindows);
builder->get_widget("headerAboutTopic", headerAboutTopic);
}
void View_about::settings() {
this->get_builder();
this->lacalization();
btnBoxAboutDialog->set_visible(false);
}
View_about* View_about::get_self() {
return this;
}

@ -0,0 +1,29 @@
#ifndef VIEW_ABOUT_H
#define VIEW_ABOUT_H
#include "../project_lib.h"
#include "model/util.h"
#include "../var.h"
class View_about
{
private:
string version_application;
private:
Glib::RefPtr<Gtk::Builder> builder;
Gtk::Label *headerAboutTopic;
Gtk::ButtonBox *btnBoxAboutDialog;
public:
Gtk::AboutDialog *aboutWindows;
public:
View_about();
~View_about();
void lacalization();
void event();
View_about* get_self();
void get_builder();
void settings();
void show();
void set_path_glade(string str_path_glade);
void set_version(string version_application);
};
#endif

@ -0,0 +1,135 @@
#include "view_add_project.h"
View_add_project::View_add_project(/* args */) {
builder = Gtk::Builder::create_from_file(path_glade);
this->setting();
}
View_add_project::~View_add_project()
{
}
void View_add_project::setting() {
this->get_builder();
this->lacalization();
check_limit(quotegroupSizeSoftLimitCheckProject
,quotegroupSizeSoftLimitSpinProject
,quotegroupSizeSoftLimitComboProject);
check_limit(quotegroupSizeHardLimitCheckProject
,quotegroupSizeHardLimitSpin1
,quotegroupSizeHardLimitComboProject);
check_limit(quotegroupFilesSoftLimitCheckProject
,quotegroupFilesSoftLimitSpinProject
,quotegroupFilesSoftLimitlabelProject);
check_limit(quotegroupFilesHardLimitCheckProject
,quotegroupFilesHardLimitSpinProject
,quotegroupFilesHarLimitLabelProject);
this->event();
}
void View_add_project::event() {
quotegroupSizeSoftLimitCheckProject->signal_toggled().connect([&]() {
check_limit(quotegroupSizeSoftLimitCheckProject
,quotegroupSizeSoftLimitSpinProject
,quotegroupSizeSoftLimitComboProject);
});
quotegroupSizeHardLimitCheckProject->signal_toggled().connect([&]() {
check_limit(quotegroupSizeHardLimitCheckProject
,quotegroupSizeHardLimitSpin1
,quotegroupSizeHardLimitComboProject);
});
quotegroupFilesSoftLimitCheckProject->signal_toggled().connect([&]() {
check_limit(quotegroupFilesSoftLimitCheckProject
,quotegroupFilesSoftLimitSpinProject
,quotegroupFilesSoftLimitlabelProject);
});
quotegroupFilesHardLimitCheckProject->signal_toggled().connect([&]() {
check_limit(quotegroupFilesHardLimitCheckProject
,quotegroupFilesHardLimitSpinProject
,quotegroupFilesHarLimitLabelProject);
});
quotegroupCancelButtonAdd->signal_clicked().connect([&]() {this->close_wnd();});
quotegroupSaveButtonAdd->signal_clicked().connect([&]() {this->save();});
}
void View_add_project::close_wnd() {
wndQuotasAddProject->hide();
}
void View_add_project::save() {
wndQuotasAddProject->hide();
}
void View_add_project::show() {
wndQuotasAddProject->show();
}
void View_add_project::get_builder() {
builder->get_widget("wndQuotasAddProject", wndQuotasAddProject);
builder->get_widget("quotegroupSizeFrameLabelProject", quotegroupSizeFrameLabelProject);
builder->get_widget("quotegroupFilesFrameLabelProject", quotegroupFilesFrameLabelProject);
builder->get_widget("quotegroupSizeCurrentlyLabelProject", quotegroupSizeCurrentlyLabelProject);
builder->get_widget("quotegroupFilesCurrentlyLabelProject", quotegroupFilesCurrentlyLabelProject);
builder->get_widget("quotegroupSizeSoftLimitLabelProject", quotegroupSizeSoftLimitLabelProject);
builder->get_widget("quotegroupFilesSoftLimitLabelProject", quotegroupFilesSoftLimitLabelProject);
builder->get_widget("quoteSizeHardLimitLabelProject", quoteSizeHardLimitLabelProject);
builder->get_widget("quoteFilesHardLimitLabelProject", quoteFilesHardLimitLabelProject);
builder->get_widget("quotegroupFilesSoftLimitlabelProject", quotegroupFilesSoftLimitlabelProject);
builder->get_widget("quotegroupFilesHarLimitLabelProject", quotegroupFilesHarLimitLabelProject);
builder->get_widget("quotegroupCancelButtonAdd", quotegroupCancelButtonAdd);
builder->get_widget("quotegroupSaveButtonAdd", quotegroupSaveButtonAdd);
builder->get_widget("lblDeviceProject", lblDeviceProject);
builder->get_widget("lblStatusQuotaProject", lblStatusQuotaProject);
builder->get_widget("lblCatalogProject", lblCatalogProject);
builder->get_widget("lblProjectId", lblProjectId);
builder->get_widget("lblProjectName", lblProjectName);
builder->get_widget("btnReviewProject", btnReviewProject);
builder->get_widget("btnGenerateProject", btnGenerateProject);
builder->get_widget("chbAuto", chbAuto);
builder->get_widget("entryCatalogProject", entryCatalogProject);
builder->get_widget("entryProjectId", entryProjectId);
builder->get_widget("entryProjectName", entryProjectName);
builder->get_widget("quotegroupSizeSoftLimitCheckProject", quotegroupSizeSoftLimitCheckProject);
builder->get_widget("quotegroupSizeHardLimitCheckProject", quotegroupSizeHardLimitCheckProject);
builder->get_widget("quotegroupFilesSoftLimitCheckProject", quotegroupFilesSoftLimitCheckProject);
builder->get_widget("quotegroupFilesHardLimitCheckProject", quotegroupFilesHardLimitCheckProject);
builder->get_widget("quotegroupSizeSoftLimitSpinProject", quotegroupSizeSoftLimitSpinProject);
builder->get_widget("quotegroupSizeHardLimitSpin1", quotegroupSizeHardLimitSpin1);
builder->get_widget("quotegroupFilesSoftLimitSpinProject", quotegroupFilesSoftLimitSpinProject);
builder->get_widget("quotegroupFilesHardLimitSpinProject", quotegroupFilesHardLimitSpinProject);
builder->get_widget("quotegroupSizeSoftLimitComboProject", quotegroupSizeSoftLimitComboProject);
builder->get_widget("quotegroupSizeHardLimitComboProject", quotegroupSizeHardLimitComboProject);
}
void View_add_project::lacalization() {
this->fill_in_pow_memory(quotegroupSizeSoftLimitComboProject);
this->fill_in_pow_memory(quotegroupSizeHardLimitComboProject);
lblDeviceProject->set_text(str_device);
lblStatusQuotaProject->set_text(str_quota_status);
// lblSetUGP->set_text("");
quotegroupSizeFrameLabelProject->set_text(str_size);
quotegroupFilesFrameLabelProject->set_text(str_files);
quotegroupSizeCurrentlyLabelProject->set_text(str_currently_using);
quotegroupFilesCurrentlyLabelProject->set_text(str_currently_using);
quotegroupSizeSoftLimitLabelProject->set_text(str_soft_limit);
quotegroupFilesSoftLimitLabelProject->set_text(str_soft_limit);
quoteSizeHardLimitLabelProject->set_text(str_hard_limit);
quoteFilesHardLimitLabelProject->set_text(str_hard_limit);
}
void View_add_project::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::ComboBoxText *combo_box) {
spin->set_sensitive(check_button->get_active());
combo_box->set_sensitive(check_button->get_active());
}
void View_add_project::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::Label *combo_box) {
spin->set_sensitive(check_button->get_active());
combo_box->set_sensitive(check_button->get_active());
}
void View_add_project::fill_in_pow_memory(Gtk::ComboBoxText *cb_text) {
cb_text->append(str_prefix_KB);
cb_text->append(str_prefix_MB);
cb_text->append(str_prefix_GB);
cb_text->append(str_prefix_TB);
}

@ -0,0 +1,62 @@
#ifndef VIEW_ADD_PROJECT_H
#define VIEW_ADD_PROJECT_H
#include "../project_lib.h"
#include "../var.h"
class View_add_project
{
private:
Glib::RefPtr<Gtk::Builder> builder;
Gtk::Window* wndQuotasAddProject;
Gtk::Label* quotegroupSizeFrameLabelProject;
Gtk::Label* quotegroupFilesFrameLabelProject;
Gtk::Label* quotegroupSizeCurrentlyLabelProject;
Gtk::Label* quotegroupFilesCurrentlyLabelProject;
Gtk::Label* quotegroupSizeSoftLimitLabelProject;
Gtk::Label* quotegroupFilesSoftLimitLabelProject;
Gtk::Label* quoteSizeHardLimitLabelProject;
Gtk::Label* quoteFilesHardLimitLabelProject;
Gtk::Label* quotegroupFilesSoftLimitlabelProject;
Gtk::Label* quotegroupFilesHarLimitLabelProject;
Gtk::Label* lblDeviceProject;
Gtk::Label* lblStatusQuotaProject;
Gtk::Label* lblCatalogProject;
Gtk::Label* lblProjectId;
Gtk::Label* lblProjectName;
Gtk::Button* quotegroupCancelButtonAdd;
Gtk::Button* quotegroupSaveButtonAdd;
Gtk::Button* btnReviewProject;
Gtk::Button* btnGenerateProject;
Gtk::Entry* entryCatalogProject;
Gtk::Entry* entryProjectId;
Gtk::Entry* entryProjectName;
Gtk::CheckButton* chbAuto;
Gtk::CheckButton* quotegroupSizeSoftLimitCheckProject;
Gtk::CheckButton* quotegroupSizeHardLimitCheckProject;
Gtk::CheckButton* quotegroupFilesSoftLimitCheckProject;
Gtk::CheckButton* quotegroupFilesHardLimitCheckProject;
Gtk::SpinButton* quotegroupSizeSoftLimitSpinProject;
Gtk::SpinButton* quotegroupSizeHardLimitSpin1;
Gtk::SpinButton* quotegroupFilesSoftLimitSpinProject;
Gtk::SpinButton* quotegroupFilesHardLimitSpinProject;
Gtk::ComboBoxText* quotegroupSizeSoftLimitComboProject;
Gtk::ComboBoxText* quotegroupSizeHardLimitComboProject;
public:
View_add_project(/* args */);
~View_add_project();
void setting();
void lacalization();
void event();
void show();
void close_wnd();
void save();
void get_builder();
void check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::ComboBoxText *combo_box);
void check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::Label *combo_box);
void fill_in_pow_memory(Gtk::ComboBoxText *cb_text);
};
#endif

@ -0,0 +1,129 @@
#include "view_add_user_group.h"
View_add_user_group::View_add_user_group(/* args */) {
builder = Gtk::Builder::create_from_file(path_glade);
this->settings();
}
View_add_user_group::~View_add_user_group() {
}
void View_add_user_group::settings() {
this->get_builder();
this->lacalization();
check_limit(quotegroupSizeSoftLimitCheck
,quotegroupSizeSoftLimitSpin
,quotegroupSizeSoftLimitCombo);
check_limit(quotegroupSizeHardLimitCheck
,quotegroupSizeHardLimitSpin
,quotegroupSizeHardLimitCombo);
check_limit(quotegroupFilesSoftLimitCheck
,quotegroupFilesSoftLimitSpin
,quotegroupFilesSoftLimitlabel);
check_limit(quotegroupFilesHardLimitCheck
,quotegroupFilesHardLimitSpin
,quotegroupFilesHarLimitLabel);
this->event();
}
void View_add_user_group::event() {
quotegroupCancelButton->signal_clicked().connect([&]() {QuotasEditWindow->hide();});
quotegroupSaveButton->signal_clicked().connect([&]() {});
quotegroupSizeSoftLimitCheck->signal_toggled().connect([&]() {
check_limit(quotegroupSizeSoftLimitCheck
,quotegroupSizeSoftLimitSpin
,quotegroupSizeSoftLimitCombo);
});
quotegroupSizeHardLimitCheck->signal_toggled().connect([&]() {
check_limit(quotegroupSizeHardLimitCheck
,quotegroupSizeHardLimitSpin
,quotegroupSizeHardLimitCombo);
});
quotegroupFilesSoftLimitCheck->signal_toggled().connect([&]() {
check_limit(quotegroupFilesSoftLimitCheck
,quotegroupFilesSoftLimitSpin
,quotegroupFilesSoftLimitlabel);
});
quotegroupFilesHardLimitCheck->signal_toggled().connect([&]() {
check_limit(quotegroupFilesHardLimitCheck
,quotegroupFilesHardLimitSpin
,quotegroupFilesHarLimitLabel);
});
}
void View_add_user_group::get_builder() {
builder->get_widget("lblSetDevice", lblSetDevice);
builder->get_widget("lblQuotasStatus", lblQuotasStatus);
builder->get_widget("lblSetUGP", lblSetUGP);
builder->get_widget("lblSetNameDevice", lblSetNameDevice);
builder->get_widget("lblSetQuotasStatus", lblSetQuotasStatus);
builder->get_widget("cmbSetNameUGP", cmbSetNameUGP);
builder->get_widget("quotegroupSizeFrameLabel", quotegroupSizeFrameLabel);
builder->get_widget("quotegroupFilesFrameLabel", quotegroupFilesFrameLabel);
builder->get_widget("quotegroupSizeCurrentlyLabel", quotegroupSizeCurrentlyLabel);
builder->get_widget("quotegroupFilesCurrentlyLabel", quotegroupFilesCurrentlyLabel);
builder->get_widget("quotegroupSizeSoftLimitLabel", quotegroupSizeSoftLimitLabel);
builder->get_widget("quoteSizeHardLimitLabel", quoteSizeHardLimitLabel);
builder->get_widget("quotegroupFilesSoftLimitLabel", quotegroupFilesSoftLimitLabel);
builder->get_widget("quoteFilesHardLimitLabel", quoteFilesHardLimitLabel);
builder->get_widget("quotegroupFilesHarLimitLabel", quotegroupFilesHarLimitLabel);
builder->get_widget("QuotasEditWindow", QuotasEditWindow);
builder->get_widget("lblHeadQuotasEditWindow", lblHeadQuotasEditWindow);
builder->get_widget("quotegroupCancelButton", quotegroupCancelButton);
builder->get_widget("quotegroupSaveButton", quotegroupSaveButton);
builder->get_widget("quotegroupSizeSoftLimitSpin", quotegroupSizeSoftLimitSpin);
builder->get_widget("quotegroupSizeHardLimitSpin", quotegroupSizeHardLimitSpin);
builder->get_widget("quotegroupFilesSoftLimitSpin", quotegroupFilesSoftLimitSpin);
builder->get_widget("quotegroupFilesHardLimitSpin", quotegroupFilesHardLimitSpin);
builder->get_widget("quotegroupFilesSoftLimitlabel", quotegroupFilesSoftLimitlabel);
builder->get_widget("quotegroupSizeSoftLimitCombo", quotegroupSizeSoftLimitCombo);
builder->get_widget("quotegroupSizeHardLimitCombo", quotegroupSizeHardLimitCombo);
builder->get_widget("quotegroupSizeSoftLimitCheck", quotegroupSizeSoftLimitCheck);
builder->get_widget("quotegroupSizeHardLimitCheck", quotegroupSizeHardLimitCheck);
builder->get_widget("quotegroupFilesSoftLimitCheck", quotegroupFilesSoftLimitCheck);
builder->get_widget("quotegroupFilesHardLimitCheck", quotegroupFilesHardLimitCheck);
}
void View_add_user_group::show() {
QuotasEditWindow->show();
}
void View_add_user_group::lacalization() {
lblSetDevice->set_text(str_device);
lblQuotasStatus->set_text(str_quota_status);
// lblSetUGP->set_text("");
quotegroupSizeFrameLabel->set_text(str_size);
quotegroupFilesFrameLabel->set_text(str_files);
quotegroupSizeCurrentlyLabel->set_text(str_currently_using);
quotegroupSizeSoftLimitLabel->set_text(str_soft_limit);
quoteSizeHardLimitLabel->set_text(str_hard_limit);
quoteFilesHardLimitLabel->set_text(str_hard_limit);
quotegroupFilesSoftLimitLabel->set_text(str_soft_limit);
quotegroupFilesCurrentlyLabel->set_text(str_currently_using);
this->fill_in_pow_memory(quotegroupSizeSoftLimitCombo);
this->fill_in_pow_memory(quotegroupSizeHardLimitCombo);
}
void View_add_user_group::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::ComboBoxText *combo_box) {
spin->set_sensitive(check_button->get_active());
combo_box->set_sensitive(check_button->get_active());
}
void View_add_user_group::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::Label *combo_box) {
spin->set_sensitive(check_button->get_active());
combo_box->set_sensitive(check_button->get_active());
}
void View_add_user_group::fill_in_pow_memory(Gtk::ComboBoxText *cb_text) {
cb_text->append(str_prefix_KB);
cb_text->append(str_prefix_MB);
cb_text->append(str_prefix_GB);
cb_text->append(str_prefix_TB);
}
void View_add_user_group::set_label_type_quota(string name) {
lblSetUGP->set_text(name);
}

@ -0,0 +1,63 @@
#ifndef VIEW_SET_USER_GROUP_H
#define VIEW_SET_USER_GROUP_H
#include "../project_lib.h"
#include "../var.h"
using namespace std;
class View_add_user_group
{
private:
string str_path_glade;
private:
Glib::RefPtr<Gtk::Builder> builder;
Gtk::Label* lblSetDevice;
Gtk::Label* lblQuotasStatus;
Gtk::Label* lblSetUGP;
Gtk::Label* lblSetNameDevice;
Gtk::Label* lblSetQuotasStatus;
Gtk::ComboBoxText* cmbSetNameUGP;
Gtk::Label *quotegroupSizeFrameLabel;
Gtk::Label *quotegroupSizeCurrentlyLabel;
Gtk::Label *quoteSizeHardLimitLabel;
Gtk::Label *quotegroupFilesFrameLabel;
Gtk::Label *quotegroupFilesCurrentlyLabel;
Gtk::Label *quotegroupFilesSoftLimitLabel;
Gtk::Label *quoteFilesHardLimitLabel;
Gtk::Label *quotegroupFilesHarLimitLabel;
Gtk::Label *quotegroupSizeSoftLimitLabel;
Gtk::Window *QuotasEditWindow;
Gtk::Label *lblHeadQuotasEditWindow;
Gtk::Button *quotegroupCancelButton;
Gtk::Button *quotegroupSaveButton;
Gtk::SpinButton *quotegroupSizeSoftLimitSpin;
Gtk::SpinButton *quotegroupSizeHardLimitSpin;
Gtk::SpinButton *quotegroupFilesSoftLimitSpin;
Gtk::SpinButton *quotegroupFilesHardLimitSpin;
Gtk::Label *quotegroupFilesSoftLimitlabel;
Gtk::ComboBoxText *quotegroupSizeSoftLimitCombo;
Gtk::ComboBoxText *quotegroupSizeHardLimitCombo;
Gtk::CheckButton *quotegroupSizeSoftLimitCheck;
Gtk::CheckButton *quotegroupSizeHardLimitCheck;
Gtk::CheckButton *quotegroupFilesSoftLimitCheck;
Gtk::CheckButton *quotegroupFilesHardLimitCheck;
public:
View_add_user_group(/* args */);
~View_add_user_group();
void lacalization();
void event();
void get_builder();
void settings();
void show();
void set_path_glade(string str_path_glade);
void set_label_type_quota(string name);
private:
void set_change_gui(Glib::RefPtr<Gtk::ListStore>* list_store, const Gtk::TreeModel::iterator* iter, bool& flag_validate, Gtk::ComboBoxText *combo_box);
void fill_in_pow_memory(Gtk::ComboBoxText *cb_text);
void check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::ComboBoxText *combo_box);
void check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::Label *combo_box);
void edit_tree_view_U(Glib::RefPtr<Gtk::ListStore>* list_store, const Gtk::TreeModel::iterator* iter, bool& flag_validate);
void edit_tree_view_G(Glib::RefPtr<Gtk::ListStore>* list_store, const Gtk::TreeModel::iterator* iter, bool& flag_validate);
void edit_tree_view_P(Glib::RefPtr<Gtk::ListStore>* list_store, const Gtk::TreeModel::iterator* iter, bool& flag_validate);
};
#endif

@ -0,0 +1,134 @@
#include "view_edit_project.h"
View_edit_project::View_edit_project(/* args */) {
builder = Gtk::Builder::create_from_file(path_glade);
this->setting();
}
View_edit_project::~View_edit_project()
{
}
void View_edit_project::setting() {
this->get_builder();
this->lacalization();
check_limit(quoteSizeSoftLimitCheckProjectEdit
,quoteSizeSoftLimitSpinProjectEdit
,quoteSizeSoftLimitComboProjectEdit);
check_limit(quoteSizeHardLimitCheckProjectEdit
,quoteSizeHardLimitSpinEdit
,quoteSizeHardLimitComboProjectEdit);
check_limit(quoteFilesSoftLimitCheckProjectEdit
,quoteFilesSoftLimitSpinProjectEdit
,quoteFilesProjectEdit);
check_limit(quoteFilesHardLimitCheckProjectEdit
,quoteFilesHardLimitSpinProjectEdit
,quoteFiles1ProjectEdit);
this->event();
}
void View_edit_project::event() {
quoteCancelButtonEdit->signal_clicked().connect([&]() {this->close_wnd();});
quoteSaveButtonEdit->signal_clicked().connect([&]() {this->save();});
quoteSizeSoftLimitCheckProjectEdit->signal_toggled().connect([&]() {
check_limit(quoteSizeSoftLimitCheckProjectEdit
,quoteSizeSoftLimitSpinProjectEdit
,quoteSizeSoftLimitComboProjectEdit);
});
quoteSizeHardLimitCheckProjectEdit->signal_toggled().connect([&]() {
check_limit(quoteSizeHardLimitCheckProjectEdit
,quoteSizeHardLimitSpinEdit
,quoteSizeHardLimitComboProjectEdit);
});
quoteFilesSoftLimitCheckProjectEdit->signal_toggled().connect([&]() {
check_limit(quoteFilesSoftLimitCheckProjectEdit
,quoteFilesSoftLimitSpinProjectEdit
,quoteFilesProjectEdit);
});
quoteFilesSoftLimitCheckProjectEdit->signal_toggled().connect([&]() {
check_limit(quoteFilesSoftLimitCheckProjectEdit
,quoteFilesHardLimitSpinProjectEdit
,quoteFiles1ProjectEdit);
});
}
void View_edit_project::close_wnd() {
wndQuotasEditProject->hide();
}
void View_edit_project::save() {
wndQuotasEditProject->hide();
}
void View_edit_project::show() {
wndQuotasEditProject->show();
}
void View_edit_project::get_builder() {
builder->get_widget("lblDeviceProjectEdit", lblDeviceProjectEdit);
builder->get_widget("lblEditDeviceProjectValue", lblEditDeviceProjectValue);
builder->get_widget("lblStatusQuotaProjectEdit", lblStatusQuotaProjectEdit);
builder->get_widget("lblStatusQuotaProjectValueEdit", lblStatusQuotaProjectValueEdit);
builder->get_widget("lblCatalogProjectEdit", lblCatalogProjectEdit);
builder->get_widget("lblCatalogProjectEdit", lblCatalogProjectEdit);
builder->get_widget("lblProjectIdEdit", lblProjectIdEdit);
builder->get_widget("lblProjectIdValueEdit", lblProjectIdValueEdit);
builder->get_widget("lblProjectNameEdit", lblProjectNameEdit);
builder->get_widget("entryProjectNameEditValue", entryProjectNameEditValue);
builder->get_widget("quoteSizeFrameLabelProjectEdit", quoteSizeFrameLabelProjectEdit);
builder->get_widget("quoteSizeCurrentlyLabelProjectEdit", quoteSizeCurrentlyLabelProjectEdit);
builder->get_widget("quoteSizeSoftLimitLabelProjectEdit", quoteSizeSoftLimitLabelProjectEdit);
builder->get_widget("quoteSizeSoftLimitCheckProjectEdit", quoteSizeSoftLimitCheckProjectEdit);
builder->get_widget("quoteSizeSoftLimitSpinProjectEdit", quoteSizeSoftLimitSpinProjectEdit);
builder->get_widget("quoteSizeSoftLimitComboProjectEdit", quoteSizeSoftLimitComboProjectEdit);
builder->get_widget("quoteSizeHardLimitLabelProjectEdit", quoteSizeHardLimitLabelProjectEdit);
builder->get_widget("quoteSizeHardLimitCheckProjectEdit", quoteSizeHardLimitCheckProjectEdit);
builder->get_widget("quoteSizeHardLimitSpinEdit", quoteSizeHardLimitSpinEdit);
builder->get_widget("quoteSizeHardLimitComboProjectEdit", quoteSizeHardLimitComboProjectEdit);
builder->get_widget("quoteFilesFrameLabelProjectEdit", quoteFilesFrameLabelProjectEdit);
builder->get_widget("quoteFilesCurrentlyLabelProjectEdit", quoteFilesCurrentlyLabelProjectEdit);
builder->get_widget("quoteFilesSoftLimitLabelProjectEdit", quoteFilesSoftLimitLabelProjectEdit);
builder->get_widget("quoteFilesSoftLimitCheckProjectEdit", quoteFilesSoftLimitCheckProjectEdit);
builder->get_widget("quoteFilesSoftLimitSpinProjectEdit", quoteFilesSoftLimitSpinProjectEdit);
builder->get_widget("quoteFilesHardLimitCheckProjectEdit", quoteFilesHardLimitCheckProjectEdit);
builder->get_widget("quoteFilesHardLimitSpinProjectEdit", quoteFilesHardLimitSpinProjectEdit);
builder->get_widget("quoteCancelButtonEdit", quoteCancelButtonEdit);
builder->get_widget("quoteSaveButtonEdit", quoteSaveButtonEdit);
builder->get_widget("quoteFilesProjectEdit", quoteFilesProjectEdit);
builder->get_widget("quoteFiles1ProjectEdit", quoteFiles1ProjectEdit);
builder->get_widget("wndQuotasEditProject", wndQuotasEditProject);
builder->get_widget("quoteFilesHardLimitLabelProject1", quoteFilesHardLimitLabelProject1);
}
void View_edit_project::lacalization() {
lblDeviceProjectEdit->set_text(str_device);
lblStatusQuotaProjectEdit->set_text(str_quota_status);
// lblSetUGP->set_text("");
quoteSizeFrameLabelProjectEdit->set_text(str_size);
quoteFilesFrameLabelProjectEdit->set_text(str_files);
quoteSizeCurrentlyLabelProjectEdit->set_text(str_currently_using);
quoteFilesCurrentlyLabelProjectEdit->set_text(str_currently_using);
quoteSizeSoftLimitLabelProjectEdit->set_text(str_soft_limit);
quoteFilesSoftLimitLabelProjectEdit->set_text(str_soft_limit);
quoteSizeHardLimitLabelProjectEdit->set_text(str_hard_limit);
quoteFilesHardLimitLabelProject1->set_text(str_hard_limit);
this->fill_in_pow_memory(quoteSizeSoftLimitComboProjectEdit);
this->fill_in_pow_memory(quoteSizeHardLimitComboProjectEdit);
}
void View_edit_project::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::ComboBoxText *combo_box) {
spin->set_sensitive(check_button->get_active());
combo_box->set_sensitive(check_button->get_active());
}
void View_edit_project::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::Label *combo_box) {
spin->set_sensitive(check_button->get_active());
combo_box->set_sensitive(check_button->get_active());
}
void View_edit_project::fill_in_pow_memory(Gtk::ComboBoxText *cb_text) {
cb_text->append(str_prefix_KB);
cb_text->append(str_prefix_MB);
cb_text->append(str_prefix_GB);
cb_text->append(str_prefix_TB);
}

@ -0,0 +1,59 @@
#ifndef VIEW_EDIT_PROJECT_H
#define VIEW_EDIT_PROJECT_H
#include "../project_lib.h"
#include "../var.h"
class View_edit_project
{
private:
Glib::RefPtr<Gtk::Builder> builder;
Gtk::Window* wndQuotasEditProject;
Gtk::Label* lblDeviceProjectEdit;
Gtk::Label* lblEditDeviceProjectValue;
Gtk::Label* lblStatusQuotaProjectEdit;
Gtk::Label* lblStatusQuotaProjectValueEdit;
Gtk::Label* lblCatalogProjectEdit;
Gtk::Label* lblProjectIdEdit;
Gtk::Label* lblProjectIdValueEdit;
Gtk::Label* lblProjectNameEdit;
Gtk::Label* quoteSizeFrameLabelProjectEdit;
Gtk::Label* quoteFilesFrameLabelProjectEdit;
Gtk::Label* quoteSizeCurrentlyLabelProjectEdit;
Gtk::Label* quoteSizeSoftLimitLabelProjectEdit;
Gtk::Label* quoteSizeHardLimitLabelProjectEdit;
Gtk::Label* quoteFilesCurrentlyLabelProjectEdit;
Gtk::Label* quoteFilesSoftLimitLabelProjectEdit;
Gtk::Label* quoteFilesHardLimitLabelProject1;
Gtk::Label* quoteFilesProjectEdit;
Gtk::Label* quoteFiles1ProjectEdit;
Gtk::CheckButton* quoteSizeSoftLimitCheckProjectEdit;
Gtk::CheckButton* quoteSizeHardLimitCheckProjectEdit;
Gtk::CheckButton* quoteFilesSoftLimitCheckProjectEdit;
Gtk::CheckButton* quoteFilesHardLimitCheckProjectEdit;
Gtk::SpinButton* quoteSizeSoftLimitSpinProjectEdit;
Gtk::SpinButton* quoteSizeHardLimitSpinEdit;
Gtk::SpinButton* quoteFilesSoftLimitSpinProjectEdit;
Gtk::SpinButton* quoteFilesHardLimitSpinProjectEdit;
Gtk::ComboBoxText* quoteSizeSoftLimitComboProjectEdit;
Gtk::ComboBoxText* quoteSizeHardLimitComboProjectEdit;
Gtk::Button* quoteSaveButtonEdit;
Gtk::Button* quoteCancelButtonEdit;
Gtk::Entry* entryProjectNameEditValue;
public:
View_edit_project(/* args */);
~View_edit_project();
void setting();
void event();
void show();
void get_builder();
void lacalization();
void check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::ComboBoxText *combo_box);
void check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::Label *combo_box);
void fill_in_pow_memory(Gtk::ComboBoxText *cb_text);
void close_wnd();
void save();
};
#endif

@ -0,0 +1,125 @@
#include "view_edit_user_group.h"
View_edit_user_group::View_edit_user_group(/* args */) {
builder = Gtk::Builder::create_from_file(path_glade);
this->setting();
}
View_edit_user_group::~View_edit_user_group()
{
}
void View_edit_user_group::setting() {
this->get_builder();
this->lacalization();
check_limit(quotegroupSizeSoftLimitCheckUser
,quotegroupSizeSoftLimitSpinUser
,quotegroupSizeSoftLimitComboUser);
check_limit(quotegroupSizeHardLimitCheckUser
,quotegroupSizeHardLimitSpinUser
,quotegroupSizeHardLimitComboUser);
check_limit(quotegroupFilesSoftLimitCheckUser
,quotegroupFilesSoftLimitSpinUser
,quotegroupFilesSoftLimitlabelUser);
check_limit(quotegroupFilesHardLimitCheckUser
,quotegroupFilesHardLimitSpinUser
,quotegroupFilesHarLimitLabelUser);
this->event();
}
void View_edit_user_group::event() {
btnCancelEditUser->signal_clicked().connect([&]() {wndQuotasEditUser->hide();});
btnSaveEditUser->signal_clicked().connect([&]() {});
quotegroupSizeSoftLimitCheckUser->signal_toggled().connect([&]() {
check_limit(quotegroupSizeSoftLimitCheckUser
,quotegroupSizeSoftLimitSpinUser
,quotegroupSizeSoftLimitComboUser);
});
quotegroupSizeHardLimitCheckUser->signal_toggled().connect([&]() {
check_limit(quotegroupSizeHardLimitCheckUser
,quotegroupSizeHardLimitSpinUser
,quotegroupSizeHardLimitComboUser);
});
quotegroupFilesSoftLimitCheckUser->signal_toggled().connect([&]() {
check_limit(quotegroupFilesSoftLimitCheckUser
,quotegroupFilesSoftLimitSpinUser
,quotegroupFilesSoftLimitlabelUser);
});
quotegroupFilesHardLimitCheckUser->signal_toggled().connect([&]() {
check_limit(quotegroupFilesHardLimitCheckUser
,quotegroupFilesHardLimitSpinUser
,quotegroupFilesHarLimitLabelUser);
});
}
void View_edit_user_group::get_builder() {
builder->get_widget("wndQuotasEditUser", wndQuotasEditUser);
builder->get_widget("btnCancelEditUser", btnCancelEditUser);
builder->get_widget("btnSaveEditUser", btnSaveEditUser);
builder->get_widget("quotegroupSizeSoftLimitCheckUser", quotegroupSizeSoftLimitCheckUser);
builder->get_widget("quotegroupSizeHardLimitCheckUser", quotegroupSizeHardLimitCheckUser);
builder->get_widget("quotegroupFilesSoftLimitCheckUser", quotegroupFilesSoftLimitCheckUser);
builder->get_widget("quotegroupFilesHardLimitCheckUser", quotegroupFilesHardLimitCheckUser);
builder->get_widget("quotegroupSizeSoftLimitSpinUser", quotegroupSizeSoftLimitSpinUser);
builder->get_widget("quotegroupSizeHardLimitSpinUser", quotegroupSizeHardLimitSpinUser);
builder->get_widget("quotegroupFilesSoftLimitSpinUser", quotegroupFilesSoftLimitSpinUser);
builder->get_widget("quotegroupFilesHardLimitSpinUser", quotegroupFilesHardLimitSpinUser);
builder->get_widget("quotegroupSizeSoftLimitComboUser", quotegroupSizeSoftLimitComboUser);
builder->get_widget("quotegroupSizeHardLimitComboUser", quotegroupSizeHardLimitComboUser);
builder->get_widget("quotegroupFilesSoftLimitlabelUser", quotegroupFilesSoftLimitlabelUser);
builder->get_widget("quotegroupFilesHarLimitLabelUser", quotegroupFilesHarLimitLabelUser);
builder->get_widget("quotegroupSizeSoftLimitLabelUser", quotegroupSizeSoftLimitLabelUser);
builder->get_widget("quotegroupFilesSoftLimitLabelUser", quotegroupFilesSoftLimitLabelUser);
builder->get_widget("quotegroupSizeCurrentlyLabelUser", quotegroupSizeCurrentlyLabelUser);
builder->get_widget("quotegroupFilesCurrentlyLabelUser", quotegroupFilesCurrentlyLabelUser);
builder->get_widget("quotegroupSizeFrameLabelUser", quotegroupSizeFrameLabelUser);
builder->get_widget("quotegroupFilesFrameLabelUser", quotegroupFilesFrameLabelUser);
builder->get_widget("lblSetDeviceUser", lblSetDeviceUser);
builder->get_widget("lblQuotasStatusUser", lblQuotasStatusUser);
builder->get_widget("lblSetUGPUser", lblSetUGPUser);
builder->get_widget("lblSetNameDeviceUser", lblSetNameDeviceUser);
builder->get_widget("lblSetQuotasStatusUser", lblSetQuotasStatusUser);
builder->get_widget("lblSetUGPUserValue", lblSetUGPUserValue);
builder->get_widget("lblHeadQuotasEditWindowUser", lblHeadQuotasEditWindowUser);
builder->get_widget("quoteSizeHardLimitLabel1", quoteSizeHardLimitLabel1);
builder->get_widget("quoteFilesHardLimitLabelUser", quoteFilesHardLimitLabelUser);
}
void View_edit_user_group::lacalization() {
lblSetDeviceUser->set_text(str_device);
lblQuotasStatusUser->set_text(str_quota_status);
quotegroupSizeFrameLabelUser->set_text(str_size);
quotegroupFilesFrameLabelUser->set_text(str_files);
quotegroupSizeCurrentlyLabelUser->set_text(str_currently_using);
quotegroupSizeSoftLimitLabelUser->set_text(str_soft_limit);
quoteSizeHardLimitLabel1->set_text(str_hard_limit);
quoteFilesHardLimitLabelUser->set_text(str_hard_limit);
quotegroupFilesSoftLimitLabelUser->set_text(str_soft_limit);
quotegroupFilesCurrentlyLabelUser->set_text(str_currently_using);
this->fill_in_pow_memory(quotegroupSizeSoftLimitComboUser);
this->fill_in_pow_memory(quotegroupSizeHardLimitComboUser);
}
void View_edit_user_group::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::ComboBoxText *combo_box) {
spin->set_sensitive(check_button->get_active());
combo_box->set_sensitive(check_button->get_active());
}
void View_edit_user_group::check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::Label *combo_box) {
spin->set_sensitive(check_button->get_active());
combo_box->set_sensitive(check_button->get_active());
}
void View_edit_user_group::fill_in_pow_memory(Gtk::ComboBoxText *cb_text) {
cb_text->append(str_prefix_KB);
cb_text->append(str_prefix_MB);
cb_text->append(str_prefix_GB);
cb_text->append(str_prefix_TB);
}
void View_edit_user_group::set_label_type_quota(string name) {
lblSetUGPUser->set_text(name);
}
void View_edit_user_group::show() {
wndQuotasEditUser->show();
}

@ -0,0 +1,61 @@
#ifndef VIEW_ADD_USER_GROUP_H
#define VIEW_ADD_USER_GROUP_H
#include "../project_lib.h"
#include "../var.h"
using namespace std;
class View_edit_user_group
{
private:
Glib::RefPtr<Gtk::Builder> builder;
private:
Gtk::Window* wndQuotasEditUser;
Gtk::Button* btnCancelEditUser;
Gtk::Button* btnSaveEditUser;
Gtk::CheckButton* quotegroupSizeSoftLimitCheckUser;
Gtk::CheckButton* quotegroupSizeHardLimitCheckUser;
Gtk::CheckButton* quotegroupFilesSoftLimitCheckUser;
Gtk::CheckButton* quotegroupFilesHardLimitCheckUser;
Gtk::SpinButton* quotegroupSizeSoftLimitSpinUser;
Gtk::SpinButton* quotegroupSizeHardLimitSpinUser;
Gtk::SpinButton* quotegroupFilesSoftLimitSpinUser;
Gtk::SpinButton* quotegroupFilesHardLimitSpinUser;
Gtk::ComboBoxText* quotegroupSizeSoftLimitComboUser;
Gtk::ComboBoxText* quotegroupSizeHardLimitComboUser;
Gtk::Label* quotegroupFilesSoftLimitlabelUser;
Gtk::Label* quotegroupFilesHarLimitLabelUser;
Gtk::Label* quotegroupSizeSoftLimitLabelUser;
Gtk::Label* quotegroupFilesSoftLimitLabelUser;
Gtk::Label* quotegroupSizeCurrentlyLabelUser;
Gtk::Label* quotegroupFilesCurrentlyLabelUser;
Gtk::Label* quotegroupSizeFrameLabelUser;
Gtk::Label* quotegroupFilesFrameLabelUser;
Gtk::Label* lblSetDeviceUser;
Gtk::Label* lblQuotasStatusUser;
Gtk::Label* lblSetUGPUser;
Gtk::Label* lblSetNameDeviceUser;
Gtk::Label* lblSetQuotasStatusUser;
Gtk::Label* lblSetUGPUserValue;
Gtk::Label* lblHeadQuotasEditWindowUser;
Gtk::Label* quoteSizeHardLimitLabel1;
Gtk::Label* quoteFilesHardLimitLabelUser;
public:
View_edit_user_group(/* args */);
~View_edit_user_group();
void setting();
void event();
void show();
void get_builder();
void check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::ComboBoxText *combo_box);
void check_limit(Gtk::CheckButton *check_button, Gtk::SpinButton *spin, Gtk::Label *combo_box);
void fill_in_pow_memory(Gtk::ComboBoxText *cb_text);
void set_label_type_quota(string name);
void lacalization();
};
#endif

@ -0,0 +1,121 @@
#include "view_filters.h"
View_filters::View_filters(/* args */){
builder = Gtk::Builder::create_from_file(path_glade);
this->settings();
}
View_filters::~View_filters()
{
}
void View_filters::settings() {
this->get_builder();
this->lacalization();
this->set_map_flag(chbFilterName);
this->set_map_flag(chbFilterQuotas);
this->set_map_flag(chbFilterSize);
this->set_map_flag(chbFilterSoftLimitSize);
this->set_map_flag(chbFilterHardLimitSize);
this->set_map_flag(chbFilterHardLimitSizeDelay);
this->set_map_flag(chbFilterFiles);
this->set_map_flag(chbFilterSoftLimitFile);
this->set_map_flag(chbFilterHardLimitFile);
this->set_map_flag(chbFilterHardLimitFileDelay);
this->event();
}
void View_filters::get_builder() {
builder->get_widget("wndFilters", wndFilters);
builder->get_widget("chbFilterName", chbFilterName);
builder->get_widget("chbFilterQuotas", chbFilterQuotas);
builder->get_widget("chbFilterSize", chbFilterSize);
builder->get_widget("chbFilterSoftLimitSize", chbFilterSoftLimitSize);
builder->get_widget("chbFilterHardLimitSize", chbFilterHardLimitSize);
builder->get_widget("chbFilterHardLimitSizeDelay", chbFilterHardLimitSizeDelay);
builder->get_widget("chbFilterFiles", chbFilterFiles);
builder->get_widget("chbFilterSoftLimitFile", chbFilterSoftLimitFile);
builder->get_widget("chbFilterHardLimitFile", chbFilterHardLimitFile);
builder->get_widget("chbFilterHardLimitFileDelay", chbFilterHardLimitFileDelay);
builder->get_widget("lblFiltersHead", lblFiltersHead);
builder->get_widget("btnFiltersSave", btnFiltersSave);
builder->get_widget("btnFiltersCancel", btnFiltersCancel);
lblFiltersHead->set_label(str_filters);
}
void View_filters::show() {
this->set_map_flag_false();
wndFilters->show();
}
void View_filters::lacalization() {
chbFilterName->set_label(str_name);
chbFilterQuotas->set_label(str_quotas);
chbFilterSize->set_label(str_size);
chbFilterSoftLimitSize->set_label(str_soft_limit_size);
chbFilterHardLimitSize->set_label(str_hard_limit_size);
chbFilterHardLimitSizeDelay->set_label(str_deferring_hard_limit_size);
chbFilterFiles->set_label(str_files);
chbFilterSoftLimitFile->set_label(str_soft_restriction_files);
chbFilterHardLimitFile->set_label(str_severe_limitation_files);
chbFilterHardLimitFileDelay->set_label(str_deferring_limit_files);
}
void View_filters::event() {
chbFilterName->signal_toggled().connect(
sigc::bind<Gtk::CheckButton*> (sigc::mem_fun(*this,
&View_filters::set_map_flag), chbFilterName));
chbFilterQuotas->signal_toggled().connect(
sigc::bind<Gtk::CheckButton*> (sigc::mem_fun(*this,
&View_filters::set_map_flag), chbFilterQuotas));
chbFilterSize->signal_toggled().connect(
sigc::bind<Gtk::CheckButton*> (sigc::mem_fun(*this,
&View_filters::set_map_flag), chbFilterSize));
chbFilterSoftLimitSize->signal_toggled().connect(
sigc::bind<Gtk::CheckButton*> (sigc::mem_fun(*this,
&View_filters::set_map_flag), chbFilterSoftLimitSize));
chbFilterHardLimitSize->signal_toggled().connect(
sigc::bind<Gtk::CheckButton*> (sigc::mem_fun(*this,
&View_filters::set_map_flag), chbFilterHardLimitSize));
chbFilterHardLimitSizeDelay->signal_toggled().connect(
sigc::bind<Gtk::CheckButton*> (sigc::mem_fun(*this,
&View_filters::set_map_flag), chbFilterHardLimitSizeDelay));
chbFilterFiles->signal_toggled().connect(
sigc::bind<Gtk::CheckButton*> (sigc::mem_fun(*this,
&View_filters::set_map_flag), chbFilterFiles));
chbFilterSoftLimitFile->signal_toggled().connect(
sigc::bind<Gtk::CheckButton*> (sigc::mem_fun(*this,
&View_filters::set_map_flag), chbFilterSoftLimitFile));
chbFilterHardLimitFile->signal_toggled().connect(
sigc::bind<Gtk::CheckButton*> (sigc::mem_fun(*this,
&View_filters::set_map_flag), chbFilterHardLimitFile));
chbFilterHardLimitFileDelay->signal_toggled().connect(
sigc::bind<Gtk::CheckButton*> (sigc::mem_fun(*this,
&View_filters::set_map_flag), chbFilterHardLimitFileDelay));
btnFiltersSave->signal_clicked().connect(sigc::mem_fun(*this,
&View_filters::btn_save));
btnFiltersCancel->signal_clicked().connect(sigc::mem_fun(*this,
&View_filters::btn_cancel));
}
void View_filters::set_map_flag(Gtk::CheckButton* check_button) {
map_filters_flag[check_button->get_label()] = check_button->get_active();
}
void View_filters::btn_save() {
wndFilters->hide();
}
void View_filters::btn_cancel() {
wndFilters->hide();
}
map<string, bool> View_filters::get_filters() {
return map_filters_flag;
}
void View_filters::set_map_flag_false() {
for (auto& [key, value]: map_filters_flag) {
map_filters_flag[key] = false;
}
}

@ -0,0 +1,46 @@
#ifndef VIEW_FILTERS_H
#define VIEW_FILTERS_H
#include "../project_lib.h"
#include "../var.h"
using namespace std;
class View_filters
{
private:
map<string, bool> map_filters_flag;
private:
Glib::RefPtr<Gtk::Builder> builder;
Gtk::Window *wndFilters;
Gtk::CheckButton *chbFilterName;
Gtk::CheckButton *chbFilterQuotas;
Gtk::CheckButton *chbFilterSize;
Gtk::CheckButton *chbFilterSoftLimitSize;
Gtk::CheckButton *chbFilterHardLimitSize;
Gtk::CheckButton *chbFilterHardLimitSizeDelay;
Gtk::CheckButton *filtersHardSizeActivationFilterCheckbox;
Gtk::CheckButton *chbFilterFiles;
Gtk::CheckButton *chbFilterSoftLimitFile;
Gtk::CheckButton *chbFilterHardLimitFile;
Gtk::CheckButton *chbFilterHardLimitFileDelay;
Gtk::Label *lblFiltersHead;
Gtk::Button *btnFiltersSave;
Gtk::Button *btnFiltersCancel;
public:
View_filters(/* args */);
~View_filters();
void lacalization();
void event();
void get_builder();
void settings();
void show();
private:
void set_map_flag(Gtk::CheckButton* check_button);
void btn_save();
void btn_cancel();
void set_map_flag_false();
map<string, bool> get_filters();
};
#endif

@ -0,0 +1,111 @@
#include "view_open_browser.h"
View_open_browser* obj_open_browser;
View_about* obj_about;
void wrapper_help_show(GtkWidget *self, char* link, gpointer user_data) {
if (self && user_data) {}
obj_open_browser->global_lick_doc = link;
obj_about->aboutWindows->hide();
obj_open_browser->temp_help_show();
}
View_open_browser::View_open_browser(/* args */) {
builder = Gtk::Builder::create_from_file(path_glade);
}
View_open_browser::~View_open_browser() {
}
void View_open_browser::settings() {
obj_open_browser = this;
this->get_builder();
#ifdef WEBKIT_FOUND
one = WEBKIT_WEB_VIEW( webkit_web_view_new() );
three = Glib::wrap(GTK_WIDGET(one));
wndWeb->add(*three);
#endif
this->lacalization();
this->event();
}
void View_open_browser::set_obj_about(View_about* obj_view_about) {
this->obj_view_about = obj_view_about;
obj_about = obj_view_about;
}
void View_open_browser::show() {
this->wndShowWeb->show();
}
void View_open_browser::get_builder() {
#ifdef WEBKIT_FOUND
builder->get_widget("wndWeb", wndWeb);
#endif
builder->get_widget("lblHeadeWndWeb", lblHeadeWndWeb);
builder->get_widget("lblwebHeaderName", lblwebHeaderName);
builder->get_widget("lblhelpText", lblhelpText);
builder->get_widget("lblhelpHeader", lblhelpHeader);
builder->get_widget("chkAlwaysOpenHelp", chkAlwaysOpenHelp);
builder->get_widget("btnReadHelp", btnReadHelp);
builder->get_widget("btnCancelHelp", btnCancelHelp);
builder->get_widget("wndShowWeb", wndShowWeb);
}
void View_open_browser::lacalization() {
lblwebHeaderName->set_label(name_app);
lblhelpText->set_text(redirected_documentation);
btnReadHelp->set_label(read_online);
btnCancelHelp->set_label(cancel);
chkAlwaysOpenHelp->set_label(always_redirect);
lblhelpHeader->set_text(read_documentation_web);
}
void View_open_browser::event() {
g_signal_connect(G_OBJECT(obj_view_about->aboutWindows->gobj()), "activate-link", G_CALLBACK(wrapper_help_show), NULL);
btnCancelHelp->signal_clicked().connect([&]() {wndShowWeb->hide();});
chkAlwaysOpenHelp->signal_toggled().connect([&]() {flag_open_browser = true;});
btnReadHelp->signal_clicked().connect(sigc::mem_fun(*this, &View_open_browser::open_browser));
}
void View_open_browser::temp_help_show() {
if (flag_open_browser == true) {
this->open_browser();
}
else {
wndShowWeb->show_all();
}
}
void View_open_browser::open_browser() {
#ifdef WEBKIT_FOUND
webkit_web_view_load_uri(one, _(global_lick_doc.c_str()));
wndWeb->show_all();
#else
this->template_open_browser(global_lick_doc);
#endif
this->wndShowWeb->hide();
}
int View_open_browser::template_open_browser(string str_link_doc) {
string cmd = cmd_xdg + string(_(str_link_doc.c_str())) + " &";
string buf = "";
if (geteuid() == 0) {
string response_user = getlogin();
int size_s = std::snprintf(nullptr, 0, cmd_execute, response_user.c_str(), cmd.c_str()) + 1;
auto size = static_cast<size_t>(size_s);
std::unique_ptr<char[]> buf(new char[ size ]);
std::snprintf(buf.get(), size, cmd_execute, response_user.c_str(), cmd.c_str());
cmd = string(buf.get(), buf.get() + size - 1);
}
return system(cmd.c_str());
}
void View_open_browser::open_help() {
global_lick_doc = const_link_doc;
temp_help_show();
}
View_about* View_open_browser::get_about() {
return obj_view_about;
}

@ -0,0 +1,50 @@
#ifndef VIEW_OPEN_BROWSER_H
#define VIEW_OPEN_BROWSER_H
#include "../project_lib.h"
#include "view_about.h"
#ifdef WEBKIT_FOUND
#include <webkit2/webkit2.h>
#endif
#include "../var.h"
class View_open_browser {
private:
bool flag_open_browser = false;
View_about* obj_view_about;
private:
Glib::RefPtr<Gtk::Builder> builder;
Gtk::Button *btnReadHelp;
Gtk::Button *btnCancelHelp;
Gtk::CheckButton *chkAlwaysOpenHelp;
Gtk::Label *lblwebHeaderName;
Gtk::Label *lblhelpText;
Gtk::Label *lblhelpHeader;
Gtk::Label *lblHeadeWndWeb;
public:
string global_lick_doc;
Gtk::Window *wndShowWeb;
#ifdef WEBKIT_FOUND
Gtk::Window *wndWeb;
Gtk::Widget *three;
WebKitWebView *one;
#endif
public:
View_open_browser(/* args */);
~View_open_browser();
void lacalization();
void event();
void get_builder();
void settings();
void show();
void open_help();
void temp_help_show();
void set_path_glade(string str_path_glade);
void set_obj_about(View_about* View_about);
View_about* get_about();
private:
int template_open_browser(string str_link_doc);
void open_browser();
};
void wrapper_help_show(GtkWidget *self, char* link, gpointer user_data);
#endif

@ -11,9 +11,6 @@
.bannerbackground {
background-color: #404040;
}
.textHead{
text-shadow: 1px 1px #ffffff;
}
.view_app {
background-color: @theme_bg_color;
}

File diff suppressed because it is too large Load Diff

@ -17,6 +17,65 @@ msgstr ""
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
msgid ""
"You will be redirected to documentation website where documentation is\n"
"translated and supported by community."
msgstr ""
msgid "ubl-settings-diskquota"
msgstr ""
msgid "Settings disk quotas - Addition"
msgstr ""
msgid "Settings disk quotas - Editing"
msgstr ""
msgid "Edit"
msgstr ""
msgid "Project ID"
msgstr ""
msgid "Catalog"
msgstr ""
msgid "Project Name"
msgstr ""
msgid "Auto"
msgstr ""
msgid "Review"
msgstr ""
msgid "Generate"
msgstr ""
msgid "User:"
msgstr ""
msgid "Group:"
msgstr ""
msgid "Projects:"
msgstr ""
msgid "Kb"
msgstr ""
msgid "Mb"
msgstr ""
msgid "Gb"
msgstr ""
msgid "Tb"
msgstr ""
msgid "Quota use status:"
msgstr ""
#: source/ubl-settings-diskquota.cc:224 source/ubl-settings-diskquota.cc:154
#: source/ubl-settings-diskquota.cc:144
msgid "About"

@ -4,7 +4,7 @@
# UBLinux Team <info@ublinux.com>, 2022
#
#, fuzzy
msgid ""
msgid "test"
msgstr ""
"Project-Id-Version: ublexec 1.0\n"
"Report-Msgid-Bugs-To: \n"
@ -15,16 +15,43 @@ msgstr ""
"Language: Russian\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Content-Transfer-Encoding: 8bit"
msgid "ubl-settings-diskquota"
msgstr "Дисковые квоты"
msgid "Settings disk quotas - Addition"
msgstr "Настройка дисковых квот - Добавление"
msgid "Settings disk quotas - Editing"
msgstr "Настройка дисковых квот - Редактирование"
msgid "Edit"
msgstr "Редактировать"
msgid "Kb"
msgstr "Кб"
msgid "Mb"
msgstr "Мб"
msgid "Gb"
msgstr "Гб"
msgid "Tb"
msgstr "Тб"
msgid "Quota use status:"
msgstr "Статус использования квот:"
msgid "Would you like to read documentation in the Web?"
msgstr "Вы хотите прочитать справку в Сети?"
msgid ""
"You will be redirected to documentation site, where user help pages are "
"You will be redirected to documentation website where documentation is\n"
"translated and supported by community."
msgstr ""
"Вы будете перенаправлены на сайт с документацией где страницы помощи "
"Вы будете перенаправлены на сайт с документацией где страницы помощи\n"
"переводятся и поддерживаются сообществом."
msgid "Cancel"
@ -142,12 +169,39 @@ msgstr "Отсрочка жесткого ограничения (объём)"
msgid "Device:"
msgstr "Устройство:"
msgid "Project ID"
msgstr "ID проекта"
msgid "Catalog"
msgstr "Каталог"
msgid "Project Name"
msgstr "Имя проекта"
msgid "Auto"
msgstr "Авто"
msgid "Review"
msgstr "Обзор"
msgid "Generate"
msgstr "Сгенерировать"
msgid "User"
msgstr "Пользователь"
msgid "Group"
msgstr "Группа"
msgid "User:"
msgstr "Пользователь:"
msgid "Group:"
msgstr "Группа:"
msgid "Projects:"
msgstr "Проект:"
msgid "Quota type"
msgstr "Тип квот"
@ -620,9 +674,7 @@ msgstr "Мягкое лимит (файлы)"
#: source/ubl-settings-quotas.cc:150 source/ubl-settings-quotas.cc:155
#, fuzzy
msgid "Soft limit"
msgstr ""
"Мягкий лимит\n"
"(объём)"
msgstr "Мягкий лимит"
#: source/ubl-settings-quotas.cc:322 source/ubl-settings-quotas.cc:326
#: source/ubl-settings-quotas.cc:318 source/ubl-settings-quotas.cc:265

Loading…
Cancel
Save