enum request
stash_request(struct view *view, enum request request, struct line *line)
{
enum open_flags flags = (view_is_displayed(view) && request != REQ_VIEW_DIFF)
? OPEN_SPLIT : OPEN_DEFAULT;
struct view *diff = &diff_view;
switch (request) {
case REQ_VIEW_DIFF:
case REQ_ENTER:
if (view_is_displayed(view) && display[0] != view)
maximize_view(view, true);
if (!view_is_displayed(diff) ||
strcmp(view->env->stash, diff->ref)) {
const char *diff_argv[] = {
"git", "stash", "show", encoding_arg, "--pretty=fuller",
"--root", "--patch-with-stat", use_mailmap_arg(),
show_notes_arg(), diff_context_arg(),
ignore_space_arg(), "%(diffargs)",
"--no-color", "%(stash)", NULL
};
if (!argv_format(diff_view.env, &diff_view.argv, diff_argv, false, false))
report("Failed to format argument");
else
open_view(view, &diff_view, flags | OPEN_PREPARED);
}
return REQ_NONE;
default:
return main_request(view, request, line);
}
}
int
view_control(int key)
{
switch(key){
case REQ_MOVE_DOWN:
case REQ_MOVE_UP:
fresh_view(key);
break;
case REQ_VIEW_CLOSE:
quit(0);
break;
case REQ_OPEN_VIM:
def_prog_mode(); /*save current tty modes*/
endwin(); /*temporarily leave curses*/
system(vim_cmd); /*run shell*/
reset_prog_mode(); /*return to the previous tty mode*/
refresh();
break;
case REQ_VIEW_MAIN:
open_view();
break;
case REQ_RELOAD_VIEW:
Reload_info();
break;
default:
return 1;
}
return 1;
}
static enum request
open_pager_mode(enum request request)
{
enum open_flags flags = OPEN_DEFAULT;
if (request == REQ_VIEW_PAGER) {
/* Detect if the user requested the main view. */
if (argv_contains(opt_rev_argv, "--stdin")) {
request = REQ_VIEW_MAIN;
flags |= OPEN_FORWARD_STDIN;
} else if (argv_contains(opt_cmdline_argv, "--pretty=raw")) {
request = REQ_VIEW_MAIN;
flags |= OPEN_STDIN;
} else {
flags |= OPEN_STDIN;
}
} else if (request == REQ_VIEW_DIFF) {
if (argv_contains(opt_rev_argv, "--stdin"))
flags |= OPEN_FORWARD_STDIN;
}
/* Open the requested view even if the pager mode is enabled so
* the warning message below is displayed correctly. */
open_view(NULL, request, flags);
if (!open_in_pager_mode(flags)) {
close(STDIN_FILENO);
report("Ignoring stdin.");
}
return REQ_NONE;
}
enum request
pager_request(struct view *view, enum request request, struct line *line)
{
int split = 0;
if (request != REQ_ENTER)
return request;
if (line->type == LINE_COMMIT && view_has_flags(view, VIEW_OPEN_DIFF)) {
open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
split = 1;
}
/* Always scroll the view even if it was split. That way
* you can use Enter to scroll through the log view and
* split open each commit diff. */
scroll_view(view, REQ_SCROLL_LINE_DOWN);
/* FIXME: A minor workaround. Scrolling the view will call report_clear()
* but if we are scrolling a non-current view this won't properly
* update the view title. */
if (split)
update_view_title(view);
return REQ_NONE;
}
static int view_driver(struct view *view, int key)
{
switch (key)
{
case REQ_MOVE_DOWN:
case REQ_MOVE_UP:
if (view)
navigate_view(view, key);
break;
case REQ_VIEW_CLOSE:
quit(0);
break;
case REQ_OPEN_VIM:
report("Shelling out...");
def_prog_mode(); /* save current tty modes */
endwin(); /* end curses mode temporarily */
system(vim_cmd); /* run shell */
report("returned"); /* prepare return message */
reset_prog_mode(); /* return to the previous tty modes */
break;
case REQ_VIEW_MAIN:
open_view(view);
break;
case REQ_SCREEN_RESIZE:
resize_display();
redraw_display(TRUE);
break;
default:
return TRUE;
}
return TRUE;
}
static enum request
blame_request(struct view *view, enum request request, struct line *line)
{
enum open_flags flags = view_is_displayed(view) ? OPEN_SPLIT : OPEN_DEFAULT;
struct blame *blame = line->data;
switch (request) {
case REQ_VIEW_BLAME:
case REQ_PARENT:
if (!check_blame_commit(blame, TRUE))
break;
blame_go_forward(view, blame, request == REQ_PARENT);
break;
case REQ_BACK:
blame_go_back(view);
break;
case REQ_ENTER:
if (!check_blame_commit(blame, FALSE))
break;
if (view_is_displayed(VIEW(REQ_VIEW_DIFF)) &&
!strcmp(blame->commit->id, VIEW(REQ_VIEW_DIFF)->ref))
break;
if (string_rev_is_null(blame->commit->id)) {
struct view *diff = VIEW(REQ_VIEW_DIFF);
const char *diff_parent_argv[] = {
GIT_DIFF_BLAME(encoding_arg,
opt_diff_context_arg,
opt_ignore_space_arg, view->vid)
};
const char *diff_no_parent_argv[] = {
GIT_DIFF_BLAME_NO_PARENT(encoding_arg,
opt_diff_context_arg,
opt_ignore_space_arg, view->vid)
};
const char **diff_index_argv = *blame->commit->parent_id
? diff_parent_argv : diff_no_parent_argv;
open_argv(view, diff, diff_index_argv, NULL, flags);
if (diff->pipe)
string_copy_rev(diff->ref, NULL_ID);
} else {
open_view(view, REQ_VIEW_DIFF, flags);
}
break;
default:
return request;
}
return REQ_NONE;
}
void
open_stage_view(struct view *prev, struct status *status, enum line_type type, enum open_flags flags)
{
if (type) {
stage_line_type = type;
if (status)
stage_status = *status;
else
memset(&stage_status, 0, sizeof(stage_status));
}
open_view(prev, &stage_view, flags);
}
static enum request
run_prompt_command(struct view *view, char *cmd)
{
enum request request;
if (cmd && 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 (cmd && iscommit(cmd)) {
string_ncopy(view->env->search, cmd, strlen(cmd));
request = view_request(view, REQ_JUMP_COMMIT);
if (request == REQ_JUMP_COMMIT) {
report("Jumping to commits is not supported by the '%s' view", view->name);
}
} else if (cmd && strlen(cmd) == 1) {
struct key_input input = { { cmd[0] } };
return get_keybinding(&view->ops->keymap, &input);
} else if (cmd && cmd[0] == '!') {
struct view *next = VIEW(REQ_VIEW_PAGER);
const char *argv[SIZEOF_ARG];
int argc = 0;
cmd++;
/* When running random commands, initially show the
* command in the title. However, it maybe later be
* overwritten if a commit line is selected. */
string_ncopy(next->ref, cmd, strlen(cmd));
if (!argv_from_string(argv, &argc, cmd)) {
report("Too many arguments");
} else if (!argv_format(view->env, &next->argv, argv, FALSE, TRUE)) {
report("Argument formatting failed");
} else {
next->dir = NULL;
open_view(view, REQ_VIEW_PAGER, OPEN_PREPARED);
}
} else if (cmd) {
request = get_request(cmd);
if (request != REQ_UNKNOWN)
return request;
char *args = strchr(cmd, ' ');
if (args) {
*args++ = 0;
if (set_option(cmd, args) == SUCCESS) {
request = !view->unrefreshable ? REQ_REFRESH : REQ_SCREEN_REDRAW;
if (!strcmp(cmd, "color"))
init_colors();
}
}
return request;
}
return REQ_NONE;
}
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;
}
