jiebi/CodeConvo huggingface dataset:
Code change:
Ubuntu 22.10, Gnome 43.1, fresh VM - The errors are not shown the second time I call and also VS Code seems to start and work I saw , but that should be in by now.

Related discussion:
text: const gtkIMModuleFile = process.env['GTK_IM_MODULE_FILE']; const gdkBackend = process.env['GDK_BACKEND']; const gioModuleDir = process.env['GIO_MODULE_DIR']; <ins> const gtkExePrefix = process.env['GTK_EXE_PREFIX']; </ins> delete process.env['GDK_PIXBUF_MODULE_FILE']; delete process.env['GDK_PIXBUF_MODULEDIR']; delete process.env['GTK_IM_MODULE_FILE']; delete process.env['GDK_BACKEND']; delete process.env['GIO_MODULE_DIR']; <ins> delete process.env['GTK_EXE_PREFIX']; </ins> shell.openExternal(url);
Code change:
Ubuntu 22.10, Gnome 43.1, fresh VM - The errors are not shown the second time I call and also VS Code seems to start and work I saw , but that should be in by now.

Related discussion:
text: process.env['GTK_IM_MODULE_FILE'] = gtkIMModuleFile; process.env['GDK_BACKEND'] = gdkBackend; process.env['GIO_MODULE_DIR'] = gioModuleDir; <ins> process.env['GTK_EXE_PREFIX'] = gtkExePrefix; </ins> } moveItemToTrash(windowId: number | undefined, fullPath: string): Promise<void> {
Code change:
a notebook and run a cell that will continuously update over time to drag the scrollbar while output is still being written :bug: scrollbar is not held and returns to the bottom
Streaming output items are all compressed into a single item in (?), so we would need to stop doing that unless needed (for editing previous lines) Also, the current method only allows passing a single output item, but the output renderer will need to be able to render the entire output as it currently does, or just append the new data. Current: Proposed method that would only be used for streaming outputs and if the chosen renderer contains the method: Another alternative would be adding info to the OutputItem itself, containing only the appended string if appending should happen.

Related discussion:
text: metadata.scrollable : options.outputScrolling; } <ins> //  div.cell_container //    div.output_container //      div.output.output-stream		<-- outputElement parameter //        div.scrollable? tabindex="0" 	<-- contentParent //          div output-item-id="{guid}"	<-- content from outputItem parameter </ins> function renderStream(outputInfo: OutputItem, outputElement: HTMLElement, error: boolean, ctx: IRichRenderContext): IDisposable { const disposableStore = createDisposableStore(); const outputScrolling = scrollingEnabled(outputInfo, ctx.settings);
Code change:
a notebook and run a cell that will continuously update over time to drag the scrollbar while output is still being written :bug: scrollbar is not held and returns to the bottom
Streaming output items are all compressed into a single item in (?), so we would need to stop doing that unless needed (for editing previous lines) Also, the current method only allows passing a single output item, but the output renderer will need to be able to render the entire output as it currently does, or just append the new data. Current: Proposed method that would only be used for streaming outputs and if the chosen renderer contains the method: Another alternative would be adding info to the OutputItem itself, containing only the appended string if appending should happen.

Related discussion:
text: const scrollTop = outputScrolling ? findScrolledHeight(outputElement) : undefined; // If the previous output item for the same cell was also a stream, append this output to the previous <del> const existingContentParent = getPreviousMatchingContentGroup(outputElement); </del> <ins> const existingContentParent = getPreviousMatchingContentGroup(outputElement) || outputElement.querySelector('div'); </ins> if (existingContentParent) { const existing = existingContentParent.querySelector(`[output-item-id="${outputInfo.id}"]`) as HTMLElement | null; if (existing) {
Code change:
Testing When there's too much output, this link uses to explain what it does: <img width="76" alt="image" src="https://user-"<img width="205" alt="image" src="https://user-"This isn't accessible, you should set such that it's read by a screen reader.

Related discussion:
text: const link = document.createElement('a'); link.textContent = '...'; link.href = `command:workbench.action.openLargeOutput?${outputId}`; <ins> link.ariaLabel = 'Open full output in text editor'; </ins> link.title = 'Open full output in text editor'; link.style.setProperty('text-decoration', 'none'); container.appendChild(link);
Code change:
Testing a Markdown file with headers up to H3, enable Sticky Scroll and scroll up and down in the editor. Stick Scroll a header leve and press . Try to scroll up and down with the arrow keys. Unclear where the cursor focus is. Try typing, the editor doesn't have focus Focus should should probably go to the editor on the selected header. That is the behavior with breadcrumb navigation
This is the general behavior of Sticky Scroll and also reproduces if you select a level via the mouse
Verified on OSS

