ublexec/source/ublexec.cc

#include "ublexec.h"
using namespace std;
const string path_app = "/usr/bin/";
const string path_glade = "/usr/share/ublexec/ui/ublexec.glade";
const string path_css = "/usr/share/ublexec/css/style.css";
const string app_name = "ublexec";
int socket_ext_id_I = 0;
int socket_trd_id_I = 0;
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} {
    Glib::OptionEntry socketIDArg;
    socketIDArg.set_long_name("socket-id");
    socketIDArg.set_flags(Glib::OptionEntry::FLAG_IN_MAIN);
    socketIDArg.set_description("Settings manager socket");
    Glib::OptionEntry socketExtId;
    socketExtId.set_long_name("socket-ext-id");
    socketExtId.set_flags(Glib::OptionEntry::FLAG_IN_MAIN);
    socketExtId.set_description("Settings manager secondary socket");
    Glib::OptionEntry socketTrdId;
    socketTrdId.set_long_name("socket-trd-id");
    socketTrdId.set_flags(Glib::OptionEntry::FLAG_IN_MAIN);
    socketTrdId.set_description("Settings manager secondary socket");
    add_entry(socketIDArg, m_socketID);
    add_entry(socketExtId, socket_ext_id_I);
    add_entry(socketTrdId, socket_trd_id_I);
}
::Window CmdArgParser::GetSocketID() const{
    return m_socketID;
}

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::get_builder() {
    builder->get_widget("btnFilemaneg", btnFilemaneg);
    builder->get_widget("btnListApp", btnListApp);
    builder->get_widget("btnStart", btnStart);
    builder->get_widget("chbTerminal", chbTerminal);
    builder->get_widget("chbAnotherUser", chbAnotherUser);
    builder->get_widget("cbxExecuteEpriority", cbxExecuteEpriority);
    builder->get_widget("cmbUser", cmbUser);
    builder->get_widget("spinPriority", spinPriority);
    builder->get_widget("scalePriority", scalePriority);
    builder->get_widget("rbPkexec", rbPkexec);
    builder->get_widget("rbSu", rbSu);
    builder->get_widget("rbSudo", rbSudo);
    builder->get_widget("txtCmd", txtCmd);
    builder->get_widget("wndChooseFileWallpaper", wndChooseFileWallpaper);
    builder->get_widget("btnFilemangerExit", btnFilemangerExit);
    builder->get_widget("btnFilemangerOk", btnFilemangerOk);
    builder->get_widget("lblTimeEpriorityLow", lblTimeEpriorityLow);
    builder->get_widget("lblTime4EpriorityHigh", lblTime4EpriorityHigh);
    builder->get_widget("messageError", messageError);
    builder->get_widget("lblMessageError", lblMessageError);
    builder->get_widget("btnMessageErrorOk", btnMessageErrorOk);
    builder->get_widget("btnMessageErrorOk", btnMessageErrorOk);
    builder->get_widget("btnMessageErrorOk", btnMessageErrorOk);
    builder->get_widget("dialogStartMenu", dialogStartMenu);
    builder->get_widget("btnStartMenuOK", btnStartMenuOK);
    builder->get_widget("btnStartMenuExit", btnStartMenuExit);
    builder->get_widget("lblInfoHead", lblInfoHead);
    builder->get_widget("lblinfoCmd", lblinfoCmd);
    builder->get_widget("lblInfoTime", lblInfoTime);
    builder->get_widget("labInfoExecutTerm", labInfoExecutTerm);
    builder->get_widget("lblInfoUser", lblInfoUser);
    builder->get_widget("lblInfoUserOther", lblInfoUserOther);
    builder->get_widget("lblInfoUserName", lblInfoUserName);
    builder->get_widget("lblInfoNooPriority", lblInfoNooPriority);
    builder->get_widget("lblInfoExec", lblInfoExec);
    builder->get_widget("lblInfoPriority", lblInfoPriority);
    builder->get_widget("boxColor", boxColor);
    builder->get_widget("lblGraphics", lblGraphics);
    builder->get_widget("lblTools", lblTools);
    builder->get_widget("lblInternet", lblInternet);
    builder->get_widget("lblMultimedia", lblMultimedia);
    builder->get_widget("lblSettings", lblSettings);
    builder->get_widget("lblEducation", lblEducation);
    builder->get_widget("lblOffice", lblOffice);
    builder->get_widget("lblOther", lblOther);
    builder->get_widget("lblDevelopment", lblDevelopment);
    builder->get_widget("iconGraphics", iconGraphics);
    builder->get_widget("iconTools", iconTools);
    builder->get_widget("iconInternet", iconInternet);
    builder->get_widget("iconMultimedia", iconMultimedia);
    builder->get_widget("iconSettings", iconSettings);
    builder->get_widget("iconEducation", iconEducation);
    builder->get_widget("iconOffice", iconOffice);
    builder->get_widget("iconOther", iconOther);
    builder->get_widget("iconDevelopment", iconDevelopment);
    builder->get_widget("iconSystem", iconSystem);
    builder->get_widget("lblSystem", lblSystem);
    builder->get_widget("lblHeaderName", lblHeaderName);
    builder->get_widget("btnSynopsis", btnSynopsis);
    builder->get_widget("btnAbout", btnAbout);
    builder->get_widget("aboutWindows", aboutWindows);
    builder->get_widget("btnSettings", btnSettings);
    builder->get_widget("btnBoxAboutDialog", btnBoxAboutDialog);
    builder->get_widget("boxAbout", boxAbout);
    builder->get_widget("cmbTerminal", cmbTerminal);
}

