| /* |
| htop - Action.c |
| (C) 2015 Hisham H. Muhammad |
| Released under the GNU GPL, see the COPYING file |
| in the source distribution for its full text. |
| */ |
| |
| #include "config.h" |
| |
| #include "Action.h" |
| #include "Affinity.h" |
| #include "AffinityPanel.h" |
| #include "CategoriesPanel.h" |
| #include "CRT.h" |
| #include "MainPanel.h" |
| #include "OpenFilesScreen.h" |
| #include "Process.h" |
| #include "ScreenManager.h" |
| #include "SignalsPanel.h" |
| #include "String.h" |
| #include "TraceScreen.h" |
| #include "Platform.h" |
| |
| #include <ctype.h> |
| #include <math.h> |
| #include <pwd.h> |
| #include <stdlib.h> |
| #include <stdbool.h> |
| #include <sys/param.h> |
| #include <sys/time.h> |
| |
| /*{ |
| |
| #include "IncSet.h" |
| #include "Settings.h" |
| #include "Header.h" |
| #include "UsersTable.h" |
| #include "ProcessList.h" |
| #include "Panel.h" |
| |
| typedef enum { |
| HTOP_OK = 0x00, |
| HTOP_REFRESH = 0x01, |
| HTOP_RECALCULATE = 0x03, // implies HTOP_REFRESH |
| HTOP_SAVE_SETTINGS = 0x04, |
| HTOP_KEEP_FOLLOWING = 0x08, |
| HTOP_QUIT = 0x10, |
| HTOP_REDRAW_BAR = 0x20, |
| HTOP_UPDATE_PANELHDR = 0x41, // implies HTOP_REFRESH |
| } Htop_Reaction; |
| |
| typedef Htop_Reaction (*Htop_Action)(); |
| |
| typedef struct State_ { |
| Settings* settings; |
| UsersTable* ut; |
| ProcessList* pl; |
| Panel* panel; |
| Header* header; |
| } State; |
| |
| }*/ |
| |
| Object* Action_pickFromVector(State* st, Panel* list, int x) { |
| Panel* panel = st->panel; |
| Header* header = st->header; |
| Settings* settings = st->settings; |
| |
| int y = panel->y; |
| ScreenManager* scr = ScreenManager_new(0, header->height, 0, -1, HORIZONTAL, header, settings, false); |
| scr->allowFocusChange = false; |
| ScreenManager_add(scr, list, x - 1); |
| ScreenManager_add(scr, panel, -1); |
| Panel* panelFocus; |
| int ch; |
| bool unfollow = false; |
| int pid = MainPanel_selectedPid((MainPanel*)panel); |
| if (header->pl->following == -1) { |
| header->pl->following = pid; |
| unfollow = true; |
| } |
| ScreenManager_run(scr, &panelFocus, &ch); |
| if (unfollow) { |
| header->pl->following = -1; |
| } |
| ScreenManager_delete(scr); |
| Panel_move(panel, 0, y); |
| Panel_resize(panel, COLS, LINES-y-1); |
| if (panelFocus == list && ch == 13) { |
| Process* selected = (Process*)Panel_getSelected(panel); |
| if (selected && selected->pid == pid) |
| return Panel_getSelected(list); |
| else |
| beep(); |
| } |
| return NULL; |
| } |
| |
| // ---------------------------------------- |
| |
| static void Action_runSetup(Settings* settings, const Header* header, ProcessList* pl) { |
| ScreenManager* scr = ScreenManager_new(0, header->height, 0, -1, HORIZONTAL, header, settings, true); |
| CategoriesPanel* panelCategories = CategoriesPanel_new(scr, settings, (Header*) header, pl); |
| ScreenManager_add(scr, (Panel*) panelCategories, 16); |
| CategoriesPanel_makeMetersPage(panelCategories); |
| Panel* panelFocus; |
| int ch; |
| ScreenManager_run(scr, &panelFocus, &ch); |
| ScreenManager_delete(scr); |
| if (settings->changed) { |
| Header_writeBackToSettings(header); |
| } |
| } |
| |
| static bool changePriority(MainPanel* panel, int delta) { |
| bool anyTagged; |
| bool ok = MainPanel_foreachProcess(panel, (MainPanel_ForeachProcessFn) Process_changePriorityBy, delta, &anyTagged); |
| if (!ok) |
| beep(); |
| return anyTagged; |
| } |
| |
| static void addUserToVector(int key, void* userCast, void* panelCast) { |
| char* user = (char*) userCast; |
| Panel* panel = (Panel*) panelCast; |
| Panel_add(panel, (Object*) ListItem_new(user, key)); |
| } |
| |
| bool Action_setUserOnly(const char* userName, uid_t* userId) { |
| struct passwd* user = getpwnam(userName); |
| if (user) { |
| *userId = user->pw_uid; |
| return true; |
| } |
| *userId = -1; |
| return false; |
| } |
| |
| static void tagAllChildren(Panel* panel, Process* parent) { |
| parent->tag = true; |
| pid_t ppid = parent->pid; |
| for (int i = 0; i < Panel_size(panel); i++) { |
| Process* p = (Process*) Panel_get(panel, i); |
| if (!p->tag && p->ppid == ppid) { |
| tagAllChildren(panel, p); |
| } |
| } |
| } |
| |
| static bool expandCollapse(Panel* panel) { |
| Process* p = (Process*) Panel_getSelected(panel); |
| if (!p) return false; |
| p->showChildren = !p->showChildren; |
| return true; |
| } |
| |
| Htop_Reaction Action_setSortKey(Settings* settings, ProcessField sortKey) { |
| settings->sortKey = sortKey; |
| settings->direction = 1; |
| settings->treeView = false; |
| return HTOP_REFRESH | HTOP_SAVE_SETTINGS | HTOP_UPDATE_PANELHDR | HTOP_KEEP_FOLLOWING; |
| } |
| |
| static Htop_Reaction sortBy(State* st) { |
| Htop_Reaction reaction = HTOP_OK; |
| Panel* sortPanel = Panel_new(0, 0, 0, 0, true, Class(ListItem), FunctionBar_newEnterEsc("Sort ", "Cancel ")); |
| Panel_setHeader(sortPanel, "Sort by"); |
| ProcessField* fields = st->settings->fields; |
| for (int i = 0; fields[i]; i++) { |
| char* name = String_trim(Process_fields[fields[i]].name); |
| Panel_add(sortPanel, (Object*) ListItem_new(name, fields[i])); |
| if (fields[i] == st->settings->sortKey) |
| Panel_setSelected(sortPanel, i); |
| free(name); |
| } |
| ListItem* field = (ListItem*) Action_pickFromVector(st, sortPanel, 15); |
| if (field) { |
| reaction |= Action_setSortKey(st->settings, field->key); |
| } |
| Object_delete(sortPanel); |
| return reaction | HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR; |
| } |
| |
| // ---------------------------------------- |
| |
| static Htop_Reaction actionResize(State* st) { |
| Panel_resize(st->panel, COLS, LINES-(st->panel->y)-1); |
| return HTOP_REDRAW_BAR; |
| } |
| |
| static Htop_Reaction actionSortByMemory(State* st) { |
| return Action_setSortKey(st->settings, PERCENT_MEM); |
| } |
| |
| static Htop_Reaction actionSortByCPU(State* st) { |
| return Action_setSortKey(st->settings, PERCENT_CPU); |
| } |
| |
| static Htop_Reaction actionSortByTime(State* st) { |
| return Action_setSortKey(st->settings, TIME); |
| } |
| |
| static Htop_Reaction actionToggleKernelThreads(State* st) { |
| st->settings->hideKernelThreads = !st->settings->hideKernelThreads; |
| return HTOP_RECALCULATE | HTOP_SAVE_SETTINGS; |
| } |
| |
| static Htop_Reaction actionToggleUserlandThreads(State* st) { |
| st->settings->hideUserlandThreads = !st->settings->hideUserlandThreads; |
| st->settings->hideThreads = st->settings->hideUserlandThreads; |
| return HTOP_RECALCULATE | HTOP_SAVE_SETTINGS; |
| } |
| |
| static Htop_Reaction actionToggleProgramPath(State* st) { |
| st->settings->showProgramPath = !st->settings->showProgramPath; |
| return HTOP_REFRESH | HTOP_SAVE_SETTINGS; |
| } |
| |
| static Htop_Reaction actionToggleTreeView(State* st) { |
| st->settings->treeView = !st->settings->treeView; |
| if (st->settings->treeView) st->settings->direction = 1; |
| ProcessList_expandTree(st->pl); |
| return HTOP_REFRESH | HTOP_SAVE_SETTINGS | HTOP_KEEP_FOLLOWING | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR; |
| } |
| |
| static Htop_Reaction actionIncFilter(State* st) { |
| IncSet* inc = ((MainPanel*)st->panel)->inc; |
| IncSet_activate(inc, INC_FILTER, st->panel); |
| st->pl->incFilter = IncSet_filter(inc); |
| return HTOP_REFRESH | HTOP_KEEP_FOLLOWING; |
| } |
| |
| static Htop_Reaction actionIncSearch(State* st) { |
| IncSet_activate(((MainPanel*)st->panel)->inc, INC_SEARCH, st->panel); |
| return HTOP_REFRESH | HTOP_KEEP_FOLLOWING; |
| } |
| |
| static Htop_Reaction actionHigherPriority(State* st) { |
| bool changed = changePriority((MainPanel*)st->panel, -1); |
| return changed ? HTOP_REFRESH : HTOP_OK; |
| } |
| |
| static Htop_Reaction actionLowerPriority(State* st) { |
| bool changed = changePriority((MainPanel*)st->panel, 1); |
| return changed ? HTOP_REFRESH : HTOP_OK; |
| } |
| |
| static Htop_Reaction actionInvertSortOrder(State* st) { |
| Settings_invertSortOrder(st->settings); |
| return HTOP_REFRESH | HTOP_SAVE_SETTINGS; |
| } |
| |
| static Htop_Reaction actionSetSortColumn(State* st) { |
| return sortBy(st); |
| } |
| |
| static Htop_Reaction actionExpandOrCollapse(State* st) { |
| bool changed = expandCollapse(st->panel); |
| return changed ? HTOP_RECALCULATE : HTOP_OK; |
| } |
| |
| static Htop_Reaction actionExpandCollapseOrSortColumn(State* st) { |
| return st->settings->treeView ? actionExpandOrCollapse(st) : actionSetSortColumn(st); |
| } |
| |
| static Htop_Reaction actionQuit() { |
| return HTOP_QUIT; |
| } |
| |
| static Htop_Reaction actionSetAffinity(State* st) { |
| if (st->pl->cpuCount == 1) |
| return HTOP_OK; |
| #if (HAVE_LIBHWLOC || HAVE_NATIVE_AFFINITY) |
| Panel* panel = st->panel; |
| |
| Process* p = (Process*) Panel_getSelected(panel); |
| if (!p) return HTOP_OK; |
| Affinity* affinity = Affinity_get(p, st->pl); |
| if (!affinity) return HTOP_OK; |
| Panel* affinityPanel = AffinityPanel_new(st->pl, affinity); |
| Affinity_delete(affinity); |
| |
| void* set = Action_pickFromVector(st, affinityPanel, 15); |
| if (set) { |
| Affinity* affinity = AffinityPanel_getAffinity(affinityPanel, st->pl); |
| bool ok = MainPanel_foreachProcess((MainPanel*)panel, (MainPanel_ForeachProcessFn) Affinity_set, (size_t) affinity, NULL); |
| if (!ok) beep(); |
| Affinity_delete(affinity); |
| } |
| Panel_delete((Object*)affinityPanel); |
| #endif |
| return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR; |
| } |
| |
| static Htop_Reaction actionKill(State* st) { |
| Panel* signalsPanel = (Panel*) SignalsPanel_new(); |
| ListItem* sgn = (ListItem*) Action_pickFromVector(st, signalsPanel, 15); |
| if (sgn) { |
| if (sgn->key != 0) { |
| Panel_setHeader(st->panel, "Sending..."); |
| Panel_draw(st->panel, true); |
| refresh(); |
| MainPanel_foreachProcess((MainPanel*)st->panel, (MainPanel_ForeachProcessFn) Process_sendSignal, (size_t) sgn->key, NULL); |
| napms(500); |
| } |
| } |
| Panel_delete((Object*)signalsPanel); |
| return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR; |
| } |
| |
| static Htop_Reaction actionFilterByUser(State* st) { |
| Panel* usersPanel = Panel_new(0, 0, 0, 0, true, Class(ListItem), FunctionBar_newEnterEsc("Show ", "Cancel ")); |
| Panel_setHeader(usersPanel, "Show processes of:"); |
| UsersTable_foreach(st->ut, addUserToVector, usersPanel); |
| Vector_insertionSort(usersPanel->items); |
| ListItem* allUsers = ListItem_new("All users", -1); |
| Panel_insert(usersPanel, 0, (Object*) allUsers); |
| ListItem* picked = (ListItem*) Action_pickFromVector(st, usersPanel, 20); |
| if (picked) { |
| if (picked == allUsers) { |
| st->pl->userId = -1; |
| } else { |
| Action_setUserOnly(ListItem_getRef(picked), &(st->pl->userId)); |
| } |
| } |
| Panel_delete((Object*)usersPanel); |
| return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR; |
| } |
| |
| static Htop_Reaction actionFollow(State* st) { |
| st->pl->following = MainPanel_selectedPid((MainPanel*)st->panel); |
| Panel_setSelectionColor(st->panel, CRT_colors[PANEL_SELECTION_FOLLOW]); |
| return HTOP_KEEP_FOLLOWING; |
| } |
| |
| static Htop_Reaction actionSetup(State* st) { |
| Action_runSetup(st->settings, st->header, st->pl); |
| // TODO: shouldn't need this, colors should be dynamic |
| int headerHeight = Header_calculateHeight(st->header); |
| Panel_move(st->panel, 0, headerHeight); |
| Panel_resize(st->panel, COLS, LINES-headerHeight-1); |
| return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR; |
| } |
| |
| static Htop_Reaction actionLsof(State* st) { |
| Process* p = (Process*) Panel_getSelected(st->panel); |
| if (!p) return HTOP_OK; |
| OpenFilesScreen* ts = OpenFilesScreen_new(p); |
| OpenFilesScreen_run(ts); |
| OpenFilesScreen_delete(ts); |
| clear(); |
| CRT_enableDelay(); |
| return HTOP_REFRESH | HTOP_REDRAW_BAR; |
| } |
| |
| static Htop_Reaction actionStrace(State* st) { |
| Process* p = (Process*) Panel_getSelected(st->panel); |
| if (!p) return HTOP_OK; |
| TraceScreen* ts = TraceScreen_new(p); |
| TraceScreen_run(ts); |
| TraceScreen_delete(ts); |
| clear(); |
| CRT_enableDelay(); |
| return HTOP_REFRESH | HTOP_REDRAW_BAR; |
| } |
| |
| static Htop_Reaction actionTag(State* st) { |
| Process* p = (Process*) Panel_getSelected(st->panel); |
| if (!p) return HTOP_OK; |
| Process_toggleTag(p); |
| Panel_onKey(st->panel, KEY_DOWN); |
| return HTOP_OK; |
| } |
| |
| static Htop_Reaction actionRedraw() { |
| clear(); |
| return HTOP_REFRESH | HTOP_REDRAW_BAR; |
| } |
| |
| static struct { const char* key; const char* info; } helpLeft[] = { |
| { .key = " Arrows: ", .info = "scroll process list" }, |
| { .key = " Digits: ", .info = "incremental PID search" }, |
| { .key = " F3 /: ", .info = "incremental name search" }, |
| { .key = " F4 \\: ",.info = "incremental name filtering" }, |
| { .key = " F5 t: ", .info = "tree view" }, |
| { .key = " u: ", .info = "show processes of a single user" }, |
| { .key = " H: ", .info = "hide/show user threads" }, |
| { .key = " K: ", .info = "hide/show kernel threads" }, |
| { .key = " F: ", .info = "cursor follows process" }, |
| { .key = " F6 + -: ", .info = "expand/collapse tree" }, |
| { .key = " P M T: ", .info = "sort by CPU%, MEM% or TIME" }, |
| { .key = " I: ", .info = "invert sort order" }, |
| { .key = " F6 >: ", .info = "select sort column" }, |
| { .key = NULL, .info = NULL } |
| }; |
| |
| static struct { const char* key; const char* info; } helpRight[] = { |
| { .key = " Space: ", .info = "tag process" }, |
| { .key = " c: ", .info = "tag process and its children" }, |
| { .key = " U: ", .info = "untag all processes" }, |
| { .key = " F9 k: ", .info = "kill process/tagged processes" }, |
| { .key = " F7 ]: ", .info = "higher priority (root only)" }, |
| { .key = " F8 [: ", .info = "lower priority (+ nice)" }, |
| #if (HAVE_LIBHWLOC || HAVE_NATIVE_AFFINITY) |
| { .key = " a: ", .info = "set CPU affinity" }, |
| #endif |
| { .key = " i: ", .info = "set IO prority" }, |
| { .key = " l: ", .info = "list open files with lsof" }, |
| { .key = " s: ", .info = "trace syscalls with strace" }, |
| { .key = " ", .info = "" }, |
| { .key = " F2 S: ", .info = "setup" }, |
| { .key = " F1 h: ", .info = "show this help screen" }, |
| { .key = " F10 q: ", .info = "quit" }, |
| { .key = NULL, .info = NULL } |
| }; |
| |
| static Htop_Reaction actionHelp(State* st) { |
| Settings* settings = st->settings; |
| |
| clear(); |
| attrset(CRT_colors[HELP_BOLD]); |
| |
| for (int i = 0; i < LINES-1; i++) |
| mvhline(i, 0, ' ', COLS); |
| |
| mvaddstr(0, 0, "htop " VERSION " - " COPYRIGHT); |
| mvaddstr(1, 0, "Released under the GNU GPL. See 'man' page for more info."); |
| |
| attrset(CRT_colors[DEFAULT_COLOR]); |
| mvaddstr(3, 0, "CPU usage bar: "); |
| #define addattrstr(a,s) attrset(a);addstr(s) |
| addattrstr(CRT_colors[BAR_BORDER], "["); |
| if (settings->detailedCPUTime) { |
| addattrstr(CRT_colors[CPU_NICE_TEXT], "low"); addstr("/"); |
| addattrstr(CRT_colors[CPU_NORMAL], "normal"); addstr("/"); |
| addattrstr(CRT_colors[CPU_KERNEL], "kernel"); addstr("/"); |
| addattrstr(CRT_colors[CPU_IRQ], "irq"); addstr("/"); |
| addattrstr(CRT_colors[CPU_SOFTIRQ], "soft-irq"); addstr("/"); |
| addattrstr(CRT_colors[CPU_STEAL], "steal"); addstr("/"); |
| addattrstr(CRT_colors[CPU_GUEST], "guest"); addstr("/"); |
| addattrstr(CRT_colors[CPU_IOWAIT], "io-wait"); |
| addattrstr(CRT_colors[BAR_SHADOW], " used%"); |
| } else { |
| addattrstr(CRT_colors[CPU_NICE_TEXT], "low-priority"); addstr("/"); |
| addattrstr(CRT_colors[CPU_NORMAL], "normal"); addstr("/"); |
| addattrstr(CRT_colors[CPU_KERNEL], "kernel"); addstr("/"); |
| addattrstr(CRT_colors[CPU_STEAL], "virtualiz"); |
| addattrstr(CRT_colors[BAR_SHADOW], " used%"); |
| } |
| addattrstr(CRT_colors[BAR_BORDER], "]"); |
| attrset(CRT_colors[DEFAULT_COLOR]); |
| mvaddstr(4, 0, "Memory bar: "); |
| addattrstr(CRT_colors[BAR_BORDER], "["); |
| addattrstr(CRT_colors[MEMORY_USED], "used"); addstr("/"); |
| addattrstr(CRT_colors[MEMORY_BUFFERS_TEXT], "buffers"); addstr("/"); |
| addattrstr(CRT_colors[MEMORY_CACHE], "cache"); |
| addattrstr(CRT_colors[BAR_SHADOW], " used/total"); |
| addattrstr(CRT_colors[BAR_BORDER], "]"); |
| attrset(CRT_colors[DEFAULT_COLOR]); |
| mvaddstr(5, 0, "Swap bar: "); |
| addattrstr(CRT_colors[BAR_BORDER], "["); |
| addattrstr(CRT_colors[SWAP], "used"); |
| addattrstr(CRT_colors[BAR_SHADOW], " used/total"); |
| addattrstr(CRT_colors[BAR_BORDER], "]"); |
| attrset(CRT_colors[DEFAULT_COLOR]); |
| mvaddstr(6,0, "Type and layout of header meters are configurable in the setup screen."); |
| if (CRT_colorScheme == COLORSCHEME_MONOCHROME) { |
| mvaddstr(7, 0, "In monochrome, meters are displayed through different chars, in order: |#*@$%&"); |
| } |
| mvaddstr( 8, 0, " Status: R: running; S: sleeping; T: traced/stopped; Z: zombie; D: disk sleep"); |
| for (int i = 0; helpLeft[i].info; i++) { mvaddstr(9+i, 9, helpLeft[i].info); } |
| for (int i = 0; helpRight[i].info; i++) { mvaddstr(9+i, 49, helpRight[i].info); } |
| attrset(CRT_colors[HELP_BOLD]); |
| for (int i = 0; helpLeft[i].key; i++) { mvaddstr(9+i, 0, helpLeft[i].key); } |
| for (int i = 0; helpRight[i].key; i++) { mvaddstr(9+i, 40, helpRight[i].key); } |
| |
| attrset(CRT_colors[HELP_BOLD]); |
| mvaddstr(23,0, "Press any key to return."); |
| attrset(CRT_colors[DEFAULT_COLOR]); |
| refresh(); |
| CRT_readKey(); |
| clear(); |
| |
| return HTOP_RECALCULATE | HTOP_REDRAW_BAR; |
| } |
| |
| static Htop_Reaction actionUntagAll(State* st) { |
| for (int i = 0; i < Panel_size(st->panel); i++) { |
| Process* p = (Process*) Panel_get(st->panel, i); |
| p->tag = false; |
| } |
| return HTOP_REFRESH; |
| } |
| |
| static Htop_Reaction actionTagAllChildren(State* st) { |
| Process* p = (Process*) Panel_getSelected(st->panel); |
| if (!p) return HTOP_OK; |
| tagAllChildren(st->panel, p); |
| return HTOP_OK; |
| } |
| |
| void Action_setBindings(Htop_Action* keys) { |
| keys[KEY_RESIZE] = actionResize; |
| keys['M'] = actionSortByMemory; |
| keys['T'] = actionSortByTime; |
| keys['P'] = actionSortByCPU; |
| keys['H'] = actionToggleUserlandThreads; |
| keys['K'] = actionToggleKernelThreads; |
| keys['p'] = actionToggleProgramPath; |
| keys['t'] = actionToggleTreeView; |
| keys[KEY_F(5)] = actionToggleTreeView; |
| keys[KEY_F(4)] = actionIncFilter; |
| keys['\\'] = actionIncFilter; |
| keys[KEY_F(3)] = actionIncSearch; |
| keys['/'] = actionIncSearch; |
| |
| keys[']'] = actionHigherPriority; |
| keys[KEY_F(7)] = actionHigherPriority; |
| keys['['] = actionLowerPriority; |
| keys[KEY_F(8)] = actionLowerPriority; |
| keys['I'] = actionInvertSortOrder; |
| keys[KEY_F(6)] = actionExpandCollapseOrSortColumn; |
| keys[KEY_F(18)] = actionExpandCollapseOrSortColumn; |
| keys['<'] = actionSetSortColumn; |
| keys[','] = actionSetSortColumn; |
| keys['>'] = actionSetSortColumn; |
| keys['.'] = actionSetSortColumn; |
| keys[KEY_F(10)] = actionQuit; |
| keys['q'] = actionQuit; |
| keys['a'] = actionSetAffinity; |
| keys[KEY_F(9)] = actionKill; |
| keys['k'] = actionKill; |
| keys['+'] = actionExpandOrCollapse; |
| keys['='] = actionExpandOrCollapse; |
| keys['-'] = actionExpandOrCollapse; |
| keys['u'] = actionFilterByUser; |
| keys['F'] = actionFollow; |
| keys['S'] = actionSetup; |
| keys['C'] = actionSetup; |
| keys[KEY_F(2)] = actionSetup; |
| keys['l'] = actionLsof; |
| keys['s'] = actionStrace; |
| keys[' '] = actionTag; |
| keys['\014'] = actionRedraw; // Ctrl+L |
| keys[KEY_F(1)] = actionHelp; |
| keys['h'] = actionHelp; |
| keys['?'] = actionHelp; |
| keys['U'] = actionUntagAll; |
| keys['c'] = actionTagAllChildren; |
| } |
| |