REQ_TOGGLE_LINE_NUMBERS,
REQ_VIEW_NEXT,
REQ_VIEW_CLOSE,
+ REQ_NEXT,
+ REQ_PREVIOUS,
REQ_MOVE_UP,
- REQ_MOVE_UP_ENTER,
REQ_MOVE_DOWN,
- REQ_MOVE_DOWN_ENTER,
REQ_MOVE_PAGE_UP,
REQ_MOVE_PAGE_DOWN,
REQ_MOVE_FIRST_LINE,
unsigned int next:1; /* For ref lists: are there more refs? */
};
-struct commit {
- char id[41]; /* SHA1 ID. */
- char title[75]; /* The first line of the commit message. */
- char author[75]; /* The author of the commit. */
- struct tm time; /* Date from the author ident. */
- struct ref **refs; /* Repository references; tags & branch heads. */
-};
+static struct ref **get_refs(char *id);
/*
* -------
**/
+static const char usage[] =
+VERSION " (" __DATE__ ")\n"
+"\n"
+"Usage: tig [options]\n"
+" or: tig [options] [--] [git log options]\n"
+" or: tig [options] log [git log options]\n"
+" or: tig [options] diff [git diff options]\n"
+" or: tig [options] show [git show options]\n"
+" or: tig [options] < [git command output]\n"
+"\n"
+"Options:\n"
+" -l Start up in log view\n"
+" -d Start up in diff view\n"
+" -n[I], --line-number[=I] Show line numbers with given interval\n"
+" -t[N], --tab-size[=N] Set number of spaces for tab expansion\n"
+" -- Mark end of tig options\n"
+" -v, --version Show version and exit\n"
+" -h, --help Show help message and exit\n";
+
/* Option and state variables. */
static bool opt_line_number = FALSE;
static int opt_num_interval = NUMBER_INTERVAL;
}
/**
+ * -h, --help::
+ * Show help message and exit.
+ **/
+ if (!strcmp(opt, "-h") ||
+ !strcmp(opt, "--help")) {
+ printf(usage);
+ return FALSE;
+ }
+
+ /**
* \--::
* End of tig(1) options. Useful when specifying command
* options for the main view. Example:
#define foreach_view(view, i) \
for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
+#define displayed_views() (display[1] != NULL ? 2 : 1)
/**
* Current head and commit ID
const char *cmd_fmt; /* Default command line format */
const char *cmd_env; /* Command line set via environment */
const char *id; /* Points to either of ref_{head,commit} */
- size_t objsize; /* Size of objects in the line index */
struct view_ops {
/* What type of content being displayed. Used in the
unsigned long offset; /* Offset of the window top */
unsigned long lineno; /* Current line number */
+ /* If non-NULL, points to the view that opened this view. If this view
+ * is closed tig will switch back to the parent view. */
+ struct view *parent;
+
/* Buffering */
unsigned long lines; /* Total number of lines */
void **line; /* Line index; each line contains user data */
static struct view_ops pager_ops;
static struct view_ops main_ops;
-#define VIEW_STR(name, cmd, env, ref, objsize, ops) \
- { name, cmd, #env, ref, objsize, ops }
+#define VIEW_STR(name, cmd, env, ref, ops) \
+ { name, cmd, #env, ref, ops }
-#define VIEW_(id, name, ops, ref, objsize) \
- VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, objsize, ops)
+#define VIEW_(id, name, ops, ref) \
+ VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
/**
* Views
**/
static struct view views[] = {
- VIEW_(MAIN, "main", &main_ops, ref_head, sizeof(struct commit)),
- VIEW_(DIFF, "diff", &pager_ops, ref_commit, sizeof(char)),
- VIEW_(LOG, "log", &pager_ops, ref_head, sizeof(char)),
- VIEW_(HELP, "help", &pager_ops, "static", sizeof(char)),
- VIEW_(PAGER, "pager", &pager_ops, "static", sizeof(char)),
+ VIEW_(MAIN, "main", &main_ops, ref_head),
+ VIEW_(DIFF, "diff", &pager_ops, ref_commit),
+ VIEW_(LOG, "log", &pager_ops, ref_head),
+ VIEW_(HELP, "help", &pager_ops, "static"),
+ VIEW_(PAGER, "pager", &pager_ops, "static"),
};
#define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
/* Scrolling backend */
static void
-do_scroll_view(struct view *view, int lines)
+do_scroll_view(struct view *view, int lines, bool redraw)
{
/* The rendering expects the new offset. */
view->offset += lines;
assert(view->offset <= view->lineno && view->lineno < view->lines);
+ if (!redraw)
+ return;
+
redrawwin(view->win);
wrefresh(view->win);
report("");
die("request %d not handled in switch", request);
}
- do_scroll_view(view, lines);
+ do_scroll_view(view, lines, TRUE);
}
/* Cursor moving */
static void
-move_view(struct view *view, enum request request)
+move_view(struct view *view, enum request request, bool redraw)
{
int steps;
break;
case REQ_MOVE_UP:
- case REQ_MOVE_UP_ENTER:
steps = -1;
break;
case REQ_MOVE_DOWN:
- case REQ_MOVE_DOWN_ENTER:
steps = 1;
break;
}
}
- do_scroll_view(view, steps);
+ do_scroll_view(view, steps, redraw);
return;
}
/* Draw the current line */
view->ops->draw(view, view->lineno - view->offset);
+ if (!redraw)
+ return;
+
redrawwin(view->win);
wrefresh(view->win);
report("");
* Incremental updating
*/
+static void
+end_update(struct view *view)
+{
+ if (!view->pipe)
+ return;
+ set_nonblocking_input(FALSE);
+ if (view->pipe == stdin)
+ fclose(view->pipe);
+ else
+ pclose(view->pipe);
+ view->pipe = NULL;
+}
+
static bool
begin_update(struct view *view)
{
const char *id = view->id;
+ if (view->pipe)
+ end_update(view);
+
if (opt_cmd[0]) {
string_copy(view->cmd, opt_cmd);
opt_cmd[0] = 0;
return TRUE;
}
-static void
-end_update(struct view *view)
-{
- if (!view->pipe)
- return;
- set_nonblocking_input(FALSE);
- if (view->pipe == stdin)
- fclose(view->pipe);
- else
- pclose(view->pipe);
- view->pipe = NULL;
-}
-
static bool
update_view(struct view *view)
{
bool split = !!(flags & OPEN_SPLIT);
bool reload = !!(flags & OPEN_RELOAD);
struct view *view = VIEW(request);
- struct view *displayed;
- int nviews;
-
- /* Cycle between displayed views and count the views. */
- foreach_view (displayed, nviews) {
- if (prev != view &&
- view == displayed &&
- !strcmp(view->vid, prev->vid)) {
- current_view = nviews;
- /* Blur out the title of the previous view. */
- update_view_title(prev);
- report("");
- return;
- }
- }
+ int nviews = displayed_views();
+ struct view *base_view = display[0];
if (view == prev && nviews == 1 && !reload) {
report("Already in %s view", view->name);
display[current_view] = view;
}
- resize_display();
+ /* Resize the view when switching between split- and full-screen,
+ * or when switching between two different full-screen views. */
+ if (nviews != displayed_views() ||
+ (nviews == 1 && base_view != display[0]))
+ resize_display();
if (split && prev->lineno - prev->offset >= prev->height) {
/* Take the title line into account. */
/* Scroll the view that was split if the current line is
* outside the new limited view. */
- do_scroll_view(prev, lines);
+ do_scroll_view(prev, lines, TRUE);
}
if (prev && view != prev) {
- /* "Blur" the previous view. */
- if (!backgrounded)
- update_view_title(prev);
-
/* Continue loading split views in the background. */
if (!split)
end_update(prev);
+ else if (!backgrounded)
+ /* "Blur" the previous view. */
+ update_view_title(prev);
+
+ view->parent = prev;
}
if (view->pipe) {
case REQ_MOVE_PAGE_DOWN:
case REQ_MOVE_FIRST_LINE:
case REQ_MOVE_LAST_LINE:
- move_view(view, request);
+ move_view(view, request, TRUE);
break;
case REQ_SCROLL_LINE_DOWN:
open_view(view, request, OPEN_DEFAULT);
break;
- case REQ_MOVE_UP_ENTER:
- case REQ_MOVE_DOWN_ENTER:
- move_view(view, request);
+ case REQ_NEXT:
+ case REQ_PREVIOUS:
+ request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
+
+ if (view == VIEW(REQ_VIEW_DIFF) &&
+ view->parent == VIEW(REQ_VIEW_MAIN)) {
+ bool redraw = display[1] == view;
+
+ view = view->parent;
+ move_view(view, request, redraw);
+ if (redraw)
+ update_view_title(view);
+ } else {
+ move_view(view, request, TRUE);
+ break;
+ }
/* Fall-through */
case REQ_ENTER:
case REQ_VIEW_NEXT:
{
- int nviews = display[1] ? 2 : 1;
+ int nviews = displayed_views();
int next_view = (current_view + 1) % nviews;
if (next_view == current_view) {
break;
case REQ_SHOW_VERSION:
- report("Version: %s", VERSION);
+ report("%s (built %s)", VERSION, __DATE__);
return TRUE;
case REQ_SCREEN_RESIZE:
return TRUE;
case REQ_VIEW_CLOSE:
- if (display[1]) {
- view = display[(current_view + 1) % ARRAY_SIZE(display)];
+ if (view->parent) {
memset(display, 0, sizeof(display));
current_view = 0;
- display[current_view] = view;
+ display[current_view] = view->parent;
+ view->parent = NULL;
resize_display();
redraw_display();
break;
/*
- * View backend handlers
+ * Pager backend
*/
static bool
pager_enter(struct view *view)
{
char *line = view->line[view->lineno];
+ int split = 0;
- if (view == VIEW(REQ_VIEW_DIFF)) {
- scroll_view(view, REQ_SCROLL_LINE_DOWN);
- return TRUE;
+ if ((view == VIEW(REQ_VIEW_LOG) ||
+ view == VIEW(REQ_VIEW_PAGER)) &&
+ get_line_type(line) == LINE_COMMIT) {
+ open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
+ split = 1;
}
- if (get_line_type(line) == LINE_COMMIT) {
- if (view == VIEW(REQ_VIEW_LOG))
- open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT | OPEN_BACKGROUNDED);
- else
- open_view(view, REQ_VIEW_DIFF, OPEN_DEFAULT);
- }
+ /* 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("")
+ * but if we are scolling a non-current view this won't properly update
+ * the view title. */
+ if (split)
+ update_view_title(view);
return TRUE;
}
};
-static struct ref **get_refs(char *id);
+/*
+ * Main view backend
+ */
+
+struct commit {
+ char id[41]; /* SHA1 ID. */
+ char title[75]; /* The first line of the commit message. */
+ char author[75]; /* The author of the commit. */
+ struct tm time; /* Date from the author ident. */
+ struct ref **refs; /* Repository references; tags & branch heads. */
+};
static bool
main_draw(struct view *view, unsigned int lineno)
static bool
main_enter(struct view *view)
{
- open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
+ enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
+
+ open_view(view, REQ_VIEW_DIFF, flags);
return TRUE;
}
* Switch to pager view.
* h::
* Show man page.
+ **/
+ { 'm', REQ_VIEW_MAIN },
+ { 'd', REQ_VIEW_DIFF },
+ { 'l', REQ_VIEW_LOG },
+ { 'p', REQ_VIEW_PAGER },
+ { 'h', REQ_VIEW_HELP },
+
+ /**
+ * View manipulation
+ * ~~~~~~~~~~~~~~~~~
* q::
- * Close view if multiple views are open, else quit.
+ * Close view, if multiple views are open it will jump back to the
+ * previous view in the view stack. If it is the last open view it
+ * will quit. Use 'Q' to quit all views at once.
* Enter::
* This key is "context sensitive" depending on what view you are
* currently in. When in log view on a commit line or in the main
* pressing Enter will simply scroll the view one line down.
* Tab::
* Switch to next view.
+ * Up::
+ * This key is "context sensitive" and will move the cursor one
+ * line up. However, uf you opened a diff view from the main view
+ * (split- or full-screen) it will change the cursor to point to
+ * the previous commit in the main view and update the diff view
+ * to display it.
+ * Down::
+ * Similar to 'Up' but will move down.
**/
- { 'm', REQ_VIEW_MAIN },
- { 'd', REQ_VIEW_DIFF },
- { 'l', REQ_VIEW_LOG },
- { 'p', REQ_VIEW_PAGER },
- { 'h', REQ_VIEW_HELP },
-
{ 'q', REQ_VIEW_CLOSE },
{ KEY_TAB, REQ_VIEW_NEXT },
{ KEY_RETURN, REQ_ENTER },
+ { KEY_UP, REQ_PREVIOUS },
+ { KEY_DOWN, REQ_NEXT },
/**
* Cursor navigation
* ~~~~~~~~~~~~~~~~~
- * Up::
+ * j::
* Move cursor one line up.
- * Down::
- * Move cursor one line down.
* k::
- * Move cursor one line up and enter. When used in the main view
- * this will always show the diff of the current commit in the
- * split diff view.
- * j::
- * Move cursor one line down and enter.
+ * Move cursor one line down.
* PgUp::
* b::
+ * -::
* Move cursor one page up.
* PgDown::
* Space::
* End::
* Jump to last line.
**/
- { KEY_UP, REQ_MOVE_UP },
- { KEY_DOWN, REQ_MOVE_DOWN },
- { 'k', REQ_MOVE_UP_ENTER },
- { 'j', REQ_MOVE_DOWN_ENTER },
+ { 'k', REQ_MOVE_UP },
+ { 'j', REQ_MOVE_DOWN },
{ KEY_HOME, REQ_MOVE_FIRST_LINE },
{ KEY_END, REQ_MOVE_LAST_LINE },
{ KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
{ ' ', REQ_MOVE_PAGE_DOWN },
{ KEY_PPAGE, REQ_MOVE_PAGE_UP },
{ 'b', REQ_MOVE_PAGE_UP },
+ { '-', REQ_MOVE_PAGE_UP },
/**
* Scrolling
unicode += ((string[3] & 0x3f) << 6);
unicode += (string[4] & 0x3f);
break;
- case 6:
+ case 6:
unicode = (string[0] & 0x01) << 30;
unicode += ((string[1] & 0x3f) << 24);
unicode += ((string[2] & 0x3f) << 18);
*/
/* Whether or not the curses interface has been initialized. */
-bool cursed = FALSE;
+static bool cursed = FALSE;
/* The status window is used for polling keystrokes. */
static WINDOW *status_win;
static struct ref *refs;
static size_t refs_size;
+/* Id <-> ref store */
+static struct ref ***id_refs;
+static size_t id_refs_size;
+
static struct ref **
get_refs(char *id)
{
- struct ref **id_refs = NULL;
- size_t id_refs_size = 0;
+ struct ref ***tmp_id_refs;
+ struct ref **ref_list = NULL;
+ size_t ref_list_size = 0;
size_t i;
+ for (i = 0; i < id_refs_size; i++)
+ if (!strcmp(id, id_refs[i][0]->id))
+ return id_refs[i];
+
+ tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
+ if (!tmp_id_refs)
+ return NULL;
+
+ id_refs = tmp_id_refs;
+
for (i = 0; i < refs_size; i++) {
struct ref **tmp;
if (strcmp(id, refs[i].id))
continue;
- tmp = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
+ tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
if (!tmp) {
- if (id_refs)
- free(id_refs);
+ if (ref_list)
+ free(ref_list);
return NULL;
}
- id_refs = tmp;
- if (id_refs_size > 0)
- id_refs[id_refs_size - 1]->next = 1;
- id_refs[id_refs_size] = &refs[i];
+ ref_list = tmp;
+ if (ref_list_size > 0)
+ ref_list[ref_list_size - 1]->next = 1;
+ ref_list[ref_list_size] = &refs[i];
/* XXX: The properties of the commit chains ensures that we can
* safely modify the shared ref. The repo references will
* always be similar for the same id. */
- id_refs[id_refs_size]->next = 0;
- id_refs_size++;
+ ref_list[ref_list_size]->next = 0;
+ ref_list_size++;
}
- return id_refs;
+ if (ref_list)
+ id_refs[id_refs_size++] = ref_list;
+
+ return ref_list;
}
static int
pclose(pipe);
- if (refs_size == 0)
- die("Not a git repository");
-
return OK;
}
if (load_refs() == ERR)
die("Failed to load refs.");
+ /* Require a git repository unless when running in pager mode. */
+ if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
+ die("Not a git repository");
+
for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
view->cmd_env = getenv(view->cmd_env);
~mdw / tig / blobdiff