void MainWindow::set_icon_array() {
    array_icon[0] = this->iconGraphics;
    array_icon[1] = this->iconTools;
    array_icon[2] = this->iconInternet;
    array_icon[3] = this->iconMultimedia;
    array_icon[4] = this->iconSettings;
    array_icon[5] = this->iconEducation;
    array_icon[6] = this->iconOffice;
    array_icon[7] = this->iconOther;
    array_icon[8] = this->iconDevelopment;
    array_icon[9] = this->iconSystem;
}

void MainWindow::template_apps_obj(Gtk::IconView *icon, Glib::RefPtr<Gtk::ListStore> &gtk_list_app) {
    gtk_list_app = Gtk::ListStore::create(m_Columns);
    gtk_list_app->set_sort_column(m_Columns.m_col_description, Gtk::SORT_ASCENDING);
    icon->set_model(gtk_list_app);
    icon->set_text_column(m_Columns.m_col_description);
}

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
    Glib::RefPtr<Gtk::StyleContext> context_box = boxColor->get_style_context();
    Glib::RefPtr<Gtk::StyleContext> context_lbl_head = lblInfoHead->get_style_context();
    context_box->add_class("cssboxColor1");
    context_lbl_head->add_class("textHead");
}

void MainWindow::localization() {
    time_t now = time(0);
    tm *ltm = localtime(&now);
    unsigned int year= 1900+ ltm->tm_year;
    string str_authors = string(_("Copyright © UBSoft LLC, 2022 - ")) + to_string(year); 
    aboutWindows->set_copyright(str_authors);
    aboutWindows->set_website(_("https://wiki.ublinux.com"));
    btnSynopsis->set_label(_("Help"));
    btnAbout->set_label(_("About"));
    aboutWindows->set_comments(_("ublexec"));
    aboutWindows->set_website_label(_("Project Home Page"));
    aboutWindows->set_version(_(version_application.c_str()));
    lblHeaderName->set_text(_("ublexec"));
    this->set_title(_("ublexec"));
    btnStart->set_label(_("Run"));
    wndChooseFileWallpaper->set_title(_("Please select File"));
    dialogStartMenu->set_title(_("Selecting Programs"));
    lblInfoHead->set_text(_("Running applications as a user with a\nspecified priority"));
    lblinfoCmd->set_text(_("Command Line"));
    lblInfoTime->set_text(_("Team:"));
    labInfoExecutTerm->set_text(_("Run in the terminal emulator"));
    lblInfoUser->set_text(_("User"));
    lblInfoUserOther->set_text(_("Run as another user:"));
    lblInfoUserName->set_text(_("User Name:"));
    lblInfoNooPriority->set_text(_("Priority"));
    lblInfoExec->set_text(_("Change startup priority"));
    lblInfoPriority->set_text(_("Priority:"));
    lblMessageError->set_text(_("Select an executable file or program"));
    lblGraphics->set_text(_("Graphics"));
    lblTools->set_text(_("Tools"));
    lblInternet->set_text(_("Internet"));
    lblMultimedia->set_text(_("Multimedia"));
    lblSettings->set_text(_("Settings"));
    lblEducation->set_text(_("Education"));
    lblOffice->set_text(_("Office"));
    lblOther->set_text(_("Other"));
    lblDevelopment->set_text(_("Development"));
    lblSystem->set_text(_("System"));

}

