void ClassCPV::state_change(const unsigned char cl, const unsigned char t) { myteam = e_Team(t); hp = 0; // we are dead until further notice (the further notice being a status update) // print PC info: if((myclass = e_Class(cl)) == NO_CLASS) // spectator Base::print_str("Spectator ", team_colour[T_SPEC], PC_INFO_X, 3, STAT_WIN, false); else // actual class { Base::print_str(pcview_classname[myclass].c_str(), team_colour[myteam], PC_INFO_X, 3, STAT_WIN, false); dam_die = classes[myclass].dam_die; dv = classes[myclass].dv; pv = classes[myclass].pv; } // Clear the rest: for(char y = 4; y < 7; ++y) Base::print_str(" ", team_colour[T_SPEC], PC_INFO_X, y, STAT_WIN, false); Base::print_str(" ", team_colour[T_SPEC], 52, 3, STAT_WIN, false); // map area // class/team change requires any class-specific action to end: if(clientstate >= CS_AIMING) { clientstate = CS_NORMAL; redraw_view(); } }
void ClassCPV::move(const e_Dir d) { if(clientstate == CS_NORMAL) // regular movement Network::send_action(XN_MOVE, d); else if(clientstate == CS_AIMING) // moving the aimer { aimer = aimer.in(d); if(aimer.x > VIEWSIZE/2) aimer.x--; else if(aimer.x < -VIEWSIZE/2) aimer.x++; if(aimer.y > VIEWSIZE/2) aimer.y--; else if(aimer.y < -VIEWSIZE/2) aimer.y++; redraw_view(); } else if(clientstate == CS_DIR) // waiting for dir input (and now got it!) { if(myclass == C_FIGHTER) Network::send_action(XN_CIRCLE_ATTACK, d); else if(myclass == C_HEALER) Network::send_action(XN_HEAL, d); else if(myclass == C_MINER) Network::send_action(XN_MINE, d); else if(myclass == C_COMBAT_MAGE) Network::send_action(XN_ZAP, d); clientstate = CS_NORMAL; } // else ignore }
void toggle_titles() { if((showtitles = !showtitles)) draw_titles(); else redraw_view(); }
static void redraw_display(bool clear) { struct view *view; view = display[0]; if (clear) wclear(view->win); redraw_view(view); update_title_win(view); }
static void leave_menu_mode(void) { reset_popup_menu(menu); clean_selected_files(view); redraw_view(view); *mode = NORMAL_MODE; if(was_redraw) update_screen(UT_FULL); else update_all_windows(); }
void redraw_display(bool clear) { struct view *view; int i; foreach_displayed_view (view, i) { if (clear) wclear(view->win); redraw_view(view); update_view_title(view); } redraw_display_separator(clear); }
void view_explore_mode_quit(FileView *view) { assert(!vle_mode_is(VIEW_MODE) && "Unexpected mode."); if(!view->explore_mode) { return; } view->explore_mode = 0; reset_view_info(&view_info[(view == &lwin) ? VI_LWIN : VI_RWIN]); redraw_view(view); ui_view_title_update(view); }
void ClassCPV::five() { if(clientstate == CS_AIMING) { if(aimer.x || aimer.y) { aimer.x = aimer.y = 0; redraw_view(); } } else if(clientstate == CS_DIR && myclass == C_HEALER) { Network::send_action(XN_HEAL, MAX_D); // heal self clientstate = CS_NORMAL; } // else ignore }
void ClassCPV::space() { if(!im_alive()) Network::send_action(XN_FOLLOW_SWITCH); else { switch(myclass) { case C_ARCHER: if(clientstate == CS_AIMING) { if(aimer.x || aimer.y) // aiming *somewhere* Network::send_action(XN_SHOOT, aimer.x, aimer.y); clientstate = CS_NORMAL; } else { aimer.x = aimer.y = 0; clientstate = CS_AIMING; } redraw_view(); break; case C_ASSASSIN: Network::send_action(XN_FLASH); break; case C_MINDCRAFTER: Network::send_action(XN_BLINK); break; case C_SCOUT: Network::send_action(XN_DISGUISE); break; case C_TRAPPER: Network::send_action(XN_SET_TRAP); break; case C_WIZARD: Network::send_action(XN_MM); break; case C_PLANEWALKER: Network::send_action(XN_MINDS_EYE); break; default: //C_FIGHTER, C_HEALER, C_MINER, C_COMBAT_MAGE clientstate = CS_DIR; break; } } // not spectator or dead }
static void prompt_update_display(enum view_flag flags) { struct view *view; int i; if (flags & VIEW_RESET_DISPLAY) { resize_display(); redraw_display(TRUE); } foreach_displayed_view(view, i) { if (view_has_flags(view, flags) && view_can_refresh(view)) reload_view(view); else redraw_view(view); } }
/* Leaves menu mode, possibly resetting selection. Does nothing if current mode * isn't menu mode. */ static void leave_menu_mode(int reset_selection) { /* Some menu implementation could have switched mode from one of handlers. */ if(!vle_mode_is(MENU_MODE)) { return; } reset_popup_menu(menu); if(reset_selection) { clean_selected_files(view); redraw_view(view); } vle_mode_set(NORMAL_MODE, VMT_PRIMARY); update_ui_on_leaving(); }
/* Leaves menu mode, possibly resetting selection. Does nothing if current mode * isn't menu mode. */ static void leave_menu_mode(int reset_selection) { /* Some menu implementation could have switched mode from one of handlers. */ if(!vle_mode_is(MENU_MODE)) { return; } menus_reset_data(menu); if(reset_selection) { flist_sel_stash(view); redraw_view(view); } vle_mode_set(NORMAL_MODE, VMT_PRIMARY); update_ui_on_leaving(); }
/* Callback that is called when menu item is selected. Should return non-zero * to stay in menu mode. */ int execute_filetype_cb(FileView *view, menu_info *m) { if(view->dir_entry[view->list_pos].type == FT_DIR && m->pos == 0) { open_dir(view); } else { const char *prog_str = strchr(m->data[m->pos], '|') + 1; if(prog_str[0] != '\0') { int background = m->extra_data & 1; run_using_prog(view, prog_str, 0, background); } } clean_selected_files(view); redraw_view(view); return 0; }
void enter_visual_mode(VisualSubmodes sub_mode) { const int ub = check_mark_directory(curr_view, '<'); const int lb = check_mark_directory(curr_view, '>'); if(sub_mode == VS_RESTORE && (ub < 0 || lb < 0)) { return; } view = curr_view; start_pos = view->list_pos; vle_mode_set(VISUAL_MODE, VMT_PRIMARY); switch(sub_mode) { case VS_NORMAL: amend_type = AT_NONE; flist_sel_stash(view); backup_selection_flags(view); select_first_one(); break; case VS_RESTORE: amend_type = AT_NONE; flist_sel_stash(view); backup_selection_flags(view); restore_previous_selection(); break; case VS_AMEND: amend_type = AT_APPEND; backup_selection_flags(view); select_first_one(); break; } redraw_view(view); }
void leave_visual_mode(int save_msg, int goto_top, int clear_selection) { if(goto_top) { int ub = check_mark_directory(view, '<'); if(ub != -1) view->list_pos = ub; } if(clear_selection) { reset_search_results(view); restore_selection_flags(view); redraw_view(view); } curr_stats.save_msg = save_msg; if(vle_mode_is(VISUAL_MODE)) { vle_mode_set(NORMAL_MODE, VMT_PRIMARY); } }
/* Performs postponed updates for the view, if any. Returns non-zero if * something was indeed updated, and zero otherwise. */ TSTATIC int process_scheduled_updates_of_view(view_t *view) { if(!window_shows_dirlist(view)) { return 0; } switch(ui_view_query_scheduled_event(view)) { case UUE_NONE: /* Nothing to do. */ return 0; case UUE_REDRAW: redraw_view(view); return 1; case UUE_RELOAD: load_saving_pos(view); return 1; } assert(0 && "Unexpected type of scheduled UI event."); return 0; }
enum request run_prompt_command(struct view *view, const char *argv[]) { enum request request; const char *cmd = argv[0]; size_t cmdlen = cmd ? strlen(cmd) : 0; if (!cmd) return REQ_NONE; if (string_isnumber(cmd)) { int lineno = view->pos.lineno + 1; if (parse_int(&lineno, cmd, 1, view->lines + 1) == SUCCESS) { select_view_line(view, lineno - 1); report_clear(); } else { report("Unable to parse '%s' as a line number", cmd); } } else if (iscommit(cmd)) { string_ncopy(view->env->search, cmd, cmdlen); return REQ_JUMP_COMMIT; } else if (cmdlen > 1 && (cmd[0] == '/' || cmd[0] == '?')) { char search[SIZEOF_STR]; if (!argv_to_string(argv, search, sizeof(search), " ")) { report("Failed to copy search string"); return REQ_NONE; } if (!strcmp(search + 1, view->env->search)) return cmd[0] == '/' ? REQ_FIND_NEXT : REQ_FIND_PREV; string_ncopy(view->env->search, search + 1, strlen(search + 1)); return cmd[0] == '/' ? REQ_SEARCH : REQ_SEARCH_BACK; } else if (cmdlen > 1 && cmd[0] == '!') { struct view *next = &pager_view; bool copied; /* Trim the leading '!'. */ argv[0] = cmd + 1; copied = argv_format(view->env, &next->argv, argv, FALSE, TRUE); argv[0] = cmd; if (!copied) { report("Argument formatting failed"); } else { /* When running random commands, initially show the * command in the title. However, it maybe later be * overwritten if a commit line is selected. */ argv_to_string(next->argv, next->ref, sizeof(next->ref), " "); next->dir = NULL; open_pager_view(view, OPEN_PREPARED | OPEN_WITH_STDERR); } } else if (!strcmp(cmd, "toggle")) { char action[SIZEOF_STR] = ""; enum view_flag flags = prompt_toggle(view, argv, action); int i; if (flags & VIEW_RESET_DISPLAY) { resize_display(); redraw_display(TRUE); } foreach_displayed_view(view, i) { if (view_has_flags(view, flags) && !view->unrefreshable) reload_view(view); else redraw_view(view); } if (*action) report("%s", action); } else {
bool Input::inputhandle() { if(clientstate == CS_TYPE_CHAT || clientstate == CS_TYPE_SHOUT) { if(check_typing()) // returns true if done typing { clientstate = CS_NORMAL; Base::def_cursor(); } return false; } // else int key = getch(); if(key != ERR) // there is some key { if(key == KEYCODE_INT) return true; // ^C quits if(clientstate == CS_HELP || clientstate == CS_TEAM_INFO) { // any key in help screen closes help leave_limbo(); // not leaving limbo, but the functionality is the same return false; } // Quickshouts handled regardless of clientstate: if(ClassCPV::im_alive()) { for(char f = 1; f <= MAX_QUICK_SHOUTS; ++f) { if(key == KEY_F(f)) { if(!Config::quick_shout(--f).empty()) Network::send_line(Config::quick_shout(f), false); return false; } } } if(clientstate == CS_LIMBO) { key = tolower(key); if(key <= 'k' && key >= 'a') // switch class { Network::send_spawn((unsigned char)(key - 'a')); leave_limbo(); } else if(key == 't') { Network::send_switch(); leave_limbo(); } else if(key == 's') { Network::send_spawn(NO_CLASS); leave_limbo(); } else if(key == 'l' || key == 27) // 27: escape leave_limbo(); } else { if(key == '?') // help key { clientstate = CS_HELP; walkmode_off(); redraw_view(); Base::type_cursor(0); return false; } // if here, we need to convert the key: e_Key_binding kb = MAX_KEY_BINDING; if(key < 256) // fits in a byte; try to convert kb = Config::convert_key(char(key)); // map arrow keys to the directions, for the n00bs: else if(key == KEY_UP) kb = KB_8; else if(key == KEY_DOWN) kb = KB_2; else if(key == KEY_LEFT) kb = KB_4; else if(key == KEY_RIGHT) kb = KB_6; if(kb < MAX_KEY_BINDING) // a recognized key { switch(kb) { /* * The effect of these depends on clientstate & class. * The handling is delegated to class_cpv.cpp */ case KB_1: // movement case KB_2: case KB_3: case KB_4: case KB_6: case KB_7: case KB_8: case KB_9: ClassCPV::move((last_dir = e_Dir(kb))); break; case KB_5: // special direction ClassCPV::five(); last_dir = MAX_D; break; case KB_SPACE: // action key ClassCPV::space(); walkmode_off(); break; case KB_p: // follow previous key ClassCPV::follow_prev(); walkmode_off(); break; /* * These can be done in the middle of unfinished actions, but will cause * interruption: */ case KB_C: // say in chat clientstate = CS_TYPE_CHAT; init_type(); walkmode_off(); break; case KB_s: // say aloud clientstate = CS_TYPE_SHOUT; init_type(); walkmode_off(); break; case KB_c: // close a door Network::send_action(XN_CLOSE_DOOR); // interrupts any aiming/casting etc: clientstate = CS_NORMAL; walkmode_off(); break; case KB_u: // torch handling Network::send_action(XN_TORCH_HANDLE); // interrupts any aiming/casting etc: clientstate = CS_NORMAL; walkmode_off(); break; case KB_T: // trigger a trap Network::send_action(XN_TRAP_TRIGGER); // interrupts any aiming/casting etc: clientstate = CS_NORMAL; walkmode_off(); break; case KB_X: // suicide ClassCPV::suicide(); walkmode_off(); break; case KB_l: // limbo toggle clientstate = CS_LIMBO; walkmode_off(); redraw_view(); Base::type_cursor(0); break; case KB_i: // request team info Network::send_teami_req(); break; case KB_Q: // quit return true; // confirmation? nah /* * The following can be carried out in any clientstate except limbo * without interruption: */ case KB_w: // walk toggle if(walkmode) walkmode_off(); else Base::print_walk((walkmode = true)); break; case KB_t: // titles toggle toggle_titles(); break; case KB_d: // differentiate titles diff_titles(); break; case KB_o: // ouching toggle add_msg(string("[Reacting to damage ") + offon[Config::toggle_ouch()], 15); break; case KB_PLUS: scroll_chat_up(); break; case KB_MINUS: scroll_chat_down(); break; case KB_PERCENT: add_msg(string("[Act per turn ") + offon[Config::toggle_act_per_turn()], 15); break; default: break; } } // a recognized key binding } // need to convert key } // key != ERR else if(clientstate == CS_NORMAL && walkmode && last_dir != MAX_D && Network::not_acted()) ClassCPV::move(last_dir); return false; }
static int view_driver(struct view *view, enum request request) { int i; if (request == REQ_NONE) return TRUE; if (request >= REQ_RUN_REQUESTS) { request = open_run_request(view, request); // exit quickly rather than going through view_request and back if (request == REQ_QUIT) return FALSE; } request = view_request(view, request); if (request == REQ_NONE) return TRUE; switch (request) { case REQ_MOVE_UP: case REQ_MOVE_DOWN: case REQ_MOVE_PAGE_UP: case REQ_MOVE_PAGE_DOWN: case REQ_MOVE_FIRST_LINE: case REQ_MOVE_LAST_LINE: move_view(view, request); break; case REQ_SCROLL_FIRST_COL: case REQ_SCROLL_LEFT: case REQ_SCROLL_RIGHT: case REQ_SCROLL_LINE_DOWN: case REQ_SCROLL_LINE_UP: case REQ_SCROLL_PAGE_DOWN: case REQ_SCROLL_PAGE_UP: case REQ_SCROLL_WHEEL_DOWN: case REQ_SCROLL_WHEEL_UP: scroll_view(view, request); break; case REQ_VIEW_GREP: open_grep_view(view); break; case REQ_VIEW_MAIN: case REQ_VIEW_DIFF: case REQ_VIEW_LOG: case REQ_VIEW_TREE: case REQ_VIEW_HELP: case REQ_VIEW_BRANCH: case REQ_VIEW_BLAME: case REQ_VIEW_BLOB: case REQ_VIEW_STATUS: case REQ_VIEW_STAGE: case REQ_VIEW_PAGER: case REQ_VIEW_STASH: open_view(view, request, OPEN_DEFAULT); break; case REQ_NEXT: case REQ_PREVIOUS: if (view->parent) { int line; view = view->parent; line = view->pos.lineno; view_request(view, request); move_view(view, request); if (view_is_displayed(view)) update_view_title(view); if (line != view->pos.lineno) view_request(view, REQ_ENTER); } else { move_view(view, request); } break; case REQ_VIEW_NEXT: { int nviews = displayed_views(); int next_view = (current_view + 1) % nviews; if (next_view == current_view) { report("Only one view is displayed"); break; } current_view = next_view; /* Blur out the title of the previous view. */ update_view_title(view); report_clear(); break; } case REQ_REFRESH: report("Refreshing is not supported by the %s view", view->name); break; case REQ_PARENT: report("Moving to parent is not supported by the the %s view", view->name); break; case REQ_BACK: report("Going back is not supported for by %s view", view->name); break; case REQ_MAXIMIZE: if (displayed_views() == 2) maximize_view(view, TRUE); break; case REQ_OPTIONS: case REQ_TOGGLE_LINENO: case REQ_TOGGLE_DATE: case REQ_TOGGLE_AUTHOR: case REQ_TOGGLE_FILENAME: case REQ_TOGGLE_GRAPHIC: case REQ_TOGGLE_REV_GRAPH: case REQ_TOGGLE_REFS: case REQ_TOGGLE_CHANGES: case REQ_TOGGLE_IGNORE_SPACE: case REQ_TOGGLE_ID: case REQ_TOGGLE_FILES: case REQ_TOGGLE_TITLE_OVERFLOW: case REQ_TOGGLE_FILE_SIZE: case REQ_TOGGLE_UNTRACKED_DIRS: case REQ_TOGGLE_VERTICAL_SPLIT: { char action[SIZEOF_STR] = ""; enum view_flag flags = toggle_option(view, request, action); if (flags == VIEW_FLAG_RESET_DISPLAY) { resize_display(); redraw_display(TRUE); } else { foreach_displayed_view(view, i) { if (view_has_flags(view, flags) && !view->unrefreshable) reload_view(view); else redraw_view(view); } } if (*action) report("%s", action); } break; case REQ_TOGGLE_SORT_FIELD: case REQ_TOGGLE_SORT_ORDER: report("Sorting is not yet supported for the %s view", view->name); break; case REQ_DIFF_CONTEXT_UP: case REQ_DIFF_CONTEXT_DOWN: report("Changing the diff context is not yet supported for the %s view", view->name); break; case REQ_SEARCH: case REQ_SEARCH_BACK: search_view(view, request); break; case REQ_FIND_NEXT: case REQ_FIND_PREV: find_next(view, request); break; case REQ_STOP_LOADING: foreach_view(view, i) { if (view->pipe) report("Stopped loading the %s view", view->name), end_update(view, TRUE); } break; case REQ_SHOW_VERSION: report("tig-%s (built %s)", TIG_VERSION, __DATE__); return TRUE; case REQ_SCREEN_REDRAW: redraw_display(TRUE); break; case REQ_EDIT: report("Nothing to edit"); break; case REQ_ENTER: report("Nothing to enter"); break; case REQ_VIEW_CLOSE: /* XXX: Mark closed views by letting view->prev point to the * view itself. Parents to closed view should never be * followed. */ if (view->prev && view->prev != view) { maximize_view(view->prev, TRUE); view->prev = view; break; } /* Fall-through */ case REQ_QUIT: return FALSE; default: report("Unknown key, press %s for help", get_view_key(view, REQ_VIEW_HELP)); return TRUE; } return TRUE; }