jiebi/CodeConvo huggingface dataset:
Code change:
So that you know that you are debugging. //cc
I'm not sure on this, personally I would find it kind of annoying to have the toolbar on all windows. Maybe it's a setting, or can be dragged between windows? (Is there reusable cross-window drag logic yet?)
To clarify: not visible on all windows at the same time, but visible on the window that has focus maybe? Otherwise, it will be quite hard to step through a file using mouse in floating windows?
I think having it appear in the active window (when in floating mode) is good.
We solved this issue for quick open where we also want to appear it at the window that has focus. For that, there is which will always be the right container to put global UI elements and is derived from the currently active window. There is a event that can be used to reparent the UI element live.
Thanks!!!
Verification: Start debugging, and drag an editor out to an aux window Make sure the debug toolbar appears on whichever window has focus The debug toolbar should reappear in the same place per-window as you focus it

Related discussion:
text: private isBuilt = false; private readonly stopActionViewItemDisposables = this._register(new DisposableStore()); <ins> /** coordinate of the debug toolbar per aux window */ private readonly auxWindowCoordinates = new WeakMap<CodeWindow, { x: number; y: number | undefined }>(); </ins> constructor( @INotificationService private readonly notificationService: INotificationService,
Code change:
So that you know that you are debugging. //cc
I'm not sure on this, personally I would find it kind of annoying to have the toolbar on all windows. Maybe it's a setting, or can be dragged between windows? (Is there reusable cross-window drag logic yet?)
To clarify: not visible on all windows at the same time, but visible on the window that has focus maybe? Otherwise, it will be quite hard to step through a file using mouse in floating windows?
I think having it appear in the active window (when in floating mode) is good.
We solved this issue for quick open where we also want to appear it at the window that has focus. For that, there is which will always be the right container to put global UI elements and is derived from the currently active window. There is a event that can be used to reparent the UI element live.
Thanks!!!
Verification: Start debugging, and drag an editor out to an aux window Make sure the debug toolbar appears on whichever window has focus The debug toolbar should reappear in the same place per-window as you focus it

Related discussion:
text: // log in telemetry this.telemetryService.publicLog2<WorkbenchActionExecutedEvent, WorkbenchActionExecutedClassification>('workbenchActionExecuted', { id: e.action.id, from: 'debugActionsWidget' }); })); <del> this._register(dom.addDisposableListener(mainWindow, dom.EventType.RESIZE, () => this.setCoordinates())); </del> this._register(dom.addDisposableGenericMouseUpListener(this.dragArea, (event: MouseEvent) => { const mouseClickEvent = new StandardMouseEvent(dom.getWindow(this.dragArea), event); <ins> const activeWindow = dom.getWindow(this.layoutService.activeContainer); </ins> if (mouseClickEvent.detail === 2) { // double click on debug bar centers it again #8250 const widgetWidth = this.$el.clientWidth; <del> this.setCoordinates(0.5 * mainWindow.innerWidth - 0.5 * widgetWidth, 0); </del> <ins> this.setCoordinates(0.5 * activeWindow.innerWidth - 0.5 * widgetWidth, 0); </ins> this.storePosition(); } })); this._register(dom.addDisposableGenericMouseDownListener(this.dragArea, (event: MouseEvent) => { this.dragArea.classList.add('dragged'); <ins> const activeWindow = dom.getWindow(this.layoutService.activeContainer); </ins> <del> const mouseMoveListener = dom.addDisposableGenericMouseMoveListener(mainWindow, (e: MouseEvent) => { const mouseMoveEvent = new StandardMouseEvent(mainWindow, e); </del> <ins> const mouseMoveListener = dom.addDisposableGenericMouseMoveListener(activeWindow, (e: MouseEvent) => { const mouseMoveEvent = new StandardMouseEvent(activeWindow, e); </ins> // Prevent default to stop editor selecting text #8524 mouseMoveEvent.preventDefault(); // Reduce x by width of drag handle to reduce jarring #16604 this.setCoordinates(mouseMoveEvent.posx - 14, mouseMoveEvent.posy - 14); }); <del> const mouseUpListener = dom.addDisposableGenericMouseUpListener(mainWindow, (e: MouseEvent) => { </del> <ins> const mouseUpListener = dom.addDisposableGenericMouseUpListener(activeWindow, (e: MouseEvent) => { </ins> this.storePosition(); this.dragArea.classList.remove('dragged');
Code change:
So that you know that you are debugging. //cc
I'm not sure on this, personally I would find it kind of annoying to have the toolbar on all windows. Maybe it's a setting, or can be dragged between windows? (Is there reusable cross-window drag logic yet?)
To clarify: not visible on all windows at the same time, but visible on the window that has focus maybe? Otherwise, it will be quite hard to step through a file using mouse in floating windows?
I think having it appear in the active window (when in floating mode) is good.
We solved this issue for quick open where we also want to appear it at the window that has focus. For that, there is which will always be the right container to put global UI elements and is derived from the currently active window. There is a event that can be used to reparent the UI element live.
Thanks!!!
Verification: Start debugging, and drag an editor out to an aux window Make sure the debug toolbar appears on whichever window has focus The debug toolbar should reappear in the same place per-window as you focus it

Related discussion:
text: this._register(this.layoutService.onDidChangePartVisibility(() => this.setYCoordinate())); this._register(browser.PixelRatio.onDidChange(() => this.setYCoordinate())); <ins> const resizeListener = this._register(new MutableDisposable()); this._register(this.layoutService.onDidChangeActiveContainer(() => { this._yRange = undefined; // note: we intentionally don't read the activeContainer before the // `then` clause to avoid any races due to quickly switching windows. this.layoutService.whenActiveContainerStylesLoaded.then(() => { if (this.isBuilt) { this.layoutService.activeContainer.appendChild(this.$el); this.setCoordinates(); } resizeListener.value = this._register(dom.addDisposableListener( dom.getWindow(this.layoutService.activeContainer), dom.EventType.RESIZE, () => this.setYCoordinate())); }); })); </ins> } private storePosition(): void { <del> const left = dom.getComputedStyle(this.$el).left; if (left) { const position = parseFloat(left) / mainWindow.innerWidth; this.storageService.store(DEBUG_TOOLBAR_POSITION_KEY, position, StorageScope.PROFILE, StorageTarget.MACHINE); } if (this.yCoordinate) { </del> <ins> const activeWindow = dom.getWindow(this.layoutService.activeContainer); const isMainWindow = this.layoutService.activeContainer === this.layoutService.mainContainer; const left = this.$el.getBoundingClientRect().left / activeWindow.innerWidth; if (isMainWindow) { this.storageService.store(DEBUG_TOOLBAR_POSITION_KEY, left, StorageScope.PROFILE, StorageTarget.MACHINE); </ins> this.storageService.store(DEBUG_TOOLBAR_Y_KEY, this.yCoordinate, StorageScope.PROFILE, StorageTarget.MACHINE); } else { <del> this.storageService.remove(DEBUG_TOOLBAR_Y_KEY, StorageScope.PROFILE); </del> <ins> this.auxWindowCoordinates.set(activeWindow, { x: left, y: this.yCoordinate }); </ins> } }
Code change:
So that you know that you are debugging. //cc
I'm not sure on this, personally I would find it kind of annoying to have the toolbar on all windows. Maybe it's a setting, or can be dragged between windows? (Is there reusable cross-window drag logic yet?)
To clarify: not visible on all windows at the same time, but visible on the window that has focus maybe? Otherwise, it will be quite hard to step through a file using mouse in floating windows?
I think having it appear in the active window (when in floating mode) is good.
We solved this issue for quick open where we also want to appear it at the window that has focus. For that, there is which will always be the right container to put global UI elements and is derived from the currently active window. There is a event that can be used to reparent the UI element live.
Thanks!!!
Verification: Start debugging, and drag an editor out to an aux window Make sure the debug toolbar appears on whichever window has focus The debug toolbar should reappear in the same place per-window as you focus it

Related discussion:
text: if (!this.isVisible) { return; } const widgetWidth = this.$el.clientWidth; <ins> const currentWindow = dom.getWindow(this.layoutService.activeContainer); const isMainWindow = currentWindow === mainWindow; </ins> if (x === undefined) { <del> const positionPercentage = this.storageService.get(DEBUG_TOOLBAR_POSITION_KEY, StorageScope.PROFILE); x = positionPercentage !== undefined ? parseFloat(positionPercentage) * mainWindow.innerWidth : (0.5 * mainWindow.innerWidth - 0.5 * widgetWidth); </del> <ins> const positionPercentage = isMainWindow ? Number(this.storageService.get(DEBUG_TOOLBAR_POSITION_KEY, StorageScope.PROFILE)) : this.auxWindowCoordinates.get(currentWindow)?.x; x = positionPercentage !== undefined ? positionPercentage * currentWindow.innerWidth : (0.5 * currentWindow.innerWidth - 0.5 * widgetWidth); </ins> } <del> x = Math.max(0, Math.min(x, mainWindow.innerWidth - widgetWidth)); // do not allow the widget to overflow on the right </del> <ins> x = clamp(x, 0, currentWindow.innerWidth - widgetWidth); // do not allow the widget to overflow on the right </ins> this.$el.style.left = `${x}px`; if (y === undefined) { <del> y = this.storageService.getNumber(DEBUG_TOOLBAR_Y_KEY, StorageScope.PROFILE, 0); </del> <ins> y = isMainWindow ? this.storageService.getNumber(DEBUG_TOOLBAR_Y_KEY, StorageScope.PROFILE) : this.auxWindowCoordinates.get(currentWindow)?.y; </ins> } <del> this.setYCoordinate(y); </del> <ins> this.setYCoordinate(y || 0); </ins> } private setYCoordinate(y = this.yCoordinate): void {
Code change:
So that you know that you are debugging. //cc
I'm not sure on this, personally I would find it kind of annoying to have the toolbar on all windows. Maybe it's a setting, or can be dragged between windows? (Is there reusable cross-window drag logic yet?)
To clarify: not visible on all windows at the same time, but visible on the window that has focus maybe? Otherwise, it will be quite hard to step through a file using mouse in floating windows?
I think having it appear in the active window (when in floating mode) is good.
We solved this issue for quick open where we also want to appear it at the window that has focus. For that, there is which will always be the right container to put global UI elements and is derived from the currently active window. There is a event that can be used to reparent the UI element live.
Thanks!!!
Verification: Start debugging, and drag an editor out to an aux window Make sure the debug toolbar appears on whichever window has focus The debug toolbar should reappear in the same place per-window as you focus it

Related discussion:
text: private _yRange: [number, number] | undefined; private get yRange(): [number, number] { if (!this._yRange) { <del> const isTitleBarVisible = this.layoutService.isVisible(Parts.TITLEBAR_PART, mainWindow); </del> <ins> const isTitleBarVisible = this.layoutService.isVisible(Parts.TITLEBAR_PART, dom.getWindow(this.layoutService.activeContainer)); </ins> const yMin = isTitleBarVisible ? 0 : this.layoutService.mainContainerOffset.top; let yMax = 0;
Code change:
So that you know that you are debugging. //cc
I'm not sure on this, personally I would find it kind of annoying to have the toolbar on all windows. Maybe it's a setting, or can be dragged between windows? (Is there reusable cross-window drag logic yet?)
To clarify: not visible on all windows at the same time, but visible on the window that has focus maybe? Otherwise, it will be quite hard to step through a file using mouse in floating windows?
I think having it appear in the active window (when in floating mode) is good.
We solved this issue for quick open where we also want to appear it at the window that has focus. For that, there is which will always be the right container to put global UI elements and is derived from the currently active window. There is a event that can be used to reparent the UI element live.
Thanks!!!
Verification: Start debugging, and drag an editor out to an aux window Make sure the debug toolbar appears on whichever window has focus The debug toolbar should reappear in the same place per-window as you focus it

Related discussion:
text: } if (!this.isBuilt) { this.isBuilt = true; <del> this.layoutService.mainContainer.appendChild(this.$el); </del> <ins> this.layoutService.activeContainer.appendChild(this.$el); </ins> } this.isVisible = true;
Code change:
Follow up on Currently we wrap the kb in brackets: <img width="193" alt="image" src=""But we use parentheses in other places where the keybinding is shown, eg hover over problems or terminal pane label, or other icons. <img width="199" alt="image" src=""
Hi thank you for posting this issue. Indeed when I chose the square brackets I was not sure what type of brackets to use. In the editor toolbar menu for example, we appear to be using square brackets. However now that I am looking at the keybindings it appears to me we may be using square brackets for keybinding chords only. I'll ask in the UX channel about this. <img width="423" alt="Screenshot 2023-11-28 at 17 26 10" src=""

Related discussion:
text: return; } this._inlineChatKeybinding = keybinding; <del> const hoverMessage = new MarkdownString(keybinding ? localize('runWithKeybinding', 'Start Inline Chat [{0}]', keybinding) : LOCALIZED_START_INLINE_CHAT_STRING); </del> <ins> const hoverMessage = new MarkdownString(keybinding ? localize('runWithKeybinding', 'Start Inline Chat ({0})', keybinding) : LOCALIZED_START_INLINE_CHAT_STRING); </ins> this._gutterDecorationTransparent.glyphMarginHoverMessage = hoverMessage; this._gutterDecorationOpaque.glyphMarginHoverMessage = hoverMessage; }
Code change:
From testing Steps to Reproduce: multiple terminals multiple terminals in the terminal view to change their color to red the terminals still select, select again time run instead Bug Only a single terminal at a time is reset

Related discussion:
text: /** * Sets or triggers a quick pick to change the color of the associated terminal tab icon. */ <del> changeColor(color?: string): Promise<string | undefined>; </del> <ins> changeColor(color?: string, skipQuickPick?: boolean): Promise<string | undefined>; </ins> /** * Triggers a quick pick that displays recent commands or cwds. Selecting one will
Code change:
From testing Steps to Reproduce: multiple terminals multiple terminals in the terminal view to change their color to red the terminals still select, select again time run instead Bug Only a single terminal at a time is reset

Related discussion:
text: precondition: ContextKeyExpr.and(ContextKeyExpr.or(TerminalContextKeys.processSupported, TerminalContextKeys.terminalHasBeenCreated), TerminalContextKeys.tabsSingularSelection), run: async (c, accessor) => { let color: string | undefined; <ins> let i = 0; </ins> for (const terminal of getSelectedInstances(accessor) ?? []) { <del> color = await terminal.changeColor(color); </del> <ins> const skipQuickPick = i !== 0; // Always show the quickpick on the first iteration color = await terminal.changeColor(color, skipQuickPick); i++; </ins> } } });
Code change:
From testing Steps to Reproduce: multiple terminals multiple terminals in the terminal view to change their color to red the terminals still select, select again time run instead Bug Only a single terminal at a time is reset

Related discussion:
text: when: TerminalContextKeys.tabsFocus }, run: async (c, accessor) => { <del> for (const terminal of getSelectedInstances(accessor) ?? []) { c.service.safeDisposeTerminal(terminal); </del> <ins> const disposePromises: Promise<void>[] = []; for (const terminal of getSelectedInstances(accessor, true) ?? []) { disposePromises.push(c.service.safeDisposeTerminal(terminal)); </ins> } <ins> await Promise.all(disposePromises); </ins> c.groupService.focusTabs(); } });
Code change:
From testing Steps to Reproduce: multiple terminals multiple terminals in the terminal view to change their color to red the terminals still select, select again time run instead Bug Only a single terminal at a time is reset

Related discussion:
text: const terminalGroupService = accessor.get(ITerminalGroupService); const result: ITerminalInstance[] = []; <del> // Get inline tab instance if (terminalGroupService.lastAccessedMenu === 'inline-tab') { </del> <ins> const list = listService.lastFocusedList; // Get selected tab list instance(s) const selections = list?.getSelection(); // Get inline tab instance if there are not tab list selections #196578 if (terminalGroupService.lastAccessedMenu === 'inline-tab' && !selections?.length) { </ins> const instance = terminalGroupService.activeInstance; return instance ? [terminalGroupService.activeInstance] : undefined; } <del> // Get tab list instance if (!listService.lastFocusedList?.getSelection()) { </del> <ins> if (!list || !selections) { </ins> return undefined; } <del> const selections = listService.lastFocusedList.getSelection(); const focused = listService.lastFocusedList.getFocus(); </del> <ins> const focused = list.getFocus(); </ins> if (focused.length === 1 && !selections.includes(focused[0])) { // focused length is always a max of 1
Code change:
From testing Steps to Reproduce: multiple terminals multiple terminals in the terminal view to change their color to red the terminals still select, select again time run instead Bug Only a single terminal at a time is reset

Related discussion:
text: return; } <del> async changeColor(color?: string): Promise<string | undefined> { </del> <ins> async changeColor(color?: string, skipQuickPick?: boolean): Promise<string | undefined> { </ins> if (color) { this.shellLaunchConfig.color = color; this._onIconChanged.fire({ instance: this, userInitiated: true }); return color; <ins> } else if (skipQuickPick) { // Reset this tab's color this.shellLaunchConfig.color = ''; this._onIconChanged.fire({ instance: this, userInitiated: true }); return; </ins> } const icon = this._getIcon(); if (!icon) {
Code change:
open the log in the output view press Ctrl + I. :bug: Inline chat opens in the output view. It's not possible to enter a question. Should not open in the output view.
Tried this and it now does nothing when I press ctrl + I. This is the expected behavior now right?

Related discussion:
text: title: { value: LOCALIZED_START_INLINE_CHAT_STRING, original: 'Start Inline Chat' }, category: AbstractInlineChatAction.category, f1: true, <del> precondition: CTX_INLINE_CHAT_HAS_PROVIDER, </del> <ins> precondition: ContextKeyExpr.and(CTX_INLINE_CHAT_HAS_PROVIDER, EditorContextKeys.writable), </ins> keybinding: { when: EditorContextKeys.focus, weight: KeybindingWeight.WorkbenchContrib,
Code change:
Does this issue occur when all extensions are disabled?: Yes Version: 1.84.2 (user setup) Commit: Date: 2023-11-09T10:51:52.184Z Electron: 25.9.2 ElectronBuildId: Chromium: 114.0.5735.289 18.15.0 V8: 11.4.183.29-electron.0 OS: WindowsNT x64 10.0. Steps to Reproduce: ! also causes to fail. Related issues: Workarround: call
I cannot reproduce, so you just move views around a bunch until the explorer disappears? Do you have any extension?
Yes, Make Folders appear independently and move Explorer into Folders. I expect view back to Explorer include Folders instead of Explorer eventually disappearing. Explorer disappearing can cause other problems, including but not limited to fail. fail. As I said at the beginning: I can even reproduce it in a completely fresh installation of the macOS version of vscode without any extensions installed. !
Okay so I can see that refresh explorer doesn't work in this case, that's for sure. I cannot get folders to completely disappear
In fact, what disappeared was the label . After the move, Its position is replaced by . The folder tree itself is not affected. As shown in the picture, the MOVIES folder contents can still be browsed, but its label(or button anyway) in activity bar is from to . The view hierarchy relationship changes from: Explorer Folders Open editors timeline outline to: Folders Open editors timeline outline The ability to browse folders itself is not affected, but those commands bound to or target to will be invalid. This is also the root cause of .
It's going to be confusion but "Explorer" is actually the container while "Folders" is what we call the view. So when you move Folders out of the explorer it creates its own container called "Folders" and this is working as intended. is a different root cause, but there's definitely a bug here around refresh and other explorer commands. Thanks for the find!
To verify: the folder view (the file tree structure) somewhere else separate from the explorer view container refresh explorer You should stay on the folder view and not be moved to a different view container. You should also see the refresh properly occur.

Related discussion:
text: import { IDisposable } from 'vs/base/common/lifecycle'; import { Event } from 'vs/base/common/event'; import { SIDE_BAR_BACKGROUND } from 'vs/workbench/common/theme'; <del> import { IViewDescriptorService, IViewsService, ViewContainerLocation } from 'vs/workbench/common/views'; </del> <ins> import { IViewDescriptorService, IViewsService } from 'vs/workbench/common/views'; </ins> import { IOpenerService } from 'vs/platform/opener/common/opener'; import { IUriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentity'; import { EditorResourceAccessor, SideBySideEditor } from 'vs/workbench/common/editor';