void MainWindow::event() {
    btnFilemaneg->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::open_filemaneg));
    btnListApp->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::open_list_app));
    btnStart->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::entry_app));
    chbTerminal->signal_toggled().connect([&]() {cmbTerminal->set_sensitive(chbTerminal->get_active());this->denamic_cmd();});
    chbAnotherUser->signal_toggled().connect(sigc::mem_fun(*this, &MainWindow::activ_or_block_other_user));
    spinPriority->signal_value_changed().connect(sigc::mem_fun(*this, &MainWindow::change_scale_priority));
    scalePriority->signal_value_changed().connect(sigc::mem_fun(*this, &MainWindow::change_spin_priority));
    btnFilemangerExit->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::close_filemaneg));
    btnFilemangerOk->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::get_path_filemaneg));
    cbxExecuteEpriority->signal_toggled().connect(sigc::mem_fun(*this, &MainWindow::activ_or_block_execute_epriority));
    btnMessageErrorOk->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::message_gui_close));
    btnStartMenuOK->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::start_menu_entry_app));
    btnStartMenuExit->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::close_entry_app));
    btnStartMenuOK->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::ok_close_entry_app));
    iconGraphics->signal_selection_changed().connect(sigc::mem_fun(*this,&MainWindow::select_Graphics));
    iconTools->signal_selection_changed().connect(sigc::mem_fun(*this,&MainWindow::select_Tools));
    iconInternet->signal_selection_changed().connect(sigc::mem_fun(*this,&MainWindow::select_Internet));
    iconMultimedia->signal_selection_changed().connect(sigc::mem_fun(*this,&MainWindow::select_Multimedia));
    iconSettings->signal_selection_changed().connect(sigc::mem_fun(*this,&MainWindow::select_Settings));
    iconEducation->signal_selection_changed().connect(sigc::mem_fun(*this,&MainWindow::select_Education));
    iconOffice->signal_selection_changed().connect(sigc::mem_fun(*this,&MainWindow::select_Office));
    iconOther->signal_selection_changed().connect(sigc::mem_fun(*this,&MainWindow::select_Other));
    iconDevelopment->signal_selection_changed().connect(sigc::mem_fun(*this,&MainWindow::select_Development));
    iconSystem->signal_selection_changed().connect(sigc::mem_fun(*this,&MainWindow::select_System));
    btnSynopsis->signal_activate().connect(sigc::mem_fun(*this, &MainWindow::synopsis_show));
    btnAbout->signal_activate().connect([&]() {aboutWindows->show();});
    cmbUser->signal_changed().connect([&]() {changed_user();denamic_cmd();});
    rbSudo->signal_toggled().connect(sigc::mem_fun(*this, &MainWindow::sudo_nice));
    txtCmd->signal_focus_out_event().connect(sigc::mem_fun(*this, &MainWindow::focus_out_txt_cmd));
    txtCmd->signal_focus_in_event().connect(sigc::mem_fun(*this, &MainWindow::focus_in_txt_cmd));
    txtCmd->signal_delete_text().connect(sigc::mem_fun(*this, &MainWindow::delete_cmd));
    rbSu->signal_toggled().connect(sigc::mem_fun(*this, &MainWindow::sudo_nice));
    rbPkexec->signal_toggled().connect(sigc::mem_fun(*this, &MainWindow::sudo_nice));
}


void MainWindow::sudo_nice(){
    string response = this->call("id -Gn"); 
    if (geteuid() == 0 || cmbUser->get_active_text() == "root" ){
        spinPriority->set_range(-20, 19);
        spinPriority->set_increments(1.0, -1.0);
        scalePriority->set_range(-20, 19);
        scalePriority->set_value(0);
        lblTimeEpriorityLow->set_text(_("19 (Low)"));
        lblTime4EpriorityHigh->set_text(_("-20 (High)"));
    }
    else if (rbSudo->get_active() && response.find("wheel") != string::npos){
        spinPriority->set_range(-20, 19);
        spinPriority->set_increments(1.0, -1.0);
        scalePriority->set_range(-20, 19);
        scalePriority->set_value(0);
        lblTimeEpriorityLow->set_text(_("19 (Low)"));
        lblTime4EpriorityHigh->set_text(_("-20 (High)"));
    }
    else if (rbSu->get_active()){
        spinPriority->set_range(0, 19);
        spinPriority->set_increments(1.0, -1.0);
        scalePriority->set_range(0, 19);
        scalePriority->set_value(0);
        lblTimeEpriorityLow->set_text(_("19 (Low)"));
        lblTime4EpriorityHigh->set_text(_("0 (High)"));
    }
    else if (rbPkexec->get_active()){
        spinPriority->set_range(0, 19);
        spinPriority->set_increments(1.0, -1.0);
        scalePriority->set_range(0, 19);
        scalePriority->set_value(0);
        lblTimeEpriorityLow->set_text(_("19 (Low)"));
        lblTime4EpriorityHigh->set_text(_("0 (High)"));
    }
    this->denamic_cmd();
}

