From e1753b3cc0e6dc14f16ad2fbf1fceb2e705389eb Mon Sep 17 00:00:00 2001 From: Anthony Olszynski Date: Sun, 7 Feb 2021 03:03:27 +0100 Subject: [PATCH 01/19] update to 1.0.4 --- Info.h | 24 +- MenuWinClass.cpp | 899 +++++++++++++++++++++++++++++++++++++++++++++ MenuWinClass.h | 205 +++++++++++ ServiceClass.cpp | 617 ++++++++++++++++--------------- ServiceClass.h | 70 ++-- ServiceControl.pro | 121 +++--- Start.cpp | 160 +++----- TaskClass.cpp | 240 +++--------- TaskClass.h | 107 ++---- 9 files changed, 1666 insertions(+), 777 deletions(-) create mode 100644 MenuWinClass.cpp create mode 100644 MenuWinClass.h diff --git a/Info.h b/Info.h index e35d4b3..46cddb6 100644 --- a/Info.h +++ b/Info.h @@ -1,23 +1,23 @@ #ifndef _INFO_H #define _INFO_H -#define VERSION "1.3" - +#define VERSION "1.0.4" +#define APPNAME "ServiceControl" #define ABOUT_INFO "\n\ - ServiceControl 1.3 \n\ + " APPNAME " " VERSION " \n\ \n\ Navigation keys: \n\ - Up - move cursor up | Down - move cursor down \n\ - right - move cursor right | left - move cursor left \n\ - PgUp - move page up | PgDown - move page down \n\ - / - for search | ? - for this help \n\ + Up - move cursor up | Down - move cursor down \n\ + right - move cursor right | left - move cursor left \n\ + PgUp - move page up | PgDown - move page down \n\ + / - for search | ? - for this help \n\ Action keys: \n\ - Space - anwählen/abwählen | F10 - exit \n\ - F1 - start/stop unit | F2 - reload/update \n\ - F3 - enabled unit | F4 - disabled unit \n\ - F5 - unmasked unit | F6 - masked unit \n\ + Space - anwählen/abwählen | F10 - exit | ESC - Close info/help\n\ + F1 - start/stop unit | F2 - reload/update | TAB - switch Menu/ \n\ + F3 - enabled unit | F4 - disabled unit | Servicelist/ \n\ + F5 - unmasked unit | F6 - masked unit | Search \n\ ---------------------------------------------------------------------------\n\ License: GPLv3 (c) Anthony Olszynski \n\ " -#endif +#endif //_INFO_H diff --git a/MenuWinClass.cpp b/MenuWinClass.cpp new file mode 100644 index 0000000..15b5aa6 --- /dev/null +++ b/MenuWinClass.cpp @@ -0,0 +1,899 @@ + #include + +using namespace std; + +TaskClass *TaskClass_MWC = new TaskClass(); +ServiceClass *ServiceClass_MWC = new ServiceClass(); +MenuWinClass *MenuWinClass_MWC = new MenuWinClass(); + +FENSTER MenuWinClass::START; +HAUPTMENU MenuWinClass::TOPMENU; +WINDOW* MenuWinClass::TMPWIN; +MENU* MenuWinClass::TMPMENU; +int MenuWinClass::MeInAl = 0; +INAPPMENU MenuWinClass::SERVICEMENU; +int MenuWinClass::LiMeInAl; +WINDOW* MenuWinClass::LiTMPWIN; +MENU* MenuWinClass::LiTMPMENU; +string MenuWinClass::PATTERN; +ServiceClass ServiceClass; +vector ServiceList; +int MenuWinClass::TabKey = 1; + +WinID& operator++(WinID& WID, int) { + return WID = (WID == WinID::ENDWIN) ? WinID::MAINWIN : static_cast(static_cast(WID) + 1); +}; +WinID& operator--(WinID& WID, int) { + return WID = (WID == WinID::ENDWIN) ? WinID::MAINWIN : static_cast(static_cast(WID) - 1); +}; +ostream& operator<<(ostream& WID, WinID e) { + static const vector EnumString = {"MENUWIN", "MAINWIN", "TERMWIN", "LISTPAD", "DESCWIN", "ENDWIN"}; + return WID << EnumString[static_cast(e)]; +}; +MenuID& operator++(MenuID& MID, int) { + return MID = (MID == MenuID::ENDMENU) ? MenuID::MAINMENU : static_cast(static_cast(MID) + 1); +}; +MenuID& operator--(MenuID& MID, int) { + return MID = (MID == MenuID::ENDMENU) ? MenuID::MAINMENU : static_cast(static_cast(MID) - 1); +}; +ostream& operator<<(ostream& MID, MenuID e) { + static const vector EnumString = {"DATEIMENU", "DAEMONMENU", "SYSTEMCTLMENU", "INFOMENU", "MAINMENU", "ENDMENU"}; + return MID << EnumString[static_cast(e)]; +}; + +MenuWinClass::MenuWinClass() { + START.WinSize.RAND = 1; + START.WinSize.h = 1; //rand + START.WinSize.w = 1; + START.WCX(); // = 80; + START.HRY(); // = 24; + START.WinSize.WCX(); // = 80; + START.WinSize.HRY(); // = 24; + START.WinSize.WCX_Real(); + START.WinSize.HRY_Real(); + START.WinSize.WCX_Center(); + START.WinSize.HRY_Center(); + START.WinSize.WCX_TmpWin(stdscr); + START.WinSize.HRY_TmpWin(stdscr); + START.WinSize.WCX_TmpWinReal(stdscr); + START.WinSize.HRY_TmpWinReal(stdscr); + START.WinSize.WCX_TmpWinCenter(stdscr); + START.WinSize.HRY_TmpWinCenter(stdscr); +} +void MenuWinClass::StartWin() { + setlocale(LC_CTYPE, "de_DE.UTF-8"); + setlocale(LC_ALL, "de_DE.UTF-8"); + initscr(); + if (has_colors() == FALSE) { endwin(); cout << "Your terminal does not support color\n" << endl; exit(1);} + start_color(); + cbreak(); + noecho(); + curs_set(false); + keypad(stdscr, true); + MenuWinClass::AppColor(); +} +void MenuWinClass::StopWin() { + endwin(); +} +void MenuWinClass::AppColor() { + start_color(); + short MY_MARIN_BLUE = 240, MY_LIGHT_BLUE = 250, MY_DARK_BLACK = 0, MY_LIGHT_WHITE = 100; + short R = 0, G = 0, B = 0; + init_color(MY_MARIN_BLUE, R, G, static_cast(300)); + init_color(MY_LIGHT_BLUE, R, G, static_cast(850)); + init_color(MY_DARK_BLACK, R, G, B); + init_color(MY_LIGHT_WHITE, 1000, 1000, 1000); + /* 0 black, 1 red, 2 green, 3 yellow, 4 blue, 5 magenta, 6 cyan, 7 white, 8 marin blue, 9 light blue */ + /* hintergrund Schwarz */ + init_pair(00, MY_DARK_BLACK, MY_DARK_BLACK); + init_pair(10, COLOR_RED, MY_DARK_BLACK); + init_pair(20, COLOR_GREEN, MY_DARK_BLACK); + init_pair(30, COLOR_YELLOW, MY_DARK_BLACK); + init_pair(40, COLOR_BLUE, MY_DARK_BLACK); + init_pair(50, COLOR_MAGENTA, MY_DARK_BLACK); + init_pair(60, COLOR_CYAN, MY_DARK_BLACK); + init_pair(70, MY_LIGHT_WHITE, MY_DARK_BLACK); + init_pair(80, MY_MARIN_BLUE, MY_DARK_BLACK); + init_pair(90, MY_LIGHT_BLUE, MY_DARK_BLACK); + /* hintergrund Rot */ + init_pair(01, MY_DARK_BLACK, COLOR_RED); + init_pair(11, COLOR_RED, COLOR_RED); + init_pair(21, COLOR_GREEN, COLOR_RED); + init_pair(31, COLOR_YELLOW, COLOR_RED); + init_pair(41, COLOR_BLUE, COLOR_RED); + init_pair(51, COLOR_MAGENTA, COLOR_RED); + init_pair(61, COLOR_CYAN, COLOR_RED); + init_pair(71, MY_LIGHT_WHITE, COLOR_RED); + init_pair(81, MY_MARIN_BLUE, COLOR_RED); + init_pair(91, MY_LIGHT_BLUE, COLOR_RED); + /* hintergrund Gruen */ + init_pair(02, MY_DARK_BLACK, COLOR_GREEN); + init_pair(12, COLOR_RED, COLOR_GREEN); + init_pair(22, COLOR_GREEN, COLOR_GREEN); + init_pair(32, COLOR_YELLOW, COLOR_GREEN); + init_pair(42, COLOR_BLUE, COLOR_GREEN); + init_pair(52, COLOR_MAGENTA, COLOR_GREEN); + init_pair(62, COLOR_CYAN, COLOR_GREEN); + init_pair(72, MY_LIGHT_WHITE, COLOR_GREEN); + init_pair(82, MY_MARIN_BLUE, COLOR_GREEN); + init_pair(92, MY_LIGHT_BLUE, COLOR_GREEN); + /* hintergrund Gelb */ + init_pair(03, MY_DARK_BLACK, COLOR_YELLOW); + init_pair(13, COLOR_RED, COLOR_YELLOW); + init_pair(23, COLOR_GREEN, COLOR_YELLOW); + init_pair(33, COLOR_YELLOW, COLOR_YELLOW); + init_pair(43, COLOR_BLUE, COLOR_YELLOW); + init_pair(53, COLOR_MAGENTA, COLOR_YELLOW); + init_pair(63, COLOR_CYAN, COLOR_YELLOW); + init_pair(73, MY_LIGHT_WHITE, COLOR_YELLOW); + init_pair(83, MY_MARIN_BLUE, COLOR_YELLOW); + init_pair(93, MY_LIGHT_BLUE, COLOR_YELLOW); + /* hintergrund Blau */ + init_pair(04, MY_DARK_BLACK, COLOR_BLUE); + init_pair(14, COLOR_RED, COLOR_BLUE); + init_pair(24, COLOR_GREEN, COLOR_BLUE); + init_pair(34, COLOR_YELLOW, COLOR_BLUE); + init_pair(44, COLOR_BLUE, COLOR_BLUE); + init_pair(54, COLOR_MAGENTA, COLOR_BLUE); + init_pair(64, COLOR_CYAN, COLOR_BLUE); + init_pair(74, MY_LIGHT_WHITE, COLOR_BLUE); + init_pair(84, MY_MARIN_BLUE, COLOR_BLUE); + /* hintergrund Magenta */ + init_pair(05, MY_DARK_BLACK, COLOR_MAGENTA); + init_pair(15, COLOR_RED, COLOR_MAGENTA); + init_pair(25, COLOR_GREEN, COLOR_MAGENTA); + init_pair(35, COLOR_YELLOW, COLOR_MAGENTA); + init_pair(45, COLOR_BLUE, COLOR_MAGENTA); + init_pair(55, COLOR_MAGENTA, COLOR_MAGENTA); + init_pair(65, COLOR_CYAN, COLOR_MAGENTA); + init_pair(75, MY_LIGHT_WHITE, COLOR_MAGENTA); + /* hintergrund Cyan */ + init_pair(06, MY_DARK_BLACK, COLOR_CYAN); + init_pair(16, COLOR_RED, COLOR_CYAN); + init_pair(26, COLOR_GREEN, COLOR_CYAN); + init_pair(36, COLOR_YELLOW, COLOR_CYAN); + init_pair(46, COLOR_BLUE, COLOR_CYAN); + init_pair(56, COLOR_MAGENTA, COLOR_CYAN); + init_pair(66, COLOR_CYAN, COLOR_CYAN); + init_pair(76, MY_LIGHT_WHITE, COLOR_CYAN); + init_pair(86, MY_MARIN_BLUE, COLOR_CYAN); + init_pair(96, MY_LIGHT_BLUE, COLOR_CYAN); + /* hintergrund White */ + init_pair(07, MY_DARK_BLACK, MY_LIGHT_WHITE); + init_pair(17, COLOR_RED, MY_LIGHT_WHITE); + init_pair(27, COLOR_GREEN, MY_LIGHT_WHITE); + init_pair(37, COLOR_YELLOW, MY_LIGHT_WHITE); + init_pair(47, COLOR_BLUE, MY_LIGHT_WHITE); + init_pair(57, COLOR_MAGENTA, MY_LIGHT_WHITE); + init_pair(67, COLOR_CYAN, MY_LIGHT_WHITE); + init_pair(77, MY_LIGHT_WHITE, MY_LIGHT_WHITE); + init_pair(87, MY_MARIN_BLUE, MY_LIGHT_WHITE); + init_pair(97, MY_LIGHT_BLUE, MY_LIGHT_WHITE); + /* hintergrund Marin Blau */ + init_pair(8, MY_DARK_BLACK, MY_MARIN_BLUE); + init_pair(18, COLOR_RED, MY_MARIN_BLUE); + init_pair(28, COLOR_GREEN, MY_MARIN_BLUE); + init_pair(38, COLOR_YELLOW, MY_MARIN_BLUE); + init_pair(48, COLOR_BLUE, MY_MARIN_BLUE); + init_pair(58, COLOR_MAGENTA, MY_MARIN_BLUE); + init_pair(68, COLOR_CYAN, MY_MARIN_BLUE); + init_pair(78, MY_LIGHT_WHITE, MY_MARIN_BLUE); + init_pair(88, MY_MARIN_BLUE, MY_MARIN_BLUE); + init_pair(98, MY_LIGHT_BLUE, MY_MARIN_BLUE); + /* hintergrund Light Blue */ + init_pair(9, MY_DARK_BLACK, MY_LIGHT_BLUE); + init_pair(19, COLOR_RED, MY_LIGHT_BLUE); + init_pair(29, COLOR_GREEN, MY_LIGHT_BLUE); + init_pair(39, COLOR_YELLOW, MY_LIGHT_BLUE); + init_pair(49, COLOR_BLUE, MY_LIGHT_BLUE); + init_pair(59, COLOR_MAGENTA, MY_LIGHT_BLUE); + init_pair(69, COLOR_CYAN, MY_LIGHT_BLUE); + init_pair(79, MY_LIGHT_WHITE, MY_LIGHT_BLUE); + init_pair(89, MY_MARIN_BLUE, MY_LIGHT_BLUE); + init_pair(99, MY_LIGHT_BLUE, MY_LIGHT_BLUE); +} /*---------Programm_Farben------------------------*/ +void MenuWinClass::SetWinSize() { + MenuWinClass::START.WCX(); + MenuWinClass::START.HRY(); + MenuWinClass::START.HRYw1(); + MenuWinClass::START.WCXw1(); + MenuWinClass::START.HRYw2(); + MenuWinClass::START.WCXw2(); + MenuWinClass::START.HRYw3(); + MenuWinClass::START.WCXw3(); + MenuWinClass::START.HRYw4(); + MenuWinClass::START.WCXw4(); + MenuWinClass::START.HRYw5(); + MenuWinClass::START.WCXw5(); + MenuWinClass::START.HRYtime(); + MenuWinClass::START.WCXtime(); + MenuWinClass::START.TMPWin1 = newwin(MenuWinClass::START.HRYw1(), MenuWinClass::START.WCXw1(), 0, 0); + MenuWinClass::START.TMPWin2 = newwin(MenuWinClass::START.HRYw2(), MenuWinClass::START.WCXw2(), 1, 0); + MenuWinClass::START.TMPWin3 = newwin(MenuWinClass::START.HRYw3(), MenuWinClass::START.WCXw3(), (MenuWinClass::START.HRYw1() + MenuWinClass::START.HRYw2()), 0); + MenuWinClass::START.TMPWin4 = newpad(MenuWinClass::START.HRYw4(), MenuWinClass::START.WCXw4()); + //MenuWinClass::START.TMPWin5 = newpad(MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); + MenuWinClass::START.TMPWin5 = newwin(MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5(), (MenuWinClass::START.HRYw1() + MenuWinClass::START.HRYw2())+ 1, 33); +} /*---------Fenster_Size_Setzen--------------------*/ +void MenuWinClass::CreateWin(WINDOW* win, WinID WID) { + switch (WID) { + case MENUWIN: { /*TMPWin1*/ + MenuWinClass::Hauptmenu(); + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_MENUWIN)); + break; + } + case MAINWIN: { /*TMPWin2*/ + box(win, 0, 0); + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_MAINWIN)); + wsetscrreg(win, 0, MenuWinClass::START.HRYw2() - 2); + scrollok(win, true); + break; + } + case INFOWIN: { /*TMPWin3*/ + box(win, 0, 0); + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN)); + wattr_on(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN) | A_BOLD, nullptr); + mvwaddnstr(win, MenuWinClass::START.HRYw3() -1, MenuWinClass::START.WCXw3() - 14, "[ EXIT F10 ]", -1); //12+2 + mvwaddnstr(win, MenuWinClass::START.HRYw3() -1, MenuWinClass::START.WCXw3() - 26, "[ MENÜ TAB ]", -1); //11+2 + wattr_off(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN) | A_BOLD, nullptr); + break; + } + case LISTPAD: { /*TMPWin4*/ + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_LISTPAD)); + win = derwin(MenuWinClass::START.TMPWin2, MenuWinClass::START.HRYw4(), MenuWinClass::START.WCXw4(), 1, 1); + break; + } + case DESCWIN: { /*TMPWin5*/ + //win = derwin(MenuWinClass::START.TMPWin3, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5(), 1, 33); + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_DESCWIN)); + break; + } + case TIMEWIN: { /*TimeWin*/ + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_TIMEWIN)); + win = derwin(MenuWinClass::START.TMPWin1, 1, 20, 0, MenuWinClass::START.WCX() - 20); + break; + } + case ENDWIN: { break; } + default: { break; } + } + refresh(); + wrefresh(win); +} /*---------Fenster_Erzeugen-----------------------*/ +void MenuWinClass::ResizeHandler(int signal) { + UNUSED(signal); + StopWin(); + StartWin(); + SetWinSize(); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin1, MENUWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin2, MAINWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin3, INFOWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin4, LISTPAD); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin5, DESCWIN); +} /*---------Resize_Fenster_neu_Erzeugen----------------*/ +void MenuWinClass::ScrollPad(WINDOW* SubWin, int StartY, int StartX, int Height, int Width, int PadHeight) { + int Choice = 0, Key = 0; + keypad(SubWin, true); + refresh(); + int cols = 0; + while (Choice == 0) { + prefresh(SubWin, cols, 0, StartY, StartX, Height, Width); + Key = wgetch(SubWin); + switch (Key) { + case KEY_UP: { + if (cols <= 0) { continue; } + cols--; + break; + } + case KEY_DOWN: { + if (cols + Height + 1 >= PadHeight) { continue; } + cols++; + break; + } + case KEY_PPAGE: { /* Page Up */ + if (cols <= 0) { continue; } + cols -= Height; + if (cols < 0) { cols = 0; } + break; + } + case KEY_NPAGE: { /* Page Down */ + if (cols + Height + 1 >= PadHeight) { continue; } + cols += Height; + if (cols + Height + 1 > PadHeight) { cols = PadHeight - Height - 1; } + break; + } + case KEY_HOME: { + cols = 0; + break; + } + case KEY_END: { + cols = PadHeight - Height - 1; + break; + } + case 10: { /* Enter */ + Choice = 1; + break; + } + } + refresh(); + } + delwin(SubWin); +} +void MenuWinClass::printInMiddle(WINDOW *win, int starty, int startx, int width, char *string, chtype color, char *sp) { + int x, y; + unsigned long length; + float temp; + + if(win == nullptr) + win = stdscr; + getyx(win, y, x); + if(startx != 0) + x = startx; + if(starty != 0) + y = starty; + if(width == 0) + width = 80; + + length = strlen(string); + temp = (width - static_cast(length))/ 2; + x = startx + static_cast(temp); + wattron(win, color); + + if (sp) { + for (int i = startx; i < width; i++) { + mvwprintw(win, y, i, "%c", sp); + } + } + + mvwprintw(win, y, x, "%s", string); + wattroff(win, color); +} +void MenuWinClass::FensterDraw() { + ServiceClass_MWC->INFOWINDOW(""); + ServiceClass_MWC->ServiceListFill(); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin1, MENUWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin2, MAINWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin3, INFOWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin4, LISTPAD); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin5, DESCWIN); +} +void MenuWinClass::Hauptmenu(void) { + MenuWinClass::TOPMENU.MID = MAINMENU; + MenuWinClass::TOPMENU.HMName = string("HAUPTMENÜ"); + MenuWinClass::TOPMENU.HMItem = static_cast(calloc(5, sizeof(ITEM*))); + MenuWinClass::TOPMENU.HMItem[0] = new_item(" Datei", MenuWinClass::TOPMENU.HMName.c_str()); + MenuWinClass::TOPMENU.HMItem[1] = new_item("DaemonType", MenuWinClass::TOPMENU.HMName.c_str()); + MenuWinClass::TOPMENU.HMItem[2] = new_item("Systemctl", MenuWinClass::TOPMENU.HMName.c_str()); + MenuWinClass::TOPMENU.HMItem[3] = new_item("Info", MenuWinClass::TOPMENU.HMName.c_str()); + MenuWinClass::TOPMENU.HMItem[4] = nullptr; + MenuWinClass::TOPMENU.HMMenu = new_menu(MenuWinClass::TOPMENU.HMItem); + MenuWinClass::START.TMPWin1 = newwin(MenuWinClass::START.HRYw1(), MenuWinClass::START.WCXw1(), 0, 0); + set_menu_win(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::START.TMPWin1); + set_menu_sub(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::START.TMPWin1); + //############################################################### + //set_menu_sub(TOPMENU.UME.UMEMenu, MenuWinClass::START.TMPWin1); + //############################################################### + set_menu_spacing(MenuWinClass::TOPMENU.HMMenu, 1, 0, 0); + set_menu_format(MenuWinClass::TOPMENU.HMMenu, 0, 5); + menu_opts_off(MenuWinClass::TOPMENU.HMMenu, O_SHOWDESC); + menu_opts_off(MenuWinClass::TOPMENU.HMMenu, O_NONCYCLIC); + wbkgd(MenuWinClass::START.TMPWin1, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_MAINMENU)); + set_menu_fore(MenuWinClass::TOPMENU.HMMenu, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_AKTIVHAME) | A_BOLD); + set_menu_back(MenuWinClass::TOPMENU.HMMenu, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_MAINMENU)); + set_menu_grey(MenuWinClass::TOPMENU.HMMenu, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_UNUSEDHM)); + set_menu_mark(MenuWinClass::TOPMENU.HMMenu, ""); + post_menu(MenuWinClass::TOPMENU.HMMenu); +} /* Hauptmenü */ +void MenuWinClass::DateiMenu(void) { + TOPMENU.UME.UMID = 1; + TOPMENU.UME.UMEName = string("Datei"); + TOPMENU.UME.UMEWin = newwin(6, 15, 1, 0); + wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + box(TOPMENU.UME.UMEWin, 0, 0); + TOPMENU.UME.UMEItem = static_cast(calloc(7, sizeof(ITEM*))); + TOPMENU.UME.UMEItem[0] = new_item("Man Systemctl", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[1] = new_item("Einstellung", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[2] = new_item("Remotectl", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[3] = new_item("Beenden", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[4] = nullptr; + TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); + set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); + set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); + set_menu_spacing(TOPMENU.UME.UMEMenu, 0, 0, 0); + set_menu_format(TOPMENU.UME.UMEMenu, 5, 0); + menu_opts_off(TOPMENU.UME.UMEMenu, O_SHOWDESC); + menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); + set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); + set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); + set_menu_mark(TOPMENU.UME.UMEMenu, ""); + set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); + post_menu(TOPMENU.UME.UMEMenu); +} /* Datei Untermenü */ +void MenuWinClass::DaemonTypeMenu(void) { + TOPMENU.UME.UMID = 2; + TOPMENU.UME.UMEName = string("DaemonType"); + TOPMENU.UME.UMEWin = newwin(12, 10, 1, 11); + box(TOPMENU.UME.UMEWin, 0, 0); + TOPMENU.UME.UMEItem = static_cast(calloc(11, sizeof(ITEM*))); + TOPMENU.UME.UMEItem[0] = new_item("Device", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[1] = new_item("Mount", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[2] = new_item("Path", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[3] = new_item("Service", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[4] = new_item("Scope", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[5] = new_item("Slice", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[6] = new_item("Socket", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[7] = new_item("Swap", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[8] = new_item("Target", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[9] = new_item("Timer", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[10] = nullptr; + TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); + set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); + set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); + set_menu_spacing(TOPMENU.UME.UMEMenu, 0, 0, 1); + set_menu_format(TOPMENU.UME.UMEMenu, 11, 0); + menu_opts_off(TOPMENU.UME.UMEMenu, O_SHOWDESC); + menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); + wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); + set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); + set_menu_mark(TOPMENU.UME.UMEMenu, ""); + set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); + post_menu(TOPMENU.UME.UMEMenu); +} /* DaemonType Untermenü */ +void MenuWinClass::SystemctlMenu(void) { + TOPMENU.UME.UMID = 3; + TOPMENU.UME.UMEName = string("Systemctl"); + TOPMENU.UME.UMEWin = newwin(12, 18, 1, 22); + box(TOPMENU.UME.UMEWin, 0, 0); + TOPMENU.UME.UMEItem = static_cast(calloc(11, sizeof(ITEM*))); + TOPMENU.UME.UMEItem[0] = new_item("START", "F1"); + TOPMENU.UME.UMEItem[1] = new_item("STOP", "F1"); + TOPMENU.UME.UMEItem[2] = new_item("STATUS", "F3"); + TOPMENU.UME.UMEItem[3] = new_item("ENABLE", "F2"); + TOPMENU.UME.UMEItem[4] = new_item("DISABLE", "F2"); + TOPMENU.UME.UMEItem[5] = new_item("MASK", "F4"); + TOPMENU.UME.UMEItem[6] = new_item("UNMASK", "F4"); + TOPMENU.UME.UMEItem[7] = new_item("RESTART", "F5"); + TOPMENU.UME.UMEItem[8] = new_item("RELOAD", "F6"); + TOPMENU.UME.UMEItem[9] = new_item("Reload-daemon", "F7"); + TOPMENU.UME.UMEItem[10] = nullptr; + TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); + set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); + set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); + set_menu_spacing(TOPMENU.UME.UMEMenu, 1, 0, 0); + set_menu_format(TOPMENU.UME.UMEMenu, 11, 0); + menu_opts_on(TOPMENU.UME.UMEMenu, O_SHOWDESC); + menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); + wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); + set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); + set_menu_mark(TOPMENU.UME.UMEMenu, ""); + set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); + post_menu(TOPMENU.UME.UMEMenu); +} /* Systemctl Untermenü */ +void MenuWinClass::InfoMenu(void) { + TOPMENU.UME.UMID = 4; + TOPMENU.UME.UMEName = string("Info"); + TOPMENU.UME.UMEWin = newwin(5, 12, 1, 33); + wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + box(TOPMENU.UME.UMEWin, 0, 0); + TOPMENU.UME.UMEItem = static_cast(calloc(4, sizeof(ITEM*))); + TOPMENU.UME.UMEItem[0] = new_item("journalctl", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[1] = new_item("E-Mail", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[2] = new_item("Beenden", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[3] = nullptr; + TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); + set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); + set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); + set_menu_spacing(TOPMENU.UME.UMEMenu, 0, 0, 0); + set_menu_format(TOPMENU.UME.UMEMenu, 5, 0); + menu_opts_off(TOPMENU.UME.UMEMenu, O_SHOWDESC); + menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); + set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); + set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); + set_menu_mark(TOPMENU.UME.UMEMenu, ""); + set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); + post_menu(TOPMENU.UME.UMEMenu); +} /* Info Untermenü */ +WINDOW* MenuWinClass::TempWin(string Name, MenuID MID) { + if ((Name.compare(" Datei") == 0) || (MID == DATEIMENU)) { + //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, DATEIMENU, "DATEIMENU"); + MenuWinClass::DateiMenu(); + MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; + MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; + } else if ((Name.compare("DaemonType") == 0) || (MID == DAEMONMENU)) { + //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, SYSTEMMENU, "SYSTEMMENU"); + MenuWinClass::DaemonTypeMenu(); + MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; + MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; + } else if ((Name.compare("Systemctl") == 0) || (MID == SYSTEMCTLMENU)) { + //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, SERVERMENU, "SERVERMENU"); + MenuWinClass::SystemctlMenu(); + MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; + MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; + } else if ((Name.compare("Info") == 0) || (MID == INFOMENU)) { + //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, SOFTWAREMENU, "SOFTWAREMENU"); + MenuWinClass::InfoMenu(); + MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; + MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; + } + return MenuWinClass::TMPWIN; +} /* Menü und Win Neuzuordnen */ +void MenuWinClass::StartMenuAuswahl(string wahl) { + string menupoint = MenuWinClass::SERVICEMENU.AktivName; + string befehl; + if (wahl.compare(" Datei") == 0) { + DateiMenu(); + } else if (wahl.compare("Systemctl") == 0) { + SystemctlMenu(); + } else if (wahl.compare("DaemonType") == 0) { + DaemonTypeMenu(); + } else if (wahl.compare("Systemctl") == 0) { + InfoMenu(); + } else if (wahl.compare("Service") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "service"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Swap") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "swap"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Timer") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "timer"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Device") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "device"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Mount") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "mount"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Path") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "path"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Target") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "target"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Socket") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "socket"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Slice") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "slice"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Scope") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "scope"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Man Page") == 0) { + exit(EXIT_SUCCESS); + //DATEIMANPAGE::Start_ManP(); + } else if (wahl.compare("Befehle") == 0) { + exit(EXIT_SUCCESS); + //DATEIBEFEHLE::befehle_main(); + } else if (wahl.compare("Einstellung") == 0) { + exit(EXIT_SUCCESS); + //einDa(); + } else if (wahl.compare("Beenden") == 0) { + exit(EXIT_SUCCESS); + } else if (wahl.compare("START") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl start " + menupoint + " --now"; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("STOP") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl stop " + menupoint + " --now"; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("RELOAD") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl reload " + menupoint + " --now"; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("RESTART") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl restart " + menupoint + " --now"; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("ENABLE") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl enable " + menupoint; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("DISABLE") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl disable " + menupoint; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("STATUS") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl status " + menupoint; + ServiceClass_MWC->Statusabfrage(TaskClass_MWC->TERM_AUSGABE(befehl)); + } else if (wahl.compare("UNMASK") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl unmask " + menupoint; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("MASK") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl mask " + menupoint; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("journalctl") == 0) { + befehl = "journalctl -b -u " + menupoint; + ServiceClass_MWC->Statusabfrage(TaskClass_MWC->TERM_AUSGABE(befehl)); + } +} /* MenüPoint to command */ +void MenuWinClass::RefreshWindows(){ + refresh(); + wrefresh(MenuWinClass::START.TMPWin1); + redrawwin(MenuWinClass::START.TMPWin2); + wrefresh(MenuWinClass::START.TMPWin2); + touchwin(MenuWinClass::START.TMPWin2); + redrawwin(MenuWinClass::START.TMPWin3); + wrefresh(MenuWinClass::START.TMPWin3); + touchwin(MenuWinClass::START.TMPWin3); + prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); + //prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY()-4, + // MenuWinClass::START.WCX()-46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); + wrefresh(MenuWinClass::START.TMPWin5); +} + +int MenuWinClass::MenuStart(int Key) { +//try { + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[MenuWinClass::MeInAl]); + TMPWIN = TempWin(item_name(current_item(MenuWinClass::TOPMENU.HMMenu)), (MenuID)item_index(current_item(MenuWinClass::TOPMENU.HMMenu))); + string tmpMeNa = string(item_name(current_item(MenuWinClass::TOPMENU.HMMenu))); + string MeAuWa = ""; + ServiceClass_MWC->TableMoveRow(); + while ((Key = wgetch(stdscr)) != KEY_F(10)) { + switch (MenuWinClass::TabKey) { + case 1: { + switch (Key) { + case '?': { ServiceClass_MWC->Statusabfrage(ABOUT_INFO); break; } + case 27: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(1, "++", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case KEY_DOWN: { + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_DOWN_ITEM); + ServiceClass_MWC->TableMoveRow(); + break; + } + case KEY_UP: { + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_UP_ITEM); + ServiceClass_MWC->TableMoveRow(); + break; + } + case KEY_NPAGE: { + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_SCR_DPAGE); + ServiceClass_MWC->TableMoveRow(); + break; + } + case KEY_PPAGE: { + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_SCR_UPAGE); + ServiceClass_MWC->TableMoveRow(); + break; + } + case KEY_END: { + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_LAST_ITEM); + ServiceClass_MWC->TableMoveRow(); + break; + } + case KEY_HOME: { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_FIRST_ITEM); + ServiceClass_MWC->TableMoveRow(); + break; + } + case 0x09: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(1, "++", 3); + TMPWIN = TempWin("Datei", DATEIMENU); + redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); + wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); + break; + } + case KEY_BTAB: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(1, "--", 3); + TMPWIN = TempWin("Datei", DATEIMENU); + redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); + wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); + break; + } + case KEY_BACKSPACE: { ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_BACK_PATTERN); break; } + case 10: { + string menupoint = MenuWinClass::SERVICEMENU.AktivName; + string befehl = "systemctl status " + menupoint; + ServiceClass_MWC->Statusabfrage(TaskClass_MWC->TERM_AUSGABE(befehl)); + break; } + case 32: { ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_TOGGLE_ITEM); break; } + default: { if (Key > 10 && Key < 128) { + //ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_NEXT_MATCH); + } + break;} + } + if (MenuWinClass_MWC->TabKey == 1) { + curs_set(false); + ServiceClass_MWC->INFOWINDOW(MenuWinClass::SERVICEMENU.AktivName); + MenuWinClass::TOPMENU.LoescheUME(); + MenuWinClass::RefreshWindows(); + } else if (MenuWinClass_MWC->TabKey == 2) { + curs_set(false); + MenuWinClass::RefreshWindows(); + wrefresh(MenuWinClass::START.TMPWin1); + redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); + wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); + } else if (MenuWinClass_MWC->TabKey == 3) { + curs_set(true); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass::PATTERN.c_str(), -1); + MenuWinClass::RefreshWindows(); + } + break; + } /* MainWindow ListMenu */ + case 2: { + switch (Key) { + case '?': { ServiceClass_MWC->Statusabfrage(ABOUT_INFO); break; } + case 27: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "++", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case KEY_DOWN: { menu_driver(TOPMENU.UME.UMEMenu, REQ_DOWN_ITEM); break; } + case KEY_UP: { menu_driver(TOPMENU.UME.UMEMenu, REQ_UP_ITEM); break; } + case KEY_RIGHT: { + MenuWinClass::TOPMENU.LoescheUME(); + menu_driver(MenuWinClass::TOPMENU.HMMenu, REQ_RIGHT_ITEM); + tmpMeNa = string(item_name(current_item(MenuWinClass::TOPMENU.HMMenu))); + TMPWIN = TempWin(item_name(current_item(MenuWinClass::TOPMENU.HMMenu)), (MenuID)item_index(current_item(MenuWinClass::TOPMENU.HMMenu))); + break; + } + case KEY_LEFT: { + MenuWinClass::TOPMENU.LoescheUME(); // delete before menu drive + menu_driver(MenuWinClass::TOPMENU.HMMenu, REQ_LEFT_ITEM); + tmpMeNa = string(item_name(current_item(MenuWinClass::TOPMENU.HMMenu))); + TMPWIN = TempWin(item_name(current_item(MenuWinClass::TOPMENU.HMMenu)), (MenuID)item_index(current_item(MenuWinClass::TOPMENU.HMMenu))); + break; + } + case 0x09: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "++", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case KEY_BTAB: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "--", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case 10: { + MenuWinClass::MeInAl = item_index(current_item(MenuWinClass::TOPMENU.HMMenu)); + StartMenuAuswahl(item_name(current_item(MenuWinClass::TOPMENU.UME.UMEMenu))); + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "++", 2); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; } + } + if (MenuWinClass_MWC->TabKey == 1) { + curs_set(false); + ServiceClass_MWC->INFOWINDOW(MenuWinClass::SERVICEMENU.AktivName); + MenuWinClass::TOPMENU.LoescheUME(); + MenuWinClass::RefreshWindows(); + } else if (MenuWinClass_MWC->TabKey == 2) { + curs_set(false); + MenuWinClass::RefreshWindows(); + wrefresh(MenuWinClass::START.TMPWin1); + redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); + wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); + } else if (MenuWinClass_MWC->TabKey == 3) { + curs_set(true); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass::PATTERN.c_str(), -1); + MenuWinClass::RefreshWindows(); + } + break; + } /* Hauptmenu */ + case 3:{ + int y,x; + getyx(MenuWinClass::START.TMPWin3, y, x); + int curposi = (x - 33); + switch (Key) { + case '?':{ ServiceClass_MWC->Statusabfrage(ABOUT_INFO); break; } + case 27:{ break; } + case 127: + case KEY_BACKSPACE:{ + MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_DEL_BACKSPACE, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); + break; } + case KEY_DC:{ + MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_DEL_DC, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); + break; } + case KEY_RIGHT:{ + MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_RIGHT, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); + break; } + case KEY_LEFT:{ + MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_LEFT, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); + break; } + case 0x09: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(3, "++", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case KEY_BTAB: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(3, "--", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case KEY_ENTER: + case 10:{ break; } + default:{ + if (Key > 10 && Key < 128) { + MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_INS_DEFAULT, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); + //ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_NEXT_MATCH); + } + break; } + } + if (MenuWinClass_MWC->TabKey == 1) { + curs_set(false); + ServiceClass_MWC->INFOWINDOW(MenuWinClass::SERVICEMENU.AktivName); + MenuWinClass::TOPMENU.LoescheUME(); + MenuWinClass::RefreshWindows(); + } else if (MenuWinClass_MWC->TabKey == 2) { + curs_set(false); + MenuWinClass::RefreshWindows(); + wrefresh(MenuWinClass::START.TMPWin1); + redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); + wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); + } else if (MenuWinClass_MWC->TabKey == 3) { + curs_set(true); + MenuWinClass::RefreshWindows(); + } + break; + }/* search at tmpwin3 */ + } + if (Key == KEY_F(10)) { break; } + } + return Key; +// } catch (const NCursesException* e) { endwin(); std::cerr << e->message << std::endl; cout << e->errorno; return -1; +// } catch (const NCursesException& e) { endwin(); std::cerr << e.message << std::endl; cout << e.errorno; return -1; +// } catch (const std::exception& e) { endwin(); std::cerr << "Exception: " << e.what() << std::endl; cout << EXIT_FAILURE; return -1; } +} /* Menü surf funktion */ + +MenuWinClass::~MenuWinClass(){ + if (MenuWinClass::START.TMPWin1) {werase(MenuWinClass::START.TMPWin1); delwin(MenuWinClass::START.TMPWin1); endwin();} + if (MenuWinClass::START.TMPWin2) {werase(MenuWinClass::START.TMPWin2); delwin(MenuWinClass::START.TMPWin2); endwin();} + if (MenuWinClass::START.TMPWin3) {werase(MenuWinClass::START.TMPWin3); delwin(MenuWinClass::START.TMPWin3); endwin();} + if (MenuWinClass::START.TMPWin4) {werase(MenuWinClass::START.TMPWin4); delwin(MenuWinClass::START.TMPWin4); endwin();} + if (MenuWinClass::START.TMPWin5) {werase(MenuWinClass::START.TMPWin5); delwin(MenuWinClass::START.TMPWin5); endwin();} +} + + diff --git a/MenuWinClass.h b/MenuWinClass.h new file mode 100644 index 0000000..20a6e63 --- /dev/null +++ b/MenuWinClass.h @@ -0,0 +1,205 @@ +#ifndef MENUWINCLASS_H +#define MENUWINCLASS_H + +#include +#include +#include + +using namespace std; + +enum WinID { MENUWIN = 0, MAINWIN = 1, INFOWIN = 2, LISTPAD = 3, DESCWIN = 4, TIMEWIN = 5, ENDWIN = 6 }; +enum MenuID { DATEIMENU = 0, DAEMONMENU = 1, SYSTEMCTLMENU = 2, INFOMENU = 3, MAINMENU = 4, ENDMENU = 5 }; + +struct FENSTER { + int FEID {0}; + string FENAME {""}; + int BorderWeight {1}; + int BorderHeight {1}; + int WCX() {return static_cast(roundf(getmaxx(stdscr)));}; /* W=weight C=column X=x achse */ + int HRY() {return static_cast(roundf(getmaxy(stdscr)));}; /* H=height R=row Y=y achse */ + int HRYw1() {return static_cast(roundf(1));}; + int WCXw1() {return static_cast(roundf(WCX()));}; + WinID TMPWin1ID {MENUWIN}; + WINDOW *TMPWin1 = newwin(HRYw1(), WCXw1(), 0, 0); + int HRYw2() {return static_cast(roundf(HRY() - (HRYw1() + HRYw3())));}; + int WCXw2() {return static_cast(roundf(WCX()));}; + WinID TMPWin2ID {MAINWIN}; + WINDOW *TMPWin2 = newwin(HRYw2(), WCXw2(), 1, 0); + int HRYw3() {return static_cast(roundf(6));}; + int WCXw3() {return static_cast(roundf(WCX()));}; + WinID TMPWin3ID {INFOWIN}; + WINDOW *TMPWin3 = newwin(HRYw3(), WCXw3(), (HRYw1() + HRYw2()), 0); + int HRYw4() {return static_cast(roundf(HRYw2() - ((BorderWeight * 2))));}; + int WCXw4() {return static_cast(roundf(WCXw2() - (BorderWeight * 2)));}; + WinID TMPWin4ID {LISTPAD}; + WINDOW *TMPWin4 = newpad(HRYw4(), WCXw4()); + int HRYw5() {return static_cast(roundf(HRYw3() - ((BorderWeight * 2) + 1)));}; + int WCXw5() {return static_cast(roundf(WCXw3() - ((BorderWeight * 2) + 32)));}; + WinID TMPWin5ID {DESCWIN}; + WINDOW *TMPWin5 = newpad(HRYw5(), WCXw5()); + int HRYtime() {return static_cast(roundf(1));}; + int WCXtime() {return static_cast(roundf(20));}; + WinID TimeWinID {TIMEWIN}; + WINDOW *TimeWin = newwin(HRYtime(), WCXtime(), 0, (WCX() - 20)); + int TMPWinHigh {0}; + FORM *TMPForm1 {nullptr}; + FIELD **TMPField1 {nullptr}; + struct WinSize { + int RAND = 1; + int w {1}; + int h {1}; + int WCX(){return static_cast(roundf(getmaxx(stdscr)));}; + int HRY(){return static_cast(roundf(getmaxy(stdscr)));}; + int WCX_Real(){return static_cast(roundf(WCX() - (2 * RAND)));} + int HRY_Real(){return static_cast(roundf(HRY() - (2 * RAND)));} + int WCX_Center(){return static_cast(roundf(WCX() / 2));}; + int HRY_Center(){return static_cast(roundf(HRY() / 2));}; + int WCX_TmpWin(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin)));}; + int HRY_TmpWin(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin)));}; + int WCX_TmpWinReal(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin) - (2 * RAND)));}; + int HRY_TmpWinReal(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin) - (2 * RAND)));}; + int WCX_TmpWinCenter(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin) / 2));}; + int HRY_TmpWinCenter(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin) / 2));}; + unsigned long WinHalfDurch(WINDOW * tmpwin, int TeilDurch){return static_cast(roundf(WCX_TmpWinCenter(tmpwin) / TeilDurch));}; + } WinSize; + struct WinColor { + int BK_MENUWIN = 78; // 78 Text=MY_LIGHT_WHITE, Bk=MY_MARIN_BLUE + int BK_MAINWIN = 78; // 87 Text=MY_MARIN_BLUE, Bk=MY_LIGHT_WHITE + int BK_INFOWIN = 78; + int BK_LISTPAD = 78; + int BK_DESCWIN = 78; + int BK_TIMEWIN = 70; + int BK_HELPWIN = 74; + int WinBk_Main = 78; //Fenster_Background + int WinFo_Main = 78; //Fenster_Foreground + int WinBk_Info = 78; //info fenster_Background + int WinFo_Info = 78; //info fenster foreground + int WinBk_Help = 74; //help fenster Background + int WinFo_Help = 74; //help fenster foreground + } WinColor; + void delwinow(WINDOW *tmpwin){ + if(tmpwin){ + int mx,my,bx,by; + getbegyx(tmpwin,by,bx); + getmaxyx(tmpwin,my,mx); + touchwin(tmpwin); + wborder(tmpwin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); + touchline(tmpwin,bx,mx); + delwin(tmpwin); + endwin(); + tmpwin=nullptr; + } + } + /* void delmenu(WINDOW *tmpwin, MENU *tmpmenu, ITEM **tmpitem){ + if (tmpmenu){ + int E = item_count(tmpmenu); + unpost_menu(tmpmenu); + SAFE_DELETE(tmpmenu); + SAFE_DELETE_ARRAY(tmpitem); + wborder(tmpwin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); + touchline(tmpwin,0,E+1); + delwin(tmpwin); + endwin(); + } + }*/ + void delform(WINDOW *tmpwin, FORM *tmpform, FIELD **tmpfield){ + if (tmpform){ + int mx,my,bx,by; + getbegyx(tmpwin,by,bx); + getmaxyx(tmpwin,my,mx); + unpost_form(tmpform); + SAFE_DELETE(tmpform); + SAFE_DELETE_ARRAY(tmpfield); + wborder(tmpwin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); + touchline(tmpwin,bx,mx); + delwin(tmpwin); + endwin(); + } + } +}; +struct HAUPTMENU { + MenuID MID; + string HMName; + MENU *HMMenu {nullptr}; + ITEM **HMItem {nullptr}; + //############################################### + struct UNTERMENU { + int UMID; + string UMEName; + WINDOW *UMEWin; + MENU *UMEMenu; + ITEM **UMEItem; + }UME; + struct MenuColor { + int BK_MAINMENU = 78; // 78 Text=MY_LIGHT_WHITE, Bk=MY_MARIN_BLUE + int BK_UNTERMENU = 78; // 87 Text=MY_MARIN_BLUE, Bk=MY_LIGHT_WHITE + int BK_AKTIVHAME = 18; + int BK_AKTIVUNME = 18; + int BK_UNUSEDHM = 78; + int BK_UNUSEDUM = 78; + } MenuColor; + void LoescheUME(){ + int E = item_count(UME.UMEMenu); + unpost_menu(UME.UMEMenu); + SAFE_DELETE(UME.UMEMenu); + SAFE_DELETE_ARRAY(UME.UMEItem); + wborder(UME.UMEWin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); + touchline(UME.UMEWin,0,E+1); + delwin(UME.UMEWin); + endwin(); + refresh(); + } +}; +struct INAPPMENU { + friend class MenuWinClass; + int LMID; + std::string LMName; + MENU* LMenu {nullptr}; + ITEM** LMItem {nullptr}; + string AktivName = ""; + +}; + +class MenuWinClass: public INAPPMENU { +public: + /*################################################*/ + static FENSTER START; + static HAUPTMENU TOPMENU; + static int MeInAl; + static WINDOW *TMPWIN; + static MENU *TMPMENU; + static INAPPMENU SERVICEMENU; + static int LiMeInAl; + static WINDOW* LiTMPWIN; + static MENU* LiTMPMENU; + static string PATTERN; + static int TabKey;// {1}; + /*#############_WINDOW_###########################*/ + static void StartWin(); + static void StopWin(); + static void SetWinSize(); + static void AppColor(); + static void CreateWin(WINDOW *win, WinID WID); + void FensterDraw(); + static void ResizeHandler(int signal); + void ScrollPad(WINDOW *SubWin, int StartY, int StartX, int Height, int Width, int PadHeight); + void printInMiddle(WINDOW *win, int starty, int startx, int width, char *text, chtype color, char *sp); + /*#############_MENÜ_#############################*/ + static void Hauptmenu(void); + static void DateiMenu(void); + static void DaemonTypeMenu(void); + static void SystemctlMenu(void); + static void InfoMenu(void); + static WINDOW* TempWin(string Name, MenuID MID); + static void StartMenuAuswahl(string wahl); + static void RefreshWindows(); + static int MenuStart(int Key); + /*#############_Constructor/De_###################*/ + MenuWinClass(); + ~MenuWinClass(); + /*################################################*/ +}; + + + +#endif // MENUWINCLASS_H diff --git a/ServiceClass.cpp b/ServiceClass.cpp index efc11bc..ed8ccca 100644 --- a/ServiceClass.cpp +++ b/ServiceClass.cpp @@ -1,22 +1,18 @@ -#include -#include -#include -#include -#include +#include using namespace std; -extern class TaskClass * TaskPtr; -extern class MenuClass * MenuPtr; -//extern class ServiceClass * ServicePtr; -extern class WinClass * WinPtr; +TaskClass *TaskClass_SC = new TaskClass(); +//MenuClass *MenuPtr_SC = new MenuClass(); +ServiceClass *ServiceClass_SC = new ServiceClass(); +//WinClass *WinPtr_SC = new WinClass(); +MenuWinClass *MenuWinClass_SC = new MenuWinClass(); int X = 0; - +/*##################################################################################*/ void ServiceClass::ServiceListFill() { - //string tmpSystemd = TaskPtr->TERM_AUSGABE("systemctl --all | egrep 'timer|target|swap|socket|service|slice|scope|path|mount|device' | awk '{$1=$1};1' | sed 's/● //g'"); - string tmpService = TaskPtr->TERM_AUSGABE("systemctl list-unit-files -t "+ systemctlwahl +" | grep '."+ systemctlwahl +"' | awk '{$1=$1};1' | sort"); - string tmpServiceInfo = TaskPtr->TERM_AUSGABE("systemctl --all --type="+ systemctlwahl +" | grep '."+ systemctlwahl +"' | awk '{$1=$1};1' | sed 's/● //g' | sort"); + string tmpService = TaskClass_SC->TERM_AUSGABE("systemctl list-unit-files -t "+ systemctlwahl +" | grep '."+ systemctlwahl +"' | awk '{$1=$1};1' | sort"); + string tmpServiceInfo = TaskClass_SC->TERM_AUSGABE("systemctl --all --type="+ systemctlwahl +" | grep '."+ systemctlwahl +"' | awk '{$1=$1};1' | sed 's/● //g' | sort"); string tmpstr1,tmpstr2; std::vector tmpaa,tmpbb; ServiceList.clear(); @@ -27,18 +23,18 @@ void ServiceClass::ServiceListFill() { if (filestream) { while (getline(filestream,tmpstr1)){ tmpaa.push_back(string()); - tmpaa = TaskPtr->StringTeiler(tmpstr1,' '); + tmpaa = TaskClass_SC->StringTeiler(tmpstr1,' '); ServiceList.push_back(SERVICES()); ServiceList[X].SID = static_cast(X); ServiceList[X].Name = tmpaa[0]; ServiceList[X].Status = tmpaa[1]; - ServiceList[X].Target = systemctlwahl; //ServiceList[X].Name.substr(ServiceList[X].Name.find(".")+1,ServiceList[X].Name.length()); + ServiceList[X].Target = systemctlwahl; X++; tmpaa.clear(); vector().swap(tmpaa); } } else { - mvwaddnstr(WinPtr->START.TMPWin3, 5, 5, "failed to open or read" ,-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 5, 5, "failed to open or read" ,-1); } X = 0; @@ -46,7 +42,7 @@ void ServiceClass::ServiceListFill() { if (filestream2) { while (getline(filestream2,tmpstr2)){ tmpbb.push_back(string()); - tmpbb = TaskPtr->StringTeiler(tmpstr2,' '); + tmpbb = TaskClass_SC->StringTeiler(tmpstr2,' '); for(unsigned long Z = 0; Z < static_cast(ServiceList.size()); Z++) { if (ServiceList[Z].Name.compare(tmpbb[0].c_str())==0) { ServiceList.push_back(SERVICES()); @@ -68,173 +64,168 @@ void ServiceClass::ServiceListFill() { vector().swap(tmpbb); } } else { - mvwaddnstr(WinPtr->START.TMPWin3, 5, 5, "failed to open or read" ,-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 5, 5, "failed to open or read" ,-1); } SetStateOption(); // ServiceListe(); } - void ServiceClass::ServiceListe(){ - if (MenuPtr->LiMENU.LMItem){unpost_menu(MenuPtr->LiMENU.LMenu);SAFE_DELETE(MenuPtr->LiMENU.LMItem);SAFE_DELETE_ARRAY(MenuPtr->LiMENU.LMItem);} - if (MenuPtr->LiMENU.LMWin){werase(MenuPtr->LiMENU.LMWin);delwin(MenuPtr->LiMENU.LMWin);endwin();} + if (MenuWinClass_SC->SERVICEMENU.LMItem){unpost_menu(MenuWinClass_SC->SERVICEMENU.LMenu);SAFE_DELETE(MenuWinClass_SC->SERVICEMENU.LMItem);SAFE_DELETE_ARRAY(MenuWinClass_SC->SERVICEMENU.LMItem);} + if (MenuWinClass::START.TMPWin4){werase(MenuWinClass::START.TMPWin4);delwin(MenuWinClass::START.TMPWin4);endwin();} int mrows = 0; int mcols = 0; unsigned long count = ServiceList.size(); - MenuPtr->LiMENU.LMItem = static_cast(calloc(count, sizeof(ITEM *))); + MenuWinClass_SC->SERVICEMENU.LMItem = static_cast(calloc(count, sizeof(ITEM *))); for (unsigned long i = 0; i < (count-2); i++) { - MenuPtr->LiMENU.LMItem[i] = new_item(ServiceList[i].Name.c_str(), ServiceList[i].Status.c_str()); + MenuWinClass_SC->SERVICEMENU.LMItem[i] = new_item(ServiceList[i].Name.c_str(), ServiceList[i].Status.c_str()); } - MenuPtr->LiMENU.LMItem[count-1] = nullptr; - MenuPtr->LiMENU.LMenu = new_menu(MenuPtr->LiMENU.LMItem); - scale_menu(MenuPtr->LiMENU.LMenu, &mrows, &mcols); - MenuPtr->LiMENU.LMWin = newpad(TaskPtr->WinFullSize(WinPtr->START.TMPWin2,static_cast(count),"H"), TaskPtr->WinFullSize(WinPtr->START.TMPWin2,mcols,"W")); - wbkgd(MenuPtr->LiMENU.LMWin, COLOR_PAIR(WinPtr->WindowColor.FeBk_Main)); - set_menu_win(MenuPtr->LiMENU.LMenu, MenuPtr->LiMENU.LMWin); - set_menu_sub(MenuPtr->LiMENU.LMenu, MenuPtr->LiMENU.LMWin); - set_menu_format(MenuPtr->LiMENU.LMenu, WinPtr->WinSize->HRY()-9, 1); //-3 - set_menu_spacing(MenuPtr->LiMENU.LMenu, 0, 0, 0); - menu_opts_off(MenuPtr->LiMENU.LMenu, O_SELECTABLE); - menu_opts_on(MenuPtr->LiMENU.LMenu, O_NONCYCLIC); - set_menu_fore(MenuPtr->LiMENU.LMenu, COLOR_PAIR(20)|A_BOLD|A_REVERSE); - set_menu_back(MenuPtr->LiMENU.LMenu, COLOR_PAIR(78)|A_BOLD); - set_menu_grey(MenuPtr->LiMENU.LMenu, COLOR_PAIR(30)); - set_menu_mark(MenuPtr->LiMENU.LMenu, ""); - post_menu(MenuPtr->LiMENU.LMenu); + MenuWinClass_SC->SERVICEMENU.LMItem[count-1] = nullptr; + MenuWinClass_SC->SERVICEMENU.LMenu = new_menu(MenuWinClass_SC->SERVICEMENU.LMItem); + scale_menu(MenuWinClass_SC->SERVICEMENU.LMenu, &mrows, &mcols); + MenuWinClass::START.TMPWin4 = newpad(TaskClass_SC->WinFullSize(MenuWinClass::START.TMPWin2,static_cast(count),"H"), TaskClass_SC->WinFullSize(MenuWinClass::START.TMPWin2,mcols,"W")); + wbkgd(MenuWinClass::START.TMPWin4, COLOR_PAIR(MenuWinClass::START.WinColor.BK_LISTPAD)); + set_menu_win(MenuWinClass_SC->SERVICEMENU.LMenu, MenuWinClass::START.TMPWin4); + set_menu_sub(MenuWinClass_SC->SERVICEMENU.LMenu, MenuWinClass::START.TMPWin4); + set_menu_format(MenuWinClass_SC->SERVICEMENU.LMenu, MenuWinClass_SC->START.HRY()-9, 1); //-3 + set_menu_spacing(MenuWinClass_SC->SERVICEMENU.LMenu, 0, 0, 0); + menu_opts_off(MenuWinClass_SC->SERVICEMENU.LMenu, O_SELECTABLE); + menu_opts_on(MenuWinClass_SC->SERVICEMENU.LMenu, O_NONCYCLIC); + set_menu_fore(MenuWinClass_SC->SERVICEMENU.LMenu, COLOR_PAIR(20)|A_BOLD|A_REVERSE); + set_menu_back(MenuWinClass_SC->SERVICEMENU.LMenu, COLOR_PAIR(78)|A_BOLD); + set_menu_grey(MenuWinClass_SC->SERVICEMENU.LMenu, COLOR_PAIR(30)); + set_menu_mark(MenuWinClass_SC->SERVICEMENU.LMenu, ""); + post_menu(MenuWinClass_SC->SERVICEMENU.LMenu); } - void ServiceClass::INFOWINDOW(string Name){ - werase(WinPtr->START.TMPWin5); - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(WinPtr->WindowColor.FeFo_Info)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 1, 1, "STATE: " ,-1); - mvwaddnstr(WinPtr->START.TMPWin4, 2, 1, "LOAD: " ,-1); - mvwaddnstr(WinPtr->START.TMPWin4, 3, 1, "AKTIVE: " ,-1); //9 - mvwaddnstr(WinPtr->START.TMPWin4, 4, 1, "SUB: " ,-1); - mvwaddnstr(WinPtr->START.TMPWin4, 1, 26, "DESC:" ,-1); - mvwaddnstr(WinPtr->START.TMPWin4, 4, 26, "Suche:" ,-1); - //mvwaddnstr(WinPtr->START.TMPWin4, 6, 1, " " ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(WinPtr->WindowColor.FeFo_Info)|A_BOLD,nullptr); + werase(MenuWinClass::START.TMPWin5); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 1, "STATE: " ,-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 1, "LOAD: " ,-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 1, "AKTIVE: " ,-1); //9 + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 1, "SUB: " ,-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 26, "DESC:" ,-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 26, "Suche:" ,-1); + //mvwaddnstr(MenuWinClass::START.TMPWin3, 6, 1, " " ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN)|A_BOLD,nullptr); for (unsigned long X = 0; X < static_cast(ServiceList.size());X++){ if (ServiceList[X].Name.compare(Name)==0) { switch (ServiceList[X].state) { case UNIT_STATE_ENABLED: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 1, 9, ServiceList[X].Status.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); break; case UNIT_STATE_BAD: case UNIT_STATE_DISABLED: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 1, 9, ServiceList[X].Status.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); break; case UNIT_STATE_STATIC: case UNIT_STATE_MASKED: case UNIT_STATE_GENERATED: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 1, 9, ServiceList[X].Status.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); break; case UNIT_STATE_TMP: default: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 1, 9, ServiceList[X].Status.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); break; } // ende status switch switch (ServiceList[X].load) { case UNIT_LOADSTATE_LOADED: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 2, 9, ServiceList[X].Load.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 9, ServiceList[X].Load.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); break; case UNIT_LOADSTATE_NOTFOUND: case UNIT_LOADSTATE_UNLOAD: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 2, 9, ServiceList[X].Load.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 9, ServiceList[X].Load.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); break; default: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 2, 9, ServiceList[X].Load.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 9, ServiceList[X].Load.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); break; } // ende load switch switch (ServiceList[X].active) { case UNIT_ACTIVESTATE_ACTIVE: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 3, 9, ServiceList[X].Active.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 9, ServiceList[X].Active.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); break; case UNIT_ACTIVESTATE_INACTIVE: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 3, 9, ServiceList[X].Active.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 9, ServiceList[X].Active.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); break; default: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 3, 9, ServiceList[X].Active.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 9, ServiceList[X].Active.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); break; } switch (ServiceList[X].substate) { case UNIT_SUBSTATE_RUNNING: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); break; case UNIT_SUBSTATE_CONNECTED: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); case UNIT_SUBSTATE_INVALID: case UNIT_SUBSTATE_EXITED: case UNIT_SUBSTATE_DEAD: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); break; default: - wattr_on(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin4, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); break; } - wattr_on(WinPtr->START.TMPWin5, COLOR_PAIR(30)|A_BOLD,nullptr); - mvwaddnstr(WinPtr->START.TMPWin5, 0, 0, ServiceList[X].Description.c_str() ,-1); - wattr_off(WinPtr->START.TMPWin5, COLOR_PAIR(30)|A_BOLD,nullptr); + //wattr_on(MenuWinClass::START.TMPWin5, COLOR_PAIR(78)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin5, 0, 0, ServiceList[X].Description.c_str() ,-1); + //wattr_off(MenuWinClass::START.TMPWin5, COLOR_PAIR(78)|A_BOLD,nullptr); } } } - void ServiceClass::Statusabfrage(string ausgabestatus) { int hoehe; - int rowy = WinPtr->WinSize->HRY()-4; - int ROWS = 0; - int keytab; - - STATUSWIN = newwin(WinPtr->WinSize->HRY()-2, WinPtr->WinSize->WCX()-2, 1, 1); - wbkgd(STATUSWIN, COLOR_PAIR(WinPtr->WindowColor.FeBk_Help)|A_BOLD); + int rowy = MenuWinClass_SC->START.HRY()-4; + int ROWS = 0; int Key; + STATUSWIN = newwin(MenuWinClass_SC->START.HRY()-2, MenuWinClass_SC->START.WCX()-2, 1, 1); + wbkgd(STATUSWIN, COLOR_PAIR(MenuWinClass::START.WinColor.WinBk_Help)|A_BOLD); box(STATUSWIN, 0,0); - hoehe = TaskPtr->Zeilen(ausgabestatus.c_str(),WinPtr->WinSize->WCX()-4); - STATUSINFO = newpad(hoehe, WinPtr->WinSize->WCX()-4); - wbkgd(STATUSINFO, COLOR_PAIR(WinPtr->WindowColor.FeBk_Help)|A_BOLD); - STATUSINFO = derwin(STATUSWIN, WinPtr->WinSize->HRY()-4, WinPtr->WinSize->WCX()-4, 1, 1); - wattr_on(STATUSINFO, COLOR_PAIR(WinPtr->WindowColor.FeFo_Help)|A_BOLD,nullptr); + hoehe = TaskClass_SC->Zeilen(ausgabestatus.c_str(),MenuWinClass_SC->START.WCX()-4); + STATUSINFO = newpad(hoehe, MenuWinClass_SC->START.WCX()-4); + wbkgd(STATUSINFO, COLOR_PAIR(MenuWinClass::START.WinColor.WinBk_Help)|A_BOLD); + STATUSINFO = derwin(STATUSWIN, MenuWinClass_SC->START.HRY()-4, MenuWinClass_SC->START.WCX()-4, 1, 1); + wattr_on(STATUSINFO, COLOR_PAIR(MenuWinClass::START.WinColor.WinFo_Help)|A_BOLD,nullptr); mvwaddnstr(STATUSINFO, 0, 0, ausgabestatus.c_str(),-1); - wattr_off(STATUSINFO, COLOR_PAIR(WinPtr->WindowColor.FeFo_Info)|A_BOLD,nullptr); + wattr_off(STATUSINFO, COLOR_PAIR(MenuWinClass::START.WinColor.WinFo_Info)|A_BOLD,nullptr); wattr_on(STATUSWIN, COLOR_PAIR(70)|A_BOLD,nullptr); - mvwaddnstr(STATUSWIN, WinPtr->WinSize->HRY() -3, WinPtr->WinSize->WCX()-15, "[ EXIT F10 ]" ,-1); + mvwaddnstr(STATUSWIN, MenuWinClass_SC->START.HRY() -3, MenuWinClass_SC->START.WCX()-15, "[ EXIT ESC ]" ,-1); wattr_off(STATUSWIN, COLOR_PAIR(70)|A_BOLD,nullptr); wrefresh(STATUSWIN); touchwin(STATUSWIN); - prefresh(STATUSINFO, 0, 0, 0, 0, WinPtr->WinSize->HRY() -4, WinPtr->WinSize->WCX()-4); + prefresh(STATUSINFO, 0, 0, 0, 0, MenuWinClass_SC->START.HRY() -4, MenuWinClass_SC->START.WCX()-4); - while ((keytab=getch()) != KEY_F(10)) { - switch (keytab) { + while ((Key=getch()) != 27) { + switch (Key) { case KEY_DOWN:{ if ((ROWS + rowy +1) >= hoehe){ ROWS = hoehe; @@ -250,71 +241,46 @@ void ServiceClass::Statusabfrage(string ausgabestatus) { } break;} default:{ - break; } } refresh(); touchwin(STATUSWIN); - prefresh(STATUSINFO, ROWS, 0, 0, 0, WinPtr->WinSize->HRY() -4, WinPtr->WinSize->WCX()-4); + prefresh(STATUSINFO, ROWS, 0, 0, 0, MenuWinClass_SC->START.HRY() -4, MenuWinClass_SC->START.WCX()-4); } if (STATUSINFO){werase(STATUSINFO);delwin(STATUSINFO);} if (STATUSWIN){werase(STATUSWIN);delwin(STATUSWIN);} - redrawwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - prefresh(MenuPtr->LiMENU.LMWin, 0, 0, 2, 1, WinPtr->WinSize->HRY()-8, WinPtr->WinSize->WCX()-2); + redrawwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + redrawwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + prefresh(MenuWinClass_SC->START.TMPWin4, 0, 0, 2, 1, MenuWinClass_SC->START.HRYw4() + 1, MenuWinClass_SC->START.WCXw4()); + prefresh(MenuWinClass_SC->START.TMPWin5, 0, 0, MenuWinClass_SC->START.HRY()-4, MenuWinClass_SC->START.WCX()-46, MenuWinClass_SC->START.HRYw5(), MenuWinClass_SC->START.WCXw5()); } - -void ServiceClass::ENDE_NEW() { - try { - ServiceList.clear(); - //vector().swap(MenuPtr->ServiceList); - vector(ServiceList).swap (ServiceList); - clear(); - //###############--Hauptmenu--############################################### - int E = item_count(MenuPtr->MENEU.HMMenu); - unpost_menu(MenuPtr->MENEU.HMMenu); - SAFE_DELETE(MenuPtr->MENEU.HMMenu); - SAFE_DELETE_ARRAY(MenuPtr->MENEU.HMItem); - wborder(MenuPtr->MENEU.HMWin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); - touchline(MenuPtr->MENEU.HMWin,0,E+1); - delwin(MenuPtr->MENEU.HMWin); - endwin(); - //###############--Untermenu--############################################### - E = item_count(MenuPtr->MENEU.UME.UMEMenu); - unpost_menu(MenuPtr->MENEU.UME.UMEMenu); - SAFE_DELETE(MenuPtr->MENEU.UME.UMEMenu); - SAFE_DELETE_ARRAY(MenuPtr->MENEU.UME.UMEItem); - wborder(MenuPtr->MENEU.UME.UMEWin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); - touchline(MenuPtr->MENEU.UME.UMEWin,0,E+1); - delwin(MenuPtr->MENEU.UME.UMEWin); - endwin(); - - refresh(); - redrawwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin3)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin3)); - } catch (const NCursesException *e) { - endwin(); - std::cerr << e->message << std::endl; - cout << e->errorno; - } catch (const NCursesException &e) { - endwin(); - std::cerr << e.message << std::endl; - cout << e.errorno; - } catch (const std::exception &e) { - endwin(); - std::cerr << "Exception: " << e.what() << std::endl; - cout << EXIT_FAILURE; - } +void ServiceClass::ENDE() { +// try { + if (MenuWinClass::START.TimeWin) {werase(MenuWinClass::START.TimeWin); delwin(MenuWinClass::START.TimeWin); endwin();} + if (MenuWinClass::SERVICEMENU.LMItem) {unpost_menu(MenuWinClass::SERVICEMENU.LMenu); SAFE_DELETE(MenuWinClass::SERVICEMENU.LMItem); SAFE_DELETE_ARRAY(MenuWinClass::SERVICEMENU.LMItem);} + if (MenuWinClass::TOPMENU.UME.UMEItem) { unpost_menu(MenuWinClass::TOPMENU.UME.UMEMenu); SAFE_DELETE(MenuWinClass::TOPMENU.UME.UMEItem); SAFE_DELETE_ARRAY(MenuWinClass::TOPMENU.UME.UMEItem);} + if (MenuWinClass::TOPMENU.HMItem) { unpost_menu(MenuWinClass::TOPMENU.HMMenu); SAFE_DELETE(MenuWinClass::TOPMENU.HMItem); SAFE_DELETE_ARRAY(MenuWinClass::TOPMENU.HMItem);} + if (MenuWinClass::START.TMPWin5) {werase(MenuWinClass::START.TMPWin5); delwin(MenuWinClass::START.TMPWin5); endwin();} + if (MenuWinClass::START.TMPWin4) {werase(MenuWinClass::START.TMPWin4); delwin(MenuWinClass::START.TMPWin4); endwin();} + if (MenuWinClass::START.TMPWin3) {werase(MenuWinClass::START.TMPWin3); delwin(MenuWinClass::START.TMPWin3); endwin();} + if (MenuWinClass::START.TMPWin2) {werase(MenuWinClass::START.TMPWin2); delwin(MenuWinClass::START.TMPWin2); endwin();} + if (MenuWinClass::START.TMPWin1) {werase(MenuWinClass::START.TMPWin1); delwin(MenuWinClass::START.TMPWin1); endwin();} + werase(stdscr); + ServiceList.clear(); + vector(ServiceList).swap (ServiceList); + clear(); +// } catch (const NCursesException *e) { endwin(); std::cerr << e->message << std::endl; cout << e->errorno; +// } catch (const NCursesException &e) { endwin(); std::cerr << e.message << std::endl; cout << e.errorno; +// } catch (const std::exception &e) { endwin(); std::cerr << "Exception: " << e.what() << std::endl; cout << EXIT_FAILURE; } } - -//################################################################################## +/*##################################################################################*/ // new Systemd bestandteile - void ServiceClass::SetStateOption() { //SERVICES unit // pushitem //vector().swap(ServiceList); //UnitItem *item = new UnitItem(); //string name(unit->id); - //item->Name = name; //item->target = name.substr(name.find_last_of('.') + 1, name.length()); //item->description = string(unit->description == nullptr ? "" : unit->description); @@ -386,195 +352,192 @@ void ServiceClass::SetStateOption() { //SERVICES unit // pushitem // items.push_back(item); BuildWin(); }; - void ServiceClass::BuildWin() { - if (MenuPtr->LiMENU.LMItem){unpost_menu(MenuPtr->LiMENU.LMenu);SAFE_DELETE(MenuPtr->LiMENU.LMItem);SAFE_DELETE_ARRAY(MenuPtr->LiMENU.LMItem);} - if (MenuPtr->LiMENU.LMWin){werase(MenuPtr->LiMENU.LMWin);delwin(MenuPtr->LiMENU.LMWin);endwin();} + if (MenuWinClass_SC->SERVICEMENU.LMItem){unpost_menu(MenuWinClass_SC->SERVICEMENU.LMenu);SAFE_DELETE(MenuWinClass_SC->SERVICEMENU.LMItem);SAFE_DELETE_ARRAY(MenuWinClass_SC->SERVICEMENU.LMItem);} + if (MenuWinClass_SC->START.TMPWin4){werase(MenuWinClass_SC->START.TMPWin4);delwin(MenuWinClass_SC->START.TMPWin4);endwin();} StateColor.Green = 28; StateColor.Yellow = 38; StateColor.Red = 18; StateColor.White = 78; unsigned long count = ServiceList.size(); - MenuPtr->LiMENU.LMWin = newpad(static_cast(count), WinPtr->WinSize->WCX_TmpWinReal(WinPtr->START.TMPWin2)); - wbkgd(MenuPtr->LiMENU.LMWin, COLOR_PAIR(WinPtr->WindowColor.FeBk_Main)); + MenuWinClass_SC->START.TMPWin4 = newpad(static_cast(count), MenuWinClass_SC->START.WinSize.WCX_TmpWinReal(MenuWinClass::START.TMPWin2)); + wbkgd(MenuWinClass_SC->START.TMPWin4, COLOR_PAIR(MenuWinClass::START.WinColor.BK_LISTPAD)); for (unsigned long i = 0; i < ServiceList.size(); i++) { TableDraw(ServiceList[i], static_cast(i)); //TableMoveRow(); } } - void ServiceClass::TableMoveRow() { //drawUnits if (ServiceList.empty()) { // updateUnits(); ServiceListFill(); } // const int oneX = unit->sub & A_COLOR; - for (int i = 0; i < WinPtr->WinSize->HRY_TmpWinReal(WinPtr->START.TMPWin2); i++) { - if ((i + start) > static_cast(ServiceList.size() - 1)) { + for (int i = 0; i < MenuWinClass_SC->START.HRYw4(); i++) { + if ((i + ServiceClass::start) > static_cast(ServiceList.size() - 1)) { break; } SERVICES unit = ServiceList[static_cast(start + i)]; if (i == selected) { StateColor.SetSignalColor(17, 37, 27, 87); - AktivName=ServiceList[static_cast(start + selected)].Name; - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(87)|A_BOLD); + MenuWinClass::SERVICEMENU.AktivName = ServiceList[static_cast(start + selected)].Name; + wattron(MenuWinClass_SC->START.TMPWin4, COLOR_PAIR(87)|A_BOLD); } TableDraw(unit, i); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(87)|A_BOLD); + wattroff(MenuWinClass_SC->START.TMPWin4, COLOR_PAIR(87)|A_BOLD); StateColor.SetSignalColor(18, 38, 28, 78); } /* if (inputFor == INPUT_FOR_LIST) { // drawInfo(); // } else { // drawSearch(); - // } -// refresh(); - wrefresh(TaskPtr->ClearWindow(MenuPtr->LiMENU.LMWin));*/ + // }*/ refresh(); - touchwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - prefresh(MenuPtr->LiMENU.LMWin, 0, 0, 2, 1, WinPtr->WinSize->HRY_TmpWinReal(WinPtr->START.TMPWin2)+1, WinPtr->WinSize->WCX_TmpWinReal(WinPtr->START.TMPWin2));// -2 + touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); + prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY() - 4, MenuWinClass::START.WCX() - 46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); } - void ServiceClass::TableDraw(SERVICES unit, int y) { if (unit.Target.compare(systemctlwahl)==0) { //unit.SID = unit.SID++; - if (unit.Name.size() < static_cast(WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2))) { - unit.Name.resize(WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2), ' '); + if (unit.Name.size() < static_cast(MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2))) { + unit.Name.resize(MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2), ' '); }else { - unit.Name.resize(WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)); + unit.Name.resize(MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)); } - if (unit.Status.size() <= WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4)) { - unit.Status.resize(WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4), ' '); + if (unit.Status.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)) { + unit.Status.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); }else { - unit.Status.resize(WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4)); + unit.Status.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); } - if (unit.SubStatus.size() <= WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4) ) { - unit.SubStatus.resize(WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4), ' '); + if (unit.SubStatus.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4) ) { + unit.SubStatus.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); } else { - unit.SubStatus.resize(WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4)); + unit.SubStatus.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); } - if (unit.Active.size() <= WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4) ) { - unit.Active.resize(WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4), ' '); + if (unit.Active.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4) ) { + unit.Active.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); }else { - unit.Active.resize(WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4)); + unit.Active.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); } - if (unit.Load.size() <= WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4) ) { - unit.Load.resize(WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4), ' '); + if (unit.Load.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4) ) { + unit.Load.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); }else { - unit.Load.resize(WinPtr->WinSize->WinHalfDurch(WinPtr->START.TMPWin2, 4)); + unit.Load.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); } std::string name(unit.Name); - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.White)|A_BOLD); - mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->RAND-1, "%s", name.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.White)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.RAND-1, "%s", name.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); switch (unit.state) { case UNIT_STATE_ENABLED: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Green)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+1, unit.Status.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+1, "%s ", unit.Status.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Green)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%s ", unit.Status.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); break; case UNIT_STATE_BAD: case UNIT_STATE_DISABLED: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Red)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+1, unit.Status.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+1, "%s ", unit.Status.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Red)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%s ", unit.Status.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); break; case UNIT_STATE_STATIC: case UNIT_STATE_MASKED: case UNIT_STATE_GENERATED: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Yellow)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+1, unit.Status.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+1, "%s ", unit.Status.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Yellow)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%s ", unit.Status.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); break; case UNIT_STATE_TMP: default: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.White)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+1, unit.Status.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+1, "%9s", unit.Status.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.White)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%9s", unit.Status.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); break; } switch (unit.load) { case UNIT_LOADSTATE_LOADED: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Green)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2) +11, unit.Load.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX() - 11, unit.LoadStatus.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Green)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +11, unit.Load.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX() - 11, unit.LoadStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); break; case UNIT_LOADSTATE_NOTFOUND: case UNIT_LOADSTATE_UNLOAD: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Red)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2) +11, unit.Load.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX()- 11, unit.LoadStatus.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Red)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +11, unit.Load.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX()- 11, unit.LoadStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); break; default: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.White)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2) +11, unit.Load.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX() - 11, unit.LoadStatus.c_str()); // 3 jetzt 9 - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.White)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +11, unit.Load.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX() - 11, unit.LoadStatus.c_str()); // 3 jetzt 9 + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); break; } switch (unit.active) { case UNIT_ACTIVESTATE_ACTIVE: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Green)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2) +21, unit.Active.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX()- 21, unit.ActiveStatus.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Green)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +21, unit.Active.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX()- 21, unit.ActiveStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); break; case UNIT_ACTIVESTATE_INACTIVE: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Red)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2) +21, unit.Active.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX()- 21, unit.ActiveStatus.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Red)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +21, unit.Active.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX()- 21, unit.ActiveStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); break; default: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.White)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2) +21, unit.Active.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX() - 11, unit.LoadStatus.c_str()); // 3 jetzt 9 - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.White)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +21, unit.Active.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX() - 11, unit.LoadStatus.c_str()); // 3 jetzt 9 + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); break; } switch (unit.substate) { case UNIT_SUBSTATE_RUNNING: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Green)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Green)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); break; case UNIT_SUBSTATE_CONNECTED: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Yellow)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Yellow)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); case UNIT_SUBSTATE_INVALID: case UNIT_SUBSTATE_EXITED: case UNIT_SUBSTATE_DEAD: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Red)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.Red)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); break; default: - wattron(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.White)|A_BOLD); - mvwaddnstr(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); - //mvwprintw(MenuPtr->LiMENU.LMWin, y, WinPtr->WinSize->WCX_TmpWinCenter(WinPtr->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); // 3 jetzt 9 - wattroff(MenuPtr->LiMENU.LMWin, COLOR_PAIR(StateColor.White)|A_BOLD); + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); // 3 jetzt 9 + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); break; } } } - -void ServiceClass::tabledriver(std::vector SRVLIST,int key){ - int ps = WinPtr->WinSize->HRY_TmpWinReal(WinPtr->START.TMPWin2)-1; +void ServiceClass::TableDriver(std::vector SRVLIST,int key){ + int ps = MenuWinClass_SC->START.HRYw4()-1; switch(key){ case REQ_LEFT_ITEM:{ break;} @@ -587,7 +550,7 @@ void ServiceClass::tabledriver(std::vector SRVLIST,int key){ selected--; } if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::tabledriver(SRVLIST,REQ_UP_ITEM); + ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); } break;} case REQ_DOWN_ITEM:{ @@ -606,7 +569,7 @@ void ServiceClass::tabledriver(std::vector SRVLIST,int key){ selected = ps; } if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::tabledriver(SRVLIST,REQ_DOWN_ITEM); + ServiceClass::TableDriver(SRVLIST,REQ_DOWN_ITEM); } break;} case REQ_SCR_ULINE:{ @@ -622,7 +585,7 @@ void ServiceClass::tabledriver(std::vector SRVLIST,int key){ selected = 0; } if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::tabledriver(SRVLIST,REQ_UP_ITEM); + ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); } break;} case REQ_SCR_DPAGE:{ @@ -635,7 +598,7 @@ void ServiceClass::tabledriver(std::vector SRVLIST,int key){ selected = ps; } if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::tabledriver(SRVLIST,REQ_DOWN_ITEM); + ServiceClass::TableDriver(SRVLIST,REQ_DOWN_ITEM); } break;} case REQ_FIRST_ITEM:{ @@ -645,7 +608,7 @@ void ServiceClass::tabledriver(std::vector SRVLIST,int key){ selected--; } if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::tabledriver(SRVLIST,REQ_UP_ITEM); + ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); } break;} case REQ_LAST_ITEM:{ @@ -653,7 +616,7 @@ void ServiceClass::tabledriver(std::vector SRVLIST,int key){ start = max - ps; selected = ps; if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::tabledriver(SRVLIST,REQ_UP_ITEM); + ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); } break;} case REQ_NEXT_ITEM:{ @@ -663,7 +626,7 @@ void ServiceClass::tabledriver(std::vector SRVLIST,int key){ selected--; } if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::tabledriver(SRVLIST,REQ_UP_ITEM); + ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); } break;} case REQ_PREV_ITEM:{ @@ -683,7 +646,7 @@ void ServiceClass::tabledriver(std::vector SRVLIST,int key){ selected = ps; } if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::tabledriver(SRVLIST,REQ_DOWN_ITEM); + ServiceClass::TableDriver(SRVLIST,REQ_DOWN_ITEM); } break;} case REQ_TOGGLE_ITEM:{ @@ -691,15 +654,15 @@ void ServiceClass::tabledriver(std::vector SRVLIST,int key){ case REQ_CLEAR_PATTERN:{ break;} case REQ_BACK_PATTERN:{ - if (MenuPtr->PATTER.size()>0) {MenuPtr->PATTER.pop_back(); MenuPtr->PATTER.shrink_to_fit();}; - mvwaddnstr(WinPtr->START.TMPWin4, 4, 33, " ",-1); - mvwaddnstr(WinPtr->START.TMPWin4, 4, 33, MenuPtr->PATTER.c_str(),-1); + if (MenuWinClass_SC->PATTERN.size()>0) {MenuWinClass_SC->PATTERN.pop_back(); MenuWinClass_SC->PATTERN.shrink_to_fit();}; + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, " ",-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); break;} case REQ_NEXT_MATCH:{ int position = 0; for (auto unit : ServiceList) { if (!unit.Name.empty()) { - if (unit.Name.rfind(MenuPtr->PATTER.c_str()) != std::string::npos) { + if (unit.Name.rfind(MenuWinClass_SC->PATTERN.c_str()) != std::string::npos) { lastFound = position; moveTo(position); } position++; @@ -708,83 +671,135 @@ void ServiceClass::tabledriver(std::vector SRVLIST,int key){ } } if (lastFound == 0) { - MenuPtr->PATTER.clear(); + MenuWinClass_SC->PATTERN.clear(); return; } lastFound = 0; - tabledriver(ServiceList,REQ_NEXT_MATCH); + TableDriver(ServiceList,REQ_NEXT_MATCH); break;} case REQ_PREV_MATCH:{ break;} } } - void ServiceClass::searchInput() { int key; while ((key=wgetch(stdscr)) != KEY_F(10)) { switch(key) { case 27:{ // ESC - MenuPtr->PATTER.clear(); - mvwaddnstr(WinPtr->START.TMPWin4, 4, 33, " ",-1); + MenuWinClass_SC->PATTERN.clear(); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, " ",-1); break;} - //case KEY_ENTER: // Ctrl-M + case KEY_ENTER: // Ctrl-M case 10: {// Enter - tabledriver(ServiceList,REQ_NEXT_MATCH); + TableDriver(ServiceList,REQ_NEXT_MATCH); break;} case KEY_BACKSPACE:{ - if (MenuPtr->PATTER.size()>0) {MenuPtr->PATTER.pop_back(); MenuPtr->PATTER.shrink_to_fit();}; - mvwaddnstr(WinPtr->START.TMPWin4, 4, 33, " ",-1); - mvwaddnstr(WinPtr->START.TMPWin4, 4, 33, MenuPtr->PATTER.c_str(),-1); - tabledriver(ServiceList,REQ_NEXT_MATCH); + if (MenuWinClass_SC->PATTERN.size()>0) {MenuWinClass_SC->PATTERN.pop_back(); MenuWinClass_SC->PATTERN.shrink_to_fit();}; + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, " ",-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); + TableDriver(ServiceList,REQ_NEXT_MATCH); break;} default:{ if (key > 10 && key < 128) { sprintf(searchString,"%c",key); - MenuPtr->PATTER.append(string(searchString)); - mvwaddnstr(WinPtr->START.TMPWin4, 4, 33, MenuPtr->PATTER.c_str(),-1); - tabledriver(ServiceList,REQ_NEXT_MATCH); + MenuWinClass_SC->PATTERN.append(string(searchString)); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); + TableDriver(ServiceList,REQ_NEXT_MATCH); } break;} } refresh(); - touchwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - touchwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin4)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin4)); - prefresh(MenuPtr->LiMENU.LMWin, 0, 0, 2, 1, - WinPtr->WinSize->HRY_TmpWinReal(WinPtr->START.TMPWin2)+1, - WinPtr->WinSize->WCX_TmpWinReal(WinPtr->START.TMPWin2)); + touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); + prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY()-4, MenuWinClass::START.WCX()-46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); } } - void ServiceClass::drawSearch() { /* * Lets indicate it is a search input */ char text[BUFSIZ] = ""; if (lastFound == 0) { sprintf(searchString,"%s",text); - MenuPtr->PATTER.append(string(searchString)); + MenuWinClass_SC->PATTERN.append(string(searchString)); //sprintf(text, "%s%s", text, searchString); } /* * Draw it using any visible, light color */ //drawStatus(1, text, 0); - mvwaddnstr(WinPtr->START.TMPWin4, 4, 33, MenuPtr->PATTER.c_str(),-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); } - void ServiceClass::moveTo(int position) { start = selected = 0; for (int i = 0; i < position; i++) { - tabledriver(ServiceList,REQ_UP_ITEM); + TableDriver(ServiceList,REQ_UP_ITEM); } } +string ServiceClass::SearchDriver(SeaReq drv, WINDOW *Win, int Key, string Search, int Posi) { + static const int Start = 33; + int hry, wcx; + getyx(Win, hry, wcx); + int MaxSearchTextLaenge = (MenuWinClass::START.WCX() - (Start + MenuWinClass::START.BorderWeight)); + int Laenge = Search.length(); + int AbsolPosi; + AbsolPosi = (Start + Posi); + char TmpKey[BUFSIZE] = ""; + sprintf(TmpKey, "%c", Key); + string dummi; + dummi.assign(MaxSearchTextLaenge,' '); + switch (drv) { + case REQ_DEL_BACKSPACE:{ + if ((wcx > Start) && (wcx <= (Start + Laenge))) { + Search.erase(Posi-1, 1); + mvwaddnstr(Win, 4, Start, dummi.c_str(), -1); + mvwaddnstr(Win, 4, Start, Search.c_str(), -1); + wmove(Win, 4, AbsolPosi - 1); + } + break; } + case REQ_DEL_DC:{ + if ((wcx > Start) && (wcx < (Start + Laenge))) { + Search.erase(Posi+1, 1); + mvwaddnstr(Win, 4, Start, dummi.c_str(), -1); + mvwaddnstr(Win, 4, Start, Search.c_str(), -1); + wmove(Win, 4, AbsolPosi - 1); + } + break; } + case REQ_RIGHT:{ + if ((wcx > Start) && (wcx <= (Start + Laenge))) { + //if ((Posi != 0) || ((Posi-1) <= Laenge)) { + int cursorbewegen = AbsolPosi +1; + wmove(Win, 4, cursorbewegen); + } + break; } + case REQ_LEFT:{ + if ((wcx > Start) && (wcx <= (Start + Laenge))) { + //if ((Posi != 0) || ((Posi-1) <= Laenge)) { + int cursorbewegen = AbsolPosi -1; + wmove(Win, 4, cursorbewegen); + } + break; } + case REQ_INS_DEFAULT:{ + if (Key > 10 && Key < 128) { + if (Posi < Laenge) { + Search.insert(Posi, string(TmpKey)); + mvwaddnstr(Win, 4, Start, Search.c_str(), -1); + wmove(Win, 4, (Start + Posi)); + } else { + Search.append(string(TmpKey)); + mvwaddnstr(Win, 4, Start, Search.c_str(), -1); + } + }; + break;} + } + wrefresh(Win); + return Search; +} +/*##################################################################################*/ ServiceClass::ServiceClass(){ systemctlwahl = "service"; } - ServiceClass::~ServiceClass(){ } - - - - +/*##################################################################################*/ diff --git a/ServiceClass.h b/ServiceClass.h index e219ca1..914b2e8 100644 --- a/ServiceClass.h +++ b/ServiceClass.h @@ -1,7 +1,9 @@ #ifndef SERVICECLASS_H #define SERVICECLASS_H -#include +#include +#include +#include //enum _INPUT_FOR { // INPUT_FOR_LIST, @@ -11,6 +13,7 @@ #define ERR_PREFIX "Failed: " #define SYSV_INSTALL_EXEC "/lib/systemd/systemd-sysv-install" +enum SeaReq { REQ_RIGHT, REQ_LEFT, REQ_DEL_DC, REQ_DEL_BACKSPACE, REQ_INS_DEFAULT}; enum { UNIT_STATE_DISABLED = 0x01, UNIT_STATE_ENABLED = 0x02, @@ -31,7 +34,6 @@ enum { UNIT_ACTIVESTATE_ACTIVE = 0x11, UNIT_ACTIVESTATE_INACTIVE = 0x12 }; - enum STATE_FLAGS { STATE_FLAGS_ENABLE, STATE_FLAGS_DISABLE, @@ -43,10 +45,10 @@ struct SignalColor { int Yellow {38}; //Warn or fails int Green {28}; //infoS int White {78}; //all all right - void SetSignalColor(int RED = 18, int YELLOW = 38, int GREEN = 28, int WHITE = 78){Red = RED; Yellow = YELLOW; Green = GREEN; White = WHITE;}; + void SetSignalColor(int RED = 18, int YELLOW = 38, int GREEN = 28, int WHITE = 78) {Red = RED; Yellow = YELLOW; Green = GREEN; White = WHITE;}; }; -typedef struct SERVICES SERVICES; +//typedef struct SERVICES SERVICES; struct SERVICES { int SID; std::string Name; @@ -61,50 +63,42 @@ struct SERVICES { std::string Active; int substate; std::string SubStatus; - SERVICES* next; }; - -class ServiceClass -{ +class ServiceClass { public: - ServiceClass(); - ~ServiceClass(); - WINDOW *STATUSWIN; - WINDOW *STATUSINFO; - WINDOW *ServiceInfo; - std::string systemctlwahl; - void ServiceFensterDesign(); - void ServiceListFill(); - void ServiceListe(); - void INFOWINDOW(std::string Name); - void Statusabfrage(std::string ausgabestatus); - void ENDE_NEW(); - int StartServiceControll(); - //##########MENÜ################################ - std::vector ServiceList; - WINDOW *ListMenuPanel; - MENU *ListMenu; - ITEM **ListMenuItem; - //##################################################### + /*#####################################################*/ + vector ServiceList; + WINDOW *STATUSWIN; + WINDOW *STATUSINFO; + string systemctlwahl; + /*#####################################################*/ SignalColor StateColor; char searchString[BUFSIZ] = ""; unsigned char inputFor = 0; int lastFound = 0; - int selected = 0; - int start = 0; - //unsigned long selected = 0; - //unsigned long start = 0; - std::string AktivName {""}; - void tabledriver(std::vector SRVLIST,int key); - void SetStateOption(); //SERVICES unit - void TableDraw(SERVICES unit, int y); - void TableMoveRow(); + int selected = 0; + int start = 0; + string AktivName {""}; + /*#####################################################*/ + void ServiceListFill(); + void ServiceListe(); + void INFOWINDOW(string Name); + void Statusabfrage(string ausgabestatus); + void ENDE(); + /*#####################################################*/ + void SetStateOption(); /*SERVICES unit*/ void BuildWin(); + void TableMoveRow(); + void TableDraw(SERVICES unit, int y); + void TableDriver(vector SRVLIST, int key); + void moveTo(int position); void searchInput(); void drawSearch(); - void moveTo(int position); - + string SearchDriver(SeaReq drv, WINDOW *Win, int Key, string Search, int Posi); + /*#####################################################*/ + ServiceClass(); + ~ServiceClass(); }; diff --git a/ServiceControl.pro b/ServiceControl.pro index 9a1eda1..a5c39c2 100644 --- a/ServiceControl.pro +++ b/ServiceControl.pro @@ -1,66 +1,101 @@ TEMPLATE = app -CONFIG += console c++11 +CONFIG += console c++17 CONFIG -= app_bundle CONFIG -= qt -########################################################################### -# # -# Meine einstellung immer ohne shadow build in QT creator!!! # -# Start # -########################################################################### - -CONFIG(debug, debug|release) { +############################################################################ +## Meine einstellung immer ohne shadow build in QT creator!!! # +############################################################################ +PROGRAMMNAME = ServiceControl +TARGET = bin/$$PROGRAMMNAME +VERSION = v1.0.4 +QMAKE_TARGET_PRODUCT = "$${PROGRAMMNAME}" +QMAKE_TARGET_COMPANY = "HOMELAND" +QMAKE_TARGET_COPYRIGHT = "Copyright (c) by Aktony" +DEFINES += APP_VERSION=\"\\\"$${VERSION}\\\"\" \ + APP_PRODUCT=\"\\\"$${QMAKE_TARGET_PRODUCT}\\\"\" \ + APP_COMPANY=\"\\\"$${QMAKE_TARGET_COMPANY}\\\"\" \ + APP_COPYRIGHT=\"\\\"$${QMAKE_TARGET_COPYRIGHT}\\\"\" +#unix:!macx:QMAKE_DEL_FILE = rm -f +#unix:!macx:QMAKE_DEL_DIR = rm -rf +#unix:!macx:OUT_PWD = "$$PWD/Build_$$VERSION" +DESTDIR = "$$PWD/Build_$$VERSION/debug/$$PROGRAMMNAME" +############################################################################ +#__________________release and debug_______________________________________# +############################################################################ +CONFIG(debug, debug|release) { DEFINES += DEBUG_MODE - DESTDIR = "$$PWD/Build/debug" - MAKEFILE = Makefile.debug } -else:CONFIG(release, debug|release) { + DESTDIR = "$$PWD/Build_$$VERSION/debug/$$PROGRAMMNAME" + QMAKE_MAKEFILE = Makefile.debug + MAKEFILE = Makefile.debug +} else:CONFIG(release, debug|release) { DEFINES += RELEASE_MODE - DESTDIR = "$$PWD/Build/release" - MAKEFILE = Makefile.release } -else:CONFIG(force_debug_info) { + DESTDIR = "$$PWD/Build_$$VERSION/release/$$PROGRAMMNAME" + QMAKE_MAKEFILE = Makefile.release + MAKEFILE = Makefile.release +} else:CONFIG(force_debug_info) { DEFINES += PROFILE_MODE - DESTDIR = "$$PWD/Build/profile" - MAKEFILE = Makefile.profile } -else { - DEFINES += PROFILE_MODE - DESTDIR = "$$PWD/Build/profile" - MAKEFILE = Makefile.profile } + DESTDIR = "$$PWD/Build_$$VERSION/profile/$$PROGRAMMNAME" + QMAKE_MAKEFILE = Makefile.profile + MAKEFILE = Makefile.profile +} else { + DEFINES += DEBUG_MODE + DESTDIR = "$$PWD/Build_$$VERSION/debug/$$PROGRAMMNAME" + QMAKE_MAKEFILE = Makefile.debug + MAKEFILE = Makefile.debug +} -RCC_DIR = "$$PWD/Build/RCCFiles" -UI_DIR = "$$PWD/Build/UICFiles" -MOC_DIR = "$$PWD/Build/MOCFiles" -OBJECTS_DIR = "$$PWD/Build/ObjFiles" +RCC_DIR = "$$PWD/Build_$$VERSION/RCCFiles" +UI_DIR = "$$PWD/Build_$$VERSION/UICFiles" +MOC_DIR = "$$PWD/Build_$$VERSION/MOCFiles" +OBJECTS_DIR = "$$PWD/Build_$$VERSION/ObjFiles" -# Copy files to build directory -#copydata0.commands = $(COPY_DIR) $$PWD/config/config.txt $$DESTDIR -#copydata1.commands = $(COPY_DIR) $$PWD/config/SystemMan.db $$DESTDIR -#first.depends = $(first) copydata0 copydata1 +message($$_PRO_FILE_ " - Profile!") +message($$_PRO_FILE_PWD_ " - Profile dir!") +message($$DESTDIR " - Destdir Name!") +message($$MAKEFILE " - Makefile Name!") +message($$OUT_PWD " - out_pwd dir!") +message($$QMAKE_MAKEFILE " - Qmakefile Name!") +############################################################################ +#__________________Copy files to build directory___________________________# +############################################################################ +#copydata0.commands = $(DEL_DIR) $$DESTDIR/config +#copydata1.commands = $(COPY_FILE) $$PWD/lib/libLogWriter.a $$DESTDIR/lib/libLogWriter.a +#copydata2.commands = $(COPY_FILE) $$PWD/lib/libUserGroupList.a $$DESTDIR/lib/libUserGroupList.a +#first.depends = $(first) copydata0 copydata1 copydata2 #export(first.depends) #export(copydata0.commands) #export(copydata1.commands) -#QMAKE_EXTRA_TARGETS += first copydata0 copydata1 - -#QFile DbFile; -#QString DatabaseDataStoragePath = QStandardPaths::writableLocation(QStandardPaths::StandardLocation::AppDataLocation); -#DbFile.setFileName("assets:/MyDatabase.sqlite"); -#DbFile.copy(DatabaseDataStoragePath + "/MyDatabase.sqlite") -#QFile::setPermissions(DatabaseDataStoragePath + "/MyDatabase.sqlite", QFile::WriteOwner | QFile::ReadOwner); - -unix:!macx: LIBS += -Wall -lncursesw -lmenuw -lformw -lpanelw -pthread -lsystemd -lncurses++w -lmenu -ldbus-c++-1 +#export(copydata2.commands) +#QMAKE_EXTRA_TARGETS += first copydata0 copydata1 copydata2 +unix:!macx: LIBS += -lncurses++w -Wall -lncursesw -lmenuw -lmenu -lformw -lpanelw -pthread -lreadline -Wreturn-type -lstdc++fs -lsystemd +#-lpam -lpam_misc -lxcb +#unix:!macx:LIBS_PRIVATE += $$DESTDIR/lib/libUserGroupList.a +#unix:!macx:LIBS_PRIVATE += $$DESTDIR/lib/libLogWriter.a +#unix:!macx: LIBS += -L$$DESTDIR/lib/ -lLogWriter -lUserGroupList +#$$DESTDIR/lib/libconfigator.a $$DESTDIR/lib/libdragonfail.a $$DESTDIR/lib/libtermbox.a $$DESTDIR/lib/libtestoasterror.a +#unix:!macx: LIBS += -L$$DESTDIR/lib/ -largoat -lconfigator -ldragonfail -ltermbox -ltestoasterror ########################################################################### # Ende !!! # ########################################################################### SOURCES += \ - MenuClass.cpp \ +# MenuClass.cpp \ +# WinClass.cpp \ + MenuWinClass.cpp \ ServiceClass.cpp \ Start.cpp \ - TaskClass.cpp \ - WinClass.cpp + TaskClass.cpp + HEADERS += \ Info.h \ - MenuClass.h \ +# WinClass.h \ +# MenuClass.h \ + MenuWinClass.h \ ServiceClass.h \ - TaskClass.h \ - WinClass.h + TaskClass.h + +DISTFILES += \ + zeug.txt + diff --git a/Start.cpp b/Start.cpp index e75a1e0..f7249fd 100644 --- a/Start.cpp +++ b/Start.cpp @@ -1,117 +1,59 @@ -#include -#include -#include -#include -#include +#include +//#include +//#include +#include +#include +#include using namespace std; -WinClass * WinPtr = new WinClass(); -TaskClass * TaskPtr = new TaskClass(); -MenuClass * MenuPtr = new MenuClass(); -ServiceClass * ServicePtr = new ServiceClass(); +TaskClass * TaskClassS = new TaskClass(); +ServiceClass * ServiceClassS = new ServiceClass(); +MenuWinClass *MenuWinClassS = new MenuWinClass(); -void WinClass::StartWin() { - setlocale(LC_CTYPE,"de_DE.UTF-8"); - setlocale(LC_ALL,"de_DE.UTF-8"); - initscr(); - if (has_colors()==FALSE) { endwin(); printf("Your terminal does not support color\n"); exit(1);} - start_color(); - cbreak(); - noecho(); - curs_set(false); - keypad(stdscr, true); - //raw(); - //(void) nonl(); - //clear(); - //syncok(stdscr,true); - //getmaxyx(stdscr,WinSize->HRY,WinSize->WCX); - WinPtr->AppColor(); - //WinPtr->SetSize(); -} - -void WinClass::StopWin() { - delete TaskPtr; - delete MenuPtr; - delete ServicePtr; - delete WinPtr; - endwin(); - //exit(EXIT_SUCCESS); -} - -void WinClass::printInMiddle(WINDOW *win, int starty, int startx, int width, char *string, chtype color, char *sp) { - int x, y; - unsigned long length; - float temp; - - if(win == nullptr) - win = stdscr; - getyx(win, y, x); - if(startx != 0) - x = startx; - if(starty != 0) - y = starty; - if(width == 0) - width = 80; - - length = strlen(string); - temp = (width - static_cast(length))/ 2; - x = startx + static_cast(temp); - wattron(win, color); - - if (sp) { - for (int i = startx; i < width; i++) { - mvwprintw(win, y, i, "%c", sp); - } - } - - mvwprintw(win, y, x, "%s", string); - wattroff(win, color); -} - -int main (int ac, char **av) { - try { - if (ac > 1) { - fprintf(stdout, ABOUT_INFO, VERSION); +int main (int argc, char* argv[]) { +//try { + if (argc > 1) { + if (string(argv[1]).compare("-h")) { + cout << ABOUT_INFO << " " << VERSION << endl; return 0; + exit(EXIT_SUCCESS); + } else { + //fn = string(argv[1]); + //ed = Editor(fn); } - werase(stdscr); - WinPtr->StartWin(); - WinPtr->FensterDraw(); - - //-------------_DatumUhrZeit_datumuhrzeit_----------------------------------------------- - std::thread worker(&TaskClass::process_signal, std::ref(TaskPtr), "DateTime"); - worker.detach(); - - refresh(); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin1)); - touchwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin1)); - redrawwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin4)); - touchwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin4)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin5)); - prefresh(MenuPtr->LiMENU.LMWin, 0, 0, 2, 1, WinPtr->WinSize->HRY_TmpWinReal(WinPtr->START.TMPWin2)+1, WinPtr->WinSize->WCX_TmpWinReal(WinPtr->START.TMPWin2)); - redrawwin(TaskPtr->ClearWindow(MenuPtr->MENEU.HMWin)); - wrefresh(TaskPtr->ClearWindow(MenuPtr->MENEU.HMWin)); - - MenuPtr->MenuStart(); - WinPtr->StopWin(); - - } catch (const NCursesException *e) { - endwin(); - std::cerr << e->message << std::endl; - cout << e->errorno; - } catch (const NCursesException &e) { - endwin(); - std::cerr << e.message << std::endl; - cout << e.errorno; - } catch (const std::exception &e) { - endwin(); - std::cerr << "Exception: " << e.what() << std::endl; - cout << EXIT_FAILURE; } -} - - + int Key = 0; + werase(stdscr); + MenuWinClassS->StartWin(); + signal(SIGWINCH, MenuWinClass::ResizeHandler); + //-------------_DatumUhrZeit_datumuhrzeit_----------------------------------------------- + //std::thread worker(&TaskClass::process_signal, std::ref(TaskPtr), "DateTime"); + //worker.detach(); + MenuWinClass::SetWinSize(); + MenuWinClassS->FensterDraw(); + + refresh(); + wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); + touchwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); + redrawwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin2)); + wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin2)); + touchwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin2)); + wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin3)); + touchwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin3)); + prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); + prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY()-4, + MenuWinClass::START.WCX()-46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); + redrawwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); + wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); + + do { Key = MenuWinClass::MenuStart(Key); if (Key == KEY_F(10)) { break; } } while ((Key = getch()) != KEY_F(10)); + + ServiceClassS->ENDE(); + MenuWinClassS->StopWin(); + +// } catch (const NCursesException *e) { endwin(); std::cerr << e->message << std::endl; cout << e->errorno; +// } catch (const NCursesException &e) { endwin(); std::cerr << e.message << std::endl; cout << e.errorno; +// } catch (const std::exception &e) { endwin(); std::cerr << "Exception: " << e.what() << std::endl; cout << EXIT_FAILURE; } +} diff --git a/TaskClass.cpp b/TaskClass.cpp index f91d261..4d72df4 100644 --- a/TaskClass.cpp +++ b/TaskClass.cpp @@ -1,125 +1,68 @@ -#include -#include -#include -#include -#include +#include +//#include +//#include +#include +#include +#include using namespace std; -//extern class TaskClass * TaskPtr; -extern class MenuClass * MenuPtr; -extern class ServiceClass * ServicePtr; -extern class WinClass * WinPtr; -extern class ServiceTableClass * TablePtr; -volatile int signal_flag; +TaskClass *TaskClass_TC = new TaskClass(); +//MenuClass *MenuPtr_TC = new MenuClass(); +ServiceClass *ServiceClass_TC = new ServiceClass(); +//WinClass *WinPtr_TC = new WinClass(); +MenuWinClass *MenuWinClass_TC = new MenuWinClass(); -//#################################################################### -//eigenes zählwerk um von forn an fangen zu können -//aktuelle zahl, string ob + oder -, maximale höchste zahl +volatile int signal_flag; +/*##########################################################################*/ int TaskClass::ZahlenWerk(int zahlen, string i, int max) { int tmp = 0; - if (strcmp(i.c_str(),"++")==0){ - if(zahlen>=max){ + if (strcmp(i.c_str(), "++") == 0) { + if (zahlen >= max) { tmp = 1; - }else if(zahlen==0){ + } else if (zahlen == 0) { tmp = 1; - }else if (zahlen>0){ + } else if (zahlen > 0) { tmp = ++zahlen; - }else if (zahlen1){ + } else if (zahlen > 1) { tmp = --zahlen; - }else if(zahlen<=max){ + } else if (zahlen <= max) { tmp = --zahlen; } - }else{ + } else { tmp = 1; } return tmp; } - -int TaskClass::ZahlenBerechnen(int posa, RANGE range, string wahl) { - int tmp; - if (wahl.compare("+") == 0){ - posa++; - }else if (wahl.compare("-") == 0){ - posa--; - } - - if (posa >= range.min && posa <= range.max){ - tmp = ((posa - range.min) + range.min); - }else if (posa >= range.min && posa > range.max){ - tmp = (posa - range.max);// + range.min; - while(tmp > range.max){ - tmp = (tmp - range.max);// + range.min; - } - }else if (posa < range.min && posa <= range.max){ - tmp = range.max + posa; - while(tmp < range.min){ - if(tmp == 0){tmp = range.max;} - else{tmp = range.max + tmp;} - } - }else if (posa == 0){ - tmp = range.max; - }else{tmp = posa;} - - return tmp; -} - -int TaskClass::RangeZahlenWerk(int mina, int posa, int maxa, string wahl){ - vector list; - int included; - RANGE range; - - range.min = mina; - range.max = maxa; - range.count(); - range.range = 1; - list.push_back(range); - - do { - included = TaskClass::ZahlenBerechnen(posa, range, wahl); - }while (included > range.max); - return included; -} - -int TaskClass::Zeilen(string data, int maxbreite){ +int TaskClass::Zeilen(string data, int maxbreite) { int rownr = 0; double zeiBr = (data.length() / static_cast(maxbreite)); int zeiBr2; stringstream datast(data); string line; - for (rownr = 0; std::getline(datast, line); ++rownr){} + for (rownr = 0; std::getline(datast, line); ++rownr) {} zeiBr2 = static_cast(ceil(zeiBr)); return (rownr + zeiBr2); } - std::vector TaskClass::StringTeiler(const std::string& str, char delimiter) { std::istringstream is(str); std::vector result; - for(std::string cur; std::getline(is, cur, delimiter); result.push_back(cur)); + for (std::string cur; std::getline(is, cur, delimiter); result.push_back(cur)); return result; } -//########################################################################## -//void TaskClass::centerplace(int hoehe, int weite) { -// // WinPtr->halb_XC = static_cast(roundf(WinPtr->WinSize.WCX/2)); -// // WinPtr->halb_YR = static_cast(roundf(WinPtr->WinSize.HRY/2)); -// WinPtr->WinSize->Center_HRY = static_cast(roundf(WinPtr->WinSize->halb_HRY() - (hoehe/2))); -// WinPtr->WinSize->Center_WCX = static_cast(roundf(WinPtr->WinSize->halb_WCX() - (weite/2))); -//} - string TaskClass::TERM_AUSGABE(string cmd) { //cmd = "systemctl list-unit-files -t service | grep '.service' | awk '{$1=$1};1' | sort"; string data; - FILE * stream; + FILE* stream; char buffer[BUFSIZE]; - cmd.append(" 2>/dev/null"); //2>&1 stream = popen(cmd.c_str(), "r"); if (stream) { @@ -133,130 +76,31 @@ string TaskClass::TERM_AUSGABE(string cmd) { memset(buffer, 0, BUFSIZE); return data; } - -WINDOW *TaskClass::ClearWindow(WINDOW *TEMPWINDOW) { - clearok(TEMPWINDOW,true); +WINDOW* TaskClass::ClearWindow(WINDOW* TEMPWINDOW) { + clearok(TEMPWINDOW, true); return TEMPWINDOW; } - -void TaskClass::ClearScreen() { - if (!cur_term) { - int result; - setupterm( nullptr, STDOUT_FILENO, &result ); - if (result <= 0) return; - } - putp(tigetstr("clear")); -} - -//NO_RETURN -void TaskClass::TermQuit(int sig) { - UNUSED(sig); - TaskClass::ConfigDateiList.clear(); - vector().swap(TaskClass::ConfigDateiList); - TaskClass::DeletAllWin("Ende"); - clear(); - raise(SIGTERM); - exit(EXIT_SUCCESS); -} - -void TaskClass::DeletAllWin(const char *name) { - try { - if (strcmp(name,"Ende")==0){ - if (WinPtr->START.TMPWin1){ - werase(WinPtr->START.TMPWin1); - delwin(WinPtr->START.TMPWin1); - endwin(); - } - if (WinPtr->START.TMPWin2){ - werase(WinPtr->START.TMPWin2); - delwin(WinPtr->START.TMPWin2); - endwin(); - } - if (WinPtr->START.TMPWin3){ - werase(WinPtr->START.TMPWin3); - delwin(WinPtr->START.TMPWin3); - endwin(); - } - if (WinPtr->START.TMPWin4){ - werase(WinPtr->START.TMPWin4); - delwin(WinPtr->START.TMPWin4); - endwin(); - } - if (WinPtr->START.TMPWin5){ - werase(WinPtr->START.TMPWin5); - delwin(WinPtr->START.TMPWin5); - endwin(); - } - endwin(); - } - } catch (const NCursesException *e) { - endwin(); - std::cerr << e->message << std::endl; - cout << e->errorno; - } catch (const NCursesException &e) { - endwin(); - std::cerr << e.message << std::endl; - cout << e.errorno; - } catch (const std::exception &e) { - endwin(); - std::cerr << "Exception: " << e.what() << std::endl; - cout << EXIT_FAILURE; - } -} - -//############################################################################# -int TaskClass::WinFullSize(WINDOW * TmpWin, int WHCRXY, string WorH){ - if (WorH.compare("W")==0) { - if (WinPtr->WinSize->WCX_TmpWinReal(TmpWin) <= WHCRXY) { +int TaskClass::WinFullSize(WINDOW* TmpWin, int WHCRXY, string WorH) { + if (WorH.compare("W") == 0) { + if (MenuWinClass_TC->START.WinSize.WCX_TmpWinReal(TmpWin) <= WHCRXY) { return WHCRXY; } else { - return WinPtr->WinSize->WCX_TmpWinReal(TmpWin); + return MenuWinClass_TC->START.WinSize.WCX_TmpWinReal(TmpWin); } - } else if (WorH.compare("H")==0) { - if (WinPtr->WinSize->HRY_TmpWinReal(TmpWin) <= WHCRXY) { + } else if (WorH.compare("H") == 0) { + if (MenuWinClass_TC->START.WinSize.HRY_TmpWinReal(TmpWin) <= WHCRXY) { return WHCRXY; } else { - return WinPtr->WinSize->HRY_TmpWinReal(TmpWin); + return MenuWinClass_TC->START.WinSize.HRY_TmpWinReal(TmpWin); } } } - -void TaskClass::set_flag(int signal) { - signal_flag = signal; +/*##########################################################################*/ +TaskClass::TaskClass() { + //TaskClass::DateTime.TIMEFIELD(MenuPtr->MENEU.HMWin,MenuWinClass_TC->WinSize.WCX); } - -void TaskClass::process_signal(std::string command) { - try { - while (signal_flag != SIGTERM) { - //MenuPtr->MENEU.HMWin - DateTime.TIMEFIELD(WinPtr->START.TimeWin,20); //WinPtr->WinSize->WCX_TmpWin(WinPtr->START.TimeWin)); - std::this_thread::sleep_for(std::chrono::milliseconds(1000)); - } - } catch (const std::exception &e) { - endwin(); - std::cerr << "Exception: " << e.what() << std::endl; - cout << EXIT_FAILURE; - } -} - -void TaskClass::Resize_Handler(int sig) { - try { - while (signal_flag != SIGTERM) { - WinPtr->ChangeSize(); - std::this_thread::sleep_for(std::chrono::milliseconds(1000)); - } - } catch (const std::exception &e) { - endwin(); - std::cerr << "Exception: " << e.what() << std::endl; - cout << EXIT_FAILURE; - } -} - -TaskClass::TaskClass(){ - //TaskClass::DateTime.TIMEFIELD(MenuPtr->MENEU.HMWin,WinPtr->WinSize.WCX); -} - -TaskClass::~TaskClass(){ +TaskClass::~TaskClass() { } +/*##########################################################################*/ diff --git a/TaskClass.h b/TaskClass.h index 0db78aa..1ec5fe9 100644 --- a/TaskClass.h +++ b/TaskClass.h @@ -7,59 +7,38 @@ #include #include #include -#include #include #include +#include +#include +#include #include +#include #include #include #include -#include #include -//thrade lib -#include -//thrade lib -#include -#include -#include -#include -#include -#include +#include #include #include -#include -#include -//#include -#include - -#ifdef __GNUC__ -#define NO_RETURN __attribute__((noreturn)) -#elif __MINGW32__ -#define NO_RETURN __attribute__((noreturn)) -#elif __clang__ -#define NO_RETURN __attribute__((noreturn)) -#elif _MSC_VER -#define NO_RETURN __declspec(noreturn) -#endif - -//#define CTRLD 4 -#define BUFSIZE 8192 -#define CLEARSCR system ( "clear" ) -#define UNUSED(x) (void) (x) -#define SAFE_DELETE(p) { if(p) { delete (p); (p) = nullptr; } } -#define SAFE_DELETE_ARRAY(p) { if(p) { delete[] (p); (p) = nullptr; } } -#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) -#define SIZEOF(table) (sizeof(table) / sizeof(table[0])) +#include -#define RST "\x1B[0m": -#define KRED "\x1B[31m": +//#define CTRLD 4 +#define BUFSIZE 8192 +#define CLEARSCR system ( "clear" ) +#define UNUSED(x) (void) (x) +#define SAFE_DELETE(p) { if(p) { delete (p); (p) = nullptr; } } +#define SAFE_DELETE_ARRAY(p) { if(p) { delete[] (p); (p) = nullptr; } } +#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) +#define SIZEOF(table) (sizeof(table) / sizeof(table[0])) +#define RST "\x1B[0m"; +#define KRED "\x1B[31m"; #define KGRN "\x1B[32m"; #define KYEL "\x1B[33m"; #define KBLU "\x1B[34m"; #define KMAG "\x1B[35m"; #define KCYN "\x1B[36m"; #define KWHT "\x1B[37m"; - #define FRED(x) KRED x RST; #define FGRN(x) KGRN x RST; #define FYEL(x) KYEL x RST; @@ -68,63 +47,39 @@ #define FCYN(x) KCYN x RST; #define FWHT(x) KWHT x RST; +using namespace std; + struct DatumUhrZeit { int n = 0; time_t Zeitstempel; - tm *UHRZEIT; + tm* UHRZEIT; char UHRZEITchar[19]; std::string UHRZEITstr; - void TIMEFIELD(WINDOW *TMPWin, int TMPmax_xc) { + void TIMEFIELD(WINDOW* TMPWin, int TMPmax_xc) { Zeitstempel = time(nullptr); UHRZEIT = localtime(&Zeitstempel); strftime(UHRZEITchar, size_t(UHRZEITchar), "%d.%m.%Y %T", UHRZEIT); UHRZEITstr = std::string(UHRZEITchar); - wattr_on(TMPWin, COLOR_PAIR(79)|A_STANDOUT|A_BOLD,nullptr);//|A_BOLD,0); + wattr_on(TMPWin, COLOR_PAIR(79) | A_STANDOUT | A_BOLD, nullptr); //|A_BOLD,0); mvwaddnstr(TMPWin, 0, 0, UHRZEITstr.c_str(), -1); - wattr_off(TMPWin, COLOR_PAIR(79)|A_STANDOUT|A_BOLD,nullptr);//|A_BOLD,0); + wattr_off(TMPWin, COLOR_PAIR(79) | A_STANDOUT | A_BOLD, nullptr); //|A_BOLD,0); refresh(); wrefresh(TMPWin); //TMPmax_xc-2 } }; - class TaskClass { -public: - DatumUhrZeit DateTime; - void set_flag(int signal); - void process_signal(std::string command); - void execute(std::string command); - static void Resize_Handler(int sig); - typedef struct { - int min; - int max; - int count(){return max - min;} - int range{1}; - } RANGE; - int ZahlenWerk(int zahlen, std::string i, int max); - int ZahlenBerechnen(int posa, RANGE range, std::string wahl); - int RangeZahlenWerk(int mina, int posa, int maxa, std::string wahl); - int Zeilen(std::string data, int maxbreite); - std::vector StringTeiler(const std::string& str, char delimiter); - //############################################################################## - std::string TERM_AUSGABE(std::string cmd); - //############################################################################## - void centerplace(int hoehe, int weite); - //############################################################################## - //--------------------Verlassen-und-Löschen------------------------------------- - void TermQuit(int); - WINDOW *ClearWindow(WINDOW *W); - void ClearScreen(); - void DeletAllWin(const char *namem); - int WinFullSize(WINDOW * TmpWin, int WHCRXY, std::string WorH); - //############################################################################## - std::string filename; - std::vector ConfigDateiList; - int CountConfigDatei; - //############################################################################### - + public: + /*##############################################################################*/ + int ZahlenWerk(int zahlen, std::string i, int max); + int Zeilen(std::string data, int maxbreite); + vector StringTeiler(const std::string& str, char delimiter); + string TERM_AUSGABE(std::string cmd); + WINDOW* ClearWindow(WINDOW* W); + int WinFullSize(WINDOW* TmpWin, int WHCRXY, std::string WorH); TaskClass(); ~TaskClass(); + /*##############################################################################*/ }; #endif // TASKCLASS_H From 6a0171af0b529125733ec58c3a247181306a1168 Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Sun, 7 Feb 2021 03:09:16 +0100 Subject: [PATCH 02/19] Delete MenuClass.cpp --- MenuClass.cpp | 566 -------------------------------------------------- 1 file changed, 566 deletions(-) delete mode 100644 MenuClass.cpp diff --git a/MenuClass.cpp b/MenuClass.cpp deleted file mode 100644 index 527d374..0000000 --- a/MenuClass.cpp +++ /dev/null @@ -1,566 +0,0 @@ -#include -#include -#include -#include -#include - -using namespace std; - -extern class TaskClass * TaskPtr; -//extern class MenuClass * MenuPtr; -extern class ServiceClass * ServicePtr; -extern class WinClass * WinPtr; -extern class ServiceTableClass * TablePtr; - -void MenuClass::Hauptmenu(void) { - MENEU.HMID = 0; - MENEU.HMName = string("HAUPTMENÜ"); - MENEU.HMItem = static_cast(calloc(5, sizeof(ITEM *))); - MENEU.HMItem[0] = new_item(" Datei", MENEU.HMName.c_str()); - MENEU.HMItem[1] = new_item("DaemonType", MENEU.HMName.c_str()); - MENEU.HMItem[2] = new_item("Systemctl", MENEU.HMName.c_str()); - MENEU.HMItem[3] = new_item("Info", MENEU.HMName.c_str()); - MENEU.HMItem[4] = nullptr; - MENEU.HMMenu = new_menu(MENEU.HMItem); - MENEU.HMWin = newwin(1, WinPtr->WinSize->WCX()-26, 0, 0); - set_menu_win (MENEU.HMMenu, MENEU.HMWin); - set_menu_sub(MENEU.HMMenu, MENEU.HMWin); - //############################################################### - //set_menu_sub(MENEU.UME.UMEMenu, MENEU.HMWin); - //############################################################### - set_menu_spacing(MENEU.HMMenu, 1, 0, 0); - set_menu_format(MENEU.HMMenu, 0, 5); - menu_opts_off(MENEU.HMMenu, O_SHOWDESC); - menu_opts_off(MENEU.HMMenu, O_NONCYCLIC); - wbkgd(MENEU.HMWin, COLOR_PAIR(HMcolor.HaMeFe_HG)|A_BOLD); - //set_item_fore(MENEU.HMItem[1], COLOR_PAIR(12)|A_REVERSE|A_BOLD); - set_menu_fore(MENEU.HMMenu, COLOR_PAIR(HMcolor.HaMe_FG)|A_REVERSE|A_BOLD); - set_menu_back(MENEU.HMMenu, COLOR_PAIR(HMcolor.HaMe_HG));//|A_BOLD); - set_menu_grey(MENEU.HMMenu, COLOR_PAIR(HMcolor.HaMe_grey)|A_BOLD); - set_menu_mark(MENEU.HMMenu,""); - post_menu(MENEU.HMMenu); -} /* Hauptmenü */ - -void MenuClass::Datei_menu(void) { - MENEU.UME.UMID = 1; - MENEU.UME.UMEName = string("Datei"); - MENEU.UME.UMEWin = newwin(6, 15, 1, 0); - wbkgd(MENEU.UME.UMEWin,COLOR_PAIR(HMcolor.UMeFe_HG)); - box(MENEU.UME.UMEWin, 0, 0); - MENEU.UME.UMEItem = static_cast(calloc(7, sizeof(ITEM *))); - MENEU.UME.UMEItem[0] = new_item("Man Systemctl", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[1] = new_item("Einstellung", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[2] = new_item("Remotectl", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[3] = new_item("Beenden", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[4] = nullptr; - MENEU.UME.UMEMenu = new_menu(MENEU.UME.UMEItem); - set_menu_win(MENEU.UME.UMEMenu, MENEU.UME.UMEWin); - set_menu_sub (MENEU.UME.UMEMenu, derwin(MENEU.UME.UMEWin, 0, 0, 1, 1)); - set_menu_spacing(MENEU.UME.UMEMenu, 0,0,0); - set_menu_format(MENEU.UME.UMEMenu, 5, 0); - menu_opts_off(MENEU.UME.UMEMenu, O_SHOWDESC); - menu_opts_off(MENEU.UME.UMEMenu, O_NONCYCLIC); - //set_menu_fore(MENEU.UME.UMEMenu, COLOR_PAIR(12)|A_REVERSE|A_BOLD); - set_menu_fore(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.UMeFe_FG)|A_REVERSE|A_BOLD); - set_menu_back(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.UMeFe_HG));//|A_BOLD); - set_menu_grey(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.HaMe_grey)|A_BOLD); - set_menu_mark(MENEU.UME.UMEMenu,""); - set_current_item(MENEU.UME.UMEMenu, MENEU.UME.UMEItem[0]); - post_menu(MENEU.UME.UMEMenu); -} /* Datei Menü */ - -void MenuClass::DaemonType_menu(void) { - MENEU.UME.UMID = 2; - MENEU.UME.UMEName = string("DaemonType"); - MENEU.UME.UMEWin = newwin(12, 10, 1, 11); - box(MENEU.UME.UMEWin, 0, 0); - MENEU.UME.UMEItem = static_cast(calloc(11, sizeof(ITEM *))); - MENEU.UME.UMEItem[0] = new_item("Device", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[1] = new_item("Mount", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[2] = new_item("Path", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[3] = new_item("Service", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[4] = new_item("Scope", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[5] = new_item("Slice", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[6] = new_item("Socket", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[7] = new_item("Swap", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[8] = new_item("Target", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[9] = new_item("Timer", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[10] = nullptr; - MENEU.UME.UMEMenu = new_menu(MENEU.UME.UMEItem); - set_menu_win (MENEU.UME.UMEMenu, MENEU.UME.UMEWin); - set_menu_sub(MENEU.UME.UMEMenu, derwin(MENEU.UME.UMEWin,0,0,1,1)); - set_menu_spacing(MENEU.UME.UMEMenu, 0, 0, 1); - set_menu_format(MENEU.UME.UMEMenu, 11, 0); - menu_opts_off(MENEU.UME.UMEMenu, O_SHOWDESC); - menu_opts_off(MENEU.UME.UMEMenu, O_NONCYCLIC); - wbkgd(MENEU.UME.UMEWin,COLOR_PAIR(HMcolor.UMeFe_HG)); - set_menu_fore(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.UMeFe_FG)|A_REVERSE|A_BOLD); - set_menu_back(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.UMeFe_HG));//|A_BOLD); - set_menu_grey(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.HaMe_grey)|A_BOLD); - set_menu_mark(MENEU.UME.UMEMenu,""); - set_current_item(MENEU.UME.UMEMenu, MENEU.UME.UMEItem[0]); - post_menu(MENEU.UME.UMEMenu); - -} /* System Untermenü */ - -void MenuClass::Systemctl_menu(void) { - MENEU.UME.UMID = 3; - MENEU.UME.UMEName = string("Systemctl"); - MENEU.UME.UMEWin = newwin(12, 18, 1, 22); - box(MENEU.UME.UMEWin, 0, 0); - MENEU.UME.UMEItem = static_cast(calloc(11, sizeof(ITEM *))); - MENEU.UME.UMEItem[0] = new_item("START", "F1"); - MENEU.UME.UMEItem[1] = new_item("STOP", "F1"); - MENEU.UME.UMEItem[2] = new_item("STATUS", "F3"); - MENEU.UME.UMEItem[3] = new_item("ENABLE", "F2"); - MENEU.UME.UMEItem[4] = new_item("DISABLE", "F2"); - MENEU.UME.UMEItem[5] = new_item("MASK", "F4"); - MENEU.UME.UMEItem[6] = new_item("UNMASK", "F4"); - MENEU.UME.UMEItem[7] = new_item("RESTART", "F5"); - MENEU.UME.UMEItem[8] = new_item("RELOAD", "F6"); - MENEU.UME.UMEItem[9] = new_item("Reload-daemon", "F7"); - MENEU.UME.UMEItem[10] = nullptr; - MENEU.UME.UMEMenu = new_menu(MENEU.UME.UMEItem); - set_menu_win (MENEU.UME.UMEMenu, MENEU.UME.UMEWin); - set_menu_sub(MENEU.UME.UMEMenu, derwin(MENEU.UME.UMEWin,0,0,1,1)); - set_menu_spacing(MENEU.UME.UMEMenu, 1, 0, 0); - set_menu_format(MENEU.UME.UMEMenu, 11, 0); - menu_opts_on(MENEU.UME.UMEMenu, O_SHOWDESC); - menu_opts_off(MENEU.UME.UMEMenu, O_NONCYCLIC); - wbkgd(MENEU.UME.UMEWin,COLOR_PAIR(HMcolor.UMeFe_HG)); - set_menu_fore(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.UMeFe_FG)|A_REVERSE|A_BOLD); - set_menu_back(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.UMeFe_HG));//|A_BOLD); - set_menu_grey(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.HaMe_grey)|A_BOLD); - set_menu_mark(MENEU.UME.UMEMenu,""); - set_current_item(MENEU.UME.UMEMenu, MENEU.UME.UMEItem[0]); - post_menu(MENEU.UME.UMEMenu); -} /* Server Untermenü */ - -void MenuClass::Info_menu(void) { - MENEU.UME.UMID = 4; - MENEU.UME.UMEName = string("Info"); - MENEU.UME.UMEWin = newwin(5, 12, 1, 33); - wbkgd(MENEU.UME.UMEWin,COLOR_PAIR(HMcolor.UMeFe_HG)); - box(MENEU.UME.UMEWin,0,0); - //MENEU.UME.UMEItem = (ITEM **)calloc(4, sizeof(ITEM *)); - MENEU.UME.UMEItem = static_cast(calloc(4, sizeof(ITEM *))); - MENEU.UME.UMEItem[0] = new_item("journalctl", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[1] = new_item("E-Mail", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[2] = new_item("Beenden", MENEU.UME.UMEName.c_str()); - MENEU.UME.UMEItem[3] = nullptr; - MENEU.UME.UMEMenu = new_menu(MENEU.UME.UMEItem); - set_menu_win(MENEU.UME.UMEMenu, MENEU.UME.UMEWin); - set_menu_sub (MENEU.UME.UMEMenu, derwin(MENEU.UME.UMEWin, 0, 0, 1, 1)); - set_menu_spacing(MENEU.UME.UMEMenu, 0,0,0); - set_menu_format(MENEU.UME.UMEMenu, 5, 0); - menu_opts_off(MENEU.UME.UMEMenu, O_SHOWDESC); - menu_opts_off(MENEU.UME.UMEMenu, O_NONCYCLIC); - //set_menu_fore(MENEU.UME.UMEMenu, COLOR_PAIR(12)|A_REVERSE|A_BOLD); - set_menu_fore(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.UMeFe_FG)|A_REVERSE|A_BOLD); - set_menu_back(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.UMeFe_HG));//|A_BOLD); - set_menu_grey(MENEU.UME.UMEMenu, COLOR_PAIR(HMcolor.HaMe_grey)|A_BOLD); - set_menu_mark(MENEU.UME.UMEMenu,""); - set_current_item(MENEU.UME.UMEMenu, MENEU.UME.UMEItem[0]); - post_menu(MENEU.UME.UMEMenu); -} /* Info Menü */ - -WINDOW *MenuClass::tmpWi(string name, int id) { - if ((strcmp(name.c_str(),"Datei")==0) || (id==0)){ - Datei_menu(); - HMTMPWIN = MENEU.UME.UMEWin; - HMTMPMENU = MENEU.UME.UMEMenu; - }else if ((strcmp(name.c_str(),"DaemonType")==0) || (id==1)){ - DaemonType_menu(); - HMTMPWIN = MENEU.UME.UMEWin; - HMTMPMENU = MENEU.UME.UMEMenu; - }else if ((strcmp(name.c_str(),"Systemctl")==0) || (id==2)){ - Systemctl_menu(); - HMTMPWIN = MENEU.UME.UMEWin; - HMTMPMENU = MENEU.UME.UMEMenu; - }else if ((strcmp(name.c_str(),"Info")==0) || (id==4)){ - Info_menu(); - HMTMPWIN = MENEU.UME.UMEWin; - HMTMPMENU = MENEU.UME.UMEMenu; - } - return HMTMPWIN; -} - -void MenuClass::fensterwahl(string wahl) { - string menupoint = ServicePtr->AktivName; //item_name(current_item(LiMENU.LMenu)); - string befehl; - if (wahl.compare(" Datei") == 0) { - Datei_menu(); - }else if (wahl.compare("Systemctl") == 0) { - Systemctl_menu(); - }else if (wahl.compare("DaemonType") == 0) { - DaemonType_menu(); - }else if (wahl.compare("Systemctl") == 0) { - Info_menu(); - }else if (wahl.compare("Service") == 0) { - ServicePtr->start = 0; - ServicePtr->selected = 0; - ServicePtr->systemctlwahl = "service"; - ServicePtr->ServiceListFill(); - }else if (wahl.compare("Swap") == 0) { - ServicePtr->start = 0; - ServicePtr->selected = 0; - ServicePtr->systemctlwahl = "swap"; - ServicePtr->ServiceListFill(); - }else if (wahl.compare("Timer") == 0) { - ServicePtr->start = 0; - ServicePtr->selected = 0; - ServicePtr->systemctlwahl = "timer"; - ServicePtr->ServiceListFill(); - }else if (wahl.compare("Device") == 0) { - ServicePtr->start = 0; - ServicePtr->selected = 0; - ServicePtr->systemctlwahl = "device"; - ServicePtr->ServiceListFill(); - }else if (wahl.compare("Mount") == 0) { - ServicePtr->start = 0; - ServicePtr->selected = 0; - ServicePtr->systemctlwahl = "mount"; - ServicePtr->ServiceListFill(); - }else if (wahl.compare("Path") == 0) { - ServicePtr->start = 0; - ServicePtr->selected = 0; - ServicePtr->systemctlwahl = "path"; - ServicePtr->ServiceListFill(); - }else if (wahl.compare("Target") == 0) { - ServicePtr->start = 0; - ServicePtr->selected = 0; - ServicePtr->systemctlwahl = "target"; - ServicePtr->ServiceListFill(); - }else if (wahl.compare("Socket") == 0) { - ServicePtr->start = 0; - ServicePtr->selected = 0; - ServicePtr->systemctlwahl = "socket"; - ServicePtr->ServiceListFill(); - }else if (wahl.compare("Slice") == 0) { - ServicePtr->start = 0; - ServicePtr->selected = 0; - ServicePtr->systemctlwahl = "slice"; - ServicePtr->ServiceListFill(); - }else if (wahl.compare("Scope") == 0) { - ServicePtr->start = 0; - ServicePtr->selected = 0; - ServicePtr->systemctlwahl = "scope"; - ServicePtr->ServiceListFill(); - }else if (wahl.compare("Man Page")==0){ - exit(EXIT_SUCCESS); - //DATEIMANPAGE::Start_ManP(); - }else if (wahl.compare("Befehle")==0){ - exit(EXIT_SUCCESS); - //DATEIBEFEHLE::befehle_main(); - }else if (wahl.compare("Einstellung")==0){ - exit(EXIT_SUCCESS); - //einDa(); - }else if (wahl.compare("Beenden")==0){ - exit(EXIT_SUCCESS); - }else if (wahl.compare("START") == 0) { - pos_menu_cursor(LiMENU.LMenu); - befehl = "systemctl start " + menupoint + " --now"; - TaskPtr->TERM_AUSGABE(befehl); - ServicePtr->ServiceListFill(); - }else if (wahl.compare("STOP") == 0) { - pos_menu_cursor(LiMENU.LMenu); - befehl = "systemctl stop " + menupoint + " --now"; - TaskPtr->TERM_AUSGABE(befehl); - ServicePtr->ServiceListFill(); - }else if (wahl.compare("RELOAD") == 0) { - pos_menu_cursor(LiMENU.LMenu); - befehl = "systemctl reload " + menupoint + " --now"; - TaskPtr->TERM_AUSGABE(befehl); - ServicePtr->ServiceListFill(); - }else if (wahl.compare("RESTART") == 0) { - pos_menu_cursor(LiMENU.LMenu); - befehl = "systemctl restart " + menupoint + " --now"; - TaskPtr->TERM_AUSGABE(befehl); - ServicePtr->ServiceListFill(); - }else if (wahl.compare("ENABLE") == 0) { - pos_menu_cursor(LiMENU.LMenu); - befehl = "systemctl enable " + menupoint; - TaskPtr->TERM_AUSGABE(befehl); - ServicePtr->ServiceListFill(); - }else if (wahl.compare("DISABLE") == 0) { - pos_menu_cursor(LiMENU.LMenu); - befehl = "systemctl disable " + menupoint; - TaskPtr->TERM_AUSGABE(befehl); - ServicePtr->ServiceListFill(); - }else if (wahl.compare("STATUS") == 0) { - pos_menu_cursor(LiMENU.LMenu); - befehl = "systemctl status " + menupoint; - ServicePtr->Statusabfrage(TaskPtr->TERM_AUSGABE(befehl)); - }else if (wahl.compare("UNMASK") == 0) { - pos_menu_cursor(LiMENU.LMenu); - befehl = "systemctl unmask " + menupoint; - TaskPtr->TERM_AUSGABE(befehl); - ServicePtr->ServiceListFill(); - }else if (wahl.compare("MASK") == 0) { - pos_menu_cursor(LiMENU.LMenu); - befehl = "systemctl mask " + menupoint; - TaskPtr->TERM_AUSGABE(befehl); - ServicePtr->ServiceListFill(); - }else if (wahl.compare("journalctl") == 0) { - befehl = "journalctl -b -u " + menupoint; - ServicePtr->Statusabfrage(TaskPtr->TERM_AUSGABE(befehl)); - } -} - -void MenuClass::QUIT(void){ - try { - //###############--Hauptmenu--############################################### - int E = item_count(MENEU.HMMenu); - unpost_menu(MENEU.HMMenu); - SAFE_DELETE(MENEU.HMMenu); - SAFE_DELETE_ARRAY(MENEU.HMItem); - wborder(MENEU.HMWin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); - touchline(MENEU.HMWin,0,E+1); - delwin(MENEU.HMWin); - endwin(); - //###############--Untermenu--############################################### - E = item_count(MENEU.UME.UMEMenu); - unpost_menu(MENEU.UME.UMEMenu); - SAFE_DELETE(MENEU.UME.UMEMenu); - SAFE_DELETE_ARRAY(MENEU.UME.UMEItem); - wborder(MENEU.UME.UMEWin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); - touchline(MENEU.UME.UMEWin,0,E+1); - delwin(MENEU.UME.UMEWin); - endwin(); - - refresh(); - redrawwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - - } catch (const NCursesException *e) { - endwin(); - std::cerr << string(e->classname()) << std::endl; - //res = e.errorno; - } catch (const NCursesException &e) { - endwin(); - std::cerr << e.message << std::endl; - //res = e.errorno; - } catch (const std::exception &e) { - endwin(); - std::cerr << "Exception: " << e.what() << std::endl; - //res = EXIT_FAILURE; - } -} - -void MenuClass::MenuStart(void){ - try { - set_current_item(MENEU.HMMenu, MENEU.HMItem[MeInAl]); - HMTMPWIN = tmpWi(item_name(current_item(MENEU.HMMenu)),item_index(current_item(MENEU.HMMenu))); - string tmpMeNa = string(item_name(current_item(MENEU.HMMenu))); - string MeAuWa = ""; - // std::string PATTER = ""; - ServicePtr->TableMoveRow(); - int tabkey = 1; - int key; - while ((key=wgetch(stdscr)) != KEY_F(10)) { - switch(tabkey){ - case 1:{ // MainWindow ListMenu - switch (key) { -// case '/':{ -// ServicePtr->searchInput(); -// break;} - case '?':{ - ServicePtr->Statusabfrage(ABOUT_INFO); - break;} - case KEY_RESIZE:{ - resize(); - break;} - case KEY_DOWN:{ - //menu_driver(LiMENU.LMenu, REQ_DOWN_ITEM); - ServicePtr->tabledriver(ServicePtr->ServiceList,REQ_DOWN_ITEM); - ServicePtr->TableMoveRow(); - break; } - case KEY_UP:{ - //menu_driver(LiMENU.LMenu, REQ_UP_ITEM); - ServicePtr->tabledriver(ServicePtr->ServiceList,REQ_UP_ITEM); - ServicePtr->TableMoveRow(); - break; } - case KEY_NPAGE:{ - //menu_driver(LiMENU.LMenu, REQ_UP_ITEM); - ServicePtr->tabledriver(ServicePtr->ServiceList,REQ_SCR_DPAGE); - ServicePtr->TableMoveRow(); - break; } - case KEY_PPAGE:{ - //menu_driver(LiMENU.LMenu, REQ_UP_ITEM); - ServicePtr->tabledriver(ServicePtr->ServiceList,REQ_SCR_UPAGE); - ServicePtr->TableMoveRow(); - break; } - case KEY_END:{ - //menu_driver(LiMENU.LMenu, REQ_UP_ITEM); - ServicePtr->tabledriver(ServicePtr->ServiceList,REQ_LAST_ITEM); - ServicePtr->TableMoveRow(); - break; } - case KEY_HOME:{ - //menu_driver(LiMENU.LMenu, REQ_UP_ITEM); - ServicePtr->start = 0; - ServicePtr->selected = 0; - ServicePtr->tabledriver(ServicePtr->ServiceList,REQ_FIRST_ITEM); - ServicePtr->TableMoveRow(); - break; } - case 0x09: { - tabkey = TaskPtr->ZahlenWerk(1,"++",2); - HMTMPWIN = tmpWi("Datei",0); - redrawwin(TaskPtr->ClearWindow(MENEU.UME.UMEWin)); - wrefresh(TaskPtr->ClearWindow(MENEU.UME.UMEWin)); - break; } - case KEY_BTAB:{ - tabkey = TaskPtr->ZahlenWerk(1,"--",2); - HMTMPWIN = tmpWi("Datei",0); - redrawwin(TaskPtr->ClearWindow(MENEU.UME.UMEWin)); - wrefresh(TaskPtr->ClearWindow(MENEU.UME.UMEWin)); - break; } - case KEY_BACKSPACE:{ - //menu_driver(LiMENU.LMenu, REQ_BACK_PATTERN); - ServicePtr->tabledriver(ServicePtr->ServiceList,REQ_BACK_PATTERN); - break; } - case 10:{ - //string menupoint = item_name(current_item(LiMENU.LMenu)); - string menupoint = ServicePtr->AktivName; - string befehl; - befehl = "systemctl status " + menupoint; - //pos_menu_cursor(LiMENU.LMenu); - ServicePtr->Statusabfrage(TaskPtr->TERM_AUSGABE(befehl)); - break; } - case 32:{ - ServicePtr->tabledriver(ServicePtr->ServiceList, REQ_TOGGLE_ITEM); - //menu_driver(LiMENU.LMenu, REQ_TOGGLE_ITEM); - break; } - default:{ - if (key > 10 && key < 128) { - sprintf(ServicePtr->searchString,"%c",key); - PATTER.append(string(ServicePtr->searchString)); - mvwaddnstr(WinPtr->START.TMPWin4, 4, 33, PATTER.c_str(),-1); - ServicePtr->tabledriver(ServicePtr->ServiceList,REQ_NEXT_MATCH); - // sprintf(searchString,"%c",key); - } - break; } - } - if (tabkey==1) { - ServicePtr->INFOWINDOW(ServicePtr->AktivName); - //ServicePtr->INFOWINDOW(item_name(current_item(LiMENU.LMenu))); - refresh(); - touchwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - touchwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin4)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin4)); - prefresh(LiMENU.LMWin, 0, 0, 2, 1, WinPtr->WinSize->HRY_TmpWinReal(WinPtr->START.TMPWin2)+1, WinPtr->WinSize->WCX_TmpWinReal(WinPtr->START.TMPWin2));// -2 - } else if (tabkey==2) { - refresh(); - wrefresh(TaskPtr->ClearWindow(MENEU.HMWin)); - redrawwin(TaskPtr->ClearWindow(MENEU.UME.UMEWin)); - wrefresh(TaskPtr->ClearWindow(MENEU.UME.UMEWin)); - } - break; } // MainWindow ListMenu - case 2:{ //Hauptmenu - switch(key){ -// case '/':{ -// ServicePtr->searchInput(); -// //ServicePtr->inputFor = INPUT_FOR_SEARCH; -// break;} - case '?':{ - ServicePtr->Statusabfrage(ABOUT_INFO); - break;} - case KEY_RESIZE:{ - resize(); - break;} - case KEY_DOWN:{ - menu_driver(MENEU.UME.UMEMenu, REQ_DOWN_ITEM); - break; } - case KEY_UP:{ - menu_driver(MENEU.UME.UMEMenu, REQ_UP_ITEM); - break; } - case KEY_RIGHT:{ - MenuClass::MENEU.LoescheUME(); - menu_driver(MENEU.HMMenu, REQ_RIGHT_ITEM); - tmpMeNa = string(item_name(current_item(MENEU.HMMenu))); - HMTMPWIN = tmpWi(item_name(current_item(MENEU.HMMenu)), item_index(current_item(MENEU.HMMenu))); - break; } - case KEY_LEFT:{ - MenuClass::MENEU.LoescheUME(); // delete before menu drive - menu_driver(MENEU.HMMenu, REQ_LEFT_ITEM); - tmpMeNa = string(item_name(current_item(MENEU.HMMenu))); - HMTMPWIN = tmpWi(item_name(current_item(MENEU.HMMenu)), item_index(current_item(MENEU.HMMenu))); - break; } - case 0x09:{ - tabkey = TaskPtr->ZahlenWerk(2,"++",2); - set_current_item(MENEU.HMMenu, MENEU.HMItem[0]); - MenuClass::MENEU.LoescheUME(); - wrefresh(TaskPtr->ClearWindow(MENEU.HMWin)); - break; } - case KEY_BTAB:{ - tabkey = TaskPtr->ZahlenWerk(2,"--",2); - set_current_item(MENEU.HMMenu, MENEU.HMItem[0]); - MenuClass::MENEU.LoescheUME(); - wrefresh(TaskPtr->ClearWindow(MENEU.HMWin)); - break;} - case 10:{ - MeInAl = item_index(current_item(MENEU.HMMenu)); - fensterwahl(item_name(current_item(MENEU.UME.UMEMenu))); - tabkey = TaskPtr->ZahlenWerk(2,"++",2); - set_current_item(MENEU.HMMenu, MENEU.HMItem[0]); - MenuClass::MENEU.LoescheUME(); - wrefresh(TaskPtr->ClearWindow(MENEU.HMWin)); - break; } - } - if (tabkey==2) { - refresh(); - redrawwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - prefresh(LiMENU.LMWin, 0, 0, 2, 1, WinPtr->WinSize->HRY_TmpWinReal(WinPtr->START.TMPWin2)+1, WinPtr->WinSize->WCX_TmpWinReal(WinPtr->START.TMPWin2)); - wrefresh(TaskPtr->ClearWindow(MENEU.HMWin)); - redrawwin(TaskPtr->ClearWindow(MENEU.UME.UMEWin)); - wrefresh(TaskPtr->ClearWindow(MENEU.UME.UMEWin)); - } else if(tabkey==1){ - MenuClass::MENEU.LoescheUME(); - refresh(); - redrawwin(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - wrefresh(TaskPtr->ClearWindow(WinPtr->START.TMPWin2)); - prefresh(LiMENU.LMWin, 0, 0, 2, 1, WinPtr->WinSize->HRY_TmpWinReal(WinPtr->START.TMPWin2)+1, WinPtr->WinSize->WCX_TmpWinReal(WinPtr->START.TMPWin2)); - } - break;} // Hauptmenu - } - } - - ServicePtr->ENDE_NEW(); - - if (LiMENU.LMItem){unpost_menu(LiMENU.LMenu);SAFE_DELETE(LiMENU.LMItem);SAFE_DELETE_ARRAY(LiMENU.LMItem);} - // int n_choices, i; - // n_choices = ARRAY_SIZE(LiMENU.LMItem); - // unpost_menu(LiMENU.LMenu); - // for(i = 0; i < n_choices; ++i) - // free_item(LiMENU.LMItem[i]); - // free_menu(LiMENU.LMenu); - endwin(); - - } catch (const NCursesException *e) { - endwin(); - std::cerr << e->message << std::endl; - cout << e->errorno; - } catch (const NCursesException &e) { - endwin(); - std::cerr << e.message << std::endl; - cout << e.errorno; - } catch (const std::exception &e) { - endwin(); - std::cerr << "Exception: " << e.what() << std::endl; - cout << EXIT_FAILURE; - } -} - -void MenuClass::resize(){ - WinPtr->WinSize->WCX(); // = 80; - WinPtr->WinSize->HRY(); // = 24; -} - -MenuClass::MenuClass(){ - -} - -MenuClass::~MenuClass(){ - -} From 98cd3eb6892788bbdf8919e00edb5ed64106f2b0 Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Sun, 7 Feb 2021 03:09:24 +0100 Subject: [PATCH 03/19] Delete MenuClass.h --- MenuClass.h | 106 ---------------------------------------------------- 1 file changed, 106 deletions(-) delete mode 100644 MenuClass.h diff --git a/MenuClass.h b/MenuClass.h deleted file mode 100644 index fa7d9b6..0000000 --- a/MenuClass.h +++ /dev/null @@ -1,106 +0,0 @@ -#ifndef MENUCLASS_H -#define MENUCLASS_H - -#include - -//-------Color-Hauptmenue------------------------ -struct MenuColor { - int HaMeFe_HG {78}; //Fenster_Background - int HaMe_FG {78}; //Hauptmenue_Foreground - int HaMe_HG {78}; //Hauptmenue_Background - int HaMe_grey {04}; //Hauptmenue_inaktive - int UMeFe_HG {87}; //Fenster_Untermenue - int UMeFe_FG {87}; //Fenster_Untermenue -}; -//-------Color-InApp-Menues---------------------- -struct InAppColor { - int IlMeFe_HG = 78; //Fenster_Background - int IlMe_FG = 71; //InnLineMenue_Foreground - int IlMe_HG = 18; //InnLineMenue_Background - int IlMe_grey = 18; //InnLineMenue_inaktive - int IlUMeFe_HG = 87;//Fenster_Untermenue -}; - -struct HAUPTMENU { - int HMID; - std::string HMName; - WINDOW *HMWin {nullptr}; - MENU *HMMenu {nullptr}; - ITEM **HMItem {nullptr}; - //############################################### - struct UNTERMENU { - int UMID; - std::string UMEName; - WINDOW *UMEWin {nullptr}; - MENU *UMEMenu {nullptr}; - ITEM **UMEItem {nullptr}; - }UME; - void LoescheUME(){ - int E = item_count(UME.UMEMenu); - unpost_menu(UME.UMEMenu); - SAFE_DELETE(UME.UMEMenu) - SAFE_DELETE_ARRAY(UME.UMEItem) - wborder(UME.UMEWin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); - touchline(UME.UMEWin,0,E+1); - delwin(UME.UMEWin); - endwin(); - refresh(); - } -}; - -struct LISTMENU { - int LMID; - std::string LMName; - WINDOW *LMWin {nullptr}; - MENU *LMenu {nullptr}; - ITEM **LMItem {nullptr}; -}; - -struct APPMENU { - WINDOW *AppWin1 {nullptr}; - MENU *AppMenu1 {nullptr}; - ITEM **AppItem1 {nullptr}; - WINDOW *AppWin2 {nullptr}; - MENU *AppMenu2 {nullptr}; - ITEM **AppItem2 {nullptr}; -}; - -class MenuClass -{ -public: - //############################variablen######### - HAUPTMENU MENEU; - int MeInAl; - WINDOW *HMTMPWIN; - MENU *HMTMPMENU; - //##########MENÜ################################ - LISTMENU LiMENU; - int LiMeInAl; - WINDOW *LiTMPWIN; - MENU *LiTMPMENU; - //############################################## - LISTMENU NEW_UNIT_MENU; - int NEW_UNIT_MeInAl; - WINDOW *NEW_UNIT_TMPWIN; - MENU *NEW_UNIT_TMPMENU; - //############################################## - APPMENU InAppMenu; - MenuColor HMcolor; - InAppColor IAcolor; - std::string PATTER = ""; - void Hauptmenu(void); - void Datei_menu(void); - void DaemonType_menu(void); - void Systemctl_menu(void); - void Info_menu(void); - MENU *tmpMe(std::string name, int id); - WINDOW *tmpWi(std::string name, int id); - void fensterwahl(std::string wahl); - void QUIT(void); - void MenuStart(void); - void resize(); - MenuClass(); - ~MenuClass(); -}; - -#endif // MENUCLASS_H From 56d93e10c9f08172b3e80fb0a6aef341697c0bec Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Sun, 7 Feb 2021 03:09:48 +0100 Subject: [PATCH 04/19] Delete WinClass.cpp --- WinClass.cpp | 267 --------------------------------------------------- 1 file changed, 267 deletions(-) delete mode 100644 WinClass.cpp diff --git a/WinClass.cpp b/WinClass.cpp deleted file mode 100644 index 8c9093a..0000000 --- a/WinClass.cpp +++ /dev/null @@ -1,267 +0,0 @@ -#include -#include -#include -#include -#include - -using namespace std; - -extern class TaskClass * TaskPtr; -extern class MenuClass * MenuPtr; -extern class ServiceClass * ServicePtr; -//extern class WinClass * WinPtr; -extern class ServiceTableClass * TablePtr; - -WinClass::WinClass() { - WinSize->RAND = 1; - WinSize->h = 1; //rand - WinSize->w = 1; - WinSize->WCX(); // = 80; - WinSize->HRY(); // = 24; - WinSize->WCX_Real(); - WinSize->HRY_Real(); - WinSize->WCX_Center(); - WinSize->HRY_Center(); - WinSize->WCX_TmpWin(stdscr); - WinSize->HRY_TmpWin(stdscr); - WinSize->WCX_TmpWinReal(stdscr); - WinSize->HRY_TmpWinReal(stdscr); - WinSize->WCX_TmpWinCenter(stdscr); - WinSize->HRY_TmpWinCenter(stdscr); -} - -void WinClass::AppColor() { - //start_color(); - short MY_MARIN_BLUE=240, MY_LIGHT_BLUE=250; - short R=0,G=0;//,B=0; - init_color(MY_MARIN_BLUE, R, G, static_cast(300)); - init_color(MY_LIGHT_BLUE, R, G, static_cast(850)); - // 0 black, 1 red, 2 green, 3 yellow, 4 blue, 5 magenta, - // 6 cyan, 7 white, 8 marin blue, 9 light blue - /* hintergrund Schwarz */ - init_pair(00, COLOR_BLACK, COLOR_BLACK); - init_pair(10, COLOR_RED, COLOR_BLACK); - init_pair(20, COLOR_GREEN, COLOR_BLACK); - init_pair(30, COLOR_YELLOW, COLOR_BLACK); - init_pair(40, COLOR_BLUE, COLOR_BLACK); - init_pair(50, COLOR_MAGENTA,COLOR_BLACK); - init_pair(60, COLOR_CYAN, COLOR_BLACK); - init_pair(70, COLOR_WHITE, COLOR_BLACK); - init_pair(80, MY_MARIN_BLUE,COLOR_BLACK); - init_pair(90, MY_LIGHT_BLUE,COLOR_BLACK); - /* hintergrund Rot */ - init_pair(01, COLOR_BLACK, COLOR_RED); - init_pair(11, COLOR_RED, COLOR_RED); - init_pair(21, COLOR_GREEN, COLOR_RED); - init_pair(31, COLOR_YELLOW, COLOR_RED); - init_pair(41, COLOR_BLUE, COLOR_RED); - init_pair(51, COLOR_MAGENTA,COLOR_RED); - init_pair(61, COLOR_CYAN, COLOR_RED); - init_pair(71, COLOR_WHITE, COLOR_RED); - init_pair(81, MY_MARIN_BLUE,COLOR_RED); - init_pair(91, MY_LIGHT_BLUE,COLOR_RED); - /* hintergrund Gruen */ - init_pair(02, COLOR_BLACK, COLOR_GREEN); - init_pair(12, COLOR_RED, COLOR_GREEN); - init_pair(22, COLOR_GREEN, COLOR_GREEN); - init_pair(32, COLOR_YELLOW, COLOR_GREEN); - init_pair(42, COLOR_BLUE, COLOR_GREEN); - init_pair(52, COLOR_MAGENTA,COLOR_GREEN); - init_pair(62, COLOR_CYAN, COLOR_GREEN); - init_pair(72, COLOR_WHITE, COLOR_GREEN); - init_pair(82, MY_MARIN_BLUE,COLOR_GREEN); - init_pair(92, MY_LIGHT_BLUE,COLOR_GREEN); - /* hintergrund Gelb */ - init_pair(03, COLOR_BLACK, COLOR_YELLOW); - init_pair(13, COLOR_RED, COLOR_YELLOW); - init_pair(23, COLOR_GREEN, COLOR_YELLOW); - init_pair(33, COLOR_YELLOW, COLOR_YELLOW); - init_pair(43, COLOR_BLUE, COLOR_YELLOW); - init_pair(53, COLOR_MAGENTA,COLOR_YELLOW); - init_pair(63, COLOR_CYAN, COLOR_YELLOW); - init_pair(73, COLOR_WHITE, COLOR_YELLOW); - init_pair(83, MY_MARIN_BLUE,COLOR_YELLOW); - init_pair(93, MY_LIGHT_BLUE,COLOR_YELLOW); - /* hintergrund Blau */ - init_pair(04, COLOR_BLACK, COLOR_BLUE); - init_pair(14, COLOR_RED, COLOR_BLUE); - init_pair(24, COLOR_GREEN, COLOR_BLUE); - init_pair(34, COLOR_YELLOW, COLOR_BLUE); - init_pair(44, COLOR_BLUE, COLOR_BLUE); - init_pair(54, COLOR_MAGENTA,COLOR_BLUE); - init_pair(64, COLOR_CYAN, COLOR_BLUE); - init_pair(74, COLOR_WHITE, COLOR_BLUE); - init_pair(84, MY_MARIN_BLUE,COLOR_BLUE); - /* hintergrund Magenta */ - init_pair(05, COLOR_BLACK, COLOR_MAGENTA); - init_pair(15, COLOR_RED, COLOR_MAGENTA); - init_pair(25, COLOR_GREEN, COLOR_MAGENTA); - init_pair(35, COLOR_YELLOW, COLOR_MAGENTA); - init_pair(45, COLOR_BLUE, COLOR_MAGENTA); - init_pair(55, COLOR_MAGENTA,COLOR_MAGENTA); - init_pair(65, COLOR_CYAN, COLOR_MAGENTA); - init_pair(75, COLOR_WHITE, COLOR_MAGENTA); - /* hintergrund Cyan */ - init_pair(06, COLOR_BLACK, COLOR_CYAN); - init_pair(16, COLOR_RED, COLOR_CYAN); - init_pair(26, COLOR_GREEN, COLOR_CYAN); - init_pair(36, COLOR_YELLOW, COLOR_CYAN); - init_pair(46, COLOR_BLUE, COLOR_CYAN); - init_pair(56, COLOR_MAGENTA,COLOR_CYAN); - init_pair(66, COLOR_CYAN, COLOR_CYAN); - init_pair(76, COLOR_WHITE, COLOR_CYAN); - init_pair(86, MY_MARIN_BLUE,COLOR_CYAN); - init_pair(96, MY_LIGHT_BLUE,COLOR_CYAN); - /* hintergrund White */ - init_pair(07, COLOR_BLACK, COLOR_WHITE); - init_pair(17, COLOR_RED, COLOR_WHITE); - init_pair(27, COLOR_GREEN, COLOR_WHITE); - init_pair(37, COLOR_YELLOW, COLOR_WHITE); - init_pair(47, COLOR_BLUE, COLOR_WHITE); - init_pair(57, COLOR_MAGENTA,COLOR_WHITE); - init_pair(67, COLOR_CYAN, COLOR_WHITE); - init_pair(77, COLOR_WHITE, COLOR_WHITE); - init_pair(87, MY_MARIN_BLUE,COLOR_WHITE); - init_pair(97, MY_LIGHT_BLUE,COLOR_WHITE); - /* hintergrund Marin Blau */ - init_pair(8, COLOR_BLACK, MY_MARIN_BLUE); - init_pair(18, COLOR_RED, MY_MARIN_BLUE); - init_pair(28, COLOR_GREEN, MY_MARIN_BLUE); - init_pair(38, COLOR_YELLOW, MY_MARIN_BLUE); - init_pair(48, COLOR_BLUE, MY_MARIN_BLUE); - init_pair(58, COLOR_MAGENTA,MY_MARIN_BLUE); - init_pair(68, COLOR_CYAN, MY_MARIN_BLUE); - init_pair(78, COLOR_WHITE, MY_MARIN_BLUE); - init_pair(88, MY_MARIN_BLUE,MY_MARIN_BLUE); - init_pair(98, MY_LIGHT_BLUE,MY_MARIN_BLUE); - /* hintergrund Light Blue */ - init_pair(9, COLOR_BLACK, MY_LIGHT_BLUE); - init_pair(19, COLOR_RED, MY_LIGHT_BLUE); - init_pair(29, COLOR_GREEN, MY_LIGHT_BLUE); - init_pair(39, COLOR_YELLOW, MY_LIGHT_BLUE); - init_pair(49, COLOR_BLUE, MY_LIGHT_BLUE); - init_pair(59, COLOR_MAGENTA,MY_LIGHT_BLUE); - init_pair(69, COLOR_CYAN, MY_LIGHT_BLUE); - init_pair(79, COLOR_WHITE, MY_LIGHT_BLUE); - init_pair(89, MY_MARIN_BLUE,MY_LIGHT_BLUE); - init_pair(99, MY_LIGHT_BLUE,MY_LIGHT_BLUE); - -} /*---------Programm_Farben------------------------*/ - -void WinClass::FensterDesign() { - if (MenuPtr->MENEU.HMWin) {werase(MenuPtr->MENEU.HMWin); delwin(MenuPtr->MENEU.HMWin); endwin();} - if (MenuPtr->LiMENU.LMWin) {werase(MenuPtr->LiMENU.LMWin); delwin(MenuPtr->LiMENU.LMWin); endwin();} - if (MenuPtr->NEW_UNIT_MENU.LMWin) {werase(MenuPtr->NEW_UNIT_MENU.LMWin); delwin(MenuPtr->NEW_UNIT_MENU.LMWin); endwin();} - if (START.TimeWin) {werase(START.TimeWin); delwin(START.TimeWin); endwin();} - if (START.TMPWin1) {werase(START.TMPWin1); delwin(START.TMPWin1); endwin();} - if (START.TMPWin2) {werase(START.TMPWin2); delwin(START.TMPWin2); endwin();} - if (START.TMPWin3) {werase(START.TMPWin3); delwin(START.TMPWin3); endwin();} - if (START.TMPWin4) {werase(START.TMPWin4); delwin(START.TMPWin4); endwin();} - if (START.TMPWin5) {werase(START.TMPWin5); delwin(START.TMPWin5); endwin();} - // - START.FEID = 0; - START.FENAME = string("VARSYSMAN"); - START.TimeWin = newwin(1, 20, 0, WinSize->WCX()-20); - START.TMPWin1 = newwin(1, WinSize->WCX(), 0, 0); - MenuPtr->MENEU.HMWin = derwin(START.TMPWin1, 1, WinSize->WCX()-20, 0, 0); - START.TimeWin = derwin(START.TMPWin1, 1, 20, 0, WinSize->WCX()-20); - wbkgd(START.TMPWin1, COLOR_PAIR(MenuPtr->HMcolor.HaMeFe_HG)); - // Hauptfenster TMPWin2 - START.TMPWin2 = newwin(WinSize->HRY() -7, WinSize->WCX(), 1, 0); //-1 -20 - wbkgd(START.TMPWin2, COLOR_PAIR(WindowColor.FeBk_Main)); - box(START.TMPWin2, 0,0); - // Listen Menü LMWin at the MainWindow as PAD - MenuPtr->LiMENU.LMWin = newpad(WinSize->HRY() -9, WinSize->WCX()-2); //-5 -20 - wbkgd(MenuPtr->LiMENU.LMWin, COLOR_PAIR(WindowColor.FeBk_Main)); - MenuPtr->LiMENU.LMWin = derwin(START.TMPWin2, WinSize->HRY_TmpWinReal(START.TMPWin2), WinSize->WCX_TmpWinReal(START.TMPWin2), 3, 2); //-4 -20 - //MenuPtr->NEW_UNIT_MENU.LMWin = derwin(START.TMPWin2, WinSize->HRY_REALMAINWIN(START.TMPWin2), WinSize->WCX_REALMAINWIN(START.TMPWin2), 3, 2); //-4 -20 - // Secondary Window on the bottom, hinweiss leiste unten TMPWin4 - START.TMPWin4 = newwin(WinSize->HRY() -18, WinSize->WCX(), WinSize->HRY()-6, 0);//-1 -60 1 -20 - box_set(START.TMPWin4, 0,0); - wbkgd(START.TMPWin4, COLOR_PAIR(WindowColor.FeBk_Info)); - wattr_on(START.TMPWin4, COLOR_PAIR(01)|A_BOLD,nullptr); - mvwaddnstr(START.TMPWin4, WinSize->HRY_TmpWin(START.TMPWin4) -1, WinSize->WCX_TmpWin(START.TMPWin4) -14, "[ EXIT F10 ]" ,-1); //12+2 - mvwaddnstr(START.TMPWin4, WinSize->HRY_TmpWin(START.TMPWin4) -1, WinSize->WCX_TmpWin(START.TMPWin4) -26, "[ MENÜ TAB ]" ,-1); //11+2 - wattr_off(START.TMPWin4, COLOR_PAIR(01)|A_BOLD,nullptr); - // Description fenster unten - START.TMPWin5 = newwin(3, WinSize->WCX() -33, WinSize->HRY()-5, WinSize->WCX() -48); - wbkgd(START.TMPWin5, COLOR_PAIR(WindowColor.FeFo_Info)|A_BOLD); //42 - START.TMPWin5 = derwin(START.TMPWin4, 3, WinSize->WCX() -33, 1, WinSize->WCX() -48); - //ServicePtr->ServiceListFill(); - // Service_Class.ServiceHauptMenu(); -} /*---------Fenster sub----------------------------*/ - -void WinClass::ScrollPad(WINDOW * SubWin, int StartY, int StartX, int Height, int Width, int PadHeight) { - int Choice = 0, Key = 0; - keypad(SubWin, true); - refresh(); - int cols = 0; - while (Choice == 0) { - prefresh(SubWin, cols,0,StartY,StartX,Height,Width); - Key = wgetch(SubWin); - switch(Key) - { - case KEY_UP: - { - if (cols <= 0) continue; - cols--; - break; - } - case KEY_DOWN: - { - if (cols+Height+1 >= PadHeight) continue; - cols++; - break; - } - case KEY_PPAGE: /* Page Up */ - { - if (cols <= 0) continue; - cols -= Height; - if (cols < 0) cols = 0; - break; - } - case KEY_NPAGE: /* Page Down */ - if (cols+Height+1 >= PadHeight) continue; - cols += Height; - if (cols+Height+1 > PadHeight) cols = PadHeight-Height-1; - break; - case KEY_HOME: - cols = 0; - break; - case KEY_END: - cols = PadHeight-Height-1; - break; - case 10: /* Enter */ - { - Choice = 1; - break; - } - } - refresh(); - } - delwin(SubWin); -} - -void WinClass::FensterDraw() { - FensterDesign(); - MenuPtr->Hauptmenu(); - ServicePtr->INFOWINDOW(""); - ServicePtr->ServiceListFill(); -} - -void WinClass::ChangeSize() { - StopWin(); - StartWin(); - FensterDraw(); -} - -//________________new_Systemd_________________ - -WinClass::~WinClass(){ - if (START.TMPWin1) {werase(START.TMPWin1); delwin(START.TMPWin1); endwin();} - if (START.TMPWin2) {werase(START.TMPWin2); delwin(START.TMPWin2); endwin();} - if (START.TMPWin3) {werase(START.TMPWin3); delwin(START.TMPWin3); endwin();} - if (START.TMPWin4) {werase(START.TMPWin4); delwin(START.TMPWin4); endwin();} - if (START.TMPWin5) {werase(START.TMPWin5); delwin(START.TMPWin5); endwin();} -}; - From a4e324bde565187ad8fee4b6f99e3384264f460f Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Sun, 7 Feb 2021 03:09:55 +0100 Subject: [PATCH 05/19] Delete WinClass.h --- WinClass.h | 81 ------------------------------------------------------ 1 file changed, 81 deletions(-) delete mode 100644 WinClass.h diff --git a/WinClass.h b/WinClass.h deleted file mode 100644 index b73af62..0000000 --- a/WinClass.h +++ /dev/null @@ -1,81 +0,0 @@ -#ifndef WINCLASS_H -#define WINCLASS_H - -#include - -struct FensterColor { - int FeBk_Main = 78; //Fenster_Background - int FeFo_Main = 78; //Fenster_Foreground - int FeBk_Info = 71; //info fenster_Background - int FeFo_Info = 71; //info fenster foreground - int FeBk_Help = 74; //help fenster Background - int FeFo_Help = 74; //help fenster foreground -}; - -typedef struct RECTANGLE { - int RAND = 1; - int WCX(){return static_cast(roundf(getmaxx(stdscr)));}; - int HRY(){return static_cast(roundf(getmaxy(stdscr)));}; - int WCX_Real(){return static_cast(roundf(WCX() - (2 * RAND)));} - int HRY_Real(){return static_cast(roundf(HRY() - (2 * RAND)));} - int WCX_Center(){return static_cast(roundf(WCX() / 2));}; - int HRY_Center(){return static_cast(roundf(HRY() / 2));}; - int WCX_TmpWin(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin)));}; - int HRY_TmpWin(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin)));}; - int WCX_TmpWinReal(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin) - (2 * RAND)));}; - int HRY_TmpWinReal(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin) - (2 * RAND)));}; - int WCX_TmpWinCenter(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin) / 2));}; - int HRY_TmpWinCenter(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin) / 2));}; - unsigned long WinHalfDurch(WINDOW * tmpwin, int TeilDurch){return static_cast(roundf(WCX_TmpWinCenter(tmpwin) / TeilDurch));}; - int w {1}; - int h {1}; -} RECTANGLE; - -struct FENSTER { - int FEID {0}; - std::string FENAME {""}; - WINDOW *TimeWin {nullptr}; - WINDOW *TMPWin1 {nullptr}; - WINDOW *TMPWin2 {nullptr}; - WINDOW *TMPWin3 {nullptr}; - WINDOW *TMPWin4 {nullptr}; - WINDOW *TMPWin5 {nullptr}; - int TMPWinHigh {0}; - void delwinow(WINDOW *tmpwin){ - if(tmpwin){ - int mx,my,bx,by; - getbegyx(tmpwin,by,bx); - getmaxyx(tmpwin,my,mx); - touchwin(tmpwin); - wborder(tmpwin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); - touchline(tmpwin,bx,mx); - delwin(tmpwin); - endwin(); - tmpwin = nullptr; - } - } -}; - -class WinClass { -public: - RECTANGLE * WinSize = new RECTANGLE; - FENSTER START; - FensterColor WindowColor; - void StartWin(); - void StopWin(); - void SetSize(); - void AppColor(); - void FensterDesign(); - void ScrollPad(WINDOW * SubWin, int StartY, int StartX, int Height, int Width, int PadHeight); - void printInMiddle(WINDOW *win, int starty, int startx, int width, char *string, chtype color, char *sp); - void FensterDraw(); - void ChangeSize(); -//#########_ende_new_systemd________________ - WinClass(); - ~WinClass(); - -}; - - - -#endif // WINCLASS_H From 5e497a00da4a7f67540c67e4c6bc4d0af39d3d59 Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Sun, 7 Feb 2021 03:59:30 +0100 Subject: [PATCH 06/19] Add files via upload --- Screenshot/ServiceControl_v1.0.4.png | Bin 0 -> 87320 bytes Screenshot/ServiceControl_v1.0.4_2.png | Bin 0 -> 59067 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 Screenshot/ServiceControl_v1.0.4.png create mode 100644 Screenshot/ServiceControl_v1.0.4_2.png diff --git a/Screenshot/ServiceControl_v1.0.4.png b/Screenshot/ServiceControl_v1.0.4.png new file mode 100644 index 0000000000000000000000000000000000000000..28f399543994b86474f3d85b1334453e698af454 GIT binary patch literal 87320 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 literal 0 HcmV?d00001 diff --git a/Screenshot/ServiceControl_v1.0.4_2.png b/Screenshot/ServiceControl_v1.0.4_2.png new file mode 100644 index 0000000000000000000000000000000000000000..4900d4fd94424a850acdff5509f52bccec93a1cc GIT binary patch literal 59067 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 literal 0 HcmV?d00001 From 3c44e93605432b7392a632a252aeb92dc4863436 Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Sun, 7 Feb 2021 04:05:29 +0100 Subject: [PATCH 07/19] Update README.md --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index bc22572..813ecd8 100644 --- a/README.md +++ b/README.md @@ -21,18 +21,18 @@ https://github.com/linuxenko/chkservice ![ServiceControl](https://github.com/fett-tony/ServiceControl/blob/main/Screenshot/ServiceControll-v1.0.2.png) -# 1. the first option is shadowbuild muss off. +# 1. The first option is Shadowbuild Must Off. -this is while this projekt have own options into the pro file and work with a special folder set. +This has to be done because this project has a special folder system for the build. ![ShadowBuild](https://github.com/fett-tony/NcursesWindowTemplate/blob/main/README/ShadowBuild.png) -# 2. the second option for debugger +# 2. The second option is for the debugger when you need to work with threads or pthread you must set SIGSTOP options off. for running with thread or pthread option -you musst set "handle SIGSTOP pass nostop noprint" into the Debugger option for "Locals & Expressions". +you must set "handle SIGSTOP pass nostop noprint" into the Debugger option for "Locals & Expressions". > TOOLS -> Options -> Debugger -> Locals & Expressions -> Debugging Helper Customization From 4543369634aa7262c05f19ebb6ec0fe896dd9b56 Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Sun, 7 Feb 2021 04:08:49 +0100 Subject: [PATCH 08/19] Update README.md --- README.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 813ecd8..70bf8e6 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,14 @@ # ServiceControl -systemctl is the basic. ServiceControl this is a Qt creator project! +chkservice is the basis for ServiceControl. -also download Qt Creator. +This is a Qt Creator project! -This is a Qt Creator Projekt for run you musst set two options. +Also download Qt Creator. -That is the clock jump of my development and also consists of parts of this preliminary work. +You need to set two options before you can begin. + +That is the clock leap in my development and also consists of parts of this preliminary work. chkservice can be installed on Ubuntu with: From dc404c2d336202da4cfe6ab06f2bd3cb89b7525c Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Sun, 7 Feb 2021 04:10:29 +0100 Subject: [PATCH 09/19] Update README.md --- README.md | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 70bf8e6..d77b537 100644 --- a/README.md +++ b/README.md @@ -20,8 +20,9 @@ https://github.com/hflautert/chkservices https://github.com/linuxenko/chkservice -![ServiceControl](https://github.com/fett-tony/ServiceControl/blob/main/Screenshot/ServiceControll-v1.0.2.png) +![ServiceControl](https://github.com/fett-tony/ServiceControl/blob/ServiceControl_v1.0.4/Screenshot/ServiceControl_v1.0.4.png) +![ServiceControl](https://github.com/fett-tony/ServiceControl/blob/ServiceControl_v1.0.4/Screenshot/ServiceControl_v1.0.4_2.png) # 1. The first option is Shadowbuild Must Off. @@ -43,8 +44,3 @@ you must set "handle SIGSTOP pass nostop noprint" into the Debugger option for " ![Debugging_Helper_Customization](https://github.com/fett-tony/NcursesWindowTemplate/blob/main/README/Debugging_Helper_Customization.png) - -![ServiceControl](https://github.com/fett-tony/ServiceControl/blob/main/Screenshot/ServiceControl-1.png) -![ServiceControl](https://github.com/fett-tony/ServiceControl/blob/main/Screenshot/ServiceControl-2.png) -![ServiceControl](https://github.com/fett-tony/ServiceControl/blob/main/Screenshot/ServiceControl-3.png) -![ServiceControl](https://github.com/fett-tony/ServiceControl/blob/main/Screenshot/ServiceControll-branch.png) From 70c90da0cc7e84ac84a481397085ad0b9efe0b67 Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Tue, 9 Feb 2021 09:01:52 +0100 Subject: [PATCH 10/19] Delete MenuWinClass.cpp --- MenuWinClass.cpp | 899 ----------------------------------------------- 1 file changed, 899 deletions(-) delete mode 100644 MenuWinClass.cpp diff --git a/MenuWinClass.cpp b/MenuWinClass.cpp deleted file mode 100644 index 15b5aa6..0000000 --- a/MenuWinClass.cpp +++ /dev/null @@ -1,899 +0,0 @@ - #include - -using namespace std; - -TaskClass *TaskClass_MWC = new TaskClass(); -ServiceClass *ServiceClass_MWC = new ServiceClass(); -MenuWinClass *MenuWinClass_MWC = new MenuWinClass(); - -FENSTER MenuWinClass::START; -HAUPTMENU MenuWinClass::TOPMENU; -WINDOW* MenuWinClass::TMPWIN; -MENU* MenuWinClass::TMPMENU; -int MenuWinClass::MeInAl = 0; -INAPPMENU MenuWinClass::SERVICEMENU; -int MenuWinClass::LiMeInAl; -WINDOW* MenuWinClass::LiTMPWIN; -MENU* MenuWinClass::LiTMPMENU; -string MenuWinClass::PATTERN; -ServiceClass ServiceClass; -vector ServiceList; -int MenuWinClass::TabKey = 1; - -WinID& operator++(WinID& WID, int) { - return WID = (WID == WinID::ENDWIN) ? WinID::MAINWIN : static_cast(static_cast(WID) + 1); -}; -WinID& operator--(WinID& WID, int) { - return WID = (WID == WinID::ENDWIN) ? WinID::MAINWIN : static_cast(static_cast(WID) - 1); -}; -ostream& operator<<(ostream& WID, WinID e) { - static const vector EnumString = {"MENUWIN", "MAINWIN", "TERMWIN", "LISTPAD", "DESCWIN", "ENDWIN"}; - return WID << EnumString[static_cast(e)]; -}; -MenuID& operator++(MenuID& MID, int) { - return MID = (MID == MenuID::ENDMENU) ? MenuID::MAINMENU : static_cast(static_cast(MID) + 1); -}; -MenuID& operator--(MenuID& MID, int) { - return MID = (MID == MenuID::ENDMENU) ? MenuID::MAINMENU : static_cast(static_cast(MID) - 1); -}; -ostream& operator<<(ostream& MID, MenuID e) { - static const vector EnumString = {"DATEIMENU", "DAEMONMENU", "SYSTEMCTLMENU", "INFOMENU", "MAINMENU", "ENDMENU"}; - return MID << EnumString[static_cast(e)]; -}; - -MenuWinClass::MenuWinClass() { - START.WinSize.RAND = 1; - START.WinSize.h = 1; //rand - START.WinSize.w = 1; - START.WCX(); // = 80; - START.HRY(); // = 24; - START.WinSize.WCX(); // = 80; - START.WinSize.HRY(); // = 24; - START.WinSize.WCX_Real(); - START.WinSize.HRY_Real(); - START.WinSize.WCX_Center(); - START.WinSize.HRY_Center(); - START.WinSize.WCX_TmpWin(stdscr); - START.WinSize.HRY_TmpWin(stdscr); - START.WinSize.WCX_TmpWinReal(stdscr); - START.WinSize.HRY_TmpWinReal(stdscr); - START.WinSize.WCX_TmpWinCenter(stdscr); - START.WinSize.HRY_TmpWinCenter(stdscr); -} -void MenuWinClass::StartWin() { - setlocale(LC_CTYPE, "de_DE.UTF-8"); - setlocale(LC_ALL, "de_DE.UTF-8"); - initscr(); - if (has_colors() == FALSE) { endwin(); cout << "Your terminal does not support color\n" << endl; exit(1);} - start_color(); - cbreak(); - noecho(); - curs_set(false); - keypad(stdscr, true); - MenuWinClass::AppColor(); -} -void MenuWinClass::StopWin() { - endwin(); -} -void MenuWinClass::AppColor() { - start_color(); - short MY_MARIN_BLUE = 240, MY_LIGHT_BLUE = 250, MY_DARK_BLACK = 0, MY_LIGHT_WHITE = 100; - short R = 0, G = 0, B = 0; - init_color(MY_MARIN_BLUE, R, G, static_cast(300)); - init_color(MY_LIGHT_BLUE, R, G, static_cast(850)); - init_color(MY_DARK_BLACK, R, G, B); - init_color(MY_LIGHT_WHITE, 1000, 1000, 1000); - /* 0 black, 1 red, 2 green, 3 yellow, 4 blue, 5 magenta, 6 cyan, 7 white, 8 marin blue, 9 light blue */ - /* hintergrund Schwarz */ - init_pair(00, MY_DARK_BLACK, MY_DARK_BLACK); - init_pair(10, COLOR_RED, MY_DARK_BLACK); - init_pair(20, COLOR_GREEN, MY_DARK_BLACK); - init_pair(30, COLOR_YELLOW, MY_DARK_BLACK); - init_pair(40, COLOR_BLUE, MY_DARK_BLACK); - init_pair(50, COLOR_MAGENTA, MY_DARK_BLACK); - init_pair(60, COLOR_CYAN, MY_DARK_BLACK); - init_pair(70, MY_LIGHT_WHITE, MY_DARK_BLACK); - init_pair(80, MY_MARIN_BLUE, MY_DARK_BLACK); - init_pair(90, MY_LIGHT_BLUE, MY_DARK_BLACK); - /* hintergrund Rot */ - init_pair(01, MY_DARK_BLACK, COLOR_RED); - init_pair(11, COLOR_RED, COLOR_RED); - init_pair(21, COLOR_GREEN, COLOR_RED); - init_pair(31, COLOR_YELLOW, COLOR_RED); - init_pair(41, COLOR_BLUE, COLOR_RED); - init_pair(51, COLOR_MAGENTA, COLOR_RED); - init_pair(61, COLOR_CYAN, COLOR_RED); - init_pair(71, MY_LIGHT_WHITE, COLOR_RED); - init_pair(81, MY_MARIN_BLUE, COLOR_RED); - init_pair(91, MY_LIGHT_BLUE, COLOR_RED); - /* hintergrund Gruen */ - init_pair(02, MY_DARK_BLACK, COLOR_GREEN); - init_pair(12, COLOR_RED, COLOR_GREEN); - init_pair(22, COLOR_GREEN, COLOR_GREEN); - init_pair(32, COLOR_YELLOW, COLOR_GREEN); - init_pair(42, COLOR_BLUE, COLOR_GREEN); - init_pair(52, COLOR_MAGENTA, COLOR_GREEN); - init_pair(62, COLOR_CYAN, COLOR_GREEN); - init_pair(72, MY_LIGHT_WHITE, COLOR_GREEN); - init_pair(82, MY_MARIN_BLUE, COLOR_GREEN); - init_pair(92, MY_LIGHT_BLUE, COLOR_GREEN); - /* hintergrund Gelb */ - init_pair(03, MY_DARK_BLACK, COLOR_YELLOW); - init_pair(13, COLOR_RED, COLOR_YELLOW); - init_pair(23, COLOR_GREEN, COLOR_YELLOW); - init_pair(33, COLOR_YELLOW, COLOR_YELLOW); - init_pair(43, COLOR_BLUE, COLOR_YELLOW); - init_pair(53, COLOR_MAGENTA, COLOR_YELLOW); - init_pair(63, COLOR_CYAN, COLOR_YELLOW); - init_pair(73, MY_LIGHT_WHITE, COLOR_YELLOW); - init_pair(83, MY_MARIN_BLUE, COLOR_YELLOW); - init_pair(93, MY_LIGHT_BLUE, COLOR_YELLOW); - /* hintergrund Blau */ - init_pair(04, MY_DARK_BLACK, COLOR_BLUE); - init_pair(14, COLOR_RED, COLOR_BLUE); - init_pair(24, COLOR_GREEN, COLOR_BLUE); - init_pair(34, COLOR_YELLOW, COLOR_BLUE); - init_pair(44, COLOR_BLUE, COLOR_BLUE); - init_pair(54, COLOR_MAGENTA, COLOR_BLUE); - init_pair(64, COLOR_CYAN, COLOR_BLUE); - init_pair(74, MY_LIGHT_WHITE, COLOR_BLUE); - init_pair(84, MY_MARIN_BLUE, COLOR_BLUE); - /* hintergrund Magenta */ - init_pair(05, MY_DARK_BLACK, COLOR_MAGENTA); - init_pair(15, COLOR_RED, COLOR_MAGENTA); - init_pair(25, COLOR_GREEN, COLOR_MAGENTA); - init_pair(35, COLOR_YELLOW, COLOR_MAGENTA); - init_pair(45, COLOR_BLUE, COLOR_MAGENTA); - init_pair(55, COLOR_MAGENTA, COLOR_MAGENTA); - init_pair(65, COLOR_CYAN, COLOR_MAGENTA); - init_pair(75, MY_LIGHT_WHITE, COLOR_MAGENTA); - /* hintergrund Cyan */ - init_pair(06, MY_DARK_BLACK, COLOR_CYAN); - init_pair(16, COLOR_RED, COLOR_CYAN); - init_pair(26, COLOR_GREEN, COLOR_CYAN); - init_pair(36, COLOR_YELLOW, COLOR_CYAN); - init_pair(46, COLOR_BLUE, COLOR_CYAN); - init_pair(56, COLOR_MAGENTA, COLOR_CYAN); - init_pair(66, COLOR_CYAN, COLOR_CYAN); - init_pair(76, MY_LIGHT_WHITE, COLOR_CYAN); - init_pair(86, MY_MARIN_BLUE, COLOR_CYAN); - init_pair(96, MY_LIGHT_BLUE, COLOR_CYAN); - /* hintergrund White */ - init_pair(07, MY_DARK_BLACK, MY_LIGHT_WHITE); - init_pair(17, COLOR_RED, MY_LIGHT_WHITE); - init_pair(27, COLOR_GREEN, MY_LIGHT_WHITE); - init_pair(37, COLOR_YELLOW, MY_LIGHT_WHITE); - init_pair(47, COLOR_BLUE, MY_LIGHT_WHITE); - init_pair(57, COLOR_MAGENTA, MY_LIGHT_WHITE); - init_pair(67, COLOR_CYAN, MY_LIGHT_WHITE); - init_pair(77, MY_LIGHT_WHITE, MY_LIGHT_WHITE); - init_pair(87, MY_MARIN_BLUE, MY_LIGHT_WHITE); - init_pair(97, MY_LIGHT_BLUE, MY_LIGHT_WHITE); - /* hintergrund Marin Blau */ - init_pair(8, MY_DARK_BLACK, MY_MARIN_BLUE); - init_pair(18, COLOR_RED, MY_MARIN_BLUE); - init_pair(28, COLOR_GREEN, MY_MARIN_BLUE); - init_pair(38, COLOR_YELLOW, MY_MARIN_BLUE); - init_pair(48, COLOR_BLUE, MY_MARIN_BLUE); - init_pair(58, COLOR_MAGENTA, MY_MARIN_BLUE); - init_pair(68, COLOR_CYAN, MY_MARIN_BLUE); - init_pair(78, MY_LIGHT_WHITE, MY_MARIN_BLUE); - init_pair(88, MY_MARIN_BLUE, MY_MARIN_BLUE); - init_pair(98, MY_LIGHT_BLUE, MY_MARIN_BLUE); - /* hintergrund Light Blue */ - init_pair(9, MY_DARK_BLACK, MY_LIGHT_BLUE); - init_pair(19, COLOR_RED, MY_LIGHT_BLUE); - init_pair(29, COLOR_GREEN, MY_LIGHT_BLUE); - init_pair(39, COLOR_YELLOW, MY_LIGHT_BLUE); - init_pair(49, COLOR_BLUE, MY_LIGHT_BLUE); - init_pair(59, COLOR_MAGENTA, MY_LIGHT_BLUE); - init_pair(69, COLOR_CYAN, MY_LIGHT_BLUE); - init_pair(79, MY_LIGHT_WHITE, MY_LIGHT_BLUE); - init_pair(89, MY_MARIN_BLUE, MY_LIGHT_BLUE); - init_pair(99, MY_LIGHT_BLUE, MY_LIGHT_BLUE); -} /*---------Programm_Farben------------------------*/ -void MenuWinClass::SetWinSize() { - MenuWinClass::START.WCX(); - MenuWinClass::START.HRY(); - MenuWinClass::START.HRYw1(); - MenuWinClass::START.WCXw1(); - MenuWinClass::START.HRYw2(); - MenuWinClass::START.WCXw2(); - MenuWinClass::START.HRYw3(); - MenuWinClass::START.WCXw3(); - MenuWinClass::START.HRYw4(); - MenuWinClass::START.WCXw4(); - MenuWinClass::START.HRYw5(); - MenuWinClass::START.WCXw5(); - MenuWinClass::START.HRYtime(); - MenuWinClass::START.WCXtime(); - MenuWinClass::START.TMPWin1 = newwin(MenuWinClass::START.HRYw1(), MenuWinClass::START.WCXw1(), 0, 0); - MenuWinClass::START.TMPWin2 = newwin(MenuWinClass::START.HRYw2(), MenuWinClass::START.WCXw2(), 1, 0); - MenuWinClass::START.TMPWin3 = newwin(MenuWinClass::START.HRYw3(), MenuWinClass::START.WCXw3(), (MenuWinClass::START.HRYw1() + MenuWinClass::START.HRYw2()), 0); - MenuWinClass::START.TMPWin4 = newpad(MenuWinClass::START.HRYw4(), MenuWinClass::START.WCXw4()); - //MenuWinClass::START.TMPWin5 = newpad(MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); - MenuWinClass::START.TMPWin5 = newwin(MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5(), (MenuWinClass::START.HRYw1() + MenuWinClass::START.HRYw2())+ 1, 33); -} /*---------Fenster_Size_Setzen--------------------*/ -void MenuWinClass::CreateWin(WINDOW* win, WinID WID) { - switch (WID) { - case MENUWIN: { /*TMPWin1*/ - MenuWinClass::Hauptmenu(); - wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_MENUWIN)); - break; - } - case MAINWIN: { /*TMPWin2*/ - box(win, 0, 0); - wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_MAINWIN)); - wsetscrreg(win, 0, MenuWinClass::START.HRYw2() - 2); - scrollok(win, true); - break; - } - case INFOWIN: { /*TMPWin3*/ - box(win, 0, 0); - wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN)); - wattr_on(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN) | A_BOLD, nullptr); - mvwaddnstr(win, MenuWinClass::START.HRYw3() -1, MenuWinClass::START.WCXw3() - 14, "[ EXIT F10 ]", -1); //12+2 - mvwaddnstr(win, MenuWinClass::START.HRYw3() -1, MenuWinClass::START.WCXw3() - 26, "[ MENÜ TAB ]", -1); //11+2 - wattr_off(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN) | A_BOLD, nullptr); - break; - } - case LISTPAD: { /*TMPWin4*/ - wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_LISTPAD)); - win = derwin(MenuWinClass::START.TMPWin2, MenuWinClass::START.HRYw4(), MenuWinClass::START.WCXw4(), 1, 1); - break; - } - case DESCWIN: { /*TMPWin5*/ - //win = derwin(MenuWinClass::START.TMPWin3, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5(), 1, 33); - wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_DESCWIN)); - break; - } - case TIMEWIN: { /*TimeWin*/ - wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_TIMEWIN)); - win = derwin(MenuWinClass::START.TMPWin1, 1, 20, 0, MenuWinClass::START.WCX() - 20); - break; - } - case ENDWIN: { break; } - default: { break; } - } - refresh(); - wrefresh(win); -} /*---------Fenster_Erzeugen-----------------------*/ -void MenuWinClass::ResizeHandler(int signal) { - UNUSED(signal); - StopWin(); - StartWin(); - SetWinSize(); - MenuWinClass::CreateWin(MenuWinClass::START.TMPWin1, MENUWIN); - MenuWinClass::CreateWin(MenuWinClass::START.TMPWin2, MAINWIN); - MenuWinClass::CreateWin(MenuWinClass::START.TMPWin3, INFOWIN); - MenuWinClass::CreateWin(MenuWinClass::START.TMPWin4, LISTPAD); - MenuWinClass::CreateWin(MenuWinClass::START.TMPWin5, DESCWIN); -} /*---------Resize_Fenster_neu_Erzeugen----------------*/ -void MenuWinClass::ScrollPad(WINDOW* SubWin, int StartY, int StartX, int Height, int Width, int PadHeight) { - int Choice = 0, Key = 0; - keypad(SubWin, true); - refresh(); - int cols = 0; - while (Choice == 0) { - prefresh(SubWin, cols, 0, StartY, StartX, Height, Width); - Key = wgetch(SubWin); - switch (Key) { - case KEY_UP: { - if (cols <= 0) { continue; } - cols--; - break; - } - case KEY_DOWN: { - if (cols + Height + 1 >= PadHeight) { continue; } - cols++; - break; - } - case KEY_PPAGE: { /* Page Up */ - if (cols <= 0) { continue; } - cols -= Height; - if (cols < 0) { cols = 0; } - break; - } - case KEY_NPAGE: { /* Page Down */ - if (cols + Height + 1 >= PadHeight) { continue; } - cols += Height; - if (cols + Height + 1 > PadHeight) { cols = PadHeight - Height - 1; } - break; - } - case KEY_HOME: { - cols = 0; - break; - } - case KEY_END: { - cols = PadHeight - Height - 1; - break; - } - case 10: { /* Enter */ - Choice = 1; - break; - } - } - refresh(); - } - delwin(SubWin); -} -void MenuWinClass::printInMiddle(WINDOW *win, int starty, int startx, int width, char *string, chtype color, char *sp) { - int x, y; - unsigned long length; - float temp; - - if(win == nullptr) - win = stdscr; - getyx(win, y, x); - if(startx != 0) - x = startx; - if(starty != 0) - y = starty; - if(width == 0) - width = 80; - - length = strlen(string); - temp = (width - static_cast(length))/ 2; - x = startx + static_cast(temp); - wattron(win, color); - - if (sp) { - for (int i = startx; i < width; i++) { - mvwprintw(win, y, i, "%c", sp); - } - } - - mvwprintw(win, y, x, "%s", string); - wattroff(win, color); -} -void MenuWinClass::FensterDraw() { - ServiceClass_MWC->INFOWINDOW(""); - ServiceClass_MWC->ServiceListFill(); - MenuWinClass::CreateWin(MenuWinClass::START.TMPWin1, MENUWIN); - MenuWinClass::CreateWin(MenuWinClass::START.TMPWin2, MAINWIN); - MenuWinClass::CreateWin(MenuWinClass::START.TMPWin3, INFOWIN); - MenuWinClass::CreateWin(MenuWinClass::START.TMPWin4, LISTPAD); - MenuWinClass::CreateWin(MenuWinClass::START.TMPWin5, DESCWIN); -} -void MenuWinClass::Hauptmenu(void) { - MenuWinClass::TOPMENU.MID = MAINMENU; - MenuWinClass::TOPMENU.HMName = string("HAUPTMENÜ"); - MenuWinClass::TOPMENU.HMItem = static_cast(calloc(5, sizeof(ITEM*))); - MenuWinClass::TOPMENU.HMItem[0] = new_item(" Datei", MenuWinClass::TOPMENU.HMName.c_str()); - MenuWinClass::TOPMENU.HMItem[1] = new_item("DaemonType", MenuWinClass::TOPMENU.HMName.c_str()); - MenuWinClass::TOPMENU.HMItem[2] = new_item("Systemctl", MenuWinClass::TOPMENU.HMName.c_str()); - MenuWinClass::TOPMENU.HMItem[3] = new_item("Info", MenuWinClass::TOPMENU.HMName.c_str()); - MenuWinClass::TOPMENU.HMItem[4] = nullptr; - MenuWinClass::TOPMENU.HMMenu = new_menu(MenuWinClass::TOPMENU.HMItem); - MenuWinClass::START.TMPWin1 = newwin(MenuWinClass::START.HRYw1(), MenuWinClass::START.WCXw1(), 0, 0); - set_menu_win(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::START.TMPWin1); - set_menu_sub(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::START.TMPWin1); - //############################################################### - //set_menu_sub(TOPMENU.UME.UMEMenu, MenuWinClass::START.TMPWin1); - //############################################################### - set_menu_spacing(MenuWinClass::TOPMENU.HMMenu, 1, 0, 0); - set_menu_format(MenuWinClass::TOPMENU.HMMenu, 0, 5); - menu_opts_off(MenuWinClass::TOPMENU.HMMenu, O_SHOWDESC); - menu_opts_off(MenuWinClass::TOPMENU.HMMenu, O_NONCYCLIC); - wbkgd(MenuWinClass::START.TMPWin1, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_MAINMENU)); - set_menu_fore(MenuWinClass::TOPMENU.HMMenu, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_AKTIVHAME) | A_BOLD); - set_menu_back(MenuWinClass::TOPMENU.HMMenu, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_MAINMENU)); - set_menu_grey(MenuWinClass::TOPMENU.HMMenu, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_UNUSEDHM)); - set_menu_mark(MenuWinClass::TOPMENU.HMMenu, ""); - post_menu(MenuWinClass::TOPMENU.HMMenu); -} /* Hauptmenü */ -void MenuWinClass::DateiMenu(void) { - TOPMENU.UME.UMID = 1; - TOPMENU.UME.UMEName = string("Datei"); - TOPMENU.UME.UMEWin = newwin(6, 15, 1, 0); - wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); - box(TOPMENU.UME.UMEWin, 0, 0); - TOPMENU.UME.UMEItem = static_cast(calloc(7, sizeof(ITEM*))); - TOPMENU.UME.UMEItem[0] = new_item("Man Systemctl", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[1] = new_item("Einstellung", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[2] = new_item("Remotectl", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[3] = new_item("Beenden", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[4] = nullptr; - TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); - set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); - set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); - set_menu_spacing(TOPMENU.UME.UMEMenu, 0, 0, 0); - set_menu_format(TOPMENU.UME.UMEMenu, 5, 0); - menu_opts_off(TOPMENU.UME.UMEMenu, O_SHOWDESC); - menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); - set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); - set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); - set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); - set_menu_mark(TOPMENU.UME.UMEMenu, ""); - set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); - post_menu(TOPMENU.UME.UMEMenu); -} /* Datei Untermenü */ -void MenuWinClass::DaemonTypeMenu(void) { - TOPMENU.UME.UMID = 2; - TOPMENU.UME.UMEName = string("DaemonType"); - TOPMENU.UME.UMEWin = newwin(12, 10, 1, 11); - box(TOPMENU.UME.UMEWin, 0, 0); - TOPMENU.UME.UMEItem = static_cast(calloc(11, sizeof(ITEM*))); - TOPMENU.UME.UMEItem[0] = new_item("Device", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[1] = new_item("Mount", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[2] = new_item("Path", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[3] = new_item("Service", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[4] = new_item("Scope", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[5] = new_item("Slice", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[6] = new_item("Socket", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[7] = new_item("Swap", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[8] = new_item("Target", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[9] = new_item("Timer", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[10] = nullptr; - TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); - set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); - set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); - set_menu_spacing(TOPMENU.UME.UMEMenu, 0, 0, 1); - set_menu_format(TOPMENU.UME.UMEMenu, 11, 0); - menu_opts_off(TOPMENU.UME.UMEMenu, O_SHOWDESC); - menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); - wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); - set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); - set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); - set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); - set_menu_mark(TOPMENU.UME.UMEMenu, ""); - set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); - post_menu(TOPMENU.UME.UMEMenu); -} /* DaemonType Untermenü */ -void MenuWinClass::SystemctlMenu(void) { - TOPMENU.UME.UMID = 3; - TOPMENU.UME.UMEName = string("Systemctl"); - TOPMENU.UME.UMEWin = newwin(12, 18, 1, 22); - box(TOPMENU.UME.UMEWin, 0, 0); - TOPMENU.UME.UMEItem = static_cast(calloc(11, sizeof(ITEM*))); - TOPMENU.UME.UMEItem[0] = new_item("START", "F1"); - TOPMENU.UME.UMEItem[1] = new_item("STOP", "F1"); - TOPMENU.UME.UMEItem[2] = new_item("STATUS", "F3"); - TOPMENU.UME.UMEItem[3] = new_item("ENABLE", "F2"); - TOPMENU.UME.UMEItem[4] = new_item("DISABLE", "F2"); - TOPMENU.UME.UMEItem[5] = new_item("MASK", "F4"); - TOPMENU.UME.UMEItem[6] = new_item("UNMASK", "F4"); - TOPMENU.UME.UMEItem[7] = new_item("RESTART", "F5"); - TOPMENU.UME.UMEItem[8] = new_item("RELOAD", "F6"); - TOPMENU.UME.UMEItem[9] = new_item("Reload-daemon", "F7"); - TOPMENU.UME.UMEItem[10] = nullptr; - TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); - set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); - set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); - set_menu_spacing(TOPMENU.UME.UMEMenu, 1, 0, 0); - set_menu_format(TOPMENU.UME.UMEMenu, 11, 0); - menu_opts_on(TOPMENU.UME.UMEMenu, O_SHOWDESC); - menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); - wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); - set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); - set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); - set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); - set_menu_mark(TOPMENU.UME.UMEMenu, ""); - set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); - post_menu(TOPMENU.UME.UMEMenu); -} /* Systemctl Untermenü */ -void MenuWinClass::InfoMenu(void) { - TOPMENU.UME.UMID = 4; - TOPMENU.UME.UMEName = string("Info"); - TOPMENU.UME.UMEWin = newwin(5, 12, 1, 33); - wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); - box(TOPMENU.UME.UMEWin, 0, 0); - TOPMENU.UME.UMEItem = static_cast(calloc(4, sizeof(ITEM*))); - TOPMENU.UME.UMEItem[0] = new_item("journalctl", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[1] = new_item("E-Mail", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[2] = new_item("Beenden", TOPMENU.UME.UMEName.c_str()); - TOPMENU.UME.UMEItem[3] = nullptr; - TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); - set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); - set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); - set_menu_spacing(TOPMENU.UME.UMEMenu, 0, 0, 0); - set_menu_format(TOPMENU.UME.UMEMenu, 5, 0); - menu_opts_off(TOPMENU.UME.UMEMenu, O_SHOWDESC); - menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); - set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); - set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); - set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); - set_menu_mark(TOPMENU.UME.UMEMenu, ""); - set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); - post_menu(TOPMENU.UME.UMEMenu); -} /* Info Untermenü */ -WINDOW* MenuWinClass::TempWin(string Name, MenuID MID) { - if ((Name.compare(" Datei") == 0) || (MID == DATEIMENU)) { - //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, DATEIMENU, "DATEIMENU"); - MenuWinClass::DateiMenu(); - MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; - MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; - } else if ((Name.compare("DaemonType") == 0) || (MID == DAEMONMENU)) { - //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, SYSTEMMENU, "SYSTEMMENU"); - MenuWinClass::DaemonTypeMenu(); - MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; - MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; - } else if ((Name.compare("Systemctl") == 0) || (MID == SYSTEMCTLMENU)) { - //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, SERVERMENU, "SERVERMENU"); - MenuWinClass::SystemctlMenu(); - MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; - MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; - } else if ((Name.compare("Info") == 0) || (MID == INFOMENU)) { - //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, SOFTWAREMENU, "SOFTWAREMENU"); - MenuWinClass::InfoMenu(); - MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; - MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; - } - return MenuWinClass::TMPWIN; -} /* Menü und Win Neuzuordnen */ -void MenuWinClass::StartMenuAuswahl(string wahl) { - string menupoint = MenuWinClass::SERVICEMENU.AktivName; - string befehl; - if (wahl.compare(" Datei") == 0) { - DateiMenu(); - } else if (wahl.compare("Systemctl") == 0) { - SystemctlMenu(); - } else if (wahl.compare("DaemonType") == 0) { - DaemonTypeMenu(); - } else if (wahl.compare("Systemctl") == 0) { - InfoMenu(); - } else if (wahl.compare("Service") == 0) { - ServiceClass_MWC->start = 0; - ServiceClass_MWC->selected = 0; - ServiceClass_MWC->systemctlwahl = "service"; - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("Swap") == 0) { - ServiceClass_MWC->start = 0; - ServiceClass_MWC->selected = 0; - ServiceClass_MWC->systemctlwahl = "swap"; - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("Timer") == 0) { - ServiceClass_MWC->start = 0; - ServiceClass_MWC->selected = 0; - ServiceClass_MWC->systemctlwahl = "timer"; - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("Device") == 0) { - ServiceClass_MWC->start = 0; - ServiceClass_MWC->selected = 0; - ServiceClass_MWC->systemctlwahl = "device"; - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("Mount") == 0) { - ServiceClass_MWC->start = 0; - ServiceClass_MWC->selected = 0; - ServiceClass_MWC->systemctlwahl = "mount"; - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("Path") == 0) { - ServiceClass_MWC->start = 0; - ServiceClass_MWC->selected = 0; - ServiceClass_MWC->systemctlwahl = "path"; - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("Target") == 0) { - ServiceClass_MWC->start = 0; - ServiceClass_MWC->selected = 0; - ServiceClass_MWC->systemctlwahl = "target"; - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("Socket") == 0) { - ServiceClass_MWC->start = 0; - ServiceClass_MWC->selected = 0; - ServiceClass_MWC->systemctlwahl = "socket"; - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("Slice") == 0) { - ServiceClass_MWC->start = 0; - ServiceClass_MWC->selected = 0; - ServiceClass_MWC->systemctlwahl = "slice"; - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("Scope") == 0) { - ServiceClass_MWC->start = 0; - ServiceClass_MWC->selected = 0; - ServiceClass_MWC->systemctlwahl = "scope"; - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("Man Page") == 0) { - exit(EXIT_SUCCESS); - //DATEIMANPAGE::Start_ManP(); - } else if (wahl.compare("Befehle") == 0) { - exit(EXIT_SUCCESS); - //DATEIBEFEHLE::befehle_main(); - } else if (wahl.compare("Einstellung") == 0) { - exit(EXIT_SUCCESS); - //einDa(); - } else if (wahl.compare("Beenden") == 0) { - exit(EXIT_SUCCESS); - } else if (wahl.compare("START") == 0) { - pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); - befehl = "systemctl start " + menupoint + " --now"; - TaskClass_MWC->TERM_AUSGABE(befehl); - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("STOP") == 0) { - pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); - befehl = "systemctl stop " + menupoint + " --now"; - TaskClass_MWC->TERM_AUSGABE(befehl); - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("RELOAD") == 0) { - pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); - befehl = "systemctl reload " + menupoint + " --now"; - TaskClass_MWC->TERM_AUSGABE(befehl); - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("RESTART") == 0) { - pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); - befehl = "systemctl restart " + menupoint + " --now"; - TaskClass_MWC->TERM_AUSGABE(befehl); - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("ENABLE") == 0) { - pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); - befehl = "systemctl enable " + menupoint; - TaskClass_MWC->TERM_AUSGABE(befehl); - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("DISABLE") == 0) { - pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); - befehl = "systemctl disable " + menupoint; - TaskClass_MWC->TERM_AUSGABE(befehl); - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("STATUS") == 0) { - pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); - befehl = "systemctl status " + menupoint; - ServiceClass_MWC->Statusabfrage(TaskClass_MWC->TERM_AUSGABE(befehl)); - } else if (wahl.compare("UNMASK") == 0) { - pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); - befehl = "systemctl unmask " + menupoint; - TaskClass_MWC->TERM_AUSGABE(befehl); - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("MASK") == 0) { - pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); - befehl = "systemctl mask " + menupoint; - TaskClass_MWC->TERM_AUSGABE(befehl); - ServiceClass_MWC->ServiceListFill(); - } else if (wahl.compare("journalctl") == 0) { - befehl = "journalctl -b -u " + menupoint; - ServiceClass_MWC->Statusabfrage(TaskClass_MWC->TERM_AUSGABE(befehl)); - } -} /* MenüPoint to command */ -void MenuWinClass::RefreshWindows(){ - refresh(); - wrefresh(MenuWinClass::START.TMPWin1); - redrawwin(MenuWinClass::START.TMPWin2); - wrefresh(MenuWinClass::START.TMPWin2); - touchwin(MenuWinClass::START.TMPWin2); - redrawwin(MenuWinClass::START.TMPWin3); - wrefresh(MenuWinClass::START.TMPWin3); - touchwin(MenuWinClass::START.TMPWin3); - prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); - //prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY()-4, - // MenuWinClass::START.WCX()-46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); - wrefresh(MenuWinClass::START.TMPWin5); -} - -int MenuWinClass::MenuStart(int Key) { -//try { - set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[MenuWinClass::MeInAl]); - TMPWIN = TempWin(item_name(current_item(MenuWinClass::TOPMENU.HMMenu)), (MenuID)item_index(current_item(MenuWinClass::TOPMENU.HMMenu))); - string tmpMeNa = string(item_name(current_item(MenuWinClass::TOPMENU.HMMenu))); - string MeAuWa = ""; - ServiceClass_MWC->TableMoveRow(); - while ((Key = wgetch(stdscr)) != KEY_F(10)) { - switch (MenuWinClass::TabKey) { - case 1: { - switch (Key) { - case '?': { ServiceClass_MWC->Statusabfrage(ABOUT_INFO); break; } - case 27: { - MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(1, "++", 3); - set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); - MenuWinClass::TOPMENU.LoescheUME(); - wrefresh(MenuWinClass::START.TMPWin1); - break; - } - case KEY_DOWN: { - ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_DOWN_ITEM); - ServiceClass_MWC->TableMoveRow(); - break; - } - case KEY_UP: { - ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_UP_ITEM); - ServiceClass_MWC->TableMoveRow(); - break; - } - case KEY_NPAGE: { - ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_SCR_DPAGE); - ServiceClass_MWC->TableMoveRow(); - break; - } - case KEY_PPAGE: { - ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_SCR_UPAGE); - ServiceClass_MWC->TableMoveRow(); - break; - } - case KEY_END: { - ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_LAST_ITEM); - ServiceClass_MWC->TableMoveRow(); - break; - } - case KEY_HOME: { - ServiceClass_MWC->start = 0; - ServiceClass_MWC->selected = 0; - ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_FIRST_ITEM); - ServiceClass_MWC->TableMoveRow(); - break; - } - case 0x09: { - MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(1, "++", 3); - TMPWIN = TempWin("Datei", DATEIMENU); - redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); - wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); - break; - } - case KEY_BTAB: { - MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(1, "--", 3); - TMPWIN = TempWin("Datei", DATEIMENU); - redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); - wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); - break; - } - case KEY_BACKSPACE: { ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_BACK_PATTERN); break; } - case 10: { - string menupoint = MenuWinClass::SERVICEMENU.AktivName; - string befehl = "systemctl status " + menupoint; - ServiceClass_MWC->Statusabfrage(TaskClass_MWC->TERM_AUSGABE(befehl)); - break; } - case 32: { ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_TOGGLE_ITEM); break; } - default: { if (Key > 10 && Key < 128) { - //ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_NEXT_MATCH); - } - break;} - } - if (MenuWinClass_MWC->TabKey == 1) { - curs_set(false); - ServiceClass_MWC->INFOWINDOW(MenuWinClass::SERVICEMENU.AktivName); - MenuWinClass::TOPMENU.LoescheUME(); - MenuWinClass::RefreshWindows(); - } else if (MenuWinClass_MWC->TabKey == 2) { - curs_set(false); - MenuWinClass::RefreshWindows(); - wrefresh(MenuWinClass::START.TMPWin1); - redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); - wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); - } else if (MenuWinClass_MWC->TabKey == 3) { - curs_set(true); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass::PATTERN.c_str(), -1); - MenuWinClass::RefreshWindows(); - } - break; - } /* MainWindow ListMenu */ - case 2: { - switch (Key) { - case '?': { ServiceClass_MWC->Statusabfrage(ABOUT_INFO); break; } - case 27: { - MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "++", 3); - set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); - MenuWinClass::TOPMENU.LoescheUME(); - wrefresh(MenuWinClass::START.TMPWin1); - break; - } - case KEY_DOWN: { menu_driver(TOPMENU.UME.UMEMenu, REQ_DOWN_ITEM); break; } - case KEY_UP: { menu_driver(TOPMENU.UME.UMEMenu, REQ_UP_ITEM); break; } - case KEY_RIGHT: { - MenuWinClass::TOPMENU.LoescheUME(); - menu_driver(MenuWinClass::TOPMENU.HMMenu, REQ_RIGHT_ITEM); - tmpMeNa = string(item_name(current_item(MenuWinClass::TOPMENU.HMMenu))); - TMPWIN = TempWin(item_name(current_item(MenuWinClass::TOPMENU.HMMenu)), (MenuID)item_index(current_item(MenuWinClass::TOPMENU.HMMenu))); - break; - } - case KEY_LEFT: { - MenuWinClass::TOPMENU.LoescheUME(); // delete before menu drive - menu_driver(MenuWinClass::TOPMENU.HMMenu, REQ_LEFT_ITEM); - tmpMeNa = string(item_name(current_item(MenuWinClass::TOPMENU.HMMenu))); - TMPWIN = TempWin(item_name(current_item(MenuWinClass::TOPMENU.HMMenu)), (MenuID)item_index(current_item(MenuWinClass::TOPMENU.HMMenu))); - break; - } - case 0x09: { - MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "++", 3); - set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); - MenuWinClass::TOPMENU.LoescheUME(); - wrefresh(MenuWinClass::START.TMPWin1); - break; - } - case KEY_BTAB: { - MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "--", 3); - set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); - MenuWinClass::TOPMENU.LoescheUME(); - wrefresh(MenuWinClass::START.TMPWin1); - break; - } - case 10: { - MenuWinClass::MeInAl = item_index(current_item(MenuWinClass::TOPMENU.HMMenu)); - StartMenuAuswahl(item_name(current_item(MenuWinClass::TOPMENU.UME.UMEMenu))); - MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "++", 2); - set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); - MenuWinClass::TOPMENU.LoescheUME(); - wrefresh(MenuWinClass::START.TMPWin1); - break; } - } - if (MenuWinClass_MWC->TabKey == 1) { - curs_set(false); - ServiceClass_MWC->INFOWINDOW(MenuWinClass::SERVICEMENU.AktivName); - MenuWinClass::TOPMENU.LoescheUME(); - MenuWinClass::RefreshWindows(); - } else if (MenuWinClass_MWC->TabKey == 2) { - curs_set(false); - MenuWinClass::RefreshWindows(); - wrefresh(MenuWinClass::START.TMPWin1); - redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); - wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); - } else if (MenuWinClass_MWC->TabKey == 3) { - curs_set(true); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass::PATTERN.c_str(), -1); - MenuWinClass::RefreshWindows(); - } - break; - } /* Hauptmenu */ - case 3:{ - int y,x; - getyx(MenuWinClass::START.TMPWin3, y, x); - int curposi = (x - 33); - switch (Key) { - case '?':{ ServiceClass_MWC->Statusabfrage(ABOUT_INFO); break; } - case 27:{ break; } - case 127: - case KEY_BACKSPACE:{ - MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_DEL_BACKSPACE, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); - break; } - case KEY_DC:{ - MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_DEL_DC, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); - break; } - case KEY_RIGHT:{ - MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_RIGHT, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); - break; } - case KEY_LEFT:{ - MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_LEFT, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); - break; } - case 0x09: { - MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(3, "++", 3); - set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); - MenuWinClass::TOPMENU.LoescheUME(); - wrefresh(MenuWinClass::START.TMPWin1); - break; - } - case KEY_BTAB: { - MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(3, "--", 3); - set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); - MenuWinClass::TOPMENU.LoescheUME(); - wrefresh(MenuWinClass::START.TMPWin1); - break; - } - case KEY_ENTER: - case 10:{ break; } - default:{ - if (Key > 10 && Key < 128) { - MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_INS_DEFAULT, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); - //ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_NEXT_MATCH); - } - break; } - } - if (MenuWinClass_MWC->TabKey == 1) { - curs_set(false); - ServiceClass_MWC->INFOWINDOW(MenuWinClass::SERVICEMENU.AktivName); - MenuWinClass::TOPMENU.LoescheUME(); - MenuWinClass::RefreshWindows(); - } else if (MenuWinClass_MWC->TabKey == 2) { - curs_set(false); - MenuWinClass::RefreshWindows(); - wrefresh(MenuWinClass::START.TMPWin1); - redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); - wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); - } else if (MenuWinClass_MWC->TabKey == 3) { - curs_set(true); - MenuWinClass::RefreshWindows(); - } - break; - }/* search at tmpwin3 */ - } - if (Key == KEY_F(10)) { break; } - } - return Key; -// } catch (const NCursesException* e) { endwin(); std::cerr << e->message << std::endl; cout << e->errorno; return -1; -// } catch (const NCursesException& e) { endwin(); std::cerr << e.message << std::endl; cout << e.errorno; return -1; -// } catch (const std::exception& e) { endwin(); std::cerr << "Exception: " << e.what() << std::endl; cout << EXIT_FAILURE; return -1; } -} /* Menü surf funktion */ - -MenuWinClass::~MenuWinClass(){ - if (MenuWinClass::START.TMPWin1) {werase(MenuWinClass::START.TMPWin1); delwin(MenuWinClass::START.TMPWin1); endwin();} - if (MenuWinClass::START.TMPWin2) {werase(MenuWinClass::START.TMPWin2); delwin(MenuWinClass::START.TMPWin2); endwin();} - if (MenuWinClass::START.TMPWin3) {werase(MenuWinClass::START.TMPWin3); delwin(MenuWinClass::START.TMPWin3); endwin();} - if (MenuWinClass::START.TMPWin4) {werase(MenuWinClass::START.TMPWin4); delwin(MenuWinClass::START.TMPWin4); endwin();} - if (MenuWinClass::START.TMPWin5) {werase(MenuWinClass::START.TMPWin5); delwin(MenuWinClass::START.TMPWin5); endwin();} -} - - From f9fb839bd793b7a801ffba2faf5b2a72a194165e Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Tue, 9 Feb 2021 09:01:59 +0100 Subject: [PATCH 11/19] Delete MenuWinClass.h --- MenuWinClass.h | 205 ------------------------------------------------- 1 file changed, 205 deletions(-) delete mode 100644 MenuWinClass.h diff --git a/MenuWinClass.h b/MenuWinClass.h deleted file mode 100644 index 20a6e63..0000000 --- a/MenuWinClass.h +++ /dev/null @@ -1,205 +0,0 @@ -#ifndef MENUWINCLASS_H -#define MENUWINCLASS_H - -#include -#include -#include - -using namespace std; - -enum WinID { MENUWIN = 0, MAINWIN = 1, INFOWIN = 2, LISTPAD = 3, DESCWIN = 4, TIMEWIN = 5, ENDWIN = 6 }; -enum MenuID { DATEIMENU = 0, DAEMONMENU = 1, SYSTEMCTLMENU = 2, INFOMENU = 3, MAINMENU = 4, ENDMENU = 5 }; - -struct FENSTER { - int FEID {0}; - string FENAME {""}; - int BorderWeight {1}; - int BorderHeight {1}; - int WCX() {return static_cast(roundf(getmaxx(stdscr)));}; /* W=weight C=column X=x achse */ - int HRY() {return static_cast(roundf(getmaxy(stdscr)));}; /* H=height R=row Y=y achse */ - int HRYw1() {return static_cast(roundf(1));}; - int WCXw1() {return static_cast(roundf(WCX()));}; - WinID TMPWin1ID {MENUWIN}; - WINDOW *TMPWin1 = newwin(HRYw1(), WCXw1(), 0, 0); - int HRYw2() {return static_cast(roundf(HRY() - (HRYw1() + HRYw3())));}; - int WCXw2() {return static_cast(roundf(WCX()));}; - WinID TMPWin2ID {MAINWIN}; - WINDOW *TMPWin2 = newwin(HRYw2(), WCXw2(), 1, 0); - int HRYw3() {return static_cast(roundf(6));}; - int WCXw3() {return static_cast(roundf(WCX()));}; - WinID TMPWin3ID {INFOWIN}; - WINDOW *TMPWin3 = newwin(HRYw3(), WCXw3(), (HRYw1() + HRYw2()), 0); - int HRYw4() {return static_cast(roundf(HRYw2() - ((BorderWeight * 2))));}; - int WCXw4() {return static_cast(roundf(WCXw2() - (BorderWeight * 2)));}; - WinID TMPWin4ID {LISTPAD}; - WINDOW *TMPWin4 = newpad(HRYw4(), WCXw4()); - int HRYw5() {return static_cast(roundf(HRYw3() - ((BorderWeight * 2) + 1)));}; - int WCXw5() {return static_cast(roundf(WCXw3() - ((BorderWeight * 2) + 32)));}; - WinID TMPWin5ID {DESCWIN}; - WINDOW *TMPWin5 = newpad(HRYw5(), WCXw5()); - int HRYtime() {return static_cast(roundf(1));}; - int WCXtime() {return static_cast(roundf(20));}; - WinID TimeWinID {TIMEWIN}; - WINDOW *TimeWin = newwin(HRYtime(), WCXtime(), 0, (WCX() - 20)); - int TMPWinHigh {0}; - FORM *TMPForm1 {nullptr}; - FIELD **TMPField1 {nullptr}; - struct WinSize { - int RAND = 1; - int w {1}; - int h {1}; - int WCX(){return static_cast(roundf(getmaxx(stdscr)));}; - int HRY(){return static_cast(roundf(getmaxy(stdscr)));}; - int WCX_Real(){return static_cast(roundf(WCX() - (2 * RAND)));} - int HRY_Real(){return static_cast(roundf(HRY() - (2 * RAND)));} - int WCX_Center(){return static_cast(roundf(WCX() / 2));}; - int HRY_Center(){return static_cast(roundf(HRY() / 2));}; - int WCX_TmpWin(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin)));}; - int HRY_TmpWin(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin)));}; - int WCX_TmpWinReal(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin) - (2 * RAND)));}; - int HRY_TmpWinReal(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin) - (2 * RAND)));}; - int WCX_TmpWinCenter(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin) / 2));}; - int HRY_TmpWinCenter(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin) / 2));}; - unsigned long WinHalfDurch(WINDOW * tmpwin, int TeilDurch){return static_cast(roundf(WCX_TmpWinCenter(tmpwin) / TeilDurch));}; - } WinSize; - struct WinColor { - int BK_MENUWIN = 78; // 78 Text=MY_LIGHT_WHITE, Bk=MY_MARIN_BLUE - int BK_MAINWIN = 78; // 87 Text=MY_MARIN_BLUE, Bk=MY_LIGHT_WHITE - int BK_INFOWIN = 78; - int BK_LISTPAD = 78; - int BK_DESCWIN = 78; - int BK_TIMEWIN = 70; - int BK_HELPWIN = 74; - int WinBk_Main = 78; //Fenster_Background - int WinFo_Main = 78; //Fenster_Foreground - int WinBk_Info = 78; //info fenster_Background - int WinFo_Info = 78; //info fenster foreground - int WinBk_Help = 74; //help fenster Background - int WinFo_Help = 74; //help fenster foreground - } WinColor; - void delwinow(WINDOW *tmpwin){ - if(tmpwin){ - int mx,my,bx,by; - getbegyx(tmpwin,by,bx); - getmaxyx(tmpwin,my,mx); - touchwin(tmpwin); - wborder(tmpwin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); - touchline(tmpwin,bx,mx); - delwin(tmpwin); - endwin(); - tmpwin=nullptr; - } - } - /* void delmenu(WINDOW *tmpwin, MENU *tmpmenu, ITEM **tmpitem){ - if (tmpmenu){ - int E = item_count(tmpmenu); - unpost_menu(tmpmenu); - SAFE_DELETE(tmpmenu); - SAFE_DELETE_ARRAY(tmpitem); - wborder(tmpwin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); - touchline(tmpwin,0,E+1); - delwin(tmpwin); - endwin(); - } - }*/ - void delform(WINDOW *tmpwin, FORM *tmpform, FIELD **tmpfield){ - if (tmpform){ - int mx,my,bx,by; - getbegyx(tmpwin,by,bx); - getmaxyx(tmpwin,my,mx); - unpost_form(tmpform); - SAFE_DELETE(tmpform); - SAFE_DELETE_ARRAY(tmpfield); - wborder(tmpwin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); - touchline(tmpwin,bx,mx); - delwin(tmpwin); - endwin(); - } - } -}; -struct HAUPTMENU { - MenuID MID; - string HMName; - MENU *HMMenu {nullptr}; - ITEM **HMItem {nullptr}; - //############################################### - struct UNTERMENU { - int UMID; - string UMEName; - WINDOW *UMEWin; - MENU *UMEMenu; - ITEM **UMEItem; - }UME; - struct MenuColor { - int BK_MAINMENU = 78; // 78 Text=MY_LIGHT_WHITE, Bk=MY_MARIN_BLUE - int BK_UNTERMENU = 78; // 87 Text=MY_MARIN_BLUE, Bk=MY_LIGHT_WHITE - int BK_AKTIVHAME = 18; - int BK_AKTIVUNME = 18; - int BK_UNUSEDHM = 78; - int BK_UNUSEDUM = 78; - } MenuColor; - void LoescheUME(){ - int E = item_count(UME.UMEMenu); - unpost_menu(UME.UMEMenu); - SAFE_DELETE(UME.UMEMenu); - SAFE_DELETE_ARRAY(UME.UMEItem); - wborder(UME.UMEWin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); - touchline(UME.UMEWin,0,E+1); - delwin(UME.UMEWin); - endwin(); - refresh(); - } -}; -struct INAPPMENU { - friend class MenuWinClass; - int LMID; - std::string LMName; - MENU* LMenu {nullptr}; - ITEM** LMItem {nullptr}; - string AktivName = ""; - -}; - -class MenuWinClass: public INAPPMENU { -public: - /*################################################*/ - static FENSTER START; - static HAUPTMENU TOPMENU; - static int MeInAl; - static WINDOW *TMPWIN; - static MENU *TMPMENU; - static INAPPMENU SERVICEMENU; - static int LiMeInAl; - static WINDOW* LiTMPWIN; - static MENU* LiTMPMENU; - static string PATTERN; - static int TabKey;// {1}; - /*#############_WINDOW_###########################*/ - static void StartWin(); - static void StopWin(); - static void SetWinSize(); - static void AppColor(); - static void CreateWin(WINDOW *win, WinID WID); - void FensterDraw(); - static void ResizeHandler(int signal); - void ScrollPad(WINDOW *SubWin, int StartY, int StartX, int Height, int Width, int PadHeight); - void printInMiddle(WINDOW *win, int starty, int startx, int width, char *text, chtype color, char *sp); - /*#############_MENÜ_#############################*/ - static void Hauptmenu(void); - static void DateiMenu(void); - static void DaemonTypeMenu(void); - static void SystemctlMenu(void); - static void InfoMenu(void); - static WINDOW* TempWin(string Name, MenuID MID); - static void StartMenuAuswahl(string wahl); - static void RefreshWindows(); - static int MenuStart(int Key); - /*#############_Constructor/De_###################*/ - MenuWinClass(); - ~MenuWinClass(); - /*################################################*/ -}; - - - -#endif // MENUWINCLASS_H From 209153b7d5a08b27154c0912743123d080fbb92d Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Tue, 9 Feb 2021 09:02:33 +0100 Subject: [PATCH 12/19] Delete Info.h --- Info.h | 23 ----------------------- 1 file changed, 23 deletions(-) delete mode 100644 Info.h diff --git a/Info.h b/Info.h deleted file mode 100644 index 46cddb6..0000000 --- a/Info.h +++ /dev/null @@ -1,23 +0,0 @@ -#ifndef _INFO_H -#define _INFO_H - -#define VERSION "1.0.4" -#define APPNAME "ServiceControl" -#define ABOUT_INFO "\n\ - " APPNAME " " VERSION " \n\ - \n\ - Navigation keys: \n\ - Up - move cursor up | Down - move cursor down \n\ - right - move cursor right | left - move cursor left \n\ - PgUp - move page up | PgDown - move page down \n\ - / - for search | ? - for this help \n\ - Action keys: \n\ - Space - anwählen/abwählen | F10 - exit | ESC - Close info/help\n\ - F1 - start/stop unit | F2 - reload/update | TAB - switch Menu/ \n\ - F3 - enabled unit | F4 - disabled unit | Servicelist/ \n\ - F5 - unmasked unit | F6 - masked unit | Search \n\ ----------------------------------------------------------------------------\n\ - License: GPLv3 (c) Anthony Olszynski \n\ -" - -#endif //_INFO_H From 30f54791557424790a4f38d4d861f0f5ebe06456 Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Tue, 9 Feb 2021 09:02:40 +0100 Subject: [PATCH 13/19] Delete ServiceClass.cpp --- ServiceClass.cpp | 805 ----------------------------------------------- 1 file changed, 805 deletions(-) delete mode 100644 ServiceClass.cpp diff --git a/ServiceClass.cpp b/ServiceClass.cpp deleted file mode 100644 index ed8ccca..0000000 --- a/ServiceClass.cpp +++ /dev/null @@ -1,805 +0,0 @@ -#include - -using namespace std; - -TaskClass *TaskClass_SC = new TaskClass(); -//MenuClass *MenuPtr_SC = new MenuClass(); -ServiceClass *ServiceClass_SC = new ServiceClass(); -//WinClass *WinPtr_SC = new WinClass(); -MenuWinClass *MenuWinClass_SC = new MenuWinClass(); - -int X = 0; -/*##################################################################################*/ -void ServiceClass::ServiceListFill() { - string tmpService = TaskClass_SC->TERM_AUSGABE("systemctl list-unit-files -t "+ systemctlwahl +" | grep '."+ systemctlwahl +"' | awk '{$1=$1};1' | sort"); - string tmpServiceInfo = TaskClass_SC->TERM_AUSGABE("systemctl --all --type="+ systemctlwahl +" | grep '."+ systemctlwahl +"' | awk '{$1=$1};1' | sed 's/● //g' | sort"); - string tmpstr1,tmpstr2; - std::vector tmpaa,tmpbb; - ServiceList.clear(); - vector().swap(ServiceList); - unsigned long X = 0; - istringstream filestream(tmpService.c_str()); - - if (filestream) { - while (getline(filestream,tmpstr1)){ - tmpaa.push_back(string()); - tmpaa = TaskClass_SC->StringTeiler(tmpstr1,' '); - ServiceList.push_back(SERVICES()); - ServiceList[X].SID = static_cast(X); - ServiceList[X].Name = tmpaa[0]; - ServiceList[X].Status = tmpaa[1]; - ServiceList[X].Target = systemctlwahl; - X++; - tmpaa.clear(); - vector().swap(tmpaa); - } - } else { - mvwaddnstr(MenuWinClass::START.TMPWin3, 5, 5, "failed to open or read" ,-1); - } - - X = 0; - istringstream filestream2(tmpServiceInfo.c_str()); - if (filestream2) { - while (getline(filestream2,tmpstr2)){ - tmpbb.push_back(string()); - tmpbb = TaskClass_SC->StringTeiler(tmpstr2,' '); - for(unsigned long Z = 0; Z < static_cast(ServiceList.size()); Z++) { - if (ServiceList[Z].Name.compare(tmpbb[0].c_str())==0) { - ServiceList.push_back(SERVICES()); - ServiceList[Z].Load = tmpbb[1]; - ServiceList[Z].Active = tmpbb[2]; - ServiceList[Z].SubStatus = tmpbb[3]; - for (unsigned long Y = 4; Y < tmpbb.size(); Y++) { - if (Y == 4) { - ServiceList[Z].Description = tmpbb[Y]; - } else { - ServiceList[Z].Description.append(" " + tmpbb[Y]); - } - } - break; - } - } - X++; - tmpbb.clear(); - vector().swap(tmpbb); - } - } else { - mvwaddnstr(MenuWinClass::START.TMPWin3, 5, 5, "failed to open or read" ,-1); - } - SetStateOption(); - // ServiceListe(); -} -void ServiceClass::ServiceListe(){ - if (MenuWinClass_SC->SERVICEMENU.LMItem){unpost_menu(MenuWinClass_SC->SERVICEMENU.LMenu);SAFE_DELETE(MenuWinClass_SC->SERVICEMENU.LMItem);SAFE_DELETE_ARRAY(MenuWinClass_SC->SERVICEMENU.LMItem);} - if (MenuWinClass::START.TMPWin4){werase(MenuWinClass::START.TMPWin4);delwin(MenuWinClass::START.TMPWin4);endwin();} - int mrows = 0; - int mcols = 0; - unsigned long count = ServiceList.size(); - MenuWinClass_SC->SERVICEMENU.LMItem = static_cast(calloc(count, sizeof(ITEM *))); - for (unsigned long i = 0; i < (count-2); i++) - { - MenuWinClass_SC->SERVICEMENU.LMItem[i] = new_item(ServiceList[i].Name.c_str(), ServiceList[i].Status.c_str()); - } - MenuWinClass_SC->SERVICEMENU.LMItem[count-1] = nullptr; - MenuWinClass_SC->SERVICEMENU.LMenu = new_menu(MenuWinClass_SC->SERVICEMENU.LMItem); - scale_menu(MenuWinClass_SC->SERVICEMENU.LMenu, &mrows, &mcols); - MenuWinClass::START.TMPWin4 = newpad(TaskClass_SC->WinFullSize(MenuWinClass::START.TMPWin2,static_cast(count),"H"), TaskClass_SC->WinFullSize(MenuWinClass::START.TMPWin2,mcols,"W")); - wbkgd(MenuWinClass::START.TMPWin4, COLOR_PAIR(MenuWinClass::START.WinColor.BK_LISTPAD)); - set_menu_win(MenuWinClass_SC->SERVICEMENU.LMenu, MenuWinClass::START.TMPWin4); - set_menu_sub(MenuWinClass_SC->SERVICEMENU.LMenu, MenuWinClass::START.TMPWin4); - set_menu_format(MenuWinClass_SC->SERVICEMENU.LMenu, MenuWinClass_SC->START.HRY()-9, 1); //-3 - set_menu_spacing(MenuWinClass_SC->SERVICEMENU.LMenu, 0, 0, 0); - menu_opts_off(MenuWinClass_SC->SERVICEMENU.LMenu, O_SELECTABLE); - menu_opts_on(MenuWinClass_SC->SERVICEMENU.LMenu, O_NONCYCLIC); - set_menu_fore(MenuWinClass_SC->SERVICEMENU.LMenu, COLOR_PAIR(20)|A_BOLD|A_REVERSE); - set_menu_back(MenuWinClass_SC->SERVICEMENU.LMenu, COLOR_PAIR(78)|A_BOLD); - set_menu_grey(MenuWinClass_SC->SERVICEMENU.LMenu, COLOR_PAIR(30)); - set_menu_mark(MenuWinClass_SC->SERVICEMENU.LMenu, ""); - post_menu(MenuWinClass_SC->SERVICEMENU.LMenu); -} -void ServiceClass::INFOWINDOW(string Name){ - werase(MenuWinClass::START.TMPWin5); - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 1, "STATE: " ,-1); - mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 1, "LOAD: " ,-1); - mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 1, "AKTIVE: " ,-1); //9 - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 1, "SUB: " ,-1); - mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 26, "DESC:" ,-1); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 26, "Suche:" ,-1); - //mvwaddnstr(MenuWinClass::START.TMPWin3, 6, 1, " " ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN)|A_BOLD,nullptr); - - for (unsigned long X = 0; X < static_cast(ServiceList.size());X++){ - if (ServiceList[X].Name.compare(Name)==0) { - switch (ServiceList[X].state) { - case UNIT_STATE_ENABLED: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - break; - case UNIT_STATE_BAD: - case UNIT_STATE_DISABLED: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - break; - case UNIT_STATE_STATIC: - case UNIT_STATE_MASKED: - case UNIT_STATE_GENERATED: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); - break; - case UNIT_STATE_TMP: - default: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - break; - } // ende status switch - switch (ServiceList[X].load) { - case UNIT_LOADSTATE_LOADED: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 9, ServiceList[X].Load.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - break; - case UNIT_LOADSTATE_NOTFOUND: - case UNIT_LOADSTATE_UNLOAD: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 9, ServiceList[X].Load.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - break; - default: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 9, ServiceList[X].Load.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - break; - } // ende load switch - switch (ServiceList[X].active) { - case UNIT_ACTIVESTATE_ACTIVE: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 9, ServiceList[X].Active.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - break; - case UNIT_ACTIVESTATE_INACTIVE: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 9, ServiceList[X].Active.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - break; - default: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 9, ServiceList[X].Active.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - break; - } - switch (ServiceList[X].substate) { - case UNIT_SUBSTATE_RUNNING: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); - break; - case UNIT_SUBSTATE_CONNECTED: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); - case UNIT_SUBSTATE_INVALID: - case UNIT_SUBSTATE_EXITED: - case UNIT_SUBSTATE_DEAD: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); - break; - default: - wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); - wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); - break; - } - //wattr_on(MenuWinClass::START.TMPWin5, COLOR_PAIR(78)|A_BOLD,nullptr); - mvwaddnstr(MenuWinClass::START.TMPWin5, 0, 0, ServiceList[X].Description.c_str() ,-1); - //wattr_off(MenuWinClass::START.TMPWin5, COLOR_PAIR(78)|A_BOLD,nullptr); - } - } -} -void ServiceClass::Statusabfrage(string ausgabestatus) { - int hoehe; - int rowy = MenuWinClass_SC->START.HRY()-4; - int ROWS = 0; int Key; - STATUSWIN = newwin(MenuWinClass_SC->START.HRY()-2, MenuWinClass_SC->START.WCX()-2, 1, 1); - wbkgd(STATUSWIN, COLOR_PAIR(MenuWinClass::START.WinColor.WinBk_Help)|A_BOLD); - box(STATUSWIN, 0,0); - - hoehe = TaskClass_SC->Zeilen(ausgabestatus.c_str(),MenuWinClass_SC->START.WCX()-4); - STATUSINFO = newpad(hoehe, MenuWinClass_SC->START.WCX()-4); - wbkgd(STATUSINFO, COLOR_PAIR(MenuWinClass::START.WinColor.WinBk_Help)|A_BOLD); - STATUSINFO = derwin(STATUSWIN, MenuWinClass_SC->START.HRY()-4, MenuWinClass_SC->START.WCX()-4, 1, 1); - wattr_on(STATUSINFO, COLOR_PAIR(MenuWinClass::START.WinColor.WinFo_Help)|A_BOLD,nullptr); - mvwaddnstr(STATUSINFO, 0, 0, ausgabestatus.c_str(),-1); - wattr_off(STATUSINFO, COLOR_PAIR(MenuWinClass::START.WinColor.WinFo_Info)|A_BOLD,nullptr); - wattr_on(STATUSWIN, COLOR_PAIR(70)|A_BOLD,nullptr); - mvwaddnstr(STATUSWIN, MenuWinClass_SC->START.HRY() -3, MenuWinClass_SC->START.WCX()-15, "[ EXIT ESC ]" ,-1); - wattr_off(STATUSWIN, COLOR_PAIR(70)|A_BOLD,nullptr); - - wrefresh(STATUSWIN); - touchwin(STATUSWIN); - prefresh(STATUSINFO, 0, 0, 0, 0, MenuWinClass_SC->START.HRY() -4, MenuWinClass_SC->START.WCX()-4); - - while ((Key=getch()) != 27) { - switch (Key) { - case KEY_DOWN:{ - if ((ROWS + rowy +1) >= hoehe){ - ROWS = hoehe; - }else { - ROWS++; - } - break;} - case KEY_UP:{ - if (ROWS <= 0){ - ROWS = 0; - }else { - ROWS--; - } - break;} - default:{ - break; } - } - refresh(); - touchwin(STATUSWIN); - prefresh(STATUSINFO, ROWS, 0, 0, 0, MenuWinClass_SC->START.HRY() -4, MenuWinClass_SC->START.WCX()-4); - } - if (STATUSINFO){werase(STATUSINFO);delwin(STATUSINFO);} - if (STATUSWIN){werase(STATUSWIN);delwin(STATUSWIN);} - redrawwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); - wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); - redrawwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); - wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); - prefresh(MenuWinClass_SC->START.TMPWin4, 0, 0, 2, 1, MenuWinClass_SC->START.HRYw4() + 1, MenuWinClass_SC->START.WCXw4()); - prefresh(MenuWinClass_SC->START.TMPWin5, 0, 0, MenuWinClass_SC->START.HRY()-4, MenuWinClass_SC->START.WCX()-46, MenuWinClass_SC->START.HRYw5(), MenuWinClass_SC->START.WCXw5()); -} -void ServiceClass::ENDE() { -// try { - if (MenuWinClass::START.TimeWin) {werase(MenuWinClass::START.TimeWin); delwin(MenuWinClass::START.TimeWin); endwin();} - if (MenuWinClass::SERVICEMENU.LMItem) {unpost_menu(MenuWinClass::SERVICEMENU.LMenu); SAFE_DELETE(MenuWinClass::SERVICEMENU.LMItem); SAFE_DELETE_ARRAY(MenuWinClass::SERVICEMENU.LMItem);} - if (MenuWinClass::TOPMENU.UME.UMEItem) { unpost_menu(MenuWinClass::TOPMENU.UME.UMEMenu); SAFE_DELETE(MenuWinClass::TOPMENU.UME.UMEItem); SAFE_DELETE_ARRAY(MenuWinClass::TOPMENU.UME.UMEItem);} - if (MenuWinClass::TOPMENU.HMItem) { unpost_menu(MenuWinClass::TOPMENU.HMMenu); SAFE_DELETE(MenuWinClass::TOPMENU.HMItem); SAFE_DELETE_ARRAY(MenuWinClass::TOPMENU.HMItem);} - if (MenuWinClass::START.TMPWin5) {werase(MenuWinClass::START.TMPWin5); delwin(MenuWinClass::START.TMPWin5); endwin();} - if (MenuWinClass::START.TMPWin4) {werase(MenuWinClass::START.TMPWin4); delwin(MenuWinClass::START.TMPWin4); endwin();} - if (MenuWinClass::START.TMPWin3) {werase(MenuWinClass::START.TMPWin3); delwin(MenuWinClass::START.TMPWin3); endwin();} - if (MenuWinClass::START.TMPWin2) {werase(MenuWinClass::START.TMPWin2); delwin(MenuWinClass::START.TMPWin2); endwin();} - if (MenuWinClass::START.TMPWin1) {werase(MenuWinClass::START.TMPWin1); delwin(MenuWinClass::START.TMPWin1); endwin();} - werase(stdscr); - ServiceList.clear(); - vector(ServiceList).swap (ServiceList); - clear(); -// } catch (const NCursesException *e) { endwin(); std::cerr << e->message << std::endl; cout << e->errorno; -// } catch (const NCursesException &e) { endwin(); std::cerr << e.message << std::endl; cout << e.errorno; -// } catch (const std::exception &e) { endwin(); std::cerr << "Exception: " << e.what() << std::endl; cout << EXIT_FAILURE; } -} -/*##################################################################################*/ -// new Systemd bestandteile -void ServiceClass::SetStateOption() { //SERVICES unit // pushitem - //vector().swap(ServiceList); - //UnitItem *item = new UnitItem(); - //string name(unit->id); - //item->Name = name; - //item->target = name.substr(name.find_last_of('.') + 1, name.length()); - //item->description = string(unit->description == nullptr ? "" : unit->description); - //item->Status = string(unit->state == nullptr ? "" : unit->state); - //item->SubStatus = string(unit->subState == nullptr ? "" : unit->subState); - //item->LoadStatus = string(unit->loadState == nullptr ? "" : unit->loadState); - //item->ActiveStatus = string(unit->activeState == nullptr ? "" : unit->activeState); - //item->ServicePath = string(unit->unitPath == nullptr ? "" : unit->unitPath); - - for (unsigned long i =0; istate); - //string sub(unit->substate == nullptr ? "" : unit->substate); - //string load(unit->load == nullptr ? "" : unit->load); - //string aktiv(unit->active == nullptr ? "" : unit->active); - if (ServiceList[i].Status.compare("enabled") == 0) { - ServiceList[i].state = UNIT_STATE_ENABLED; - } else if (ServiceList[i].Status.compare("masked") == 0) { - ServiceList[i].state = UNIT_STATE_MASKED; - } else if (ServiceList[i].Status.compare("static") == 0) { - ServiceList[i].state = UNIT_STATE_STATIC; - } else if (ServiceList[i].Status.compare("bad") == 0 || ServiceList[i].Status.compare("removed") == 0) { - ServiceList[i].state = UNIT_STATE_BAD; - } else if (ServiceList[i].Status.compare("disabled") == 0){ - ServiceList[i].state = UNIT_STATE_DISABLED; - } else if (ServiceList[i].Status.compare("generated") == 0){ - ServiceList[i].state = UNIT_STATE_GENERATED; - } else{ - ServiceList[i].state = UNIT_STATE_TMP; - } - if (!ServiceList[i].SubStatus.empty()) { - if (ServiceList[i].SubStatus.compare("running") == 0) { - ServiceList[i].substate = UNIT_SUBSTATE_RUNNING; - } else if (ServiceList[i].SubStatus.compare("dead") == 0) { - ServiceList[i].substate = UNIT_SUBSTATE_DEAD; - } else if (ServiceList[i].SubStatus.compare("exited") == 0) { - ServiceList[i].substate = UNIT_SUBSTATE_EXITED; - } else{ - ServiceList[i].substate = UNIT_SUBSTATE_CONNECTED; - } - } else { - ServiceList[i].substate = UNIT_SUBSTATE_INVALID; - } - if (!ServiceList[i].Load.empty()) { - if (ServiceList[i].Load.compare("loaded") == 0) { - ServiceList[i].load = UNIT_LOADSTATE_LOADED; - } else if (ServiceList[i].Load.compare("not-found") == 0) { - ServiceList[i].load = UNIT_LOADSTATE_NOTFOUND; - } else if (ServiceList[i].Load.compare("unloaded") == 0) { - ServiceList[i].load = UNIT_LOADSTATE_UNLOAD; - } - } else { - ServiceList[i].load = UNIT_SUBSTATE_INVALID; - } - if (!ServiceList[i].Active.empty()) { - if (ServiceList[i].Active.compare("active") == 0) { - ServiceList[i].active = UNIT_ACTIVESTATE_ACTIVE; - } else if (ServiceList[i].Active.compare("inactive") == 0) { - ServiceList[i].active = UNIT_ACTIVESTATE_INACTIVE; - } - } else { - ServiceList[i].active = UNIT_SUBSTATE_INVALID; - } - } else { - ServiceList[i].state = UNIT_STATE_MASKED; - } - } - // freeUnitInfo(unit); - // items.push_back(item); - BuildWin(); -}; -void ServiceClass::BuildWin() { - if (MenuWinClass_SC->SERVICEMENU.LMItem){unpost_menu(MenuWinClass_SC->SERVICEMENU.LMenu);SAFE_DELETE(MenuWinClass_SC->SERVICEMENU.LMItem);SAFE_DELETE_ARRAY(MenuWinClass_SC->SERVICEMENU.LMItem);} - if (MenuWinClass_SC->START.TMPWin4){werase(MenuWinClass_SC->START.TMPWin4);delwin(MenuWinClass_SC->START.TMPWin4);endwin();} - StateColor.Green = 28; - StateColor.Yellow = 38; - StateColor.Red = 18; - StateColor.White = 78; - unsigned long count = ServiceList.size(); - MenuWinClass_SC->START.TMPWin4 = newpad(static_cast(count), MenuWinClass_SC->START.WinSize.WCX_TmpWinReal(MenuWinClass::START.TMPWin2)); - wbkgd(MenuWinClass_SC->START.TMPWin4, COLOR_PAIR(MenuWinClass::START.WinColor.BK_LISTPAD)); - - for (unsigned long i = 0; i < ServiceList.size(); i++) { - TableDraw(ServiceList[i], static_cast(i)); - //TableMoveRow(); - } -} -void ServiceClass::TableMoveRow() { //drawUnits - if (ServiceList.empty()) { - // updateUnits(); - ServiceListFill(); - } - // const int oneX = unit->sub & A_COLOR; - for (int i = 0; i < MenuWinClass_SC->START.HRYw4(); i++) { - if ((i + ServiceClass::start) > static_cast(ServiceList.size() - 1)) { - break; - } - SERVICES unit = ServiceList[static_cast(start + i)]; - if (i == selected) { - StateColor.SetSignalColor(17, 37, 27, 87); - MenuWinClass::SERVICEMENU.AktivName = ServiceList[static_cast(start + selected)].Name; - wattron(MenuWinClass_SC->START.TMPWin4, COLOR_PAIR(87)|A_BOLD); - } - TableDraw(unit, i); - wattroff(MenuWinClass_SC->START.TMPWin4, COLOR_PAIR(87)|A_BOLD); - StateColor.SetSignalColor(18, 38, 28, 78); - } - /* if (inputFor == INPUT_FOR_LIST) { - // drawInfo(); - // } else { - // drawSearch(); - // }*/ - refresh(); - touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); - wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); - touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); - wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); - prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); - prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY() - 4, MenuWinClass::START.WCX() - 46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); -} -void ServiceClass::TableDraw(SERVICES unit, int y) { - if (unit.Target.compare(systemctlwahl)==0) { - //unit.SID = unit.SID++; - if (unit.Name.size() < static_cast(MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2))) { - unit.Name.resize(MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2), ' '); - }else { - unit.Name.resize(MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)); - } - if (unit.Status.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)) { - unit.Status.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); - }else { - unit.Status.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); - } - if (unit.SubStatus.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4) ) { - unit.SubStatus.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); - } else { - unit.SubStatus.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); - } - if (unit.Active.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4) ) { - unit.Active.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); - }else { - unit.Active.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); - } - if (unit.Load.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4) ) { - unit.Load.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); - }else { - unit.Load.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); - } - - std::string name(unit.Name); - - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); - mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.RAND-1, "%s", name.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); - - switch (unit.state) { - case UNIT_STATE_ENABLED: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%s ", unit.Status.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); - break; - case UNIT_STATE_BAD: - case UNIT_STATE_DISABLED: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%s ", unit.Status.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); - break; - case UNIT_STATE_STATIC: - case UNIT_STATE_MASKED: - case UNIT_STATE_GENERATED: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%s ", unit.Status.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); - break; - case UNIT_STATE_TMP: - default: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%9s", unit.Status.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); - break; - } - switch (unit.load) { - case UNIT_LOADSTATE_LOADED: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +11, unit.Load.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX() - 11, unit.LoadStatus.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); - break; - case UNIT_LOADSTATE_NOTFOUND: - case UNIT_LOADSTATE_UNLOAD: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +11, unit.Load.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX()- 11, unit.LoadStatus.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); - break; - default: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +11, unit.Load.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX() - 11, unit.LoadStatus.c_str()); // 3 jetzt 9 - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); - break; - } - switch (unit.active) { - case UNIT_ACTIVESTATE_ACTIVE: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +21, unit.Active.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX()- 21, unit.ActiveStatus.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); - break; - case UNIT_ACTIVESTATE_INACTIVE: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +21, unit.Active.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX()- 21, unit.ActiveStatus.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); - break; - default: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +21, unit.Active.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX() - 11, unit.LoadStatus.c_str()); // 3 jetzt 9 - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); - break; - } - switch (unit.substate) { - case UNIT_SUBSTATE_RUNNING: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); - break; - case UNIT_SUBSTATE_CONNECTED: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); - case UNIT_SUBSTATE_INVALID: - case UNIT_SUBSTATE_EXITED: - case UNIT_SUBSTATE_DEAD: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); - break; - default: - wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); - mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); - //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); // 3 jetzt 9 - wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); - break; - } - } -} -void ServiceClass::TableDriver(std::vector SRVLIST,int key){ - int ps = MenuWinClass_SC->START.HRYw4()-1; - switch(key){ - case REQ_LEFT_ITEM:{ - break;} - case REQ_RIGHT_ITEM:{ - break;} - case REQ_UP_ITEM:{ - if (start > 0 && selected < ps) { // / 2 - start--; - } else if (selected > 0) { - selected--; - } - if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); - } - break;} - case REQ_DOWN_ITEM:{ - int offset = start + selected; - int max = static_cast(SRVLIST.size()); - if ((start + ps) < max) { - if (selected < ps) { // / 2 - selected++; - } else { - start++; - } - } else if (offset < max) { - selected++; - } - if (offset >= max) { - selected = ps; - } - if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::TableDriver(SRVLIST,REQ_DOWN_ITEM); - } - break;} - case REQ_SCR_ULINE:{ - break;} - case REQ_SCR_DLINE:{ - break;} - case REQ_SCR_UPAGE:{ - if (start > 0) { - start -= ps; - } - if (start < 0) { - start = 0; - selected = 0; - } - if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); - } - break;} - case REQ_SCR_DPAGE:{ - int max = static_cast(SRVLIST.size()-1); - if ((start + ps) < max) { // / 2 - start += ps; - } - if ((start + ps) > max) { - start = max - ps; - selected = ps; - } - if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::TableDriver(SRVLIST,REQ_DOWN_ITEM); - } - break;} - case REQ_FIRST_ITEM:{ - if (start > 0 && selected < ps) { // / 2 - start--; - } else if (selected > 0) { - selected--; - } - if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); - } - break;} - case REQ_LAST_ITEM:{ - int max = static_cast(SRVLIST.size()-1); - start = max - ps; - selected = ps; - if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); - } - break;} - case REQ_NEXT_ITEM:{ - if (start > 0 && selected < ps) { // / 2 - start--; - } else if (selected > 0) { - selected--; - } - if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); - } - break;} - case REQ_PREV_ITEM:{ - int offset = start + selected; - int max = static_cast(SRVLIST.size()); - - if ((start + ps) < max) { - if (selected < ps) { // / 2 - selected++; - } else { - start++; - } - } else if (offset < max) { - selected++; - } - if (offset >= max) { - selected = ps; - } - if (SRVLIST[static_cast(start + selected)].Name.empty()) { - ServiceClass::TableDriver(SRVLIST,REQ_DOWN_ITEM); - } - break;} - case REQ_TOGGLE_ITEM:{ - break;} - case REQ_CLEAR_PATTERN:{ - break;} - case REQ_BACK_PATTERN:{ - if (MenuWinClass_SC->PATTERN.size()>0) {MenuWinClass_SC->PATTERN.pop_back(); MenuWinClass_SC->PATTERN.shrink_to_fit();}; - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, " ",-1); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); - break;} - case REQ_NEXT_MATCH:{ - int position = 0; - for (auto unit : ServiceList) { - if (!unit.Name.empty()) { - if (unit.Name.rfind(MenuWinClass_SC->PATTERN.c_str()) != std::string::npos) { - lastFound = position; - moveTo(position); } - position++; - } else { - continue; - } - } - if (lastFound == 0) { - MenuWinClass_SC->PATTERN.clear(); - return; - } - lastFound = 0; - TableDriver(ServiceList,REQ_NEXT_MATCH); - break;} - case REQ_PREV_MATCH:{ - break;} - } -} -void ServiceClass::searchInput() { - int key; - while ((key=wgetch(stdscr)) != KEY_F(10)) { - switch(key) { - case 27:{ // ESC - MenuWinClass_SC->PATTERN.clear(); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, " ",-1); - break;} - case KEY_ENTER: // Ctrl-M - case 10: {// Enter - TableDriver(ServiceList,REQ_NEXT_MATCH); - break;} - case KEY_BACKSPACE:{ - if (MenuWinClass_SC->PATTERN.size()>0) {MenuWinClass_SC->PATTERN.pop_back(); MenuWinClass_SC->PATTERN.shrink_to_fit();}; - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, " ",-1); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); - TableDriver(ServiceList,REQ_NEXT_MATCH); - break;} - default:{ - if (key > 10 && key < 128) { - sprintf(searchString,"%c",key); - MenuWinClass_SC->PATTERN.append(string(searchString)); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); - TableDriver(ServiceList,REQ_NEXT_MATCH); - } - break;} - } - refresh(); - touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); - wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); - touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); - wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); - prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); - prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY()-4, MenuWinClass::START.WCX()-46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); - } -} -void ServiceClass::drawSearch() { - /* * Lets indicate it is a search input */ - char text[BUFSIZ] = ""; - if (lastFound == 0) { - sprintf(searchString,"%s",text); - MenuWinClass_SC->PATTERN.append(string(searchString)); - //sprintf(text, "%s%s", text, searchString); - } - /* * Draw it using any visible, light color */ - //drawStatus(1, text, 0); - mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); -} -void ServiceClass::moveTo(int position) { - start = selected = 0; - for (int i = 0; i < position; i++) { - TableDriver(ServiceList,REQ_UP_ITEM); - } -} - -string ServiceClass::SearchDriver(SeaReq drv, WINDOW *Win, int Key, string Search, int Posi) { - static const int Start = 33; - int hry, wcx; - getyx(Win, hry, wcx); - int MaxSearchTextLaenge = (MenuWinClass::START.WCX() - (Start + MenuWinClass::START.BorderWeight)); - int Laenge = Search.length(); - int AbsolPosi; - AbsolPosi = (Start + Posi); - char TmpKey[BUFSIZE] = ""; - sprintf(TmpKey, "%c", Key); - string dummi; - dummi.assign(MaxSearchTextLaenge,' '); - switch (drv) { - case REQ_DEL_BACKSPACE:{ - if ((wcx > Start) && (wcx <= (Start + Laenge))) { - Search.erase(Posi-1, 1); - mvwaddnstr(Win, 4, Start, dummi.c_str(), -1); - mvwaddnstr(Win, 4, Start, Search.c_str(), -1); - wmove(Win, 4, AbsolPosi - 1); - } - break; } - case REQ_DEL_DC:{ - if ((wcx > Start) && (wcx < (Start + Laenge))) { - Search.erase(Posi+1, 1); - mvwaddnstr(Win, 4, Start, dummi.c_str(), -1); - mvwaddnstr(Win, 4, Start, Search.c_str(), -1); - wmove(Win, 4, AbsolPosi - 1); - } - break; } - case REQ_RIGHT:{ - if ((wcx > Start) && (wcx <= (Start + Laenge))) { - //if ((Posi != 0) || ((Posi-1) <= Laenge)) { - int cursorbewegen = AbsolPosi +1; - wmove(Win, 4, cursorbewegen); - } - break; } - case REQ_LEFT:{ - if ((wcx > Start) && (wcx <= (Start + Laenge))) { - //if ((Posi != 0) || ((Posi-1) <= Laenge)) { - int cursorbewegen = AbsolPosi -1; - wmove(Win, 4, cursorbewegen); - } - break; } - case REQ_INS_DEFAULT:{ - if (Key > 10 && Key < 128) { - if (Posi < Laenge) { - Search.insert(Posi, string(TmpKey)); - mvwaddnstr(Win, 4, Start, Search.c_str(), -1); - wmove(Win, 4, (Start + Posi)); - } else { - Search.append(string(TmpKey)); - mvwaddnstr(Win, 4, Start, Search.c_str(), -1); - } - }; - break;} - } - wrefresh(Win); - return Search; -} -/*##################################################################################*/ -ServiceClass::ServiceClass(){ - systemctlwahl = "service"; -} -ServiceClass::~ServiceClass(){ - -} -/*##################################################################################*/ From 91ec29d3af26d5a45cff68642d1d7cea90ee472d Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Tue, 9 Feb 2021 09:02:47 +0100 Subject: [PATCH 14/19] Delete ServiceClass.h --- ServiceClass.h | 106 ------------------------------------------------- 1 file changed, 106 deletions(-) delete mode 100644 ServiceClass.h diff --git a/ServiceClass.h b/ServiceClass.h deleted file mode 100644 index 914b2e8..0000000 --- a/ServiceClass.h +++ /dev/null @@ -1,106 +0,0 @@ -#ifndef SERVICECLASS_H -#define SERVICECLASS_H - -#include -#include -#include - -//enum _INPUT_FOR { -// INPUT_FOR_LIST, -// INPUT_FOR_SEARCH -//}; - -#define ERR_PREFIX "Failed: " -#define SYSV_INSTALL_EXEC "/lib/systemd/systemd-sysv-install" - -enum SeaReq { REQ_RIGHT, REQ_LEFT, REQ_DEL_DC, REQ_DEL_BACKSPACE, REQ_INS_DEFAULT}; -enum { - UNIT_STATE_DISABLED = 0x01, - UNIT_STATE_ENABLED = 0x02, - UNIT_STATE_STATIC = 0x03, - UNIT_STATE_BAD = 0x04, - UNIT_STATE_MASKED = 0x05, - UNIT_STATE_TMP = 0x06, - UNIT_STATE_GENERATED = 0x07, - UNIT_SUBSTATE_RUNNING = 0x08, - UNIT_SUBSTATE_CONNECTED = 0x09, - UNIT_SUBSTATE_INVALID = 0x0a, - UNIT_SUBSTATE_TMP = 0x0b, - UNIT_SUBSTATE_DEAD = 0x0c, - UNIT_SUBSTATE_EXITED = 0x0d, - UNIT_LOADSTATE_LOADED = 0x0e, - UNIT_LOADSTATE_NOTFOUND = 0x0f, - UNIT_LOADSTATE_UNLOAD = 0x10, - UNIT_ACTIVESTATE_ACTIVE = 0x11, - UNIT_ACTIVESTATE_INACTIVE = 0x12 -}; -enum STATE_FLAGS { - STATE_FLAGS_ENABLE, - STATE_FLAGS_DISABLE, - STATE_FLAGS_DISABLE_ISO -}; - -struct SignalColor { - int Red {18}; //Error or inaktive - int Yellow {38}; //Warn or fails - int Green {28}; //infoS - int White {78}; //all all right - void SetSignalColor(int RED = 18, int YELLOW = 38, int GREEN = 28, int WHITE = 78) {Red = RED; Yellow = YELLOW; Green = GREEN; White = WHITE;}; -}; - -//typedef struct SERVICES SERVICES; -struct SERVICES { - int SID; - std::string Name; - std::string Target; //(){return Name.substr(Name.find(".")+1,Name.length());}; - std::string Path; - std::string Description; - int state; - std::string Status; - int load; - std::string Load; - int active; - std::string Active; - int substate; - std::string SubStatus; -}; - -class ServiceClass { -public: - /*#####################################################*/ - vector ServiceList; - WINDOW *STATUSWIN; - WINDOW *STATUSINFO; - string systemctlwahl; - /*#####################################################*/ - SignalColor StateColor; - char searchString[BUFSIZ] = ""; - unsigned char inputFor = 0; - int lastFound = 0; - int selected = 0; - int start = 0; - string AktivName {""}; - /*#####################################################*/ - void ServiceListFill(); - void ServiceListe(); - void INFOWINDOW(string Name); - void Statusabfrage(string ausgabestatus); - void ENDE(); - /*#####################################################*/ - void SetStateOption(); /*SERVICES unit*/ - void BuildWin(); - void TableMoveRow(); - void TableDraw(SERVICES unit, int y); - void TableDriver(vector SRVLIST, int key); - void moveTo(int position); - void searchInput(); - void drawSearch(); - string SearchDriver(SeaReq drv, WINDOW *Win, int Key, string Search, int Posi); - /*#####################################################*/ - ServiceClass(); - ~ServiceClass(); -}; - - - -#endif // SERVICECLASS_H From d82d0e0874cd7f2a4e22d6ca4ec1ea69c9c92e57 Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Tue, 9 Feb 2021 09:02:54 +0100 Subject: [PATCH 15/19] Delete ServiceControl.pro --- ServiceControl.pro | 101 --------------------------------------------- 1 file changed, 101 deletions(-) delete mode 100644 ServiceControl.pro diff --git a/ServiceControl.pro b/ServiceControl.pro deleted file mode 100644 index a5c39c2..0000000 --- a/ServiceControl.pro +++ /dev/null @@ -1,101 +0,0 @@ -TEMPLATE = app -CONFIG += console c++17 -CONFIG -= app_bundle -CONFIG -= qt - -############################################################################ -## Meine einstellung immer ohne shadow build in QT creator!!! # -############################################################################ -PROGRAMMNAME = ServiceControl -TARGET = bin/$$PROGRAMMNAME -VERSION = v1.0.4 -QMAKE_TARGET_PRODUCT = "$${PROGRAMMNAME}" -QMAKE_TARGET_COMPANY = "HOMELAND" -QMAKE_TARGET_COPYRIGHT = "Copyright (c) by Aktony" -DEFINES += APP_VERSION=\"\\\"$${VERSION}\\\"\" \ - APP_PRODUCT=\"\\\"$${QMAKE_TARGET_PRODUCT}\\\"\" \ - APP_COMPANY=\"\\\"$${QMAKE_TARGET_COMPANY}\\\"\" \ - APP_COPYRIGHT=\"\\\"$${QMAKE_TARGET_COPYRIGHT}\\\"\" -#unix:!macx:QMAKE_DEL_FILE = rm -f -#unix:!macx:QMAKE_DEL_DIR = rm -rf -#unix:!macx:OUT_PWD = "$$PWD/Build_$$VERSION" -DESTDIR = "$$PWD/Build_$$VERSION/debug/$$PROGRAMMNAME" -############################################################################ -#__________________release and debug_______________________________________# -############################################################################ -CONFIG(debug, debug|release) { - DEFINES += DEBUG_MODE - DESTDIR = "$$PWD/Build_$$VERSION/debug/$$PROGRAMMNAME" - QMAKE_MAKEFILE = Makefile.debug - MAKEFILE = Makefile.debug -} else:CONFIG(release, debug|release) { - DEFINES += RELEASE_MODE - DESTDIR = "$$PWD/Build_$$VERSION/release/$$PROGRAMMNAME" - QMAKE_MAKEFILE = Makefile.release - MAKEFILE = Makefile.release -} else:CONFIG(force_debug_info) { - DEFINES += PROFILE_MODE - DESTDIR = "$$PWD/Build_$$VERSION/profile/$$PROGRAMMNAME" - QMAKE_MAKEFILE = Makefile.profile - MAKEFILE = Makefile.profile -} else { - DEFINES += DEBUG_MODE - DESTDIR = "$$PWD/Build_$$VERSION/debug/$$PROGRAMMNAME" - QMAKE_MAKEFILE = Makefile.debug - MAKEFILE = Makefile.debug -} - -RCC_DIR = "$$PWD/Build_$$VERSION/RCCFiles" -UI_DIR = "$$PWD/Build_$$VERSION/UICFiles" -MOC_DIR = "$$PWD/Build_$$VERSION/MOCFiles" -OBJECTS_DIR = "$$PWD/Build_$$VERSION/ObjFiles" - -message($$_PRO_FILE_ " - Profile!") -message($$_PRO_FILE_PWD_ " - Profile dir!") -message($$DESTDIR " - Destdir Name!") -message($$MAKEFILE " - Makefile Name!") -message($$OUT_PWD " - out_pwd dir!") -message($$QMAKE_MAKEFILE " - Qmakefile Name!") -############################################################################ -#__________________Copy files to build directory___________________________# -############################################################################ -#copydata0.commands = $(DEL_DIR) $$DESTDIR/config -#copydata1.commands = $(COPY_FILE) $$PWD/lib/libLogWriter.a $$DESTDIR/lib/libLogWriter.a -#copydata2.commands = $(COPY_FILE) $$PWD/lib/libUserGroupList.a $$DESTDIR/lib/libUserGroupList.a -#first.depends = $(first) copydata0 copydata1 copydata2 -#export(first.depends) -#export(copydata0.commands) -#export(copydata1.commands) -#export(copydata2.commands) -#QMAKE_EXTRA_TARGETS += first copydata0 copydata1 copydata2 -unix:!macx: LIBS += -lncurses++w -Wall -lncursesw -lmenuw -lmenu -lformw -lpanelw -pthread -lreadline -Wreturn-type -lstdc++fs -lsystemd -#-lpam -lpam_misc -lxcb -#unix:!macx:LIBS_PRIVATE += $$DESTDIR/lib/libUserGroupList.a -#unix:!macx:LIBS_PRIVATE += $$DESTDIR/lib/libLogWriter.a -#unix:!macx: LIBS += -L$$DESTDIR/lib/ -lLogWriter -lUserGroupList -#$$DESTDIR/lib/libconfigator.a $$DESTDIR/lib/libdragonfail.a $$DESTDIR/lib/libtermbox.a $$DESTDIR/lib/libtestoasterror.a -#unix:!macx: LIBS += -L$$DESTDIR/lib/ -largoat -lconfigator -ldragonfail -ltermbox -ltestoasterror -########################################################################### -# Ende !!! # -########################################################################### - -SOURCES += \ -# MenuClass.cpp \ -# WinClass.cpp \ - MenuWinClass.cpp \ - ServiceClass.cpp \ - Start.cpp \ - TaskClass.cpp - - -HEADERS += \ - Info.h \ -# WinClass.h \ -# MenuClass.h \ - MenuWinClass.h \ - ServiceClass.h \ - TaskClass.h - -DISTFILES += \ - zeug.txt - From 0cf21735d838ba80a6cd2df752cf6e8082f0d864 Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Tue, 9 Feb 2021 09:03:02 +0100 Subject: [PATCH 16/19] Delete Start.cpp --- Start.cpp | 59 ------------------------------------------------------- 1 file changed, 59 deletions(-) delete mode 100644 Start.cpp diff --git a/Start.cpp b/Start.cpp deleted file mode 100644 index f7249fd..0000000 --- a/Start.cpp +++ /dev/null @@ -1,59 +0,0 @@ -#include -//#include -//#include -#include -#include -#include - -using namespace std; - -TaskClass * TaskClassS = new TaskClass(); -ServiceClass * ServiceClassS = new ServiceClass(); -MenuWinClass *MenuWinClassS = new MenuWinClass(); - -int main (int argc, char* argv[]) { -//try { - if (argc > 1) { - if (string(argv[1]).compare("-h")) { - cout << ABOUT_INFO << " " << VERSION << endl; - return 0; - exit(EXIT_SUCCESS); - } else { - //fn = string(argv[1]); - //ed = Editor(fn); - } - } - - int Key = 0; - werase(stdscr); - MenuWinClassS->StartWin(); - signal(SIGWINCH, MenuWinClass::ResizeHandler); - //-------------_DatumUhrZeit_datumuhrzeit_----------------------------------------------- - //std::thread worker(&TaskClass::process_signal, std::ref(TaskPtr), "DateTime"); - //worker.detach(); - MenuWinClass::SetWinSize(); - MenuWinClassS->FensterDraw(); - - refresh(); - wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); - touchwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); - redrawwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin2)); - wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin2)); - touchwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin2)); - wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin3)); - touchwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin3)); - prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); - prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY()-4, - MenuWinClass::START.WCX()-46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); - redrawwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); - wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); - - do { Key = MenuWinClass::MenuStart(Key); if (Key == KEY_F(10)) { break; } } while ((Key = getch()) != KEY_F(10)); - - ServiceClassS->ENDE(); - MenuWinClassS->StopWin(); - -// } catch (const NCursesException *e) { endwin(); std::cerr << e->message << std::endl; cout << e->errorno; -// } catch (const NCursesException &e) { endwin(); std::cerr << e.message << std::endl; cout << e.errorno; -// } catch (const std::exception &e) { endwin(); std::cerr << "Exception: " << e.what() << std::endl; cout << EXIT_FAILURE; } -} From 3f05d8779c12425ec968aa001155ef029b0d5dd7 Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Tue, 9 Feb 2021 09:03:11 +0100 Subject: [PATCH 17/19] Delete TaskClass.cpp --- TaskClass.cpp | 106 -------------------------------------------------- 1 file changed, 106 deletions(-) delete mode 100644 TaskClass.cpp diff --git a/TaskClass.cpp b/TaskClass.cpp deleted file mode 100644 index 4d72df4..0000000 --- a/TaskClass.cpp +++ /dev/null @@ -1,106 +0,0 @@ -#include -//#include -//#include -#include -#include -#include - -using namespace std; - -TaskClass *TaskClass_TC = new TaskClass(); -//MenuClass *MenuPtr_TC = new MenuClass(); -ServiceClass *ServiceClass_TC = new ServiceClass(); -//WinClass *WinPtr_TC = new WinClass(); -MenuWinClass *MenuWinClass_TC = new MenuWinClass(); - -volatile int signal_flag; -/*##########################################################################*/ -int TaskClass::ZahlenWerk(int zahlen, string i, int max) { - int tmp = 0; - if (strcmp(i.c_str(), "++") == 0) { - if (zahlen >= max) { - tmp = 1; - } else if (zahlen == 0) { - tmp = 1; - } else if (zahlen > 0) { - tmp = ++zahlen; - } else if (zahlen < max) { - tmp = ++zahlen; - } - } else if (strcmp(i.c_str(), "--") == 0) { - if (zahlen <= 0) { - tmp = max; - } else if (zahlen == 1) { - tmp = max; - } else if (zahlen > 1) { - tmp = --zahlen; - } else if (zahlen <= max) { - tmp = --zahlen; - } - } else { - tmp = 1; - } - return tmp; -} -int TaskClass::Zeilen(string data, int maxbreite) { - int rownr = 0; - double zeiBr = (data.length() / static_cast(maxbreite)); - int zeiBr2; - stringstream datast(data); - string line; - for (rownr = 0; std::getline(datast, line); ++rownr) {} - zeiBr2 = static_cast(ceil(zeiBr)); - return (rownr + zeiBr2); -} -std::vector TaskClass::StringTeiler(const std::string& str, char delimiter) { - std::istringstream is(str); - std::vector result; - for (std::string cur; std::getline(is, cur, delimiter); result.push_back(cur)); - return result; -} -string TaskClass::TERM_AUSGABE(string cmd) { - //cmd = "systemctl list-unit-files -t service | grep '.service' | awk '{$1=$1};1' | sort"; - string data; - FILE* stream; - char buffer[BUFSIZE]; - cmd.append(" 2>/dev/null"); //2>&1 - stream = popen(cmd.c_str(), "r"); - if (stream) { - while (!feof(stream)) { - if (fgets(buffer, BUFSIZE, stream) != nullptr) { - data.append(buffer); - } - } - pclose(stream); - } - memset(buffer, 0, BUFSIZE); - return data; -} -WINDOW* TaskClass::ClearWindow(WINDOW* TEMPWINDOW) { - clearok(TEMPWINDOW, true); - return TEMPWINDOW; -} -int TaskClass::WinFullSize(WINDOW* TmpWin, int WHCRXY, string WorH) { - if (WorH.compare("W") == 0) { - if (MenuWinClass_TC->START.WinSize.WCX_TmpWinReal(TmpWin) <= WHCRXY) { - return WHCRXY; - } else { - return MenuWinClass_TC->START.WinSize.WCX_TmpWinReal(TmpWin); - } - } else if (WorH.compare("H") == 0) { - if (MenuWinClass_TC->START.WinSize.HRY_TmpWinReal(TmpWin) <= WHCRXY) { - return WHCRXY; - } else { - return MenuWinClass_TC->START.WinSize.HRY_TmpWinReal(TmpWin); - } - } -} - -/*##########################################################################*/ -TaskClass::TaskClass() { - //TaskClass::DateTime.TIMEFIELD(MenuPtr->MENEU.HMWin,MenuWinClass_TC->WinSize.WCX); -} -TaskClass::~TaskClass() { - -} -/*##########################################################################*/ From db6a700a8f56b92b7ad21a05fa6cc6fe7e88b61d Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Tue, 9 Feb 2021 09:03:18 +0100 Subject: [PATCH 18/19] Delete TaskClass.h --- TaskClass.h | 85 ----------------------------------------------------- 1 file changed, 85 deletions(-) delete mode 100644 TaskClass.h diff --git a/TaskClass.h b/TaskClass.h deleted file mode 100644 index 1ec5fe9..0000000 --- a/TaskClass.h +++ /dev/null @@ -1,85 +0,0 @@ -#ifndef TASKCLASS_H -#define TASKCLASS_H - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -//#define CTRLD 4 -#define BUFSIZE 8192 -#define CLEARSCR system ( "clear" ) -#define UNUSED(x) (void) (x) -#define SAFE_DELETE(p) { if(p) { delete (p); (p) = nullptr; } } -#define SAFE_DELETE_ARRAY(p) { if(p) { delete[] (p); (p) = nullptr; } } -#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) -#define SIZEOF(table) (sizeof(table) / sizeof(table[0])) -#define RST "\x1B[0m"; -#define KRED "\x1B[31m"; -#define KGRN "\x1B[32m"; -#define KYEL "\x1B[33m"; -#define KBLU "\x1B[34m"; -#define KMAG "\x1B[35m"; -#define KCYN "\x1B[36m"; -#define KWHT "\x1B[37m"; -#define FRED(x) KRED x RST; -#define FGRN(x) KGRN x RST; -#define FYEL(x) KYEL x RST; -#define FBLU(x) KBLU x RST; -#define FMAG(x) KMAG x RST; -#define FCYN(x) KCYN x RST; -#define FWHT(x) KWHT x RST; - -using namespace std; - -struct DatumUhrZeit { - int n = 0; - time_t Zeitstempel; - tm* UHRZEIT; - char UHRZEITchar[19]; - std::string UHRZEITstr; - void TIMEFIELD(WINDOW* TMPWin, int TMPmax_xc) { - Zeitstempel = time(nullptr); - UHRZEIT = localtime(&Zeitstempel); - strftime(UHRZEITchar, size_t(UHRZEITchar), "%d.%m.%Y %T", UHRZEIT); - UHRZEITstr = std::string(UHRZEITchar); - wattr_on(TMPWin, COLOR_PAIR(79) | A_STANDOUT | A_BOLD, nullptr); //|A_BOLD,0); - mvwaddnstr(TMPWin, 0, 0, UHRZEITstr.c_str(), -1); - wattr_off(TMPWin, COLOR_PAIR(79) | A_STANDOUT | A_BOLD, nullptr); //|A_BOLD,0); - refresh(); - wrefresh(TMPWin); //TMPmax_xc-2 - } -}; - -class TaskClass { - public: - /*##############################################################################*/ - int ZahlenWerk(int zahlen, std::string i, int max); - int Zeilen(std::string data, int maxbreite); - vector StringTeiler(const std::string& str, char delimiter); - string TERM_AUSGABE(std::string cmd); - WINDOW* ClearWindow(WINDOW* W); - int WinFullSize(WINDOW* TmpWin, int WHCRXY, std::string WorH); - TaskClass(); - ~TaskClass(); - /*##############################################################################*/ -}; - -#endif // TASKCLASS_H From 12c656dd9a2f2649bdf930e8cb1e26fa0d4d9447 Mon Sep 17 00:00:00 2001 From: tony <76898277+fett-tony@users.noreply.github.com> Date: Tue, 9 Feb 2021 09:05:26 +0100 Subject: [PATCH 19/19] Add files via upload --- Info.h | 23 ++ MenuWinClass.cpp | 899 +++++++++++++++++++++++++++++++++++++++++++++ MenuWinClass.h | 205 +++++++++++ ServiceClass.cpp | 805 ++++++++++++++++++++++++++++++++++++++++ ServiceClass.h | 106 ++++++ ServiceControl.pro | 101 +++++ Start.cpp | 59 +++ TaskClass.cpp | 106 ++++++ TaskClass.h | 85 +++++ 9 files changed, 2389 insertions(+) create mode 100644 Info.h create mode 100644 MenuWinClass.cpp create mode 100644 MenuWinClass.h create mode 100644 ServiceClass.cpp create mode 100644 ServiceClass.h create mode 100644 ServiceControl.pro create mode 100644 Start.cpp create mode 100644 TaskClass.cpp create mode 100644 TaskClass.h diff --git a/Info.h b/Info.h new file mode 100644 index 0000000..46cddb6 --- /dev/null +++ b/Info.h @@ -0,0 +1,23 @@ +#ifndef _INFO_H +#define _INFO_H + +#define VERSION "1.0.4" +#define APPNAME "ServiceControl" +#define ABOUT_INFO "\n\ + " APPNAME " " VERSION " \n\ + \n\ + Navigation keys: \n\ + Up - move cursor up | Down - move cursor down \n\ + right - move cursor right | left - move cursor left \n\ + PgUp - move page up | PgDown - move page down \n\ + / - for search | ? - for this help \n\ + Action keys: \n\ + Space - anwählen/abwählen | F10 - exit | ESC - Close info/help\n\ + F1 - start/stop unit | F2 - reload/update | TAB - switch Menu/ \n\ + F3 - enabled unit | F4 - disabled unit | Servicelist/ \n\ + F5 - unmasked unit | F6 - masked unit | Search \n\ +---------------------------------------------------------------------------\n\ + License: GPLv3 (c) Anthony Olszynski \n\ +" + +#endif //_INFO_H diff --git a/MenuWinClass.cpp b/MenuWinClass.cpp new file mode 100644 index 0000000..15b5aa6 --- /dev/null +++ b/MenuWinClass.cpp @@ -0,0 +1,899 @@ + #include + +using namespace std; + +TaskClass *TaskClass_MWC = new TaskClass(); +ServiceClass *ServiceClass_MWC = new ServiceClass(); +MenuWinClass *MenuWinClass_MWC = new MenuWinClass(); + +FENSTER MenuWinClass::START; +HAUPTMENU MenuWinClass::TOPMENU; +WINDOW* MenuWinClass::TMPWIN; +MENU* MenuWinClass::TMPMENU; +int MenuWinClass::MeInAl = 0; +INAPPMENU MenuWinClass::SERVICEMENU; +int MenuWinClass::LiMeInAl; +WINDOW* MenuWinClass::LiTMPWIN; +MENU* MenuWinClass::LiTMPMENU; +string MenuWinClass::PATTERN; +ServiceClass ServiceClass; +vector ServiceList; +int MenuWinClass::TabKey = 1; + +WinID& operator++(WinID& WID, int) { + return WID = (WID == WinID::ENDWIN) ? WinID::MAINWIN : static_cast(static_cast(WID) + 1); +}; +WinID& operator--(WinID& WID, int) { + return WID = (WID == WinID::ENDWIN) ? WinID::MAINWIN : static_cast(static_cast(WID) - 1); +}; +ostream& operator<<(ostream& WID, WinID e) { + static const vector EnumString = {"MENUWIN", "MAINWIN", "TERMWIN", "LISTPAD", "DESCWIN", "ENDWIN"}; + return WID << EnumString[static_cast(e)]; +}; +MenuID& operator++(MenuID& MID, int) { + return MID = (MID == MenuID::ENDMENU) ? MenuID::MAINMENU : static_cast(static_cast(MID) + 1); +}; +MenuID& operator--(MenuID& MID, int) { + return MID = (MID == MenuID::ENDMENU) ? MenuID::MAINMENU : static_cast(static_cast(MID) - 1); +}; +ostream& operator<<(ostream& MID, MenuID e) { + static const vector EnumString = {"DATEIMENU", "DAEMONMENU", "SYSTEMCTLMENU", "INFOMENU", "MAINMENU", "ENDMENU"}; + return MID << EnumString[static_cast(e)]; +}; + +MenuWinClass::MenuWinClass() { + START.WinSize.RAND = 1; + START.WinSize.h = 1; //rand + START.WinSize.w = 1; + START.WCX(); // = 80; + START.HRY(); // = 24; + START.WinSize.WCX(); // = 80; + START.WinSize.HRY(); // = 24; + START.WinSize.WCX_Real(); + START.WinSize.HRY_Real(); + START.WinSize.WCX_Center(); + START.WinSize.HRY_Center(); + START.WinSize.WCX_TmpWin(stdscr); + START.WinSize.HRY_TmpWin(stdscr); + START.WinSize.WCX_TmpWinReal(stdscr); + START.WinSize.HRY_TmpWinReal(stdscr); + START.WinSize.WCX_TmpWinCenter(stdscr); + START.WinSize.HRY_TmpWinCenter(stdscr); +} +void MenuWinClass::StartWin() { + setlocale(LC_CTYPE, "de_DE.UTF-8"); + setlocale(LC_ALL, "de_DE.UTF-8"); + initscr(); + if (has_colors() == FALSE) { endwin(); cout << "Your terminal does not support color\n" << endl; exit(1);} + start_color(); + cbreak(); + noecho(); + curs_set(false); + keypad(stdscr, true); + MenuWinClass::AppColor(); +} +void MenuWinClass::StopWin() { + endwin(); +} +void MenuWinClass::AppColor() { + start_color(); + short MY_MARIN_BLUE = 240, MY_LIGHT_BLUE = 250, MY_DARK_BLACK = 0, MY_LIGHT_WHITE = 100; + short R = 0, G = 0, B = 0; + init_color(MY_MARIN_BLUE, R, G, static_cast(300)); + init_color(MY_LIGHT_BLUE, R, G, static_cast(850)); + init_color(MY_DARK_BLACK, R, G, B); + init_color(MY_LIGHT_WHITE, 1000, 1000, 1000); + /* 0 black, 1 red, 2 green, 3 yellow, 4 blue, 5 magenta, 6 cyan, 7 white, 8 marin blue, 9 light blue */ + /* hintergrund Schwarz */ + init_pair(00, MY_DARK_BLACK, MY_DARK_BLACK); + init_pair(10, COLOR_RED, MY_DARK_BLACK); + init_pair(20, COLOR_GREEN, MY_DARK_BLACK); + init_pair(30, COLOR_YELLOW, MY_DARK_BLACK); + init_pair(40, COLOR_BLUE, MY_DARK_BLACK); + init_pair(50, COLOR_MAGENTA, MY_DARK_BLACK); + init_pair(60, COLOR_CYAN, MY_DARK_BLACK); + init_pair(70, MY_LIGHT_WHITE, MY_DARK_BLACK); + init_pair(80, MY_MARIN_BLUE, MY_DARK_BLACK); + init_pair(90, MY_LIGHT_BLUE, MY_DARK_BLACK); + /* hintergrund Rot */ + init_pair(01, MY_DARK_BLACK, COLOR_RED); + init_pair(11, COLOR_RED, COLOR_RED); + init_pair(21, COLOR_GREEN, COLOR_RED); + init_pair(31, COLOR_YELLOW, COLOR_RED); + init_pair(41, COLOR_BLUE, COLOR_RED); + init_pair(51, COLOR_MAGENTA, COLOR_RED); + init_pair(61, COLOR_CYAN, COLOR_RED); + init_pair(71, MY_LIGHT_WHITE, COLOR_RED); + init_pair(81, MY_MARIN_BLUE, COLOR_RED); + init_pair(91, MY_LIGHT_BLUE, COLOR_RED); + /* hintergrund Gruen */ + init_pair(02, MY_DARK_BLACK, COLOR_GREEN); + init_pair(12, COLOR_RED, COLOR_GREEN); + init_pair(22, COLOR_GREEN, COLOR_GREEN); + init_pair(32, COLOR_YELLOW, COLOR_GREEN); + init_pair(42, COLOR_BLUE, COLOR_GREEN); + init_pair(52, COLOR_MAGENTA, COLOR_GREEN); + init_pair(62, COLOR_CYAN, COLOR_GREEN); + init_pair(72, MY_LIGHT_WHITE, COLOR_GREEN); + init_pair(82, MY_MARIN_BLUE, COLOR_GREEN); + init_pair(92, MY_LIGHT_BLUE, COLOR_GREEN); + /* hintergrund Gelb */ + init_pair(03, MY_DARK_BLACK, COLOR_YELLOW); + init_pair(13, COLOR_RED, COLOR_YELLOW); + init_pair(23, COLOR_GREEN, COLOR_YELLOW); + init_pair(33, COLOR_YELLOW, COLOR_YELLOW); + init_pair(43, COLOR_BLUE, COLOR_YELLOW); + init_pair(53, COLOR_MAGENTA, COLOR_YELLOW); + init_pair(63, COLOR_CYAN, COLOR_YELLOW); + init_pair(73, MY_LIGHT_WHITE, COLOR_YELLOW); + init_pair(83, MY_MARIN_BLUE, COLOR_YELLOW); + init_pair(93, MY_LIGHT_BLUE, COLOR_YELLOW); + /* hintergrund Blau */ + init_pair(04, MY_DARK_BLACK, COLOR_BLUE); + init_pair(14, COLOR_RED, COLOR_BLUE); + init_pair(24, COLOR_GREEN, COLOR_BLUE); + init_pair(34, COLOR_YELLOW, COLOR_BLUE); + init_pair(44, COLOR_BLUE, COLOR_BLUE); + init_pair(54, COLOR_MAGENTA, COLOR_BLUE); + init_pair(64, COLOR_CYAN, COLOR_BLUE); + init_pair(74, MY_LIGHT_WHITE, COLOR_BLUE); + init_pair(84, MY_MARIN_BLUE, COLOR_BLUE); + /* hintergrund Magenta */ + init_pair(05, MY_DARK_BLACK, COLOR_MAGENTA); + init_pair(15, COLOR_RED, COLOR_MAGENTA); + init_pair(25, COLOR_GREEN, COLOR_MAGENTA); + init_pair(35, COLOR_YELLOW, COLOR_MAGENTA); + init_pair(45, COLOR_BLUE, COLOR_MAGENTA); + init_pair(55, COLOR_MAGENTA, COLOR_MAGENTA); + init_pair(65, COLOR_CYAN, COLOR_MAGENTA); + init_pair(75, MY_LIGHT_WHITE, COLOR_MAGENTA); + /* hintergrund Cyan */ + init_pair(06, MY_DARK_BLACK, COLOR_CYAN); + init_pair(16, COLOR_RED, COLOR_CYAN); + init_pair(26, COLOR_GREEN, COLOR_CYAN); + init_pair(36, COLOR_YELLOW, COLOR_CYAN); + init_pair(46, COLOR_BLUE, COLOR_CYAN); + init_pair(56, COLOR_MAGENTA, COLOR_CYAN); + init_pair(66, COLOR_CYAN, COLOR_CYAN); + init_pair(76, MY_LIGHT_WHITE, COLOR_CYAN); + init_pair(86, MY_MARIN_BLUE, COLOR_CYAN); + init_pair(96, MY_LIGHT_BLUE, COLOR_CYAN); + /* hintergrund White */ + init_pair(07, MY_DARK_BLACK, MY_LIGHT_WHITE); + init_pair(17, COLOR_RED, MY_LIGHT_WHITE); + init_pair(27, COLOR_GREEN, MY_LIGHT_WHITE); + init_pair(37, COLOR_YELLOW, MY_LIGHT_WHITE); + init_pair(47, COLOR_BLUE, MY_LIGHT_WHITE); + init_pair(57, COLOR_MAGENTA, MY_LIGHT_WHITE); + init_pair(67, COLOR_CYAN, MY_LIGHT_WHITE); + init_pair(77, MY_LIGHT_WHITE, MY_LIGHT_WHITE); + init_pair(87, MY_MARIN_BLUE, MY_LIGHT_WHITE); + init_pair(97, MY_LIGHT_BLUE, MY_LIGHT_WHITE); + /* hintergrund Marin Blau */ + init_pair(8, MY_DARK_BLACK, MY_MARIN_BLUE); + init_pair(18, COLOR_RED, MY_MARIN_BLUE); + init_pair(28, COLOR_GREEN, MY_MARIN_BLUE); + init_pair(38, COLOR_YELLOW, MY_MARIN_BLUE); + init_pair(48, COLOR_BLUE, MY_MARIN_BLUE); + init_pair(58, COLOR_MAGENTA, MY_MARIN_BLUE); + init_pair(68, COLOR_CYAN, MY_MARIN_BLUE); + init_pair(78, MY_LIGHT_WHITE, MY_MARIN_BLUE); + init_pair(88, MY_MARIN_BLUE, MY_MARIN_BLUE); + init_pair(98, MY_LIGHT_BLUE, MY_MARIN_BLUE); + /* hintergrund Light Blue */ + init_pair(9, MY_DARK_BLACK, MY_LIGHT_BLUE); + init_pair(19, COLOR_RED, MY_LIGHT_BLUE); + init_pair(29, COLOR_GREEN, MY_LIGHT_BLUE); + init_pair(39, COLOR_YELLOW, MY_LIGHT_BLUE); + init_pair(49, COLOR_BLUE, MY_LIGHT_BLUE); + init_pair(59, COLOR_MAGENTA, MY_LIGHT_BLUE); + init_pair(69, COLOR_CYAN, MY_LIGHT_BLUE); + init_pair(79, MY_LIGHT_WHITE, MY_LIGHT_BLUE); + init_pair(89, MY_MARIN_BLUE, MY_LIGHT_BLUE); + init_pair(99, MY_LIGHT_BLUE, MY_LIGHT_BLUE); +} /*---------Programm_Farben------------------------*/ +void MenuWinClass::SetWinSize() { + MenuWinClass::START.WCX(); + MenuWinClass::START.HRY(); + MenuWinClass::START.HRYw1(); + MenuWinClass::START.WCXw1(); + MenuWinClass::START.HRYw2(); + MenuWinClass::START.WCXw2(); + MenuWinClass::START.HRYw3(); + MenuWinClass::START.WCXw3(); + MenuWinClass::START.HRYw4(); + MenuWinClass::START.WCXw4(); + MenuWinClass::START.HRYw5(); + MenuWinClass::START.WCXw5(); + MenuWinClass::START.HRYtime(); + MenuWinClass::START.WCXtime(); + MenuWinClass::START.TMPWin1 = newwin(MenuWinClass::START.HRYw1(), MenuWinClass::START.WCXw1(), 0, 0); + MenuWinClass::START.TMPWin2 = newwin(MenuWinClass::START.HRYw2(), MenuWinClass::START.WCXw2(), 1, 0); + MenuWinClass::START.TMPWin3 = newwin(MenuWinClass::START.HRYw3(), MenuWinClass::START.WCXw3(), (MenuWinClass::START.HRYw1() + MenuWinClass::START.HRYw2()), 0); + MenuWinClass::START.TMPWin4 = newpad(MenuWinClass::START.HRYw4(), MenuWinClass::START.WCXw4()); + //MenuWinClass::START.TMPWin5 = newpad(MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); + MenuWinClass::START.TMPWin5 = newwin(MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5(), (MenuWinClass::START.HRYw1() + MenuWinClass::START.HRYw2())+ 1, 33); +} /*---------Fenster_Size_Setzen--------------------*/ +void MenuWinClass::CreateWin(WINDOW* win, WinID WID) { + switch (WID) { + case MENUWIN: { /*TMPWin1*/ + MenuWinClass::Hauptmenu(); + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_MENUWIN)); + break; + } + case MAINWIN: { /*TMPWin2*/ + box(win, 0, 0); + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_MAINWIN)); + wsetscrreg(win, 0, MenuWinClass::START.HRYw2() - 2); + scrollok(win, true); + break; + } + case INFOWIN: { /*TMPWin3*/ + box(win, 0, 0); + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN)); + wattr_on(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN) | A_BOLD, nullptr); + mvwaddnstr(win, MenuWinClass::START.HRYw3() -1, MenuWinClass::START.WCXw3() - 14, "[ EXIT F10 ]", -1); //12+2 + mvwaddnstr(win, MenuWinClass::START.HRYw3() -1, MenuWinClass::START.WCXw3() - 26, "[ MENÜ TAB ]", -1); //11+2 + wattr_off(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN) | A_BOLD, nullptr); + break; + } + case LISTPAD: { /*TMPWin4*/ + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_LISTPAD)); + win = derwin(MenuWinClass::START.TMPWin2, MenuWinClass::START.HRYw4(), MenuWinClass::START.WCXw4(), 1, 1); + break; + } + case DESCWIN: { /*TMPWin5*/ + //win = derwin(MenuWinClass::START.TMPWin3, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5(), 1, 33); + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_DESCWIN)); + break; + } + case TIMEWIN: { /*TimeWin*/ + wbkgd(win, COLOR_PAIR(MenuWinClass::START.WinColor.BK_TIMEWIN)); + win = derwin(MenuWinClass::START.TMPWin1, 1, 20, 0, MenuWinClass::START.WCX() - 20); + break; + } + case ENDWIN: { break; } + default: { break; } + } + refresh(); + wrefresh(win); +} /*---------Fenster_Erzeugen-----------------------*/ +void MenuWinClass::ResizeHandler(int signal) { + UNUSED(signal); + StopWin(); + StartWin(); + SetWinSize(); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin1, MENUWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin2, MAINWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin3, INFOWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin4, LISTPAD); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin5, DESCWIN); +} /*---------Resize_Fenster_neu_Erzeugen----------------*/ +void MenuWinClass::ScrollPad(WINDOW* SubWin, int StartY, int StartX, int Height, int Width, int PadHeight) { + int Choice = 0, Key = 0; + keypad(SubWin, true); + refresh(); + int cols = 0; + while (Choice == 0) { + prefresh(SubWin, cols, 0, StartY, StartX, Height, Width); + Key = wgetch(SubWin); + switch (Key) { + case KEY_UP: { + if (cols <= 0) { continue; } + cols--; + break; + } + case KEY_DOWN: { + if (cols + Height + 1 >= PadHeight) { continue; } + cols++; + break; + } + case KEY_PPAGE: { /* Page Up */ + if (cols <= 0) { continue; } + cols -= Height; + if (cols < 0) { cols = 0; } + break; + } + case KEY_NPAGE: { /* Page Down */ + if (cols + Height + 1 >= PadHeight) { continue; } + cols += Height; + if (cols + Height + 1 > PadHeight) { cols = PadHeight - Height - 1; } + break; + } + case KEY_HOME: { + cols = 0; + break; + } + case KEY_END: { + cols = PadHeight - Height - 1; + break; + } + case 10: { /* Enter */ + Choice = 1; + break; + } + } + refresh(); + } + delwin(SubWin); +} +void MenuWinClass::printInMiddle(WINDOW *win, int starty, int startx, int width, char *string, chtype color, char *sp) { + int x, y; + unsigned long length; + float temp; + + if(win == nullptr) + win = stdscr; + getyx(win, y, x); + if(startx != 0) + x = startx; + if(starty != 0) + y = starty; + if(width == 0) + width = 80; + + length = strlen(string); + temp = (width - static_cast(length))/ 2; + x = startx + static_cast(temp); + wattron(win, color); + + if (sp) { + for (int i = startx; i < width; i++) { + mvwprintw(win, y, i, "%c", sp); + } + } + + mvwprintw(win, y, x, "%s", string); + wattroff(win, color); +} +void MenuWinClass::FensterDraw() { + ServiceClass_MWC->INFOWINDOW(""); + ServiceClass_MWC->ServiceListFill(); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin1, MENUWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin2, MAINWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin3, INFOWIN); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin4, LISTPAD); + MenuWinClass::CreateWin(MenuWinClass::START.TMPWin5, DESCWIN); +} +void MenuWinClass::Hauptmenu(void) { + MenuWinClass::TOPMENU.MID = MAINMENU; + MenuWinClass::TOPMENU.HMName = string("HAUPTMENÜ"); + MenuWinClass::TOPMENU.HMItem = static_cast(calloc(5, sizeof(ITEM*))); + MenuWinClass::TOPMENU.HMItem[0] = new_item(" Datei", MenuWinClass::TOPMENU.HMName.c_str()); + MenuWinClass::TOPMENU.HMItem[1] = new_item("DaemonType", MenuWinClass::TOPMENU.HMName.c_str()); + MenuWinClass::TOPMENU.HMItem[2] = new_item("Systemctl", MenuWinClass::TOPMENU.HMName.c_str()); + MenuWinClass::TOPMENU.HMItem[3] = new_item("Info", MenuWinClass::TOPMENU.HMName.c_str()); + MenuWinClass::TOPMENU.HMItem[4] = nullptr; + MenuWinClass::TOPMENU.HMMenu = new_menu(MenuWinClass::TOPMENU.HMItem); + MenuWinClass::START.TMPWin1 = newwin(MenuWinClass::START.HRYw1(), MenuWinClass::START.WCXw1(), 0, 0); + set_menu_win(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::START.TMPWin1); + set_menu_sub(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::START.TMPWin1); + //############################################################### + //set_menu_sub(TOPMENU.UME.UMEMenu, MenuWinClass::START.TMPWin1); + //############################################################### + set_menu_spacing(MenuWinClass::TOPMENU.HMMenu, 1, 0, 0); + set_menu_format(MenuWinClass::TOPMENU.HMMenu, 0, 5); + menu_opts_off(MenuWinClass::TOPMENU.HMMenu, O_SHOWDESC); + menu_opts_off(MenuWinClass::TOPMENU.HMMenu, O_NONCYCLIC); + wbkgd(MenuWinClass::START.TMPWin1, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_MAINMENU)); + set_menu_fore(MenuWinClass::TOPMENU.HMMenu, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_AKTIVHAME) | A_BOLD); + set_menu_back(MenuWinClass::TOPMENU.HMMenu, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_MAINMENU)); + set_menu_grey(MenuWinClass::TOPMENU.HMMenu, COLOR_PAIR(MenuWinClass::TOPMENU.MenuColor.BK_UNUSEDHM)); + set_menu_mark(MenuWinClass::TOPMENU.HMMenu, ""); + post_menu(MenuWinClass::TOPMENU.HMMenu); +} /* Hauptmenü */ +void MenuWinClass::DateiMenu(void) { + TOPMENU.UME.UMID = 1; + TOPMENU.UME.UMEName = string("Datei"); + TOPMENU.UME.UMEWin = newwin(6, 15, 1, 0); + wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + box(TOPMENU.UME.UMEWin, 0, 0); + TOPMENU.UME.UMEItem = static_cast(calloc(7, sizeof(ITEM*))); + TOPMENU.UME.UMEItem[0] = new_item("Man Systemctl", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[1] = new_item("Einstellung", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[2] = new_item("Remotectl", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[3] = new_item("Beenden", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[4] = nullptr; + TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); + set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); + set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); + set_menu_spacing(TOPMENU.UME.UMEMenu, 0, 0, 0); + set_menu_format(TOPMENU.UME.UMEMenu, 5, 0); + menu_opts_off(TOPMENU.UME.UMEMenu, O_SHOWDESC); + menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); + set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); + set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); + set_menu_mark(TOPMENU.UME.UMEMenu, ""); + set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); + post_menu(TOPMENU.UME.UMEMenu); +} /* Datei Untermenü */ +void MenuWinClass::DaemonTypeMenu(void) { + TOPMENU.UME.UMID = 2; + TOPMENU.UME.UMEName = string("DaemonType"); + TOPMENU.UME.UMEWin = newwin(12, 10, 1, 11); + box(TOPMENU.UME.UMEWin, 0, 0); + TOPMENU.UME.UMEItem = static_cast(calloc(11, sizeof(ITEM*))); + TOPMENU.UME.UMEItem[0] = new_item("Device", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[1] = new_item("Mount", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[2] = new_item("Path", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[3] = new_item("Service", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[4] = new_item("Scope", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[5] = new_item("Slice", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[6] = new_item("Socket", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[7] = new_item("Swap", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[8] = new_item("Target", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[9] = new_item("Timer", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[10] = nullptr; + TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); + set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); + set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); + set_menu_spacing(TOPMENU.UME.UMEMenu, 0, 0, 1); + set_menu_format(TOPMENU.UME.UMEMenu, 11, 0); + menu_opts_off(TOPMENU.UME.UMEMenu, O_SHOWDESC); + menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); + wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); + set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); + set_menu_mark(TOPMENU.UME.UMEMenu, ""); + set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); + post_menu(TOPMENU.UME.UMEMenu); +} /* DaemonType Untermenü */ +void MenuWinClass::SystemctlMenu(void) { + TOPMENU.UME.UMID = 3; + TOPMENU.UME.UMEName = string("Systemctl"); + TOPMENU.UME.UMEWin = newwin(12, 18, 1, 22); + box(TOPMENU.UME.UMEWin, 0, 0); + TOPMENU.UME.UMEItem = static_cast(calloc(11, sizeof(ITEM*))); + TOPMENU.UME.UMEItem[0] = new_item("START", "F1"); + TOPMENU.UME.UMEItem[1] = new_item("STOP", "F1"); + TOPMENU.UME.UMEItem[2] = new_item("STATUS", "F3"); + TOPMENU.UME.UMEItem[3] = new_item("ENABLE", "F2"); + TOPMENU.UME.UMEItem[4] = new_item("DISABLE", "F2"); + TOPMENU.UME.UMEItem[5] = new_item("MASK", "F4"); + TOPMENU.UME.UMEItem[6] = new_item("UNMASK", "F4"); + TOPMENU.UME.UMEItem[7] = new_item("RESTART", "F5"); + TOPMENU.UME.UMEItem[8] = new_item("RELOAD", "F6"); + TOPMENU.UME.UMEItem[9] = new_item("Reload-daemon", "F7"); + TOPMENU.UME.UMEItem[10] = nullptr; + TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); + set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); + set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); + set_menu_spacing(TOPMENU.UME.UMEMenu, 1, 0, 0); + set_menu_format(TOPMENU.UME.UMEMenu, 11, 0); + menu_opts_on(TOPMENU.UME.UMEMenu, O_SHOWDESC); + menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); + wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); + set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); + set_menu_mark(TOPMENU.UME.UMEMenu, ""); + set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); + post_menu(TOPMENU.UME.UMEMenu); +} /* Systemctl Untermenü */ +void MenuWinClass::InfoMenu(void) { + TOPMENU.UME.UMID = 4; + TOPMENU.UME.UMEName = string("Info"); + TOPMENU.UME.UMEWin = newwin(5, 12, 1, 33); + wbkgd(TOPMENU.UME.UMEWin, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + box(TOPMENU.UME.UMEWin, 0, 0); + TOPMENU.UME.UMEItem = static_cast(calloc(4, sizeof(ITEM*))); + TOPMENU.UME.UMEItem[0] = new_item("journalctl", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[1] = new_item("E-Mail", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[2] = new_item("Beenden", TOPMENU.UME.UMEName.c_str()); + TOPMENU.UME.UMEItem[3] = nullptr; + TOPMENU.UME.UMEMenu = new_menu(TOPMENU.UME.UMEItem); + set_menu_win(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEWin); + set_menu_sub(TOPMENU.UME.UMEMenu, derwin(TOPMENU.UME.UMEWin, 0, 0, 1, 1)); + set_menu_spacing(TOPMENU.UME.UMEMenu, 0, 0, 0); + set_menu_format(TOPMENU.UME.UMEMenu, 5, 0); + menu_opts_off(TOPMENU.UME.UMEMenu, O_SHOWDESC); + menu_opts_off(TOPMENU.UME.UMEMenu, O_NONCYCLIC); + set_menu_fore(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_AKTIVUNME)|A_REVERSE|A_BOLD); + set_menu_back(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNTERMENU)); + set_menu_grey(TOPMENU.UME.UMEMenu, COLOR_PAIR(TOPMENU.MenuColor.BK_UNUSEDUM)|A_BOLD); + set_menu_mark(TOPMENU.UME.UMEMenu, ""); + set_current_item(TOPMENU.UME.UMEMenu, TOPMENU.UME.UMEItem[0]); + post_menu(TOPMENU.UME.UMEMenu); +} /* Info Untermenü */ +WINDOW* MenuWinClass::TempWin(string Name, MenuID MID) { + if ((Name.compare(" Datei") == 0) || (MID == DATEIMENU)) { + //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, DATEIMENU, "DATEIMENU"); + MenuWinClass::DateiMenu(); + MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; + MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; + } else if ((Name.compare("DaemonType") == 0) || (MID == DAEMONMENU)) { + //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, SYSTEMMENU, "SYSTEMMENU"); + MenuWinClass::DaemonTypeMenu(); + MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; + MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; + } else if ((Name.compare("Systemctl") == 0) || (MID == SYSTEMCTLMENU)) { + //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, SERVERMENU, "SERVERMENU"); + MenuWinClass::SystemctlMenu(); + MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; + MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; + } else if ((Name.compare("Info") == 0) || (MID == INFOMENU)) { + //MenuWinClass::CreateMenu(MenuWinClass::TOPMENU.UME.UMEWin, MenuWinClass::TOPMENU.UME.UMEMenu, SOFTWAREMENU, "SOFTWAREMENU"); + MenuWinClass::InfoMenu(); + MenuWinClass::TMPWIN = MenuWinClass::TOPMENU.UME.UMEWin; + MenuWinClass::TMPMENU = MenuWinClass::TOPMENU.UME.UMEMenu; + } + return MenuWinClass::TMPWIN; +} /* Menü und Win Neuzuordnen */ +void MenuWinClass::StartMenuAuswahl(string wahl) { + string menupoint = MenuWinClass::SERVICEMENU.AktivName; + string befehl; + if (wahl.compare(" Datei") == 0) { + DateiMenu(); + } else if (wahl.compare("Systemctl") == 0) { + SystemctlMenu(); + } else if (wahl.compare("DaemonType") == 0) { + DaemonTypeMenu(); + } else if (wahl.compare("Systemctl") == 0) { + InfoMenu(); + } else if (wahl.compare("Service") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "service"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Swap") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "swap"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Timer") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "timer"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Device") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "device"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Mount") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "mount"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Path") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "path"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Target") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "target"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Socket") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "socket"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Slice") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "slice"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Scope") == 0) { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->systemctlwahl = "scope"; + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("Man Page") == 0) { + exit(EXIT_SUCCESS); + //DATEIMANPAGE::Start_ManP(); + } else if (wahl.compare("Befehle") == 0) { + exit(EXIT_SUCCESS); + //DATEIBEFEHLE::befehle_main(); + } else if (wahl.compare("Einstellung") == 0) { + exit(EXIT_SUCCESS); + //einDa(); + } else if (wahl.compare("Beenden") == 0) { + exit(EXIT_SUCCESS); + } else if (wahl.compare("START") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl start " + menupoint + " --now"; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("STOP") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl stop " + menupoint + " --now"; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("RELOAD") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl reload " + menupoint + " --now"; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("RESTART") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl restart " + menupoint + " --now"; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("ENABLE") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl enable " + menupoint; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("DISABLE") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl disable " + menupoint; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("STATUS") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl status " + menupoint; + ServiceClass_MWC->Statusabfrage(TaskClass_MWC->TERM_AUSGABE(befehl)); + } else if (wahl.compare("UNMASK") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl unmask " + menupoint; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("MASK") == 0) { + pos_menu_cursor(MenuWinClass::SERVICEMENU.LMenu); + befehl = "systemctl mask " + menupoint; + TaskClass_MWC->TERM_AUSGABE(befehl); + ServiceClass_MWC->ServiceListFill(); + } else if (wahl.compare("journalctl") == 0) { + befehl = "journalctl -b -u " + menupoint; + ServiceClass_MWC->Statusabfrage(TaskClass_MWC->TERM_AUSGABE(befehl)); + } +} /* MenüPoint to command */ +void MenuWinClass::RefreshWindows(){ + refresh(); + wrefresh(MenuWinClass::START.TMPWin1); + redrawwin(MenuWinClass::START.TMPWin2); + wrefresh(MenuWinClass::START.TMPWin2); + touchwin(MenuWinClass::START.TMPWin2); + redrawwin(MenuWinClass::START.TMPWin3); + wrefresh(MenuWinClass::START.TMPWin3); + touchwin(MenuWinClass::START.TMPWin3); + prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); + //prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY()-4, + // MenuWinClass::START.WCX()-46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); + wrefresh(MenuWinClass::START.TMPWin5); +} + +int MenuWinClass::MenuStart(int Key) { +//try { + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[MenuWinClass::MeInAl]); + TMPWIN = TempWin(item_name(current_item(MenuWinClass::TOPMENU.HMMenu)), (MenuID)item_index(current_item(MenuWinClass::TOPMENU.HMMenu))); + string tmpMeNa = string(item_name(current_item(MenuWinClass::TOPMENU.HMMenu))); + string MeAuWa = ""; + ServiceClass_MWC->TableMoveRow(); + while ((Key = wgetch(stdscr)) != KEY_F(10)) { + switch (MenuWinClass::TabKey) { + case 1: { + switch (Key) { + case '?': { ServiceClass_MWC->Statusabfrage(ABOUT_INFO); break; } + case 27: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(1, "++", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case KEY_DOWN: { + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_DOWN_ITEM); + ServiceClass_MWC->TableMoveRow(); + break; + } + case KEY_UP: { + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_UP_ITEM); + ServiceClass_MWC->TableMoveRow(); + break; + } + case KEY_NPAGE: { + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_SCR_DPAGE); + ServiceClass_MWC->TableMoveRow(); + break; + } + case KEY_PPAGE: { + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_SCR_UPAGE); + ServiceClass_MWC->TableMoveRow(); + break; + } + case KEY_END: { + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_LAST_ITEM); + ServiceClass_MWC->TableMoveRow(); + break; + } + case KEY_HOME: { + ServiceClass_MWC->start = 0; + ServiceClass_MWC->selected = 0; + ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_FIRST_ITEM); + ServiceClass_MWC->TableMoveRow(); + break; + } + case 0x09: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(1, "++", 3); + TMPWIN = TempWin("Datei", DATEIMENU); + redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); + wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); + break; + } + case KEY_BTAB: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(1, "--", 3); + TMPWIN = TempWin("Datei", DATEIMENU); + redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); + wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); + break; + } + case KEY_BACKSPACE: { ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_BACK_PATTERN); break; } + case 10: { + string menupoint = MenuWinClass::SERVICEMENU.AktivName; + string befehl = "systemctl status " + menupoint; + ServiceClass_MWC->Statusabfrage(TaskClass_MWC->TERM_AUSGABE(befehl)); + break; } + case 32: { ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_TOGGLE_ITEM); break; } + default: { if (Key > 10 && Key < 128) { + //ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_NEXT_MATCH); + } + break;} + } + if (MenuWinClass_MWC->TabKey == 1) { + curs_set(false); + ServiceClass_MWC->INFOWINDOW(MenuWinClass::SERVICEMENU.AktivName); + MenuWinClass::TOPMENU.LoescheUME(); + MenuWinClass::RefreshWindows(); + } else if (MenuWinClass_MWC->TabKey == 2) { + curs_set(false); + MenuWinClass::RefreshWindows(); + wrefresh(MenuWinClass::START.TMPWin1); + redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); + wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); + } else if (MenuWinClass_MWC->TabKey == 3) { + curs_set(true); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass::PATTERN.c_str(), -1); + MenuWinClass::RefreshWindows(); + } + break; + } /* MainWindow ListMenu */ + case 2: { + switch (Key) { + case '?': { ServiceClass_MWC->Statusabfrage(ABOUT_INFO); break; } + case 27: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "++", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case KEY_DOWN: { menu_driver(TOPMENU.UME.UMEMenu, REQ_DOWN_ITEM); break; } + case KEY_UP: { menu_driver(TOPMENU.UME.UMEMenu, REQ_UP_ITEM); break; } + case KEY_RIGHT: { + MenuWinClass::TOPMENU.LoescheUME(); + menu_driver(MenuWinClass::TOPMENU.HMMenu, REQ_RIGHT_ITEM); + tmpMeNa = string(item_name(current_item(MenuWinClass::TOPMENU.HMMenu))); + TMPWIN = TempWin(item_name(current_item(MenuWinClass::TOPMENU.HMMenu)), (MenuID)item_index(current_item(MenuWinClass::TOPMENU.HMMenu))); + break; + } + case KEY_LEFT: { + MenuWinClass::TOPMENU.LoescheUME(); // delete before menu drive + menu_driver(MenuWinClass::TOPMENU.HMMenu, REQ_LEFT_ITEM); + tmpMeNa = string(item_name(current_item(MenuWinClass::TOPMENU.HMMenu))); + TMPWIN = TempWin(item_name(current_item(MenuWinClass::TOPMENU.HMMenu)), (MenuID)item_index(current_item(MenuWinClass::TOPMENU.HMMenu))); + break; + } + case 0x09: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "++", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case KEY_BTAB: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "--", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case 10: { + MenuWinClass::MeInAl = item_index(current_item(MenuWinClass::TOPMENU.HMMenu)); + StartMenuAuswahl(item_name(current_item(MenuWinClass::TOPMENU.UME.UMEMenu))); + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(2, "++", 2); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; } + } + if (MenuWinClass_MWC->TabKey == 1) { + curs_set(false); + ServiceClass_MWC->INFOWINDOW(MenuWinClass::SERVICEMENU.AktivName); + MenuWinClass::TOPMENU.LoescheUME(); + MenuWinClass::RefreshWindows(); + } else if (MenuWinClass_MWC->TabKey == 2) { + curs_set(false); + MenuWinClass::RefreshWindows(); + wrefresh(MenuWinClass::START.TMPWin1); + redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); + wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); + } else if (MenuWinClass_MWC->TabKey == 3) { + curs_set(true); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass::PATTERN.c_str(), -1); + MenuWinClass::RefreshWindows(); + } + break; + } /* Hauptmenu */ + case 3:{ + int y,x; + getyx(MenuWinClass::START.TMPWin3, y, x); + int curposi = (x - 33); + switch (Key) { + case '?':{ ServiceClass_MWC->Statusabfrage(ABOUT_INFO); break; } + case 27:{ break; } + case 127: + case KEY_BACKSPACE:{ + MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_DEL_BACKSPACE, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); + break; } + case KEY_DC:{ + MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_DEL_DC, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); + break; } + case KEY_RIGHT:{ + MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_RIGHT, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); + break; } + case KEY_LEFT:{ + MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_LEFT, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); + break; } + case 0x09: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(3, "++", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case KEY_BTAB: { + MenuWinClass_MWC->TabKey = TaskClass_MWC->ZahlenWerk(3, "--", 3); + set_current_item(MenuWinClass::TOPMENU.HMMenu, MenuWinClass::TOPMENU.HMItem[0]); + MenuWinClass::TOPMENU.LoescheUME(); + wrefresh(MenuWinClass::START.TMPWin1); + break; + } + case KEY_ENTER: + case 10:{ break; } + default:{ + if (Key > 10 && Key < 128) { + MenuWinClass::PATTERN = ServiceClass_MWC->SearchDriver(REQ_INS_DEFAULT, MenuWinClass::START.TMPWin3, Key, MenuWinClass::PATTERN, curposi); + //ServiceClass_MWC->TableDriver(ServiceClass_MWC->ServiceList, REQ_NEXT_MATCH); + } + break; } + } + if (MenuWinClass_MWC->TabKey == 1) { + curs_set(false); + ServiceClass_MWC->INFOWINDOW(MenuWinClass::SERVICEMENU.AktivName); + MenuWinClass::TOPMENU.LoescheUME(); + MenuWinClass::RefreshWindows(); + } else if (MenuWinClass_MWC->TabKey == 2) { + curs_set(false); + MenuWinClass::RefreshWindows(); + wrefresh(MenuWinClass::START.TMPWin1); + redrawwin(MenuWinClass::TOPMENU.UME.UMEWin); + wrefresh(MenuWinClass::TOPMENU.UME.UMEWin); + } else if (MenuWinClass_MWC->TabKey == 3) { + curs_set(true); + MenuWinClass::RefreshWindows(); + } + break; + }/* search at tmpwin3 */ + } + if (Key == KEY_F(10)) { break; } + } + return Key; +// } catch (const NCursesException* e) { endwin(); std::cerr << e->message << std::endl; cout << e->errorno; return -1; +// } catch (const NCursesException& e) { endwin(); std::cerr << e.message << std::endl; cout << e.errorno; return -1; +// } catch (const std::exception& e) { endwin(); std::cerr << "Exception: " << e.what() << std::endl; cout << EXIT_FAILURE; return -1; } +} /* Menü surf funktion */ + +MenuWinClass::~MenuWinClass(){ + if (MenuWinClass::START.TMPWin1) {werase(MenuWinClass::START.TMPWin1); delwin(MenuWinClass::START.TMPWin1); endwin();} + if (MenuWinClass::START.TMPWin2) {werase(MenuWinClass::START.TMPWin2); delwin(MenuWinClass::START.TMPWin2); endwin();} + if (MenuWinClass::START.TMPWin3) {werase(MenuWinClass::START.TMPWin3); delwin(MenuWinClass::START.TMPWin3); endwin();} + if (MenuWinClass::START.TMPWin4) {werase(MenuWinClass::START.TMPWin4); delwin(MenuWinClass::START.TMPWin4); endwin();} + if (MenuWinClass::START.TMPWin5) {werase(MenuWinClass::START.TMPWin5); delwin(MenuWinClass::START.TMPWin5); endwin();} +} + + diff --git a/MenuWinClass.h b/MenuWinClass.h new file mode 100644 index 0000000..20a6e63 --- /dev/null +++ b/MenuWinClass.h @@ -0,0 +1,205 @@ +#ifndef MENUWINCLASS_H +#define MENUWINCLASS_H + +#include +#include +#include + +using namespace std; + +enum WinID { MENUWIN = 0, MAINWIN = 1, INFOWIN = 2, LISTPAD = 3, DESCWIN = 4, TIMEWIN = 5, ENDWIN = 6 }; +enum MenuID { DATEIMENU = 0, DAEMONMENU = 1, SYSTEMCTLMENU = 2, INFOMENU = 3, MAINMENU = 4, ENDMENU = 5 }; + +struct FENSTER { + int FEID {0}; + string FENAME {""}; + int BorderWeight {1}; + int BorderHeight {1}; + int WCX() {return static_cast(roundf(getmaxx(stdscr)));}; /* W=weight C=column X=x achse */ + int HRY() {return static_cast(roundf(getmaxy(stdscr)));}; /* H=height R=row Y=y achse */ + int HRYw1() {return static_cast(roundf(1));}; + int WCXw1() {return static_cast(roundf(WCX()));}; + WinID TMPWin1ID {MENUWIN}; + WINDOW *TMPWin1 = newwin(HRYw1(), WCXw1(), 0, 0); + int HRYw2() {return static_cast(roundf(HRY() - (HRYw1() + HRYw3())));}; + int WCXw2() {return static_cast(roundf(WCX()));}; + WinID TMPWin2ID {MAINWIN}; + WINDOW *TMPWin2 = newwin(HRYw2(), WCXw2(), 1, 0); + int HRYw3() {return static_cast(roundf(6));}; + int WCXw3() {return static_cast(roundf(WCX()));}; + WinID TMPWin3ID {INFOWIN}; + WINDOW *TMPWin3 = newwin(HRYw3(), WCXw3(), (HRYw1() + HRYw2()), 0); + int HRYw4() {return static_cast(roundf(HRYw2() - ((BorderWeight * 2))));}; + int WCXw4() {return static_cast(roundf(WCXw2() - (BorderWeight * 2)));}; + WinID TMPWin4ID {LISTPAD}; + WINDOW *TMPWin4 = newpad(HRYw4(), WCXw4()); + int HRYw5() {return static_cast(roundf(HRYw3() - ((BorderWeight * 2) + 1)));}; + int WCXw5() {return static_cast(roundf(WCXw3() - ((BorderWeight * 2) + 32)));}; + WinID TMPWin5ID {DESCWIN}; + WINDOW *TMPWin5 = newpad(HRYw5(), WCXw5()); + int HRYtime() {return static_cast(roundf(1));}; + int WCXtime() {return static_cast(roundf(20));}; + WinID TimeWinID {TIMEWIN}; + WINDOW *TimeWin = newwin(HRYtime(), WCXtime(), 0, (WCX() - 20)); + int TMPWinHigh {0}; + FORM *TMPForm1 {nullptr}; + FIELD **TMPField1 {nullptr}; + struct WinSize { + int RAND = 1; + int w {1}; + int h {1}; + int WCX(){return static_cast(roundf(getmaxx(stdscr)));}; + int HRY(){return static_cast(roundf(getmaxy(stdscr)));}; + int WCX_Real(){return static_cast(roundf(WCX() - (2 * RAND)));} + int HRY_Real(){return static_cast(roundf(HRY() - (2 * RAND)));} + int WCX_Center(){return static_cast(roundf(WCX() / 2));}; + int HRY_Center(){return static_cast(roundf(HRY() / 2));}; + int WCX_TmpWin(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin)));}; + int HRY_TmpWin(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin)));}; + int WCX_TmpWinReal(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin) - (2 * RAND)));}; + int HRY_TmpWinReal(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin) - (2 * RAND)));}; + int WCX_TmpWinCenter(WINDOW * tmpwin){return static_cast(roundf(getmaxx(tmpwin) / 2));}; + int HRY_TmpWinCenter(WINDOW * tmpwin){return static_cast(roundf(getmaxy(tmpwin) / 2));}; + unsigned long WinHalfDurch(WINDOW * tmpwin, int TeilDurch){return static_cast(roundf(WCX_TmpWinCenter(tmpwin) / TeilDurch));}; + } WinSize; + struct WinColor { + int BK_MENUWIN = 78; // 78 Text=MY_LIGHT_WHITE, Bk=MY_MARIN_BLUE + int BK_MAINWIN = 78; // 87 Text=MY_MARIN_BLUE, Bk=MY_LIGHT_WHITE + int BK_INFOWIN = 78; + int BK_LISTPAD = 78; + int BK_DESCWIN = 78; + int BK_TIMEWIN = 70; + int BK_HELPWIN = 74; + int WinBk_Main = 78; //Fenster_Background + int WinFo_Main = 78; //Fenster_Foreground + int WinBk_Info = 78; //info fenster_Background + int WinFo_Info = 78; //info fenster foreground + int WinBk_Help = 74; //help fenster Background + int WinFo_Help = 74; //help fenster foreground + } WinColor; + void delwinow(WINDOW *tmpwin){ + if(tmpwin){ + int mx,my,bx,by; + getbegyx(tmpwin,by,bx); + getmaxyx(tmpwin,my,mx); + touchwin(tmpwin); + wborder(tmpwin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); + touchline(tmpwin,bx,mx); + delwin(tmpwin); + endwin(); + tmpwin=nullptr; + } + } + /* void delmenu(WINDOW *tmpwin, MENU *tmpmenu, ITEM **tmpitem){ + if (tmpmenu){ + int E = item_count(tmpmenu); + unpost_menu(tmpmenu); + SAFE_DELETE(tmpmenu); + SAFE_DELETE_ARRAY(tmpitem); + wborder(tmpwin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); + touchline(tmpwin,0,E+1); + delwin(tmpwin); + endwin(); + } + }*/ + void delform(WINDOW *tmpwin, FORM *tmpform, FIELD **tmpfield){ + if (tmpform){ + int mx,my,bx,by; + getbegyx(tmpwin,by,bx); + getmaxyx(tmpwin,my,mx); + unpost_form(tmpform); + SAFE_DELETE(tmpform); + SAFE_DELETE_ARRAY(tmpfield); + wborder(tmpwin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); + touchline(tmpwin,bx,mx); + delwin(tmpwin); + endwin(); + } + } +}; +struct HAUPTMENU { + MenuID MID; + string HMName; + MENU *HMMenu {nullptr}; + ITEM **HMItem {nullptr}; + //############################################### + struct UNTERMENU { + int UMID; + string UMEName; + WINDOW *UMEWin; + MENU *UMEMenu; + ITEM **UMEItem; + }UME; + struct MenuColor { + int BK_MAINMENU = 78; // 78 Text=MY_LIGHT_WHITE, Bk=MY_MARIN_BLUE + int BK_UNTERMENU = 78; // 87 Text=MY_MARIN_BLUE, Bk=MY_LIGHT_WHITE + int BK_AKTIVHAME = 18; + int BK_AKTIVUNME = 18; + int BK_UNUSEDHM = 78; + int BK_UNUSEDUM = 78; + } MenuColor; + void LoescheUME(){ + int E = item_count(UME.UMEMenu); + unpost_menu(UME.UMEMenu); + SAFE_DELETE(UME.UMEMenu); + SAFE_DELETE_ARRAY(UME.UMEItem); + wborder(UME.UMEWin, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '); + touchline(UME.UMEWin,0,E+1); + delwin(UME.UMEWin); + endwin(); + refresh(); + } +}; +struct INAPPMENU { + friend class MenuWinClass; + int LMID; + std::string LMName; + MENU* LMenu {nullptr}; + ITEM** LMItem {nullptr}; + string AktivName = ""; + +}; + +class MenuWinClass: public INAPPMENU { +public: + /*################################################*/ + static FENSTER START; + static HAUPTMENU TOPMENU; + static int MeInAl; + static WINDOW *TMPWIN; + static MENU *TMPMENU; + static INAPPMENU SERVICEMENU; + static int LiMeInAl; + static WINDOW* LiTMPWIN; + static MENU* LiTMPMENU; + static string PATTERN; + static int TabKey;// {1}; + /*#############_WINDOW_###########################*/ + static void StartWin(); + static void StopWin(); + static void SetWinSize(); + static void AppColor(); + static void CreateWin(WINDOW *win, WinID WID); + void FensterDraw(); + static void ResizeHandler(int signal); + void ScrollPad(WINDOW *SubWin, int StartY, int StartX, int Height, int Width, int PadHeight); + void printInMiddle(WINDOW *win, int starty, int startx, int width, char *text, chtype color, char *sp); + /*#############_MENÜ_#############################*/ + static void Hauptmenu(void); + static void DateiMenu(void); + static void DaemonTypeMenu(void); + static void SystemctlMenu(void); + static void InfoMenu(void); + static WINDOW* TempWin(string Name, MenuID MID); + static void StartMenuAuswahl(string wahl); + static void RefreshWindows(); + static int MenuStart(int Key); + /*#############_Constructor/De_###################*/ + MenuWinClass(); + ~MenuWinClass(); + /*################################################*/ +}; + + + +#endif // MENUWINCLASS_H diff --git a/ServiceClass.cpp b/ServiceClass.cpp new file mode 100644 index 0000000..ed8ccca --- /dev/null +++ b/ServiceClass.cpp @@ -0,0 +1,805 @@ +#include + +using namespace std; + +TaskClass *TaskClass_SC = new TaskClass(); +//MenuClass *MenuPtr_SC = new MenuClass(); +ServiceClass *ServiceClass_SC = new ServiceClass(); +//WinClass *WinPtr_SC = new WinClass(); +MenuWinClass *MenuWinClass_SC = new MenuWinClass(); + +int X = 0; +/*##################################################################################*/ +void ServiceClass::ServiceListFill() { + string tmpService = TaskClass_SC->TERM_AUSGABE("systemctl list-unit-files -t "+ systemctlwahl +" | grep '."+ systemctlwahl +"' | awk '{$1=$1};1' | sort"); + string tmpServiceInfo = TaskClass_SC->TERM_AUSGABE("systemctl --all --type="+ systemctlwahl +" | grep '."+ systemctlwahl +"' | awk '{$1=$1};1' | sed 's/● //g' | sort"); + string tmpstr1,tmpstr2; + std::vector tmpaa,tmpbb; + ServiceList.clear(); + vector().swap(ServiceList); + unsigned long X = 0; + istringstream filestream(tmpService.c_str()); + + if (filestream) { + while (getline(filestream,tmpstr1)){ + tmpaa.push_back(string()); + tmpaa = TaskClass_SC->StringTeiler(tmpstr1,' '); + ServiceList.push_back(SERVICES()); + ServiceList[X].SID = static_cast(X); + ServiceList[X].Name = tmpaa[0]; + ServiceList[X].Status = tmpaa[1]; + ServiceList[X].Target = systemctlwahl; + X++; + tmpaa.clear(); + vector().swap(tmpaa); + } + } else { + mvwaddnstr(MenuWinClass::START.TMPWin3, 5, 5, "failed to open or read" ,-1); + } + + X = 0; + istringstream filestream2(tmpServiceInfo.c_str()); + if (filestream2) { + while (getline(filestream2,tmpstr2)){ + tmpbb.push_back(string()); + tmpbb = TaskClass_SC->StringTeiler(tmpstr2,' '); + for(unsigned long Z = 0; Z < static_cast(ServiceList.size()); Z++) { + if (ServiceList[Z].Name.compare(tmpbb[0].c_str())==0) { + ServiceList.push_back(SERVICES()); + ServiceList[Z].Load = tmpbb[1]; + ServiceList[Z].Active = tmpbb[2]; + ServiceList[Z].SubStatus = tmpbb[3]; + for (unsigned long Y = 4; Y < tmpbb.size(); Y++) { + if (Y == 4) { + ServiceList[Z].Description = tmpbb[Y]; + } else { + ServiceList[Z].Description.append(" " + tmpbb[Y]); + } + } + break; + } + } + X++; + tmpbb.clear(); + vector().swap(tmpbb); + } + } else { + mvwaddnstr(MenuWinClass::START.TMPWin3, 5, 5, "failed to open or read" ,-1); + } + SetStateOption(); + // ServiceListe(); +} +void ServiceClass::ServiceListe(){ + if (MenuWinClass_SC->SERVICEMENU.LMItem){unpost_menu(MenuWinClass_SC->SERVICEMENU.LMenu);SAFE_DELETE(MenuWinClass_SC->SERVICEMENU.LMItem);SAFE_DELETE_ARRAY(MenuWinClass_SC->SERVICEMENU.LMItem);} + if (MenuWinClass::START.TMPWin4){werase(MenuWinClass::START.TMPWin4);delwin(MenuWinClass::START.TMPWin4);endwin();} + int mrows = 0; + int mcols = 0; + unsigned long count = ServiceList.size(); + MenuWinClass_SC->SERVICEMENU.LMItem = static_cast(calloc(count, sizeof(ITEM *))); + for (unsigned long i = 0; i < (count-2); i++) + { + MenuWinClass_SC->SERVICEMENU.LMItem[i] = new_item(ServiceList[i].Name.c_str(), ServiceList[i].Status.c_str()); + } + MenuWinClass_SC->SERVICEMENU.LMItem[count-1] = nullptr; + MenuWinClass_SC->SERVICEMENU.LMenu = new_menu(MenuWinClass_SC->SERVICEMENU.LMItem); + scale_menu(MenuWinClass_SC->SERVICEMENU.LMenu, &mrows, &mcols); + MenuWinClass::START.TMPWin4 = newpad(TaskClass_SC->WinFullSize(MenuWinClass::START.TMPWin2,static_cast(count),"H"), TaskClass_SC->WinFullSize(MenuWinClass::START.TMPWin2,mcols,"W")); + wbkgd(MenuWinClass::START.TMPWin4, COLOR_PAIR(MenuWinClass::START.WinColor.BK_LISTPAD)); + set_menu_win(MenuWinClass_SC->SERVICEMENU.LMenu, MenuWinClass::START.TMPWin4); + set_menu_sub(MenuWinClass_SC->SERVICEMENU.LMenu, MenuWinClass::START.TMPWin4); + set_menu_format(MenuWinClass_SC->SERVICEMENU.LMenu, MenuWinClass_SC->START.HRY()-9, 1); //-3 + set_menu_spacing(MenuWinClass_SC->SERVICEMENU.LMenu, 0, 0, 0); + menu_opts_off(MenuWinClass_SC->SERVICEMENU.LMenu, O_SELECTABLE); + menu_opts_on(MenuWinClass_SC->SERVICEMENU.LMenu, O_NONCYCLIC); + set_menu_fore(MenuWinClass_SC->SERVICEMENU.LMenu, COLOR_PAIR(20)|A_BOLD|A_REVERSE); + set_menu_back(MenuWinClass_SC->SERVICEMENU.LMenu, COLOR_PAIR(78)|A_BOLD); + set_menu_grey(MenuWinClass_SC->SERVICEMENU.LMenu, COLOR_PAIR(30)); + set_menu_mark(MenuWinClass_SC->SERVICEMENU.LMenu, ""); + post_menu(MenuWinClass_SC->SERVICEMENU.LMenu); +} +void ServiceClass::INFOWINDOW(string Name){ + werase(MenuWinClass::START.TMPWin5); + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 1, "STATE: " ,-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 1, "LOAD: " ,-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 1, "AKTIVE: " ,-1); //9 + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 1, "SUB: " ,-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 26, "DESC:" ,-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 26, "Suche:" ,-1); + //mvwaddnstr(MenuWinClass::START.TMPWin3, 6, 1, " " ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(MenuWinClass::START.WinColor.BK_INFOWIN)|A_BOLD,nullptr); + + for (unsigned long X = 0; X < static_cast(ServiceList.size());X++){ + if (ServiceList[X].Name.compare(Name)==0) { + switch (ServiceList[X].state) { + case UNIT_STATE_ENABLED: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + break; + case UNIT_STATE_BAD: + case UNIT_STATE_DISABLED: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + break; + case UNIT_STATE_STATIC: + case UNIT_STATE_MASKED: + case UNIT_STATE_GENERATED: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); + break; + case UNIT_STATE_TMP: + default: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 1, 9, ServiceList[X].Status.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + break; + } // ende status switch + switch (ServiceList[X].load) { + case UNIT_LOADSTATE_LOADED: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 9, ServiceList[X].Load.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + break; + case UNIT_LOADSTATE_NOTFOUND: + case UNIT_LOADSTATE_UNLOAD: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 9, ServiceList[X].Load.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + break; + default: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 2, 9, ServiceList[X].Load.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + break; + } // ende load switch + switch (ServiceList[X].active) { + case UNIT_ACTIVESTATE_ACTIVE: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 9, ServiceList[X].Active.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + break; + case UNIT_ACTIVESTATE_INACTIVE: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 9, ServiceList[X].Active.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + break; + default: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 3, 9, ServiceList[X].Active.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + break; + } + switch (ServiceList[X].substate) { + case UNIT_SUBSTATE_RUNNING: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Green)|A_BOLD,nullptr); + break; + case UNIT_SUBSTATE_CONNECTED: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Yellow)|A_BOLD,nullptr); + case UNIT_SUBSTATE_INVALID: + case UNIT_SUBSTATE_EXITED: + case UNIT_SUBSTATE_DEAD: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.Red)|A_BOLD,nullptr); + break; + default: + wattr_on(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 9, ServiceList[X].SubStatus.c_str() ,-1); + wattr_off(MenuWinClass::START.TMPWin3, COLOR_PAIR(StateColor.White)|A_BOLD,nullptr); + break; + } + //wattr_on(MenuWinClass::START.TMPWin5, COLOR_PAIR(78)|A_BOLD,nullptr); + mvwaddnstr(MenuWinClass::START.TMPWin5, 0, 0, ServiceList[X].Description.c_str() ,-1); + //wattr_off(MenuWinClass::START.TMPWin5, COLOR_PAIR(78)|A_BOLD,nullptr); + } + } +} +void ServiceClass::Statusabfrage(string ausgabestatus) { + int hoehe; + int rowy = MenuWinClass_SC->START.HRY()-4; + int ROWS = 0; int Key; + STATUSWIN = newwin(MenuWinClass_SC->START.HRY()-2, MenuWinClass_SC->START.WCX()-2, 1, 1); + wbkgd(STATUSWIN, COLOR_PAIR(MenuWinClass::START.WinColor.WinBk_Help)|A_BOLD); + box(STATUSWIN, 0,0); + + hoehe = TaskClass_SC->Zeilen(ausgabestatus.c_str(),MenuWinClass_SC->START.WCX()-4); + STATUSINFO = newpad(hoehe, MenuWinClass_SC->START.WCX()-4); + wbkgd(STATUSINFO, COLOR_PAIR(MenuWinClass::START.WinColor.WinBk_Help)|A_BOLD); + STATUSINFO = derwin(STATUSWIN, MenuWinClass_SC->START.HRY()-4, MenuWinClass_SC->START.WCX()-4, 1, 1); + wattr_on(STATUSINFO, COLOR_PAIR(MenuWinClass::START.WinColor.WinFo_Help)|A_BOLD,nullptr); + mvwaddnstr(STATUSINFO, 0, 0, ausgabestatus.c_str(),-1); + wattr_off(STATUSINFO, COLOR_PAIR(MenuWinClass::START.WinColor.WinFo_Info)|A_BOLD,nullptr); + wattr_on(STATUSWIN, COLOR_PAIR(70)|A_BOLD,nullptr); + mvwaddnstr(STATUSWIN, MenuWinClass_SC->START.HRY() -3, MenuWinClass_SC->START.WCX()-15, "[ EXIT ESC ]" ,-1); + wattr_off(STATUSWIN, COLOR_PAIR(70)|A_BOLD,nullptr); + + wrefresh(STATUSWIN); + touchwin(STATUSWIN); + prefresh(STATUSINFO, 0, 0, 0, 0, MenuWinClass_SC->START.HRY() -4, MenuWinClass_SC->START.WCX()-4); + + while ((Key=getch()) != 27) { + switch (Key) { + case KEY_DOWN:{ + if ((ROWS + rowy +1) >= hoehe){ + ROWS = hoehe; + }else { + ROWS++; + } + break;} + case KEY_UP:{ + if (ROWS <= 0){ + ROWS = 0; + }else { + ROWS--; + } + break;} + default:{ + break; } + } + refresh(); + touchwin(STATUSWIN); + prefresh(STATUSINFO, ROWS, 0, 0, 0, MenuWinClass_SC->START.HRY() -4, MenuWinClass_SC->START.WCX()-4); + } + if (STATUSINFO){werase(STATUSINFO);delwin(STATUSINFO);} + if (STATUSWIN){werase(STATUSWIN);delwin(STATUSWIN);} + redrawwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + redrawwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + prefresh(MenuWinClass_SC->START.TMPWin4, 0, 0, 2, 1, MenuWinClass_SC->START.HRYw4() + 1, MenuWinClass_SC->START.WCXw4()); + prefresh(MenuWinClass_SC->START.TMPWin5, 0, 0, MenuWinClass_SC->START.HRY()-4, MenuWinClass_SC->START.WCX()-46, MenuWinClass_SC->START.HRYw5(), MenuWinClass_SC->START.WCXw5()); +} +void ServiceClass::ENDE() { +// try { + if (MenuWinClass::START.TimeWin) {werase(MenuWinClass::START.TimeWin); delwin(MenuWinClass::START.TimeWin); endwin();} + if (MenuWinClass::SERVICEMENU.LMItem) {unpost_menu(MenuWinClass::SERVICEMENU.LMenu); SAFE_DELETE(MenuWinClass::SERVICEMENU.LMItem); SAFE_DELETE_ARRAY(MenuWinClass::SERVICEMENU.LMItem);} + if (MenuWinClass::TOPMENU.UME.UMEItem) { unpost_menu(MenuWinClass::TOPMENU.UME.UMEMenu); SAFE_DELETE(MenuWinClass::TOPMENU.UME.UMEItem); SAFE_DELETE_ARRAY(MenuWinClass::TOPMENU.UME.UMEItem);} + if (MenuWinClass::TOPMENU.HMItem) { unpost_menu(MenuWinClass::TOPMENU.HMMenu); SAFE_DELETE(MenuWinClass::TOPMENU.HMItem); SAFE_DELETE_ARRAY(MenuWinClass::TOPMENU.HMItem);} + if (MenuWinClass::START.TMPWin5) {werase(MenuWinClass::START.TMPWin5); delwin(MenuWinClass::START.TMPWin5); endwin();} + if (MenuWinClass::START.TMPWin4) {werase(MenuWinClass::START.TMPWin4); delwin(MenuWinClass::START.TMPWin4); endwin();} + if (MenuWinClass::START.TMPWin3) {werase(MenuWinClass::START.TMPWin3); delwin(MenuWinClass::START.TMPWin3); endwin();} + if (MenuWinClass::START.TMPWin2) {werase(MenuWinClass::START.TMPWin2); delwin(MenuWinClass::START.TMPWin2); endwin();} + if (MenuWinClass::START.TMPWin1) {werase(MenuWinClass::START.TMPWin1); delwin(MenuWinClass::START.TMPWin1); endwin();} + werase(stdscr); + ServiceList.clear(); + vector(ServiceList).swap (ServiceList); + clear(); +// } catch (const NCursesException *e) { endwin(); std::cerr << e->message << std::endl; cout << e->errorno; +// } catch (const NCursesException &e) { endwin(); std::cerr << e.message << std::endl; cout << e.errorno; +// } catch (const std::exception &e) { endwin(); std::cerr << "Exception: " << e.what() << std::endl; cout << EXIT_FAILURE; } +} +/*##################################################################################*/ +// new Systemd bestandteile +void ServiceClass::SetStateOption() { //SERVICES unit // pushitem + //vector().swap(ServiceList); + //UnitItem *item = new UnitItem(); + //string name(unit->id); + //item->Name = name; + //item->target = name.substr(name.find_last_of('.') + 1, name.length()); + //item->description = string(unit->description == nullptr ? "" : unit->description); + //item->Status = string(unit->state == nullptr ? "" : unit->state); + //item->SubStatus = string(unit->subState == nullptr ? "" : unit->subState); + //item->LoadStatus = string(unit->loadState == nullptr ? "" : unit->loadState); + //item->ActiveStatus = string(unit->activeState == nullptr ? "" : unit->activeState); + //item->ServicePath = string(unit->unitPath == nullptr ? "" : unit->unitPath); + + for (unsigned long i =0; istate); + //string sub(unit->substate == nullptr ? "" : unit->substate); + //string load(unit->load == nullptr ? "" : unit->load); + //string aktiv(unit->active == nullptr ? "" : unit->active); + if (ServiceList[i].Status.compare("enabled") == 0) { + ServiceList[i].state = UNIT_STATE_ENABLED; + } else if (ServiceList[i].Status.compare("masked") == 0) { + ServiceList[i].state = UNIT_STATE_MASKED; + } else if (ServiceList[i].Status.compare("static") == 0) { + ServiceList[i].state = UNIT_STATE_STATIC; + } else if (ServiceList[i].Status.compare("bad") == 0 || ServiceList[i].Status.compare("removed") == 0) { + ServiceList[i].state = UNIT_STATE_BAD; + } else if (ServiceList[i].Status.compare("disabled") == 0){ + ServiceList[i].state = UNIT_STATE_DISABLED; + } else if (ServiceList[i].Status.compare("generated") == 0){ + ServiceList[i].state = UNIT_STATE_GENERATED; + } else{ + ServiceList[i].state = UNIT_STATE_TMP; + } + if (!ServiceList[i].SubStatus.empty()) { + if (ServiceList[i].SubStatus.compare("running") == 0) { + ServiceList[i].substate = UNIT_SUBSTATE_RUNNING; + } else if (ServiceList[i].SubStatus.compare("dead") == 0) { + ServiceList[i].substate = UNIT_SUBSTATE_DEAD; + } else if (ServiceList[i].SubStatus.compare("exited") == 0) { + ServiceList[i].substate = UNIT_SUBSTATE_EXITED; + } else{ + ServiceList[i].substate = UNIT_SUBSTATE_CONNECTED; + } + } else { + ServiceList[i].substate = UNIT_SUBSTATE_INVALID; + } + if (!ServiceList[i].Load.empty()) { + if (ServiceList[i].Load.compare("loaded") == 0) { + ServiceList[i].load = UNIT_LOADSTATE_LOADED; + } else if (ServiceList[i].Load.compare("not-found") == 0) { + ServiceList[i].load = UNIT_LOADSTATE_NOTFOUND; + } else if (ServiceList[i].Load.compare("unloaded") == 0) { + ServiceList[i].load = UNIT_LOADSTATE_UNLOAD; + } + } else { + ServiceList[i].load = UNIT_SUBSTATE_INVALID; + } + if (!ServiceList[i].Active.empty()) { + if (ServiceList[i].Active.compare("active") == 0) { + ServiceList[i].active = UNIT_ACTIVESTATE_ACTIVE; + } else if (ServiceList[i].Active.compare("inactive") == 0) { + ServiceList[i].active = UNIT_ACTIVESTATE_INACTIVE; + } + } else { + ServiceList[i].active = UNIT_SUBSTATE_INVALID; + } + } else { + ServiceList[i].state = UNIT_STATE_MASKED; + } + } + // freeUnitInfo(unit); + // items.push_back(item); + BuildWin(); +}; +void ServiceClass::BuildWin() { + if (MenuWinClass_SC->SERVICEMENU.LMItem){unpost_menu(MenuWinClass_SC->SERVICEMENU.LMenu);SAFE_DELETE(MenuWinClass_SC->SERVICEMENU.LMItem);SAFE_DELETE_ARRAY(MenuWinClass_SC->SERVICEMENU.LMItem);} + if (MenuWinClass_SC->START.TMPWin4){werase(MenuWinClass_SC->START.TMPWin4);delwin(MenuWinClass_SC->START.TMPWin4);endwin();} + StateColor.Green = 28; + StateColor.Yellow = 38; + StateColor.Red = 18; + StateColor.White = 78; + unsigned long count = ServiceList.size(); + MenuWinClass_SC->START.TMPWin4 = newpad(static_cast(count), MenuWinClass_SC->START.WinSize.WCX_TmpWinReal(MenuWinClass::START.TMPWin2)); + wbkgd(MenuWinClass_SC->START.TMPWin4, COLOR_PAIR(MenuWinClass::START.WinColor.BK_LISTPAD)); + + for (unsigned long i = 0; i < ServiceList.size(); i++) { + TableDraw(ServiceList[i], static_cast(i)); + //TableMoveRow(); + } +} +void ServiceClass::TableMoveRow() { //drawUnits + if (ServiceList.empty()) { + // updateUnits(); + ServiceListFill(); + } + // const int oneX = unit->sub & A_COLOR; + for (int i = 0; i < MenuWinClass_SC->START.HRYw4(); i++) { + if ((i + ServiceClass::start) > static_cast(ServiceList.size() - 1)) { + break; + } + SERVICES unit = ServiceList[static_cast(start + i)]; + if (i == selected) { + StateColor.SetSignalColor(17, 37, 27, 87); + MenuWinClass::SERVICEMENU.AktivName = ServiceList[static_cast(start + selected)].Name; + wattron(MenuWinClass_SC->START.TMPWin4, COLOR_PAIR(87)|A_BOLD); + } + TableDraw(unit, i); + wattroff(MenuWinClass_SC->START.TMPWin4, COLOR_PAIR(87)|A_BOLD); + StateColor.SetSignalColor(18, 38, 28, 78); + } + /* if (inputFor == INPUT_FOR_LIST) { + // drawInfo(); + // } else { + // drawSearch(); + // }*/ + refresh(); + touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); + prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY() - 4, MenuWinClass::START.WCX() - 46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); +} +void ServiceClass::TableDraw(SERVICES unit, int y) { + if (unit.Target.compare(systemctlwahl)==0) { + //unit.SID = unit.SID++; + if (unit.Name.size() < static_cast(MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2))) { + unit.Name.resize(MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2), ' '); + }else { + unit.Name.resize(MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)); + } + if (unit.Status.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)) { + unit.Status.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); + }else { + unit.Status.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); + } + if (unit.SubStatus.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4) ) { + unit.SubStatus.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); + } else { + unit.SubStatus.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); + } + if (unit.Active.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4) ) { + unit.Active.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); + }else { + unit.Active.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); + } + if (unit.Load.size() <= MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4) ) { + unit.Load.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4), ' '); + }else { + unit.Load.resize(MenuWinClass_SC->START.WinSize.WinHalfDurch(MenuWinClass_SC->START.TMPWin2, 4)); + } + + std::string name(unit.Name); + + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.RAND-1, "%s", name.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + + switch (unit.state) { + case UNIT_STATE_ENABLED: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%s ", unit.Status.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + break; + case UNIT_STATE_BAD: + case UNIT_STATE_DISABLED: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%s ", unit.Status.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + break; + case UNIT_STATE_STATIC: + case UNIT_STATE_MASKED: + case UNIT_STATE_GENERATED: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%s ", unit.Status.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); + break; + case UNIT_STATE_TMP: + default: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, unit.Status.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+1, "%9s", unit.Status.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + break; + } + switch (unit.load) { + case UNIT_LOADSTATE_LOADED: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +11, unit.Load.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX() - 11, unit.LoadStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + break; + case UNIT_LOADSTATE_NOTFOUND: + case UNIT_LOADSTATE_UNLOAD: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +11, unit.Load.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX()- 11, unit.LoadStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + break; + default: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +11, unit.Load.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX() - 11, unit.LoadStatus.c_str()); // 3 jetzt 9 + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + break; + } + switch (unit.active) { + case UNIT_ACTIVESTATE_ACTIVE: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +21, unit.Active.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX()- 21, unit.ActiveStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + break; + case UNIT_ACTIVESTATE_INACTIVE: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +21, unit.Active.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX()- 21, unit.ActiveStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + break; + default: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +21, unit.Active.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX() - 11, unit.LoadStatus.c_str()); // 3 jetzt 9 + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + break; + } + switch (unit.substate) { + case UNIT_SUBSTATE_RUNNING: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Green)|A_BOLD); + break; + case UNIT_SUBSTATE_CONNECTED: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Yellow)|A_BOLD); + case UNIT_SUBSTATE_INVALID: + case UNIT_SUBSTATE_EXITED: + case UNIT_SUBSTATE_DEAD: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.Red)|A_BOLD); + break; + default: + wattron(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + mvwaddnstr(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2) +31, unit.SubStatus.c_str(), -1); + //mvwprintw(MenuWinClass::START.TMPWin4, y, MenuWinClass_SC->START.WinSize.WCX_TmpWinCenter(MenuWinClass_SC->START.TMPWin2)+11, "%10s", unit.SubStatus.c_str()); // 3 jetzt 9 + wattroff(MenuWinClass::START.TMPWin4, COLOR_PAIR(StateColor.White)|A_BOLD); + break; + } + } +} +void ServiceClass::TableDriver(std::vector SRVLIST,int key){ + int ps = MenuWinClass_SC->START.HRYw4()-1; + switch(key){ + case REQ_LEFT_ITEM:{ + break;} + case REQ_RIGHT_ITEM:{ + break;} + case REQ_UP_ITEM:{ + if (start > 0 && selected < ps) { // / 2 + start--; + } else if (selected > 0) { + selected--; + } + if (SRVLIST[static_cast(start + selected)].Name.empty()) { + ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); + } + break;} + case REQ_DOWN_ITEM:{ + int offset = start + selected; + int max = static_cast(SRVLIST.size()); + if ((start + ps) < max) { + if (selected < ps) { // / 2 + selected++; + } else { + start++; + } + } else if (offset < max) { + selected++; + } + if (offset >= max) { + selected = ps; + } + if (SRVLIST[static_cast(start + selected)].Name.empty()) { + ServiceClass::TableDriver(SRVLIST,REQ_DOWN_ITEM); + } + break;} + case REQ_SCR_ULINE:{ + break;} + case REQ_SCR_DLINE:{ + break;} + case REQ_SCR_UPAGE:{ + if (start > 0) { + start -= ps; + } + if (start < 0) { + start = 0; + selected = 0; + } + if (SRVLIST[static_cast(start + selected)].Name.empty()) { + ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); + } + break;} + case REQ_SCR_DPAGE:{ + int max = static_cast(SRVLIST.size()-1); + if ((start + ps) < max) { // / 2 + start += ps; + } + if ((start + ps) > max) { + start = max - ps; + selected = ps; + } + if (SRVLIST[static_cast(start + selected)].Name.empty()) { + ServiceClass::TableDriver(SRVLIST,REQ_DOWN_ITEM); + } + break;} + case REQ_FIRST_ITEM:{ + if (start > 0 && selected < ps) { // / 2 + start--; + } else if (selected > 0) { + selected--; + } + if (SRVLIST[static_cast(start + selected)].Name.empty()) { + ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); + } + break;} + case REQ_LAST_ITEM:{ + int max = static_cast(SRVLIST.size()-1); + start = max - ps; + selected = ps; + if (SRVLIST[static_cast(start + selected)].Name.empty()) { + ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); + } + break;} + case REQ_NEXT_ITEM:{ + if (start > 0 && selected < ps) { // / 2 + start--; + } else if (selected > 0) { + selected--; + } + if (SRVLIST[static_cast(start + selected)].Name.empty()) { + ServiceClass::TableDriver(SRVLIST,REQ_UP_ITEM); + } + break;} + case REQ_PREV_ITEM:{ + int offset = start + selected; + int max = static_cast(SRVLIST.size()); + + if ((start + ps) < max) { + if (selected < ps) { // / 2 + selected++; + } else { + start++; + } + } else if (offset < max) { + selected++; + } + if (offset >= max) { + selected = ps; + } + if (SRVLIST[static_cast(start + selected)].Name.empty()) { + ServiceClass::TableDriver(SRVLIST,REQ_DOWN_ITEM); + } + break;} + case REQ_TOGGLE_ITEM:{ + break;} + case REQ_CLEAR_PATTERN:{ + break;} + case REQ_BACK_PATTERN:{ + if (MenuWinClass_SC->PATTERN.size()>0) {MenuWinClass_SC->PATTERN.pop_back(); MenuWinClass_SC->PATTERN.shrink_to_fit();}; + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, " ",-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); + break;} + case REQ_NEXT_MATCH:{ + int position = 0; + for (auto unit : ServiceList) { + if (!unit.Name.empty()) { + if (unit.Name.rfind(MenuWinClass_SC->PATTERN.c_str()) != std::string::npos) { + lastFound = position; + moveTo(position); } + position++; + } else { + continue; + } + } + if (lastFound == 0) { + MenuWinClass_SC->PATTERN.clear(); + return; + } + lastFound = 0; + TableDriver(ServiceList,REQ_NEXT_MATCH); + break;} + case REQ_PREV_MATCH:{ + break;} + } +} +void ServiceClass::searchInput() { + int key; + while ((key=wgetch(stdscr)) != KEY_F(10)) { + switch(key) { + case 27:{ // ESC + MenuWinClass_SC->PATTERN.clear(); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, " ",-1); + break;} + case KEY_ENTER: // Ctrl-M + case 10: {// Enter + TableDriver(ServiceList,REQ_NEXT_MATCH); + break;} + case KEY_BACKSPACE:{ + if (MenuWinClass_SC->PATTERN.size()>0) {MenuWinClass_SC->PATTERN.pop_back(); MenuWinClass_SC->PATTERN.shrink_to_fit();}; + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, " ",-1); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); + TableDriver(ServiceList,REQ_NEXT_MATCH); + break;} + default:{ + if (key > 10 && key < 128) { + sprintf(searchString,"%c",key); + MenuWinClass_SC->PATTERN.append(string(searchString)); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); + TableDriver(ServiceList,REQ_NEXT_MATCH); + } + break;} + } + refresh(); + touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin2)); + touchwin(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + wrefresh(TaskClass_SC->ClearWindow(MenuWinClass::START.TMPWin3)); + prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); + prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY()-4, MenuWinClass::START.WCX()-46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); + } +} +void ServiceClass::drawSearch() { + /* * Lets indicate it is a search input */ + char text[BUFSIZ] = ""; + if (lastFound == 0) { + sprintf(searchString,"%s",text); + MenuWinClass_SC->PATTERN.append(string(searchString)); + //sprintf(text, "%s%s", text, searchString); + } + /* * Draw it using any visible, light color */ + //drawStatus(1, text, 0); + mvwaddnstr(MenuWinClass::START.TMPWin3, 4, 33, MenuWinClass_SC->PATTERN.c_str(),-1); +} +void ServiceClass::moveTo(int position) { + start = selected = 0; + for (int i = 0; i < position; i++) { + TableDriver(ServiceList,REQ_UP_ITEM); + } +} + +string ServiceClass::SearchDriver(SeaReq drv, WINDOW *Win, int Key, string Search, int Posi) { + static const int Start = 33; + int hry, wcx; + getyx(Win, hry, wcx); + int MaxSearchTextLaenge = (MenuWinClass::START.WCX() - (Start + MenuWinClass::START.BorderWeight)); + int Laenge = Search.length(); + int AbsolPosi; + AbsolPosi = (Start + Posi); + char TmpKey[BUFSIZE] = ""; + sprintf(TmpKey, "%c", Key); + string dummi; + dummi.assign(MaxSearchTextLaenge,' '); + switch (drv) { + case REQ_DEL_BACKSPACE:{ + if ((wcx > Start) && (wcx <= (Start + Laenge))) { + Search.erase(Posi-1, 1); + mvwaddnstr(Win, 4, Start, dummi.c_str(), -1); + mvwaddnstr(Win, 4, Start, Search.c_str(), -1); + wmove(Win, 4, AbsolPosi - 1); + } + break; } + case REQ_DEL_DC:{ + if ((wcx > Start) && (wcx < (Start + Laenge))) { + Search.erase(Posi+1, 1); + mvwaddnstr(Win, 4, Start, dummi.c_str(), -1); + mvwaddnstr(Win, 4, Start, Search.c_str(), -1); + wmove(Win, 4, AbsolPosi - 1); + } + break; } + case REQ_RIGHT:{ + if ((wcx > Start) && (wcx <= (Start + Laenge))) { + //if ((Posi != 0) || ((Posi-1) <= Laenge)) { + int cursorbewegen = AbsolPosi +1; + wmove(Win, 4, cursorbewegen); + } + break; } + case REQ_LEFT:{ + if ((wcx > Start) && (wcx <= (Start + Laenge))) { + //if ((Posi != 0) || ((Posi-1) <= Laenge)) { + int cursorbewegen = AbsolPosi -1; + wmove(Win, 4, cursorbewegen); + } + break; } + case REQ_INS_DEFAULT:{ + if (Key > 10 && Key < 128) { + if (Posi < Laenge) { + Search.insert(Posi, string(TmpKey)); + mvwaddnstr(Win, 4, Start, Search.c_str(), -1); + wmove(Win, 4, (Start + Posi)); + } else { + Search.append(string(TmpKey)); + mvwaddnstr(Win, 4, Start, Search.c_str(), -1); + } + }; + break;} + } + wrefresh(Win); + return Search; +} +/*##################################################################################*/ +ServiceClass::ServiceClass(){ + systemctlwahl = "service"; +} +ServiceClass::~ServiceClass(){ + +} +/*##################################################################################*/ diff --git a/ServiceClass.h b/ServiceClass.h new file mode 100644 index 0000000..914b2e8 --- /dev/null +++ b/ServiceClass.h @@ -0,0 +1,106 @@ +#ifndef SERVICECLASS_H +#define SERVICECLASS_H + +#include +#include +#include + +//enum _INPUT_FOR { +// INPUT_FOR_LIST, +// INPUT_FOR_SEARCH +//}; + +#define ERR_PREFIX "Failed: " +#define SYSV_INSTALL_EXEC "/lib/systemd/systemd-sysv-install" + +enum SeaReq { REQ_RIGHT, REQ_LEFT, REQ_DEL_DC, REQ_DEL_BACKSPACE, REQ_INS_DEFAULT}; +enum { + UNIT_STATE_DISABLED = 0x01, + UNIT_STATE_ENABLED = 0x02, + UNIT_STATE_STATIC = 0x03, + UNIT_STATE_BAD = 0x04, + UNIT_STATE_MASKED = 0x05, + UNIT_STATE_TMP = 0x06, + UNIT_STATE_GENERATED = 0x07, + UNIT_SUBSTATE_RUNNING = 0x08, + UNIT_SUBSTATE_CONNECTED = 0x09, + UNIT_SUBSTATE_INVALID = 0x0a, + UNIT_SUBSTATE_TMP = 0x0b, + UNIT_SUBSTATE_DEAD = 0x0c, + UNIT_SUBSTATE_EXITED = 0x0d, + UNIT_LOADSTATE_LOADED = 0x0e, + UNIT_LOADSTATE_NOTFOUND = 0x0f, + UNIT_LOADSTATE_UNLOAD = 0x10, + UNIT_ACTIVESTATE_ACTIVE = 0x11, + UNIT_ACTIVESTATE_INACTIVE = 0x12 +}; +enum STATE_FLAGS { + STATE_FLAGS_ENABLE, + STATE_FLAGS_DISABLE, + STATE_FLAGS_DISABLE_ISO +}; + +struct SignalColor { + int Red {18}; //Error or inaktive + int Yellow {38}; //Warn or fails + int Green {28}; //infoS + int White {78}; //all all right + void SetSignalColor(int RED = 18, int YELLOW = 38, int GREEN = 28, int WHITE = 78) {Red = RED; Yellow = YELLOW; Green = GREEN; White = WHITE;}; +}; + +//typedef struct SERVICES SERVICES; +struct SERVICES { + int SID; + std::string Name; + std::string Target; //(){return Name.substr(Name.find(".")+1,Name.length());}; + std::string Path; + std::string Description; + int state; + std::string Status; + int load; + std::string Load; + int active; + std::string Active; + int substate; + std::string SubStatus; +}; + +class ServiceClass { +public: + /*#####################################################*/ + vector ServiceList; + WINDOW *STATUSWIN; + WINDOW *STATUSINFO; + string systemctlwahl; + /*#####################################################*/ + SignalColor StateColor; + char searchString[BUFSIZ] = ""; + unsigned char inputFor = 0; + int lastFound = 0; + int selected = 0; + int start = 0; + string AktivName {""}; + /*#####################################################*/ + void ServiceListFill(); + void ServiceListe(); + void INFOWINDOW(string Name); + void Statusabfrage(string ausgabestatus); + void ENDE(); + /*#####################################################*/ + void SetStateOption(); /*SERVICES unit*/ + void BuildWin(); + void TableMoveRow(); + void TableDraw(SERVICES unit, int y); + void TableDriver(vector SRVLIST, int key); + void moveTo(int position); + void searchInput(); + void drawSearch(); + string SearchDriver(SeaReq drv, WINDOW *Win, int Key, string Search, int Posi); + /*#####################################################*/ + ServiceClass(); + ~ServiceClass(); +}; + + + +#endif // SERVICECLASS_H diff --git a/ServiceControl.pro b/ServiceControl.pro new file mode 100644 index 0000000..a5c39c2 --- /dev/null +++ b/ServiceControl.pro @@ -0,0 +1,101 @@ +TEMPLATE = app +CONFIG += console c++17 +CONFIG -= app_bundle +CONFIG -= qt + +############################################################################ +## Meine einstellung immer ohne shadow build in QT creator!!! # +############################################################################ +PROGRAMMNAME = ServiceControl +TARGET = bin/$$PROGRAMMNAME +VERSION = v1.0.4 +QMAKE_TARGET_PRODUCT = "$${PROGRAMMNAME}" +QMAKE_TARGET_COMPANY = "HOMELAND" +QMAKE_TARGET_COPYRIGHT = "Copyright (c) by Aktony" +DEFINES += APP_VERSION=\"\\\"$${VERSION}\\\"\" \ + APP_PRODUCT=\"\\\"$${QMAKE_TARGET_PRODUCT}\\\"\" \ + APP_COMPANY=\"\\\"$${QMAKE_TARGET_COMPANY}\\\"\" \ + APP_COPYRIGHT=\"\\\"$${QMAKE_TARGET_COPYRIGHT}\\\"\" +#unix:!macx:QMAKE_DEL_FILE = rm -f +#unix:!macx:QMAKE_DEL_DIR = rm -rf +#unix:!macx:OUT_PWD = "$$PWD/Build_$$VERSION" +DESTDIR = "$$PWD/Build_$$VERSION/debug/$$PROGRAMMNAME" +############################################################################ +#__________________release and debug_______________________________________# +############################################################################ +CONFIG(debug, debug|release) { + DEFINES += DEBUG_MODE + DESTDIR = "$$PWD/Build_$$VERSION/debug/$$PROGRAMMNAME" + QMAKE_MAKEFILE = Makefile.debug + MAKEFILE = Makefile.debug +} else:CONFIG(release, debug|release) { + DEFINES += RELEASE_MODE + DESTDIR = "$$PWD/Build_$$VERSION/release/$$PROGRAMMNAME" + QMAKE_MAKEFILE = Makefile.release + MAKEFILE = Makefile.release +} else:CONFIG(force_debug_info) { + DEFINES += PROFILE_MODE + DESTDIR = "$$PWD/Build_$$VERSION/profile/$$PROGRAMMNAME" + QMAKE_MAKEFILE = Makefile.profile + MAKEFILE = Makefile.profile +} else { + DEFINES += DEBUG_MODE + DESTDIR = "$$PWD/Build_$$VERSION/debug/$$PROGRAMMNAME" + QMAKE_MAKEFILE = Makefile.debug + MAKEFILE = Makefile.debug +} + +RCC_DIR = "$$PWD/Build_$$VERSION/RCCFiles" +UI_DIR = "$$PWD/Build_$$VERSION/UICFiles" +MOC_DIR = "$$PWD/Build_$$VERSION/MOCFiles" +OBJECTS_DIR = "$$PWD/Build_$$VERSION/ObjFiles" + +message($$_PRO_FILE_ " - Profile!") +message($$_PRO_FILE_PWD_ " - Profile dir!") +message($$DESTDIR " - Destdir Name!") +message($$MAKEFILE " - Makefile Name!") +message($$OUT_PWD " - out_pwd dir!") +message($$QMAKE_MAKEFILE " - Qmakefile Name!") +############################################################################ +#__________________Copy files to build directory___________________________# +############################################################################ +#copydata0.commands = $(DEL_DIR) $$DESTDIR/config +#copydata1.commands = $(COPY_FILE) $$PWD/lib/libLogWriter.a $$DESTDIR/lib/libLogWriter.a +#copydata2.commands = $(COPY_FILE) $$PWD/lib/libUserGroupList.a $$DESTDIR/lib/libUserGroupList.a +#first.depends = $(first) copydata0 copydata1 copydata2 +#export(first.depends) +#export(copydata0.commands) +#export(copydata1.commands) +#export(copydata2.commands) +#QMAKE_EXTRA_TARGETS += first copydata0 copydata1 copydata2 +unix:!macx: LIBS += -lncurses++w -Wall -lncursesw -lmenuw -lmenu -lformw -lpanelw -pthread -lreadline -Wreturn-type -lstdc++fs -lsystemd +#-lpam -lpam_misc -lxcb +#unix:!macx:LIBS_PRIVATE += $$DESTDIR/lib/libUserGroupList.a +#unix:!macx:LIBS_PRIVATE += $$DESTDIR/lib/libLogWriter.a +#unix:!macx: LIBS += -L$$DESTDIR/lib/ -lLogWriter -lUserGroupList +#$$DESTDIR/lib/libconfigator.a $$DESTDIR/lib/libdragonfail.a $$DESTDIR/lib/libtermbox.a $$DESTDIR/lib/libtestoasterror.a +#unix:!macx: LIBS += -L$$DESTDIR/lib/ -largoat -lconfigator -ldragonfail -ltermbox -ltestoasterror +########################################################################### +# Ende !!! # +########################################################################### + +SOURCES += \ +# MenuClass.cpp \ +# WinClass.cpp \ + MenuWinClass.cpp \ + ServiceClass.cpp \ + Start.cpp \ + TaskClass.cpp + + +HEADERS += \ + Info.h \ +# WinClass.h \ +# MenuClass.h \ + MenuWinClass.h \ + ServiceClass.h \ + TaskClass.h + +DISTFILES += \ + zeug.txt + diff --git a/Start.cpp b/Start.cpp new file mode 100644 index 0000000..f7249fd --- /dev/null +++ b/Start.cpp @@ -0,0 +1,59 @@ +#include +//#include +//#include +#include +#include +#include + +using namespace std; + +TaskClass * TaskClassS = new TaskClass(); +ServiceClass * ServiceClassS = new ServiceClass(); +MenuWinClass *MenuWinClassS = new MenuWinClass(); + +int main (int argc, char* argv[]) { +//try { + if (argc > 1) { + if (string(argv[1]).compare("-h")) { + cout << ABOUT_INFO << " " << VERSION << endl; + return 0; + exit(EXIT_SUCCESS); + } else { + //fn = string(argv[1]); + //ed = Editor(fn); + } + } + + int Key = 0; + werase(stdscr); + MenuWinClassS->StartWin(); + signal(SIGWINCH, MenuWinClass::ResizeHandler); + //-------------_DatumUhrZeit_datumuhrzeit_----------------------------------------------- + //std::thread worker(&TaskClass::process_signal, std::ref(TaskPtr), "DateTime"); + //worker.detach(); + MenuWinClass::SetWinSize(); + MenuWinClassS->FensterDraw(); + + refresh(); + wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); + touchwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); + redrawwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin2)); + wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin2)); + touchwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin2)); + wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin3)); + touchwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin3)); + prefresh(MenuWinClass::START.TMPWin4, 0, 0, 2, 1, MenuWinClass::START.HRYw4() + 1, MenuWinClass::START.WCXw4()); + prefresh(MenuWinClass::START.TMPWin5, 0, 0, MenuWinClass::START.HRY()-4, + MenuWinClass::START.WCX()-46, MenuWinClass::START.HRYw5(), MenuWinClass::START.WCXw5()); + redrawwin(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); + wrefresh(TaskClassS->ClearWindow(MenuWinClass::START.TMPWin1)); + + do { Key = MenuWinClass::MenuStart(Key); if (Key == KEY_F(10)) { break; } } while ((Key = getch()) != KEY_F(10)); + + ServiceClassS->ENDE(); + MenuWinClassS->StopWin(); + +// } catch (const NCursesException *e) { endwin(); std::cerr << e->message << std::endl; cout << e->errorno; +// } catch (const NCursesException &e) { endwin(); std::cerr << e.message << std::endl; cout << e.errorno; +// } catch (const std::exception &e) { endwin(); std::cerr << "Exception: " << e.what() << std::endl; cout << EXIT_FAILURE; } +} diff --git a/TaskClass.cpp b/TaskClass.cpp new file mode 100644 index 0000000..4d72df4 --- /dev/null +++ b/TaskClass.cpp @@ -0,0 +1,106 @@ +#include +//#include +//#include +#include +#include +#include + +using namespace std; + +TaskClass *TaskClass_TC = new TaskClass(); +//MenuClass *MenuPtr_TC = new MenuClass(); +ServiceClass *ServiceClass_TC = new ServiceClass(); +//WinClass *WinPtr_TC = new WinClass(); +MenuWinClass *MenuWinClass_TC = new MenuWinClass(); + +volatile int signal_flag; +/*##########################################################################*/ +int TaskClass::ZahlenWerk(int zahlen, string i, int max) { + int tmp = 0; + if (strcmp(i.c_str(), "++") == 0) { + if (zahlen >= max) { + tmp = 1; + } else if (zahlen == 0) { + tmp = 1; + } else if (zahlen > 0) { + tmp = ++zahlen; + } else if (zahlen < max) { + tmp = ++zahlen; + } + } else if (strcmp(i.c_str(), "--") == 0) { + if (zahlen <= 0) { + tmp = max; + } else if (zahlen == 1) { + tmp = max; + } else if (zahlen > 1) { + tmp = --zahlen; + } else if (zahlen <= max) { + tmp = --zahlen; + } + } else { + tmp = 1; + } + return tmp; +} +int TaskClass::Zeilen(string data, int maxbreite) { + int rownr = 0; + double zeiBr = (data.length() / static_cast(maxbreite)); + int zeiBr2; + stringstream datast(data); + string line; + for (rownr = 0; std::getline(datast, line); ++rownr) {} + zeiBr2 = static_cast(ceil(zeiBr)); + return (rownr + zeiBr2); +} +std::vector TaskClass::StringTeiler(const std::string& str, char delimiter) { + std::istringstream is(str); + std::vector result; + for (std::string cur; std::getline(is, cur, delimiter); result.push_back(cur)); + return result; +} +string TaskClass::TERM_AUSGABE(string cmd) { + //cmd = "systemctl list-unit-files -t service | grep '.service' | awk '{$1=$1};1' | sort"; + string data; + FILE* stream; + char buffer[BUFSIZE]; + cmd.append(" 2>/dev/null"); //2>&1 + stream = popen(cmd.c_str(), "r"); + if (stream) { + while (!feof(stream)) { + if (fgets(buffer, BUFSIZE, stream) != nullptr) { + data.append(buffer); + } + } + pclose(stream); + } + memset(buffer, 0, BUFSIZE); + return data; +} +WINDOW* TaskClass::ClearWindow(WINDOW* TEMPWINDOW) { + clearok(TEMPWINDOW, true); + return TEMPWINDOW; +} +int TaskClass::WinFullSize(WINDOW* TmpWin, int WHCRXY, string WorH) { + if (WorH.compare("W") == 0) { + if (MenuWinClass_TC->START.WinSize.WCX_TmpWinReal(TmpWin) <= WHCRXY) { + return WHCRXY; + } else { + return MenuWinClass_TC->START.WinSize.WCX_TmpWinReal(TmpWin); + } + } else if (WorH.compare("H") == 0) { + if (MenuWinClass_TC->START.WinSize.HRY_TmpWinReal(TmpWin) <= WHCRXY) { + return WHCRXY; + } else { + return MenuWinClass_TC->START.WinSize.HRY_TmpWinReal(TmpWin); + } + } +} + +/*##########################################################################*/ +TaskClass::TaskClass() { + //TaskClass::DateTime.TIMEFIELD(MenuPtr->MENEU.HMWin,MenuWinClass_TC->WinSize.WCX); +} +TaskClass::~TaskClass() { + +} +/*##########################################################################*/ diff --git a/TaskClass.h b/TaskClass.h new file mode 100644 index 0000000..1ec5fe9 --- /dev/null +++ b/TaskClass.h @@ -0,0 +1,85 @@ +#ifndef TASKCLASS_H +#define TASKCLASS_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//#define CTRLD 4 +#define BUFSIZE 8192 +#define CLEARSCR system ( "clear" ) +#define UNUSED(x) (void) (x) +#define SAFE_DELETE(p) { if(p) { delete (p); (p) = nullptr; } } +#define SAFE_DELETE_ARRAY(p) { if(p) { delete[] (p); (p) = nullptr; } } +#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) +#define SIZEOF(table) (sizeof(table) / sizeof(table[0])) +#define RST "\x1B[0m"; +#define KRED "\x1B[31m"; +#define KGRN "\x1B[32m"; +#define KYEL "\x1B[33m"; +#define KBLU "\x1B[34m"; +#define KMAG "\x1B[35m"; +#define KCYN "\x1B[36m"; +#define KWHT "\x1B[37m"; +#define FRED(x) KRED x RST; +#define FGRN(x) KGRN x RST; +#define FYEL(x) KYEL x RST; +#define FBLU(x) KBLU x RST; +#define FMAG(x) KMAG x RST; +#define FCYN(x) KCYN x RST; +#define FWHT(x) KWHT x RST; + +using namespace std; + +struct DatumUhrZeit { + int n = 0; + time_t Zeitstempel; + tm* UHRZEIT; + char UHRZEITchar[19]; + std::string UHRZEITstr; + void TIMEFIELD(WINDOW* TMPWin, int TMPmax_xc) { + Zeitstempel = time(nullptr); + UHRZEIT = localtime(&Zeitstempel); + strftime(UHRZEITchar, size_t(UHRZEITchar), "%d.%m.%Y %T", UHRZEIT); + UHRZEITstr = std::string(UHRZEITchar); + wattr_on(TMPWin, COLOR_PAIR(79) | A_STANDOUT | A_BOLD, nullptr); //|A_BOLD,0); + mvwaddnstr(TMPWin, 0, 0, UHRZEITstr.c_str(), -1); + wattr_off(TMPWin, COLOR_PAIR(79) | A_STANDOUT | A_BOLD, nullptr); //|A_BOLD,0); + refresh(); + wrefresh(TMPWin); //TMPmax_xc-2 + } +}; + +class TaskClass { + public: + /*##############################################################################*/ + int ZahlenWerk(int zahlen, std::string i, int max); + int Zeilen(std::string data, int maxbreite); + vector StringTeiler(const std::string& str, char delimiter); + string TERM_AUSGABE(std::string cmd); + WINDOW* ClearWindow(WINDOW* W); + int WinFullSize(WINDOW* TmpWin, int WHCRXY, std::string WorH); + TaskClass(); + ~TaskClass(); + /*##############################################################################*/ +}; + +#endif // TASKCLASS_H