Related discussion:
text: import { IRange, Range } from 'vs/editor/common/core/range'; import { getDefinitionsAtPosition } from 'vs/editor/contrib/gotoSymbol/browser/goToSymbol'; import { goToDefinitionWithLocation } from 'vs/editor/contrib/inlayHints/browser/inlayHintsLocations'; <del> import { Position } from 'vs/editor/common/core/position'; </del> <ins> import { IPosition, Position } from 'vs/editor/common/core/position'; </ins> import { CancellationTokenSource } from 'vs/base/common/cancellation'; import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry'; import { ILanguageFeatureDebounceService } from 'vs/editor/common/services/languageFeatureDebounce';
Code change:
Testing a Markdown file with headers up to H3, enable Sticky Scroll and scroll up and down in the editor. Stick Scroll a header leve and press . Try to scroll up and down with the arrow keys. Unclear where the cursor focus is. Try typing, the editor doesn't have focus Focus should should probably go to the editor on the selected header. That is the behavior with breadcrumb navigation
This is the general behavior of Sticky Scroll and also reproduces if you select a level via the mouse
Verified on OSS

Related discussion:
text: private _focusedStickyElementIndex: number = -1; private _enabled = false; private _focused = false; <ins> private _positionRevealed = false; private _onMouseDown = false; </ins> constructor( private readonly _editor: ICodeEditor,
Code change:
Testing a Markdown file with headers up to H3, enable Sticky Scroll and scroll up and down in the editor. Stick Scroll a header leve and press . Try to scroll up and down with the arrow keys. Unclear where the cursor focus is. Try typing, the editor doesn't have focus Focus should should probably go to the editor on the selected header. That is the behavior with breadcrumb navigation
This is the general behavior of Sticky Scroll and also reproduces if you select a level via the mouse
Verified on OSS

Related discussion:
text: const focusTracker = this._register(dom.trackFocus(this._stickyScrollWidget.getDomNode())); this._register(focusTracker.onDidBlur(_ => { const height = this._stickyScrollWidget.getDomNode().clientHeight; <del> if (height !== 0) { this._disposeFocusStickyScrollStore(); } else { // If the height is 0, then the blur has been caused by scrolling. In that case keep the focus on the sticky scroll. </del> <ins> // Suppose that the blurring is caused by scrolling, then keep the focus on the sticky scroll // This is determined by the fact that the height of the widget has become zero and there has been no position revealing if (this._positionRevealed === false && height === 0) { </ins> this._focusedStickyElementIndex = -1; this.focus(); <ins> } // In all other casees, dispose the focus on the sticky scroll else { this._disposeFocusStickyScrollStore(); </ins> } })); this._register(focusTracker.onDidFocus(_ => { this.focus(); })); this._register(this._createClickLinkGesture()); <ins> // Suppose that mouse down on the sticky scroll, then do not focus on the sticky scroll because this will be followed by the revealing of a position this._register(dom.addDisposableListener(this._stickyScrollWidget.getDomNode(), dom.EventType.MOUSE_DOWN, (e) => { this._onMouseDown = true; })); </ins> } get stickyScrollCandidateProvider(): IStickyLineCandidateProvider {
Code change:
Testing a Markdown file with headers up to H3, enable Sticky Scroll and scroll up and down in the editor. Stick Scroll a header leve and press . Try to scroll up and down with the arrow keys. Unclear where the cursor focus is. Try typing, the editor doesn't have focus Focus should should probably go to the editor on the selected header. That is the behavior with breadcrumb navigation
This is the general behavior of Sticky Scroll and also reproduces if you select a level via the mouse
Verified on OSS

Related discussion:
text: private _disposeFocusStickyScrollStore() { this._stickyScrollFocusedContextKey.set(false); <del> this._focusDisposableStore!.dispose(); </del> <ins> this._focusDisposableStore?.dispose(); </ins> this._focused = false; <ins> this._positionRevealed = false; this._onMouseDown = false; </ins> } public focus(): void { <ins> // If the mouse is down, do not focus on the sticky scroll if (this._onMouseDown) { this._onMouseDown = false; this._editor.focus(); return; } </ins> const focusState = this._stickyScrollFocusedContextKey.get(); if (focusState === true) { return;
Code change:
Testing a Markdown file with headers up to H3, enable Sticky Scroll and scroll up and down in the editor. Stick Scroll a header leve and press . Try to scroll up and down with the arrow keys. Unclear where the cursor focus is. Try typing, the editor doesn't have focus Focus should should probably go to the editor on the selected header. That is the behavior with breadcrumb navigation
This is the general behavior of Sticky Scroll and also reproduces if you select a level via the mouse
Verified on OSS

Related discussion:
text: public goToFocused(): void { const lineNumbers = this._stickyScrollWidget.lineNumbers; this._disposeFocusStickyScrollStore(); <del> this._editor.revealPosition({ lineNumber: lineNumbers[this._focusedStickyElementIndex], column: 1 }); </del> <ins> this._revealPosition({ lineNumber: lineNumbers[this._focusedStickyElementIndex], column: 1 }); } private _revealPosition(position: IPosition): void { this._positionRevealed = true; this._editor.revealPosition(position); this._editor.setSelection(Range.fromPositions(position)); this._editor.focus(); </ins> } private _createClickLinkGesture(): IDisposable {
Code change:
Testing a Markdown file with headers up to H3, enable Sticky Scroll and scroll up and down in the editor. Stick Scroll a header leve and press . Try to scroll up and down with the arrow keys. Unclear where the cursor focus is. Try typing, the editor doesn't have focus Focus should should probably go to the editor on the selected header. That is the behavior with breadcrumb navigation
This is the general behavior of Sticky Scroll and also reproduces if you select a level via the mouse
Verified on OSS

Related discussion:
text: if (this._focused) { this._disposeFocusStickyScrollStore(); } <del> this._editor.revealPosition({ lineNumber: this._stickyScrollWidget.hoverOnLine, column: 1 }); </del> <ins> this._revealPosition({ lineNumber: this._stickyScrollWidget.hoverOnLine, column: 1 }); </ins> } this._instaService.invokeFunction(goToDefinitionWithLocation, e, this._editor as IActiveCodeEditor, { uri: this._editor.getModel()!.uri, range: this._stickyRangeProjectedOnEditor! }); } else if (!e.isRightClick) { // Normal click <del> const position = { lineNumber: this._stickyScrollWidget.hoverOnLine, column: this._stickyScrollWidget.hoverOnColumn }; </del> if (this._focused) { this._disposeFocusStickyScrollStore(); } <del> this._editor.revealPosition(position); this._editor.setSelection(Range.fromPositions(position)); </del> <ins> this._revealPosition({ lineNumber: this._stickyScrollWidget.hoverOnLine, column: this._stickyScrollWidget.hoverOnColumn }); </ins> } })); return linkGestureStore;
Code change:
Currently when you use navigate accessible buffer you get a quick pick with the options, I expected changing these to scroll to the position without accepting it, and escape to revert to the original scroll position.
As part of this, providing ~1/3 of the viewport of context above would also be good
We'd need to think about how we to communicate the preview information to a screen reader user, as a pre"view" is usually visual
I don't think making this available to the screen reader makes sense, it would just complicate navigating the list. It is useful for sighted users though.
Oh I understand now - you mean on change of the active quick pick item, reveal the line and on enter, focus that line (as it already does)
Yep
To verify, in a terminal with shell integration, run some commands. to enter the accessible buffer. to . Without pressing , use the arrow keys to go between the options. It should scroll to the command if it is outside of the viewport.
Works but I opened

Related discussion:
text: import { AudioCue, IAudioCueService } from 'vs/platform/audioCues/browser/audioCueService'; import { IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; import { TerminalContextKeys } from 'vs/workbench/contrib/terminal/common/terminalContextKey'; <ins> import { withNullAsUndefined } from 'vs/base/common/types'; </ins> const enum CssClass { Active = 'active', Hide = 'hide' } <ins> interface IAccessibleBufferQuickPickItem extends IQuickPickItem { lineNumber: number; exitCode?: number; } </ins> export class AccessibleBufferWidget extends DisposableStore { private _accessibleBuffer: HTMLElement; private _bufferEditor: CodeEditorWidget;
Code change:
Currently when you use navigate accessible buffer you get a quick pick with the options, I expected changing these to scroll to the position without accepting it, and escape to revert to the original scroll position.
As part of this, providing ~1/3 of the viewport of context above would also be good
We'd need to think about how we to communicate the preview information to a screen reader user, as a pre"view" is usually visual
I don't think making this available to the screen reader makes sense, it would just complicate navigating the list. It is useful for sighted users though.
Oh I understand now - you mean on change of the active quick pick item, reveal the line and on enter, focus that line (as it already does)
Yep
To verify, in a terminal with shell integration, run some commands. to enter the accessible buffer. to . Without pressing , use the arrow keys to go between the options. It should scroll to the command if it is outside of the viewport.
Works but I opened

Related discussion:
text: private readonly _focusedContextKey: IContextKey<boolean>; private readonly _focusTracker: dom.IFocusTracker; private _inQuickPick = false; <del> private _prependNewLine = false; private _bufferToEditorIndex: Map<number, number> = new Map(); </del> constructor( private readonly _instance: ITerminalInstance,
Code change:
Currently when you use navigate accessible buffer you get a quick pick with the options, I expected changing these to scroll to the position without accepting it, and escape to revert to the original scroll position.
As part of this, providing ~1/3 of the viewport of context above would also be good
We'd need to think about how we to communicate the preview information to a screen reader user, as a pre"view" is usually visual
I don't think making this available to the screen reader makes sense, it would just complicate navigating the list. It is useful for sighted users though.
Oh I understand now - you mean on change of the active quick pick item, reveal the line and on enter, focus that line (as it already does)
Yep
To verify, in a terminal with shell integration, run some commands. to enter the accessible buffer. to . Without pressing , use the arrow keys to go between the options. It should scroll to the command if it is outside of the viewport.
Works but I opened

Related discussion:
text: if (insertion && model && lineCount > this._xterm.raw.rows) { const lineNumber = lineCount + 1; model.pushEditOperations(null, [{ <del> range: { startLineNumber: lineNumber, endLineNumber: lineNumber, startColumn: 1, endColumn: 1 }, text: this._getContent(true) </del> <ins> range: { startLineNumber: lineNumber, endLineNumber: lineNumber, startColumn: 1, endColumn: 1 }, text: this._getContent(1) </ins> }], () => []); } else { model = await this._getTextModel(this._instance.resource.with({ fragment: this._getContent() }));
Code change:
Currently when you use navigate accessible buffer you get a quick pick with the options, I expected changing these to scroll to the position without accepting it, and escape to revert to the original scroll position.
As part of this, providing ~1/3 of the viewport of context above would also be good
We'd need to think about how we to communicate the preview information to a screen reader user, as a pre"view" is usually visual
I don't think making this available to the screen reader makes sense, it would just complicate navigating the list. It is useful for sighted users though.
Oh I understand now - you mean on change of the active quick pick item, reveal the line and on enter, focus that line (as it already does)
Yep
To verify, in a terminal with shell integration, run some commands. to enter the accessible buffer. to . Without pressing , use the arrow keys to go between the options. It should scroll to the command if it is outside of the viewport.
Works but I opened

Related discussion:
text: this._bufferEditor.focus(); } <del> private async _getTextModel(resource: URI): Promise<ITextModel | null> { const existing = this._modelService.getModel(resource); if (existing && !existing.isDisposed()) { return existing; } return this._modelService.createModel(resource.fragment, null, resource, false); } private _getContent(lastBufferIndex?: boolean): string { const buffer = this._xterm?.raw.buffer.active; </del> <ins> private _getContent(startIndex?: number): string { const buffer = this._xterm.raw.buffer.active; </ins> if (!buffer) { return ''; }
Code change:
Currently when you use navigate accessible buffer you get a quick pick with the options, I expected changing these to scroll to the position without accepting it, and escape to revert to the original scroll position.
As part of this, providing ~1/3 of the viewport of context above would also be good
We'd need to think about how we to communicate the preview information to a screen reader user, as a pre"view" is usually visual
I don't think making this available to the screen reader makes sense, it would just complicate navigating the list. It is useful for sighted users though.
Oh I understand now - you mean on change of the active quick pick item, reveal the line and on enter, focus that line (as it already does)
Yep
To verify, in a terminal with shell integration, run some commands. to enter the accessible buffer. to . Without pressing , use the arrow keys to go between the options. It should scroll to the command if it is outside of the viewport.
Works but I opened

Related discussion:
text: const scrollback: number = this._configurationService.getValue(TerminalSettingId.Scrollback); const maxBufferSize = scrollback + this._xterm.raw.rows - 1; const end = Math.min(maxBufferSize, buffer.length - 1); <del> if (lastBufferIndex) { </del> <ins> if (startIndex) { </ins> // If the last buffer index is requested, this is as a result of // a dynamic addition. Return only the last line to prevent duplication. const line = buffer.getLine(end - 1)?.translateToString(false).replace(new RegExp(' ', 'g'), 'xA0'); <del> const result = line ? (this._prependNewLine ? 'n' : '') + line + 'n' : ''; this._prependNewLine = false; </del> <ins> const result = line ? line + 'n' : ''; </ins> return result; } <del> this._bufferToEditorIndex = new Map(); </del> const lines: string[] = []; let currentLine: string = ''; for (let i = 0; i <= end; i++) {
Code change:
Currently when you use navigate accessible buffer you get a quick pick with the options, I expected changing these to scroll to the position without accepting it, and escape to revert to the original scroll position.
As part of this, providing ~1/3 of the viewport of context above would also be good
We'd need to think about how we to communicate the preview information to a screen reader user, as a pre"view" is usually visual
I don't think making this available to the screen reader makes sense, it would just complicate navigating the list. It is useful for sighted users though.
Oh I understand now - you mean on change of the active quick pick item, reveal the line and on enter, focus that line (as it already does)
Yep
To verify, in a terminal with shell integration, run some commands. to enter the accessible buffer. to . Without pressing , use the arrow keys to go between the options. It should scroll to the command if it is outside of the viewport.
Works but I opened

Related discussion:
text: continue; } const isWrapped = buffer.getLine(i + 1)?.isWrapped; <del> this._bufferToEditorIndex.set(i, lines.length); </del> currentLine += line.translateToString(!isWrapped); if (currentLine && !isWrapped || i === end - 1) { lines.push(currentLine.replace(new RegExp(' ', 'g'), 'xA0'));
Code change:
Currently when you use navigate accessible buffer you get a quick pick with the options, I expected changing these to scroll to the position without accepting it, and escape to revert to the original scroll position.
As part of this, providing ~1/3 of the viewport of context above would also be good
We'd need to think about how we to communicate the preview information to a screen reader user, as a pre"view" is usually visual
I don't think making this available to the screen reader makes sense, it would just complicate navigating the list. It is useful for sighted users though.
Oh I understand now - you mean on change of the active quick pick item, reveal the line and on enter, focus that line (as it already does)
Yep
To verify, in a terminal with shell integration, run some commands. to enter the accessible buffer. to . Without pressing , use the arrow keys to go between the options. It should scroll to the command if it is outside of the viewport.
Works but I opened

Related discussion:
text: return lines.join('n'); } <ins> private async _getTextModel(resource: URI): Promise<ITextModel | null> { const existing = this._modelService.getModel(resource); if (existing && !existing.isDisposed()) { return existing; } return this._modelService.createModel(resource.fragment, null, resource, false); } </ins> }
Code change:
Using here, I cannot enter the accessible buffer https://user-
The issue is that here, the default tab behavior is to focus the terminal tabs element edit: hard to repro, that's not the cause
ok this happens when is not applied to . See here that the buffer editor does get focused here, but you cannot see it https://user-
Repro: run some commands - - - Try to wasn't applied to so the accessible buffer isn't visible
https://user-

Related discussion:
text: import { AudioCue, IAudioCueService } from 'vs/platform/audioCues/browser/audioCueService'; import { IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; import { TerminalContextKeys } from 'vs/workbench/contrib/terminal/common/terminalContextKey'; <ins> import { withNullAsUndefined } from 'vs/base/common/types'; </ins> const enum CssClass { Active = 'active', Hide = 'hide' } <ins> interface IAccessibleBufferQuickPickItem extends IQuickPickItem { lineNumber: number; exitCode?: number; } </ins> export class AccessibleBufferWidget extends DisposableStore { private _accessibleBuffer: HTMLElement; private _bufferEditor: CodeEditorWidget;