void MainWindow::changed_user() {
    Glib::ustring entry_user = cmbUser->get_active_text();
    string response = this->call("id -Gn"); 
    bool flag_wheel_sudo = (rbSudo->get_active()==true && response.find("wheel") != string::npos);
    if (geteuid() == 0 || entry_user == "root" || flag_wheel_sudo==true) {
        spinPriority->set_range(-20, 19);
        spinPriority->set_increments(1.0, -1.0);
        scalePriority->set_range(-20, 19);
        scalePriority->set_value(0);
        lblTimeEpriorityLow->set_text(_("19 (Low)"));
        lblTime4EpriorityHigh->set_text(_("-20 (High)"));
    }
    else{
        spinPriority->set_range(0, 19);
        spinPriority->set_increments(1.0, -1.0);
        scalePriority->set_range(0, 19);
        scalePriority->set_value(0);
        lblTimeEpriorityLow->set_text(_("19 (Low)"));
        lblTime4EpriorityHigh->set_text(_("0 (High)"));    
    }
}

void MainWindow::delete_cmd(const int &x, const int &y) {
    if (y > 1) {
        chbTerminal->set_active(false);
        chbAnotherUser->set_active(false);
        cbxExecuteEpriority->set_active(false);
        txtCmd->set_text("");
    }
}

bool MainWindow::focus_in_txt_cmd(GdkEventFocus* event) {
    if (user_cmd.length() != 0) {
    }
    else if (name_app.length() != 0) {
    }
    else if (path_file.length() != 0) {
    }
    else{
        user_cmd = txtCmd->get_text();
    }
    cmd_old = txtCmd->get_text();
    return true;
}

void MainWindow::synopsis_show() {
    string cmd = "xdg-open " + string(_("https://wiki.ublinux.com/ru/Программное_обеспечение/Программы_и_утилиты/Все/")) + app_name + " &";
    system(cmd.c_str());
}

void MainWindow::icon_clear() {
    list_Graphics->clear();
    list_Tools->clear();
    list_Internet->clear();
    list_Multimedia->clear();
    list_Settings->clear();
    list_Education->clear();
    list_Office->clear();
    list_Other->clear();
    list_Development->clear();
    list_System->clear();
}

void MainWindow::ok_close_entry_app() {
    this->icon_clear();
    dialogStartMenu->hide();
}

void MainWindow::select_Graphics() {
    this->tempate_icon_select(this->iconGraphics, list_Graphics);
}
void MainWindow::select_Tools() {
    this->tempate_icon_select(this->iconTools, list_Tools);
}
void MainWindow::select_Internet() {
    this->tempate_icon_select(this->iconInternet, list_Internet);
}
void MainWindow::select_Multimedia() {
    this->tempate_icon_select(this->iconMultimedia, list_Multimedia);
}
void MainWindow::select_Settings() {
    this->tempate_icon_select(this->iconSettings, list_Settings);
}
void MainWindow::select_Education() {
    this->tempate_icon_select(this->iconEducation, list_Education);
}
void MainWindow::select_Office() {
    this->tempate_icon_select(this->iconOffice, list_Office);
}
void MainWindow::select_Other() {
    this->tempate_icon_select(this->iconOther, list_Other);
}
void MainWindow::select_Development() {
    this->tempate_icon_select(this->iconDevelopment, list_Development);
}
void MainWindow::select_System() {
    this->tempate_icon_select(this->iconSystem, list_System);
}
void MainWindow::tempate_icon_select(Gtk::IconView *icon, Glib::RefPtr<Gtk::ListStore> &gtk_list) {
    auto selected = (*icon).get_selected_items();
    if(!selected.empty()) {   
        this->set_icon_array();
        this->unselect_icon(icon);
        const Gtk::TreeModel::Path& path = *selected.begin();
        Gtk::TreeModel::iterator iter = gtk_list->get_iter(path);
        Gtk::TreeModel::Row row = *iter;
        auto app_name_exec = row[m_Columns.app_name_exec];
        const Glib::ustring description = row[m_Columns.m_col_description];
        path_file = "";
        name_app = "";
        user_cmd = "";
        txtCmd->set_text(app_name_exec);
        name_app = txtCmd->get_text();
        int len_name_app = name_app.length();
        string array_del[] = {"%f", "%F", "%d", "%D", "%n", "%N", "%U"};
        for (auto &del_sim: array_del) {
            str_remove(name_app, del_sim);
            if (name_app.length() != len_name_app) {
                txtCmd->set_text(name_app);
                this->denamic_cmd();
                break;
            }
        }
    }
}

