diff --git a/public/git-graph-render.js b/public/git-graph-render.js
index e755c5269..3c1731952 100644
--- a/public/git-graph-render.js
+++ b/public/git-graph-render.js
@@ -168,6 +168,8 @@ function gitGraphRenderGraphSvg(rows, laneAssignments, opts = {}) {
const rowY = Array.isArray(opts.rowY) && opts.rowY.length === rows.length ? opts.rowY : null;
const yOf = i => (rowY ? rowY[i] : rowHeight / 2 + i * rowHeight);
const height = rowY && opts.height ? opts.height : rows.length * rowHeight;
+ // A table row's own height: measured rows are taller than rowHeight.
+ const bendHeight = opts.bendHeight || rowHeight;
const paths = [];
const nodes = [];
@@ -182,15 +184,18 @@ function gitGraphRenderGraphSvg(rows, laneAssignments, opts = {}) {
// An edge bends into its own lane on the first row, runs straight down,
// and only bends again on the last row if its parent sits in another lane.
// A parent that isn't loaded yet keeps the lane running off the bottom.
+ // Across an inline Commit Details panel a bend still takes one row's
+ // height, as everywhere else, and the line runs straight beside the panel.
const via = laneWidth / 2 + (edge.viaLane != null ? edge.viaLane : edge.toLane) * laneWidth;
const targetRow = byHash.get(edge.parentHash);
const loaded = targetRow !== undefined;
const tx = loaded ? laneWidth / 2 + edge.toLane * laneWidth : via;
const ty = loaded ? yOf(targetRow) : height + rowHeight / 2;
const endRow = loaded ? targetRow : rows.length;
- const route = endRow - i > 1
- ? { via, top: yOf(i + 1), bottom: loaded ? yOf(targetRow - 1) : height }
- : null;
+ const span = endRow - i;
+ const top = Math.min(span > 1 ? yOf(i + 1) : ty, cy + bendHeight);
+ const bottom = loaded ? Math.max(top, span > 1 ? yOf(targetRow - 1) : top, ty - bendHeight) : height;
+ const route = span > 1 || ty - cy > bendHeight * 1.5 ? { via, top, bottom } : null;
paths.push(gitGraphEdgePath(cx, cy, tx, ty, color, style, route));
}
diff --git a/public/git-graph.css b/public/git-graph.css
index 8b6449706..acbf66d0f 100644
--- a/public/git-graph.css
+++ b/public/git-graph.css
@@ -321,6 +321,13 @@
padding: 14px 16px 16px;
}
+/* The panel sits under its row and leaves the graph column free, so the lanes
+ run on beside it to the rows below. */
+.gg-details-inline {
+ margin-left: var(--gg-graph-width, 60px);
+ border-bottom: 1px solid rgba(255,255,255,0.07);
+}
+
.gg-details-close {
position: absolute;
top: 8px;
diff --git a/public/project-git-graph-view.js b/public/project-git-graph-view.js
index 022648d09..d86376ef3 100644
--- a/public/project-git-graph-view.js
+++ b/public/project-git-graph-view.js
@@ -411,6 +411,11 @@ function gitGraphPaint(project, state, body, opts = {}) {
gitGraphWireFindWidget(project, state, body);
gitGraphWireHeader(project, state, body);
gitGraphWireRows(project, state, body);
+ // Before the details: bringing a just-opened panel into view starts from here.
+ if (prevScrollTop != null) {
+ const newWrap = body.querySelector('.gg-table-wrap');
+ if (newWrap) newWrap.scrollTop = prevScrollTop;
+ }
if (state.detailsData) {
// The inline details markup already came back inside #gg-tbody's own
// innerHTML (gitGraphRowsHtml/gitGraphInlineDetailsHtml), so only the
@@ -418,11 +423,6 @@ function gitGraphPaint(project, state, body, opts = {}) {
const inline = body.querySelector('#gg-details-inline');
if (inline) { gitGraphWireDetailsPanel(project, state, body, inline); gitGraphMaybeAutoCenterDetails(state, inline); }
}
-
- if (prevScrollTop != null) {
- const newWrap = body.querySelector('.gg-table-wrap');
- if (newWrap) newWrap.scrollTop = prevScrollTop;
- }
}
function gitGraphRepoPickerHtml(repos, active) {
@@ -642,11 +642,22 @@ function gitGraphWireHeader(project, state, body) {
// --- Rows ---
+/** The inline Commit Details open right under the row they belong to: the
+ * commit's own row, or for a comparison the row clicked first. Only when that
+ * row is no longer loaded do they fall to the end of the list. */
function gitGraphRowsHtml(state) {
if (!state.rows.length) return '
No commits yet.
';
const showCols = { date: state.columns.date, author: state.columns.author, commit: state.columns.commit };
- return state.rows.map((row, index) => gitGraphRowHtml(row, state, showCols, index)).join('') +
- (state.detailsData ? gitGraphInlineDetailsHtml(state) : '');
+ const data = state.detailsData;
+ const anchor = data ? (data.mode === 'compare' ? state.selectedHash : data.hash) : null;
+ let placed = false;
+ const html = state.rows.map((row, index) => {
+ const rowHtml = gitGraphRowHtml(row, state, showCols, index);
+ if (!data || placed || row.hash !== anchor) return rowHtml;
+ placed = true;
+ return rowHtml + gitGraphInlineDetailsHtml(state);
+ }).join('');
+ return html + (data && !placed ? gitGraphInlineDetailsHtml(state) : '');
}
function gitGraphRowHtml(row, state, showCols, index) {
@@ -682,13 +693,15 @@ function gitGraphWireRows(project, state, body) {
// (every row repeating every other row's paths/circles) was O(rows²)
// DOM nodes; this is O(rows).
const rowY = [];
+ let rowHeight = 0;
tbody.querySelectorAll('.gg-row[data-row-index]').forEach((el) => {
rowY[Number(el.dataset.rowIndex)] = el.offsetTop + el.offsetHeight / 2;
+ rowHeight = rowHeight || el.offsetHeight;
});
const measured = rowY.length === state.rows.length && rowY.some(y => y > 0);
const svg = gitGraphRenderGraphSvg(state.rows, state.layout, {
style: state.graphStyle, uncommittedChangesStyle: state.uncommittedChangesStyle,
- rowY: measured ? rowY : null, height: measured ? tbody.scrollHeight : null,
+ rowY: measured ? rowY : null, height: measured ? tbody.scrollHeight : null, bendHeight: measured ? rowHeight : null,
});
const clip = document.createElement('div');
clip.className = 'gg-graph-clip'; // decorative only — clicks/right-clicks fall through to the row underneath
@@ -796,7 +809,7 @@ function gitGraphOpenDetails(project, state, body, row) {
state.detailsLoading = true;
state.detailsData = { mode: 'single', hash: row.hash, kind: row.kind };
state.detailsJustOpened = true;
- gitGraphPaint(project, state, body);
+ gitGraphPaintDetails(project, state, body);
const fetch = row.kind === 'uncommitted'
? gitGraphApi('getGitGraphCompareDetail', project.id, repo.path, state.headHash, null)
: gitGraphApi('getGitGraphCommitDetail', project.id, repo.path, row.hash);
@@ -808,7 +821,7 @@ function gitGraphOpenDetails(project, state, body, row) {
} else {
state.detailsData = { mode: 'single', hash: row.hash, kind: row.kind, error: (result && result.error) || 'Could not load commit details.' };
}
- gitGraphPaint(project, state, body);
+ gitGraphPaintDetails(project, state, body);
});
}
@@ -818,7 +831,7 @@ function gitGraphOpenComparison(project, state, body, fromHash, toHash) {
state.detailsLoading = true;
state.detailsData = { mode: 'compare', fromHash, toHash };
state.detailsJustOpened = true;
- gitGraphPaint(project, state, body);
+ gitGraphPaintDetails(project, state, body);
const toArg = toHash === '#uncommitted' ? null : toHash;
gitGraphApi('getGitGraphCompareDetail', project.id, repo.path, fromHash === '#uncommitted' ? toHash : fromHash, fromHash === '#uncommitted' ? null : toArg)
.then((result) => {
@@ -826,33 +839,48 @@ function gitGraphOpenComparison(project, state, body, fromHash, toHash) {
state.detailsLoading = false;
if (result && result.ok) state.detailsData = { mode: 'compare', fromHash, toHash, files: result.files || [] };
else state.detailsData = { mode: 'compare', fromHash, toHash, error: (result && result.error) || 'Could not load comparison.' };
- gitGraphPaint(project, state, body);
+ gitGraphPaintDetails(project, state, body);
});
}
+/** The panel sits among the rows, so painting it repaints the table: that
+ * keeps the graph's lines measured around it, and the scroll position where it
+ * was (a fresh table starts at the top). */
+function gitGraphPaintDetails(project, state, body) {
+ gitGraphPaint(project, state, body, { preserveScroll: true });
+}
+
function gitGraphInlineDetailsHtml(state) {
return `${gitGraphDetailsBodyHtml(state)}
`;
}
function gitGraphRenderDetailsPanel(project, state, body) {
- const container = body.querySelector('#gg-details-inline');
- if (!container) return;
- container.innerHTML = gitGraphDetailsBodyHtml(state);
- gitGraphWireDetailsPanel(project, state, body, container);
-}
-
-/** Scrolls the panel into view exactly once per open — the moment it opens,
- * not on every subsequent repaint of an already-open panel.
- * `state.detailsJustOpened` is set by gitGraphOpenDetails/OpenComparison and
- * cleared the first time this runs *with the real content loaded*. The
- * request's first paint (still `detailsLoading`) shows only the tiny
- * "Loading…" placeholder, so centering on it would land short of where the
- * eventual, much taller panel actually ends up — wait for the repaint that
- * carries the real commit/diff content before centering and clearing it. */
+ // A new height (Tree/List, a folder folded) moves every row below the panel.
+ gitGraphPaintDetails(project, state, body);
+}
+
+/** Brings the panel into view exactly once per open, not on every later
+ * repaint of an already-open panel: `state.detailsJustOpened` is set by
+ * gitGraphOpenDetails/OpenComparison and cleared the first time this runs
+ * *with the real content loaded*. The request's first paint (still
+ * `detailsLoading`) shows only the tiny "Loading…" placeholder, so centering
+ * on it would land short of where the eventual, much taller panel ends up.
+ * The clicked row and its panel are centered in the table, or the row goes to
+ * the top if they are taller than the table. Only the table scrolls, never
+ * the tab around it. */
function gitGraphMaybeAutoCenterDetails(state, container) {
if (!state.detailsJustOpened || state.detailsLoading) return;
state.detailsJustOpened = false;
- if (container && typeof container.scrollIntoView === 'function') container.scrollIntoView({ block: 'center' });
+ const wrap = container && typeof container.closest === 'function' ? container.closest('.gg-table-wrap') : null;
+ if (!wrap) return;
+ const head = wrap.querySelector('.gg-thead');
+ const headHeight = head ? head.offsetHeight : 0;
+ const origin = wrap.getBoundingClientRect().top - wrap.scrollTop;
+ const row = container.previousElementSibling;
+ const top = (row && row.classList && row.classList.contains('gg-row') ? row : container).getBoundingClientRect().top - origin;
+ const bottom = container.getBoundingClientRect().bottom - origin;
+ const room = wrap.clientHeight - headHeight - (bottom - top);
+ wrap.scrollTop = Math.max(0, top - headHeight - Math.max(0, room / 2));
}
function gitGraphDetailsBodyHtml(state) {
@@ -981,7 +1009,7 @@ function gitGraphCloseDetails(project, state, body) {
state.detailsData = null;
state.selectedHash = null;
state.compareHash = null;
- gitGraphPaint(project, state, body);
+ gitGraphPaintDetails(project, state, body);
}
function gitGraphOpenFileDiff(project, state, body, repo, filePath, opts = {}) {
@@ -1236,7 +1264,7 @@ if (typeof module !== 'undefined' && module.exports) {
gitGraphLoadGraph, gitGraphLoadRepositories, gitGraphPaint, gitGraphApi, renderProjectGitGraphTab,
gitGraphSingleCommitHeaderHtml, gitGraphLinkifyBody, gitGraphFileRowHtml, gitGraphFileListHtml,
gitGraphOpenDetails, gitGraphOpenComparison, gitGraphCloseDetails,
- gitGraphMaybeAutoCenterDetails, gitGraphIsAncestor, gitGraphHandleRowClick, gitGraphBindKeyboard,
+ gitGraphMaybeAutoCenterDetails, gitGraphRowsHtml, gitGraphIsAncestor, gitGraphHandleRowClick, gitGraphBindKeyboard,
gitGraphSameBranchNeighbor, gitGraphAlternateBranchNeighbor, gitGraphMoveDetailsFocus,
gitGraphSameStringSet, gitGraphRepoList, gitGraphEnsureWatcherBound,
};
diff --git a/test/project-git-graph-view.test.js b/test/project-git-graph-view.test.js
index 86018eec3..ad397ddae 100644
--- a/test/project-git-graph-view.test.js
+++ b/test/project-git-graph-view.test.js
@@ -786,3 +786,120 @@ test('gitGraphEnsureWatcherBound binds once and repaints into the current Git Hi
delete require.cache[modulePath];
}
});
+
+// === Inline Commit Details open under the clicked row and stay in view ===
+
+function inlineDetailsState(id) {
+ const state = view.gitGraphState(id);
+ state.repositories = [{ path: '/repo', git: true }];
+ state.selectedRepo = '/repo';
+ state.rows = [
+ { hash: 'c3', kind: 'commit', parents: ['c2'], subject: 'third' },
+ { hash: 'c2', kind: 'commit', parents: ['c1'], subject: 'second' },
+ { hash: 'c1', kind: 'commit', parents: [], subject: 'first' },
+ ];
+ state.layout = state.rows.map(() => ({ lane: 0, colorIndex: 0, edges: [] }));
+ return state;
+}
+
+/** Index of each row and of the inline panel in the rows markup. */
+function inlineOrder(html) {
+ return [...html.matchAll(/data-gg-hash="(c\d)" data-row-index|id="gg-details-inline"/g)].map(m => m[1] || 'details');
+}
+
+test('the inline Commit Details sit right under the clicked row, not after the last loaded one', () => {
+ const state = inlineDetailsState('proj-inline-1');
+ state.selectedHash = 'c2';
+ state.detailsData = { mode: 'single', hash: 'c2', kind: 'commit', commit: null, files: [] };
+ assert.deepEqual(inlineOrder(view.gitGraphRowsHtml(state)), ['c3', 'c2', 'details', 'c1']);
+});
+
+test('a comparison opens under the row clicked first, and a commit no longer loaded still shows its details at the end', () => {
+ const state = inlineDetailsState('proj-inline-2');
+ state.selectedHash = 'c3';
+ state.compareHash = 'c1';
+ state.detailsData = { mode: 'compare', fromHash: 'c1', toHash: 'c3', files: [] };
+ assert.deepEqual(inlineOrder(view.gitGraphRowsHtml(state)), ['c3', 'details', 'c2', 'c1']);
+
+ state.selectedHash = 'gone';
+ state.detailsData = { mode: 'single', hash: 'gone', kind: 'commit', commit: null, files: [] };
+ assert.deepEqual(inlineOrder(view.gitGraphRowsHtml(state)), ['c3', 'c2', 'c1', 'details']);
+});
+
+test('opening, loading and closing the inline details never jumps the table back to the top', async () => {
+ const state = inlineDetailsState('proj-inline-3');
+ const project = { id: 'proj-inline-3' };
+ const body = fakeScrollBody();
+ global.window = { api: { getGitGraphCommitDetail: () => Promise.resolve({ ok: true, commit: { hash: 'c2', parents: ['c1'] }, files: [] }) } };
+ body.querySelector('.gg-table-wrap').scrollTop = 400;
+
+ view.gitGraphOpenDetails(project, state, body, state.rows[1]);
+ assert.equal(body.querySelector('.gg-table-wrap').scrollTop, 400, 'the loading paint keeps the scroll position');
+ await new Promise(resolve => setImmediate(resolve));
+ assert.equal(state.detailsLoading, false);
+ assert.equal(body.querySelector('.gg-table-wrap').scrollTop, 400, 'the loaded paint keeps the scroll position');
+
+ view.gitGraphCloseDetails(project, state, body);
+ assert.equal(body.querySelector('.gg-table-wrap').scrollTop, 400, 'closing keeps the scroll position');
+});
+
+/** A wrap/row/panel trio with fixed geometry, in the wrap's own coordinates. */
+function centeringFixture({ scrollTop, clientHeight, headHeight, rowTop, rowHeight, panelHeight }) {
+ const wrap = {
+ scrollTop, clientHeight,
+ getBoundingClientRect: () => ({ top: 100 }),
+ querySelector: (sel) => (sel === '.gg-thead' ? { offsetHeight: headHeight } : null),
+ };
+ const at = (top, height) => () => ({ top: 100 + top - wrap.scrollTop, bottom: 100 + top + height - wrap.scrollTop });
+ const row = { classList: { contains: (c) => c === 'gg-row' }, getBoundingClientRect: at(rowTop, rowHeight) };
+ const panel = {
+ previousElementSibling: row,
+ closest: (sel) => (sel === '.gg-table-wrap' ? wrap : null),
+ getBoundingClientRect: at(rowTop + rowHeight, panelHeight),
+ };
+ return { wrap, panel };
+}
+
+test('auto-center waits for the loaded details, then centers the row and its panel inside the table only', () => {
+ const state = inlineDetailsState('proj-inline-4');
+ const { wrap, panel } = centeringFixture({ scrollTop: 0, clientHeight: 600, headHeight: 30, rowTop: 1000, rowHeight: 24, panelHeight: 200 });
+ state.detailsJustOpened = true;
+ state.detailsLoading = true;
+ view.gitGraphMaybeAutoCenterDetails(state, panel);
+ assert.equal(wrap.scrollTop, 0, 'a "Loading…" placeholder is not worth scrolling to');
+ assert.equal(state.detailsJustOpened, true);
+
+ state.detailsLoading = false;
+ view.gitGraphMaybeAutoCenterDetails(state, panel);
+ // 570px visible under the 30px header, a 224px block: (570 - 224) / 2 = 173 above it.
+ assert.equal(wrap.scrollTop, 1000 - 30 - 173);
+ assert.equal(state.detailsJustOpened, false, 'only once per open');
+
+ const before = wrap.scrollTop;
+ view.gitGraphMaybeAutoCenterDetails(state, panel);
+ assert.equal(wrap.scrollTop, before, 'a later repaint of the same open panel leaves the scroll alone');
+});
+
+test('a panel taller than the table puts its row at the top of the table', () => {
+ const { wrap, panel } = centeringFixture({ scrollTop: 0, clientHeight: 600, headHeight: 30, rowTop: 1000, rowHeight: 24, panelHeight: 900 });
+ const state = inlineDetailsState('proj-inline-5');
+ state.detailsJustOpened = true;
+ view.gitGraphMaybeAutoCenterDetails(state, panel);
+ assert.equal(wrap.scrollTop, 1000 - 30);
+});
+
+test('beside an inline panel a lane change still bends within one row, then the line runs straight', () => {
+ const rows = [{ hash: 'child', kind: 'commit', parents: ['parent'] }, { hash: 'parent', kind: 'commit', parents: [] }];
+ const layout = [
+ { lane: 1, colorIndex: 0, edges: [{ parentHash: 'parent', toLane: 0, viaLane: 1, style: 'same-lane' }] },
+ { lane: 0, colorIndex: 0, edges: [] },
+ ];
+ const pathOf = (svg) => / render.GG_LANE_WIDTH / 2 + n * render.GG_LANE_WIDTH;
+ assert.equal(d, `M${lane(1)} 15 L${lane(1)} 45 L${lane(1)} 215 C${lane(1)} 230, ${lane(0)} 230, ${lane(0)} 245`);
+});