void MainWindow::unselect_icon(Gtk::IconView *icon_entry) {
    for (int index=0; index<10; ++index) {
        Gtk::IconView *icon = this->array_icon[index];
        if (icon_entry != icon) {
            icon->unselect_all();
        }
    }
}

void MainWindow::settings() {
    this->pars_apps();
    this->get_builder();
    this->event();
    this->localization();
    this->add_CSS();
    spinPriority->set_range(0, 19);
    spinPriority->set_increments(1.0, -1.0);
    scalePriority->set_range(0, 19);
    scalePriority->set_value(0);
    lblTimeEpriorityLow->set_text(_("19 (Low)"));
    lblTime4EpriorityHigh->set_text(_("0 (High)")); 
    scalePriority->set_inverted(true);
    this->pars_dir_bin();
    this->pars_dir_terminal();
    this->pars_users();
    this->is_user_wheel();
    cmbUser->set_active_text(user_exec_app);
    this->activ_or_block_execute_epriority();
    this->changed_user();
    cmbUser->set_sensitive(false);
    lblInfoUserName->set_sensitive(false);
    rbPkexec->set_sensitive(false);
    rbSu->set_sensitive(false);
    rbSudo->set_sensitive(false);
    btnBoxAboutDialog->set_visible(false);
    cmbTerminal->set_sensitive(false);
    ubl_make_plugs(boxAbout, boxAbout, socket_ext_id_I, 0);
}

void MainWindow::close_entry_app() {
    this->icon_clear();
    dialogStartMenu->hide();
}

void MainWindow::start_menu_entry_app() {}

void MainWindow::message_gui_close() {
    messageError->hide();
}

void MainWindow::activ_or_block_execute_epriority() {
    bool flag = cbxExecuteEpriority->get_active();
    scalePriority->set_sensitive(flag);
    spinPriority->set_sensitive(flag);
    lblTimeEpriorityLow->set_sensitive(flag);
    lblTime4EpriorityHigh->set_sensitive(flag);
    this->denamic_cmd();
}

void MainWindow::open_filemaneg() {
    wndChooseFileWallpaper->set_current_folder("/bin/");
    wndChooseFileWallpaper->show();
}

void MainWindow::close_filemaneg() {
    wndChooseFileWallpaper->hide();
}

void MainWindow::get_path_filemaneg() {
    name_app = "";
    user_cmd = "";
    path_file = wndChooseFileWallpaper->get_filename();
    if (path_file.length() == 0) {}
    else{
        txtCmd->set_text(path_file);
        this->close_filemaneg();
        
    }
    this->denamic_cmd();
}

vector <size_t> MainWindow::find_all(string &text, string &word) {
    size_t index{};
    vector <size_t> list_index;
    while ((index = text.find(word, index)) != std::string::npos)
    {
        index += word.length();
        list_index.push_back(index);
    }
    return list_index;
}

void MainWindow::tempalte_row(string Name, string Exec,  string path , Glib::RefPtr<Gtk::ListStore> &dtk_list) {
    Gtk::TreeModel::Row row = *(dtk_list->append());
    string s_remove[] = {".png", ".jpg", ".jpeg", ".svg", ".xpm"};
    string str_search = "/";
    if (path.find(str_search) != string::npos){
        vector <size_t> list_index = this->find_all(path, str_search);
        int index = list_index.size();
        if (index>1){
            index = index-1;
            index = list_index.at(index);
            if (index){
                size_t len_path = path.length();
                path = path.substr(index, len_path);
            } 
        }
    }
    for (string &del: s_remove){
        if (path.find(del) != string::npos){
            str_remove(path, del);
        }
    }
    row[m_Columns.m_col_filename] = path;
    row[m_Columns.m_col_description] = Name;
    row[m_Columns.icon_name] = path;
    row[m_Columns.app_name_exec] = Exec;
    row[m_Columns.float_h_align] = 0.5;
    row[m_Columns.float_w_align] = 0.5;
}

void MainWindow::open_list_app() {
    this->template_apps_obj(iconGraphics, list_Graphics);
    this->template_apps_obj(iconTools, list_Tools);
    this->template_apps_obj(iconInternet, list_Internet);
    this->template_apps_obj(iconMultimedia, list_Multimedia);
    this->template_apps_obj(iconSettings, list_Settings);
    this->template_apps_obj(iconEducation, list_Education);
    this->template_apps_obj(iconOffice, list_Office);
    this->template_apps_obj(iconOther, list_Other);
    this->template_apps_obj(iconDevelopment, list_Development);
    this->template_apps_obj(iconSystem, list_System);
    string path = "";
    for ( const auto &st_app: list_app) {
        for ( const auto &str_categor: st_app.Categories) {
            path = st_app.Icon;
            if (str_categor == "Graphics") {
                this->tempalte_row(st_app.Name,st_app.Exec, path, list_Graphics);
            }
            else if (str_categor == "Utility") {
                this->tempalte_row(st_app.Name,st_app.Exec, path, list_Tools);
            }
            else if (str_categor == "Network") {
                this->tempalte_row(st_app.Name,st_app.Exec, path, list_Internet);
            }
            else if (str_categor == "AudioVideo") {
                this->tempalte_row(st_app.Name,st_app.Exec, path, list_Multimedia);
            }
            else if (str_categor == "Settings") {
                this->tempalte_row(st_app.Name,st_app.Exec, path, list_Settings);
            }
            else if (str_categor == "Education") {
                this->tempalte_row(st_app.Name,st_app.Exec, path, list_Education);
            }
            else if (str_categor == "Office") {
                this->tempalte_row(st_app.Name,st_app.Exec, path, list_Office);
            }
            else if (str_categor == "Other") {
                this->tempalte_row(st_app.Name,st_app.Exec, path, list_Other);
            }
            else if (str_categor == "Development") {
                this->tempalte_row(st_app.Name,st_app.Exec, path, list_Development);
            }
            else if (str_categor == "System") {
                this->tempalte_row(st_app.Name,st_app.Exec, path, list_System);
            }
        }
    }
    dialogStartMenu->show_all();
}


string MainWindow::start_cmd(string user_cmd) {
    string str_cmd_terminal = "";
    string str_variants_root = "";
    string str_nice_cmd = "";
    if (chbAnotherUser->get_active()) {
        if (rbPkexec->get_active()) {
            str_variants_root = "pkexec --user " + cmbUser->get_active_text();
            if (cbxExecuteEpriority->get_active()) {
                str_variants_root += " nice -n " + to_string(spinPriority->get_value_as_int());
            }
            str_variants_root += " env PATH=$PATH DISPLAY=$DISPLAY XAUTHORITY=$XAUTHORITY ";    
        }
        else if (rbSu->get_active()) {
            chbTerminal->set_active(true);
            string str_user = cmbUser->get_active_text();
            if (str_user != "root") {
                str_variants_root = "su -l " + cmbUser->get_active_text();
            }
            else{
                str_variants_root = "su ";
            }
            str_variants_root += " -c \" DISPLAY=$DISPLAY ";
            if (cbxExecuteEpriority->get_active()) {
                str_variants_root += "nice -n " + to_string(spinPriority->get_value_as_int()) + " ";
            }
        }
        else if (rbSudo->get_active()) {
            chbTerminal->set_active(true);
            if (user_exec_app==cmbUser->get_active_text()) {
                str_variants_root = "sudo ";
            }
            else{
                str_variants_root = "sudo -u " + cmbUser->get_active_text() + " ";
            }
            if (cbxExecuteEpriority->get_active()) {
                str_variants_root += "nice -n " + to_string(spinPriority->get_value_as_int()) + " ";
            }
        }
    }
    if (cmbUser->get_active_text().length() != 0) {
        string user_cmd_X = "xhost +SI:localuser:";
        user_cmd_X += cmbUser->get_active_text();
        user_cmd_X += " > /dev/null 2>&1";
        system(user_cmd_X.c_str());
    }
    if ((cbxExecuteEpriority->get_active()) && (chbAnotherUser->get_active() == false)) {
        str_nice_cmd = "nice -n " + to_string(spinPriority->get_value_as_int()) + " ";
    }
    if (user_cmd.length() == 0 && name_app.length() == 0 && path_file.length() == 0) {
        messageError->show();
        return "";
    }
    if (chbTerminal->get_active() == true) {
        string name_terminal =  cmbTerminal->get_active_text();
        if (name_terminal.length() != 0){
            if (name_terminal == "xfce4-terminal") {
                str_cmd_terminal = "xfce4-terminal -x ";
            }
            else if (name_terminal == "konsole") {
                str_cmd_terminal = "konsole -e ";
            }
            else if (name_terminal == "xterm") {
                str_cmd_terminal = "xterm -e ";
            }
            else{
                str_cmd_terminal = "";
            }
        }
        else{
            str_cmd_terminal = "";
        }
        
    }
    else{
        str_cmd_terminal = "";
    }
    string cmd = "";
    if (path_file.length() > 0) {
        if (access(path_file.c_str(), X_OK) != -1) {
            cmd = str_nice_cmd + str_cmd_terminal + str_variants_root + " " + path_file;
        }
        else{
            cmd = str_nice_cmd + str_cmd_terminal + str_variants_root + " xdg-open '" + path_file + "' ";
        }
        
    }
    else if (name_app.length() > 0) {
        cmd = str_nice_cmd + str_cmd_terminal + str_variants_root  + name_app;
    }
    else if (user_cmd.length() > 0) {
        cmd = str_nice_cmd + str_cmd_terminal + str_variants_root + " " + user_cmd;
    }
    if ((cmd.find("-e su ") != string::npos) || (cmd.find("-x su ") != string::npos)) {
        cmd+=" \"";
    }
    cmd = "nohup " + cmd;
    cmd += " > /dev/null 2>&1";
    return cmd; 
}

void MainWindow::call_app(string &cmd) {
    if (cmd.length() != 0) {
        std::thread t([&](string cmd) {system(cmd.c_str());}, cmd);
        t.detach();
    }
}
void MainWindow::denamic_cmd() {
    if (chbTerminal->get_active() == true || chbAnotherUser->get_active() == true || cbxExecuteEpriority->get_active() == true) {
        if (txtCmd->get_text().length() == 0) {
            chbTerminal->set_active(false);
            chbAnotherUser->set_active(false);
            cbxExecuteEpriority->set_active(false);
            path_file = "";
            name_app = "";
            user_cmd = "";
            txtCmd->set_text(user_cmd);
            messageError->show();
        }
        else{
            txtCmd->set_text(this->start_cmd(user_cmd));
        }
    }
    else{
        if (user_cmd.length() != 0) {
            txtCmd->set_text(this->start_cmd(user_cmd));
        }
        else if (path_file.length() != 0) {
            txtCmd->set_text(this->start_cmd(user_cmd));
        }
        else if (name_app.length() != 0) {
            txtCmd->set_text(this->start_cmd(user_cmd));
        }
    }
}

string MainWindow::call(string cmd) {
    FILE *fp;
    int status;
    char path[PATH_MAX] = {0};
    fp = popen(cmd.c_str(), "r");
    if (fp == NULL) {
        exit(1);
    }  
    while (fgets(path, PATH_MAX, fp) != NULL) {
        break;  
    }
    status = pclose(fp);
    if (status == -1) {
        exit(1);
    }
    return path;
}

bool MainWindow::focus_out_txt_cmd(GdkEventFocus* event) {
    if (cmd_old != txtCmd->get_text()) {
        user_cmd = txtCmd->get_text();
    }
    return true;
}

void MainWindow::entry_app() {
    this->denamic_cmd();
    if (name_app.length() == 0 && path_file.length() == 0) {
    }
    string cmd = txtCmd->get_text();
    this->call_app(cmd);
}

void MainWindow::activ_or_block_other_user() {
    bool flag = chbAnotherUser->get_active();
    cmbUser->set_active(0);
    cmbUser->set_sensitive(flag);
    lblInfoUserName->set_sensitive(flag);  
    if (flag_pkexec == true) {
        rbPkexec->set_sensitive(flag);
    }
    if (flag_su == true) {
        rbSu->set_sensitive(flag);
    }
    if (flag_sudo == true) {
        rbSudo->set_sensitive(flag);
    }
    this->denamic_cmd();
}

void MainWindow::change_scale_priority() {
    scalePriority->set_value(spinPriority->get_value_as_int());
    this->denamic_cmd();
}

void MainWindow::change_spin_priority() {
    spinPriority->set_value(scalePriority->get_value());
    this->denamic_cmd();
}

void MainWindow::pars_dir_bin() {
    namespace fs = std::filesystem;  
    std::string path = "/bin";
    string file_name = "";
    for (const auto & entry: fs::directory_iterator(path)) {
        file_name = entry.path().filename().string();
        if (file_name == "su") {
            flag_su = true;
        }
        else if (file_name == "sudo") {
            flag_sudo = true;
        }
        else if (file_name == "pkexec") {
            flag_pkexec = true;
        }
    }
    rbPkexec->set_sensitive(flag_pkexec);
    rbSu->set_sensitive(flag_su);
    rbSudo->set_sensitive(flag_sudo);
}

void MainWindow::pars_dir_terminal() {
    namespace fs = std::filesystem;  
    std::string path = "/bin";
    string file_name = "";
    for (const auto & entry: fs::directory_iterator(path)) {
        file_name = entry.path().filename().string();
        if (file_name == "konsole") {
            cmbTerminal->append("konsole");
            cmbTerminal->set_active_text("konsole");
        }
        else if (file_name == "xfce4-terminal") {
            cmbTerminal->append("xfce4-terminal");
            cmbTerminal->set_active_text("xfce4-terminal"); 
        }
        else if (file_name == "xterm") {
            cmbTerminal->append("xterm");
        }
    }
}

void MainWindow::is_user_wheel(){
    string response = this->call("id -Gn");
    if (response.find("wheel") == string::npos){
        flag_sudo = false;
        rbSudo->set_sensitive(flag_sudo);
    }
    size_t user_index = response.find(" ");
    if (user_index!=string::npos){
        user_exec_app = response.substr(0, user_index);
    }
}

void MainWindow::pars_users() {
    //string str_uid_max = this->call("grep \"^UID_MAX\" /etc/login.defs | xargs | cut -d ' ' -f 2)");
    //int uid_max = 0;
    //if (str_uid_max.length() > 3){
    //    int uid_max = stoi(str_uid_max);
    //}
    //else{
    int uid_max = 65534;
    //}
    while (true) {
        errno = 0;
        passwd* entry = getpwent();
        if (!entry) {
            if (errno) {
                break;
            }
            break;
        }
        if ((entry->pw_uid >= 1000 && entry->pw_uid < uid_max) || entry->pw_uid == 0) {
            cmbUser->append(entry->pw_name);
        }
    }
    endpwent();
}

vector<std::string> MainWindow::split(const std::string &s, char delim) {
    std::stringstream ss(s);
    std::string item;
    std::vector<std::string> elems;
    while (std::getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems;
}

void MainWindow::str_remove(std::string& source, std::string & to_remove) {
    string::size_type n = to_remove.length();
    for (string::size_type i = source.find(to_remove);
        i != string::npos;
        i = source.find(to_remove))
        source.erase(i, n);
}

void MainWindow::pars_apps() {
    if (list_app.size() != 0 ) {return;}
    namespace fs = std::filesystem;
    struct struct_App App;
    string file_name = "";
    string str_Categories;
    string path = "/usr/share/applications/";
    for (const auto & entry : fs::directory_iterator(path)) {
        file_name = entry.path().filename().string();
        path = "/usr/share/applications/"+file_name;
        if (file_name.find(".desktop") != std::string::npos) {
            GKeyFile *gfile=g_key_file_new();
            g_key_file_load_from_file(gfile, path.c_str(), G_KEY_FILE_KEEP_TRANSLATIONS, NULL);
            char *Type = g_key_file_get_string(gfile, "Desktop Entry", "Type", NULL);
            char *Name = g_key_file_get_locale_string(gfile, "Desktop Entry", "Name", setlocale(LC_ALL, NULL), NULL);
            char *Exec = g_key_file_get_string(gfile, "Desktop Entry", "Exec", NULL);
            char *Categories = g_key_file_get_locale_string(gfile, "Desktop Entry", "Categories", setlocale(LC_ALL, ""), NULL);
            char *Icon = g_key_file_get_string(gfile, "Desktop Entry", "Icon", NULL);
            char *Mime = g_key_file_get_string(gfile, "Desktop Entry", "MimeType", NULL);
            if (Type == NULL) continue;
            if (Name == NULL) continue;
            if (Exec == NULL) continue;
            if (Categories == NULL) continue;
            if (Icon == NULL) continue;
            str_Categories = Categories;
            App.Name = Name;
            App.Type = Type;
            App.Exec = Exec;
            App.Icon = Icon;
            if (Mime != NULL) {
                App.MimeType = Mime;
            }
            else{
                App.MimeType = ""; 
            }
            App.Name_desktop = file_name;
            App.Categories = split(str_Categories, ';');
        }
        list_app.push_back(App);
    }
}

SettingsPlug::SettingsPlug(::Window p_socketID, Glib::RefPtr<Gtk::Builder> builder)
    : Gtk::Plug{p_socketID} {   
    MainWindow* wnd = nullptr;
    builder->get_widget_derived("window", wnd);
    builder->get_widget("plugBox", plugBox);
    plugBox->get_parent()->remove(*plugBox);
    add(*plugBox);
    show_all_children();
}