8ee64e6145a115d3d4d644df48da4e88508d760a
17
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Oleksandr KholiavkoandSmit Barmase
|
5555a09eec |
csv_preview: Make horizontal scrollbar width respect pinned columns config (#57245)
## Data table: Add left inset for scrollbar alignment with pinned columns When pinned columns are enabled in the data table, the horizontal scrollbar previously extended across the full table width, including behind the pinned columns. This change adds a left inset to the scrollbar so it only spans the scrollable area, properly aligning with the content layout. ## Demo (look at bottom scrollbar) | Before | After| | --- | --- | | <img width="1614" height="482" alt="image_2026-05-20_12-29-22" src="https://github.com/user-attachments/assets/87050173-0f3a-46dd-a7e1-10f769c7b5b8" /> | <img width="1526" height="420" alt="image_2026-05-20_12-32-48" src="https://github.com/user-attachments/assets/5041069f-2289-449b-8d30-8bcb3d0890eb" /> | ### Changes - Add `pinned_width()` and `scrollable_width()` helper methods to `ResizableColumnsState` to compute column widths - Refactor scrollbar rendering to use absolute positioning with inset when pinned columns are present - Scrollbar now correctly positions itself to span only the scrollable (non-pinned) column area Self-Review Checklist: - [x] I've reviewed my own diff for quality, security, and reliability - [x] Unsafe blocks (if any) have justifying comments - [x] The content is consistent with the [UI/UX checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist) - [x] Tests cover the new/changed behavior - [x] Performance impact has been considered and is acceptable Release Notes: - Improved horizontal scrollbar alignment when pinned columns are active - N/A or Added/Fixed/Improved ... --------- Co-authored-by: Smit Barmase <heysmitbarmase@gmail.com> |
||
|
Bowen Xu
|
3d5f7d4762 |
gpui: Allow chaining flex_grow() and flex_shrink() with custom factors (#58142)
Self-Review Checklist: - [x] I've reviewed my own diff for quality, security, and reliability - [x] Unsafe blocks (if any) have justifying comments - [x] The content is consistent with the [UI/UX checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist) - [x] Tests cover the new/changed behavior - [x] Performance impact has been considered and is acceptable Release Notes: - Allow chaining of `flex_grow()` and `flex_shrink()` with custom factors, following Tailwind CSS conventions. _For example:_ <img width="509" height="308" alt="aaa" src="https://github.com/user-attachments/assets/02094fb2-d762-4ac9-a1d9-ef06e2fb047f" /> Before: ``` rust div() .flex() .flex_row() .size_full() .bg(gpui::white()) .child( div() .map(|mut this| { this.style().flex_grow = Some(1.); this }) .bg(gpui::blue()), ) .child( div() .map(|mut this| { this.style().flex_grow = Some(2.); this }) .bg(gpui::green()), ) .child( div() .map(|mut this| { this.style().flex_grow = Some(3.); this }) .bg(gpui::red()), ) ``` After: ``` rust div() .flex() .flex_row() .size_full() .bg(gpui::white()) .child(div().flex_grow(1.).bg(gpui::blue())) .child(div().flex_grow(2.).bg(gpui::green())) .child(div().flex_grow(3.).bg(gpui::red())) ``` |
||
|
Finn Evers
|
5ad5075ccd |
component_preview: Clean up Component trait (#57731)
This primarily
- requires components to have a description as well as a preview
(especially having no preview makes no sense)
- implements some basic previews where missing
- adds a scrollbar to the preview navigation
with a sadly large diff due to reformatting (less indentation 🎉 ), but
very little changes at its core.
Release Notes:
- N/A
|
||
|
Oleksandr KholiavkoandSmit Barmase
|
672393f95c |
csv_preview: Implement data_table columns pining (#56619)
## Summary Adds column pinning (freeze) capability to data tables, allowing the first N columns to remain visible while scrolling horizontally through the rest of the table content. Common spreadsheet/data table UX pattern. When viewing wide tables with many columns, users need to see identifying information (row labels, IDs) while scrolling right to explore data. ## Demo Idle state: <img width="559" height="179" alt="image" src="https://github.com/user-attachments/assets/b3f89221-8aa9-4e8a-9a39-6f06cc8a4eea" /> Scrolled horizontally (name column dissapeared, line numbers column stayed pinned): <img width="522" height="174" alt="image" src="https://github.com/user-attachments/assets/c6695a00-5e40-49b8-81d7-0b30e26bb7bb" /> ## Implementation - New `pin_cols(n: usize)` builder method on `Table` to specify how many columns to pin - Pinned columns render in a fixed section that doesn't scroll horizontally - Scrollable columns render separately with independent scroll state - Horizontal scroll offset adjustments for proper column resize handle positioning with pinned sections - Pinned section stays at viewport left edge while scrollable section scrolls independently - Supports 0 < pinned_cols < total_cols (partial pinning) - Applied to CSV preview for better UX with wide datasets ## Context Part of CSV preview feature series, following PR #53496 (settings UI). Before you mark this PR as ready for review, make sure that you have: - [x] Added a solid test coverage and/or screenshots from doing manual testing - [x] Done a self-review taking into account security and performance aspects - [ ] ~~Aligned any UI changes with the [UI checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)~~ no ui changes besides pinning itself. UI improvements out of scope of this PR Release Notes: - Improved CSV preview with column pinning to keep identifiers visible while scrolling --------- Co-authored-by: Smit Barmase <heysmitbarmase@gmail.com> |
||
|
Oleksandr KholiavkoandAnthony Eid
|
45ea641c6a |
csv_preview: Add independently resizable columns (#53295)
This PR adds spreadsheet-style independently resizable columns (dragging
changes total table width) and fixes scrolling issues in variable list
mode.
**What changed:**
- Adds `ResizableColumnsState` struct for independently resizable
columns (spreadsheet-style)
- Adds `ColumnWidthConfig::Resizable` variant for spreadsheet mode
- Adds `DraggedResizableColumn` drag payload type
- Adds `ResizableHeaderInfo` for double-click-to-reset functionality
- Adds `render_resize_handles_resizable` function for resize handles
rendering
- Adds horizontal scroll handle to `TableInteractionState`
- Adds `.on_drag_move::<DraggedResizableColumn>` handler to Table for
drag resizing
**Bug fixes:**
- Fixed missing vertical scrollbar in variable list mode
- Fixed half-broken scrolling in variable list mode (added
.measure_all() to make scrollbar aware of the height of the table)
- Moved vertical scrollbar to be pinned at the right side of the pane
with table — previously it was attached to the table content and was
pushed off-screen when table content was too wide
**API addition:**
```rust
// New variant added:
pub enum ColumnWidthConfig {
Static { widths: StaticColumnWidths, table_width: Option<DefiniteLength> },
Redistributable { entity: Entity<RedistributableColumnsState>, table_width: Option<DefiniteLength> },
Resizable(Entity<ResizableColumnsState>), // NEW: spreadsheet-style
}
```
**Callers updated:**
- csv_preview: Changed from `ColumnWidthConfig::redistributable()` to
use new resizable mode
- git_graph: Added `resizable_info` parameter
**Context:**
This is part 3 of a 3-PR series improving data table column width
handling:
1. [#51059](https://github.com/zed-industries/zed/pull/51059) - Extract
modules into separate files (mechanical change)
2. [#51120](https://github.com/zed-industries/zed/pull/51120) -
Introduce width config enum for redistributable column widths (API
rework)
3. **This PR**: Add independently resizable columns + fix variable list
scrolling (new feature + bug fixes)
The series builds on previously merged infrastructure:
- [#46341](https://github.com/zed-industries/zed/pull/46341) - Data
table dynamic column support
- [#46190](https://github.com/zed-industries/zed/pull/46190) - Variable
row height mode for data tables
Primary beneficiary: CSV preview feature
([#48207](https://github.com/zed-industries/zed/pull/48207))
This work is based on the [original draft PR
#44344](https://github.com/zed-industries/zed/pull/44344), decomposed
into reviewable pieces.
-----
Self-Review Checklist:
- [x] I've reviewed my own diff for quality, security, and reliability
- [x] Unsafe blocks (if any) have justifying comments
- [x] The content is consistent with the [UI/UX
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
- [x] Tests cover the new/changed behavior
- [x] Performance impact has been considered and is acceptable
Closes #ISSUE
Release Notes:
- N/A or Added/Fixed/Improved ...
---------
Co-authored-by: Anthony Eid <anthony@zed.dev>
|
||
|
Anthony Eid
|
e80cd7351e |
git_graph: Make the graph canvas resizable (#52953)
### Summary This PR integrates the git graph canvas with the `Table` component’s `RedistributableColumnsState`, making the graph column resizable while preserving the table’s existing resize behavior. In particular, column resizing continues to use the same cascading redistribution behavior as the table. This is also the last PR needed to remove the feature flag on the git graph! ### Table API changes I pulled the redistributable column logic out of `Table` into reusable UI helpers so layouts outside of `Table` can participate in the same column resizing behavior. This adds a shared `RedistributableColumnsState` API, along with helpers for binding drag/drop behavior, rendering resize handles, and constructing header resize metadata. I also added `ColumnWidthConfig::explicit` and `TableRenderContext::for_column_widths` so callers can render table like headers and content with externally managed column widths. The reason for this change is that the git graph now renders a custom split layout: a graph canvas on the left and table content on the right. By reusing the same column state and resize machinery, the graph column can resize together with the table columns while preserving the existing table behavior, including cascading column redistribution and double click reset to default sizing. I also adjusted the resize handle interaction styling so the divider stays in its hovered/highlighted state while a drag is active, which makes the drag target feel more stable and visually consistent during resizing. ### Preview https://github.com/user-attachments/assets/347eed71-0cc1-4db4-9dee-a86ee5ab6f91 Self-Review Checklist: - [x] I've reviewed my own diff for quality, security, and reliability - [x] Unsafe blocks (if any) have justifying comments - [x] The content is consistent with the [UI/UX checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist) - [ ] Tests cover the new/changed behavior - [x] Performance impact has been considered and is acceptable Release Notes: - N/A or Added/Fixed/Improved ... |
||
|
Oleksandr KholiavkoandAnthony Eid
|
ae472aac1d |
Rework column/table width API in data table (#51060)
data_table: Replace column width builder API with `ColumnWidthConfig`
enum
This PR consolidates the data table width configuration API from three
separate builder methods (`.column_widths()`, `.resizable_columns()`,
`.width()`) into a single `.width_config(ColumnWidthConfig)` call. This
makes invalid state combinations unrepresentable and clarifies the two
distinct width management modes.
**What changed:**
- Introduces `ColumnWidthConfig` enum with two variants:
- `Static`: Fixed column widths, no resize handles
- `Redistributable`: Drag-to-resize columns that redistribute space
within a fixed table width
- Introduces `TableResizeBehavior` enum (`None`, `Resizable`,
`MinSize(f32)`) for per-column resize policy
- Renames `TableColumnWidths` → `RedistributableColumnsState` to better
reflect its purpose
- Extracts all width management logic into a new `width_management.rs`
module
- Updates all callers: `csv_preview`, `git_graph`, `keymap_editor`,
`edit_prediction_context_view`
```rust
pub enum ColumnWidthConfig {
/// Static column widths (no resize handles).
Static {
widths: StaticColumnWidths,
/// Controls widths of the whole table.
table_width: Option<DefiniteLength>,
},
/// Redistributable columns — dragging redistributes the fixed available space
/// among columns without changing the overall table width.
Redistributable {
entity: Entity<RedistributableColumnsState>,
table_width: Option<DefiniteLength>,
},
}
```
**Why:**
The old API allowed callers to combine methods incorrectly. The new
enum-based design enforces correct usage at compile time and provides a
clearer path for adding independently resizable columns in PR #3.
**Context:**
This is part 2 of a 3-PR series improving data table column width
handling:
1. [#51059](https://github.com/zed-industries/zed/pull/51059) - Extract
modules into separate files (mechanical change)
2. **This PR**: Introduce width config enum for redistributable column
widths (API rework)
3. Implement independently resizable column widths (new feature)
The series builds on previously merged infrastructure:
- [#46341](https://github.com/zed-industries/zed/pull/46341) - Data
table dynamic column support
- [#46190](https://github.com/zed-industries/zed/pull/46190) - Variable
row height mode for data tables
Primary beneficiary: CSV preview feature
([#48207](https://github.com/zed-industries/zed/pull/48207))
### Anthony's note
This PR also fixes the table dividers being a couple pixels off, and the
csv preview from having double line rendering for a single column in
some cases.
Before you mark this PR as ready for review, make sure that you have:
- [x] Added a solid test coverage and/or screenshots from doing manual
testing
- [x] Done a self-review taking into account security and performance
aspects
- [ ] Aligned any UI changes with the [UI
checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist)
Release Notes:
- N/A
---------
Co-authored-by: Anthony Eid <anthony@zed.dev>
|
||
|
Oleksandr Kholiavko
|
e4f4525493 |
ui: Extract table_row & tests modules to separate files (#51059)
Extract data table modules into separate files This PR extracts the `tests` and `table_row` modules from `data_table.rs` into separate files to improve code organization. This is preparatory work for the upcoming column width API rework (#2 in the series), where separating mechanical changes from logical changes will make the review easier. The extraction was performed using rust-analyzer's "Extract module to file" command. **Context:** This is part 1 of a 3-PR series improving data table column width handling: 1. **This PR**: Extract modules into separate files (mechanical change) 2. [#51060](https://github.com/zed-industries/zed/pull/51060) - Introduce width config enum for redistributable column widths (API rework) 3. Implement independently resizable column widths (new feature) The series builds on previously merged infrastructure: - [#46341](https://github.com/zed-industries/zed/pull/46341) - Data table dynamic column support - [#46190](https://github.com/zed-industries/zed/pull/46190) - Variable row height mode for data tables Primary beneficiary: CSV preview feature ([#48207](https://github.com/zed-industries/zed/pull/48207)) Release Notes: - N/A |
||
|
Oleksandr KholiavkoandAnthony Eid
|
d4634441e2 |
Add CSV preview with live table view and interactive features (#48207)
## **Description:** **Context:** This PR introduces an initial CSV preview feature for Zed, building upon two previously merged infrastructure PRs: - [#46341](https://github.com/zed-industries/zed/pull/46341) - Data table dynamic column support (removed const generics) - [#46190](https://github.com/zed-industries/zed/pull/46190) - Variable row height mode for data tables This implementation is based on the [original draft PR #44344](https://github.com/zed-industries/zed/pull/44344), which has been carefully decomposed into smaller, reviewable pieces. --- #### **Features Included:** **Core Infrastructure:** - Live CSV parsing with smart debouncing (200ms cooldown) - Performance monitoring with built-in timing metrics (not displayed in UI yet) - Automatic file change detection and re-parsing - Support for quoted fields, multiline cells, and escaped characters **Table Display:** - Variable row height rendering with fallback to uniform mode (switchable via settings) - Draggable column resizing (reusing existing data table infrastructure) - Row identifiers supporting both source line numbers and sequential row numbers - Configurable font rendering (UI font vs monospace) - Tooltips showing full cell content on hover **Interactive Features:** - Column sorting (ascending/descending) with visual indicators **Settings Panel:** - Toggle between variable/uniform row rendering - Font type selection (UI/monospace) - Row identifier type configuration - Debug information display - Multiline cell rendering options --- #### **Features Intentionally Removed for This PR:** To reduce complexity and review scope, the following features were temporarily reverted and will be reintroduced in subsequent PRs: - ❌ Settings pannel with performance metrics overlay - ❌ Cell selection (single, multiple, and range selections) - ❌ Keyboard navigation with arrow keys and selection extension - ❌ Copy functionality supporting CSV, TSV, and Markdown table formats - ❌ Inline cell editing with file persistence - ❌ Viewport following for large datasets - ❌ Column filtering and search capabilities These removals were done via "time-machine" commits that cleanly nuked vertical slices of functionality from the complete implementation. --- **Technical Implementation:** The feature is organized into a dedicated `csv_preview` crate with the following structure: ``` crates/csv_preview/ ├── src/ │ ├── csv_preview.rs # Main view and coordination logic │ ├── parser.rs # CSV parsing and editor integration │ ├── settings.rs # Configuration types and defaults │ ├── table_data_engine.rs # Data transformation logic │ ├── renderer/ # UI rendering modules │ │ ├── preview_view.rs # Main render implementation │ │ ├── render_table.rs # Table component assembly │ │ ├── table_cell.rs # Individual cell rendering │ │ ├── table_header.rs # Header with sorting controls │ │ └── row_identifiers.rs # Line number column │ └── types/ # Core data structures │ ├── table_like_content.rs │ ├── coordinates.rs # Display vs data coordinate systems │ └── table_cell.rs ``` **Key architectural decisions:** - **Dual coordinate system**: Separates data indices from display indices to support sorting/filtering - **Component reuse**: Leverages existing `data_table` infrastructure from the keymap editor --- **Integration:** - Registers `csv::OpenPreview` action (currently without default keybindings) - Follows the same workspace integration pattern as `markdown_preview` and `svg_preview` - Automatically detects `.csv` file extensions - Tab integration with appropriate icons and naming --- **Code Structure Note:** Some code structures, types, and documentation may appear redundant or over-engineered in this initial implementation. This is intentional - the feature was developed as a complete system and then decomposed by functionality rather than being built incrementally. The "extra" infrastructure supports features that were removed for this PR but will be reintroduced in subsequent ones. This approach was chosen over extensive refactoring because: 1. The complete feature took 200+ commits to develop with significant rewrites 2. Clean extraction of vertical slices was more feasible than rebuilding incrementally 3. The end state will utilize all these components, making current "redundancy" temporary I apologize for any inconvenience this may cause during review, but the alternative would have required significant refactoring effort just to make intermediate states "prettier," which seemed counterproductive. --- **Future Work:** This lays the groundwork for upcoming PRs that will reintroduce the removed features: - Cell selection and keyboard navigation - Copy functionality with multiple output formats - Inline editing capabilities with undo/redo - Column filtering and search - TSV and other delimiter support - Improved horizontal scrolling behavior - Settings persistence **Testing:** Includes test fixtures demonstrating multiline cell handling, various column counts, and edge cases. --- **Release Notes:** - N/A This is feature flagged --------- Co-authored-by: Anthony Eid <anthony@zed.dev> |
||
|
Danilo LealandAnthony Eid
|
b5d5936029 |
git_graph: Add some design adjustments (#49899)
- Made hover/active styles, as well as clicks, work for the entire row, capture the graph element, too (needed to make some manual hover and other states management to pull that off) - Used the existing `Chip` component for the branch chip instead of a local recreation - Adjusted spacing and sizing of commit detail panel, including button labels truncation and tooltip content - Added diff stat numbers for the changed files, to match the commit view - Standardized the commit avatar component across the git graph, the commit view, and the file history view - Added scrollbar to the changed files uniform list - Removed author name display redundancy (kept only email) - Made the commit detail UI have a min-width <img width="750" height="1964" alt="Screenshot 2026-02-23 at 11 31@2x" src="https://github.com/user-attachments/assets/d1433bd8-5edb-4829-882b-52b1bffbd6db" /> --- Before you mark this PR as ready for review, make sure that you have: - [x] Added a solid test coverage and/or screenshots from doing manual testing - [x] Done a self-review taking into account security and performance aspects - [x] Aligned any UI changes with the [UI checklist](https://github.com/zed-industries/zed/blob/main/CONTRIBUTING.md#uiux-checklist) Release Notes: - N/A --------- Co-authored-by: Anthony Eid <anthony@zed.dev> |
||
|
|
c51f7b8a66 |
git: Add graph support (#44434)
Closes #26866 ### Summary Adds a git graph to Zed, accessible via the `git_graph::Open` action if a project has an active repository. There's still more to do, but this is a solid foundation to expand upon. The code structure is in line with Zed's codebase and shouldn't require architectural changes to add missing features. The git graph can be opened via the command palette (`git graph: open`) or by binding a key to `git_graph::Open`. It's available when the project has an active git repository. ### Architecture Similar to the Debugger, the git graph is split between a data layer and a view/UI layer. When the view layer is rendering, it queries the data layer for its active state. This setup allows the data layer to lazily request graph data (only when needed for rendering), abstracts collab from the view layer, allows most of the data loading to happen on a background thread, and makes caching easy to implement. #### Graph Loading The graph data is loaded in two phases: 1. `Repository::graph_data()` streams commit structure (SHA, parents, refs) in chunks of 1000 via `git log` 2. `CommitDataReader` lazily fetches full commit details (author, timestamp, subject) on-demand using a persistent `git cat-file --batch` process This two-phase approach makes the initial loading of the graph as fast as possible, because `git log` takes significantly longer when all the needed graph data is queried through it. Zed then lazily loads commits in the user's viewport through `cat-file --batch`. This makes scrolling to any place in the graph extremely snappy and benefits the collaborative architecture by only fetching data needed to render the graph. It also allows Zed to share commit data between different graph visualizations (e.g., date order vs. topological order). #### Performance Tested on both the Zed and LLVM repositories with good performance in both cases. The two-phase loading approach and lazy fetching keep the UI responsive even with large commit histories. #### Testing I added property testing that builds randomized commit graphs and verifies that the graph is constructed correctly. This also works as an integration test and will be expanded in the future to test collab graph visualization, graph filtering, commit actions, etc. ### New Crate - `git_graph` (GPL-licensed) — contains UI and graph computation logic ### Not Yet Implemented - Remote repository support (collab) - Filtering by branch - Commit actions (checkout, cherry-pick, etc.) - Search - Open commit view for selected commit - Resizable columns - Column filtering #### Reference <img width="1624" height="976" alt="Screenshot 2025-01-22 at 8 15 39 PM" src="https://github.com/user-attachments/assets/0f10924a-3964-462f-b320-42d84d02f7bf" /> Special thanks to [Alberto Slavica](https://github.com/pyundev) for submitting #44405, which was a good base to work off of. Release Notes: - git: Add initial version of git graph --------- Co-authored-by: pyundev <pyundev@users.noreply.github.com> Co-authored-by: Cole Miller <cole@zed.dev> Co-authored-by: Zed Zippy <234243425+zed-zippy[bot]@users.noreply.github.com> |
||
|
Oleksandr KholiavkoandAnthony Eid
|
6c2a0c21e6 |
Remove const generics from data table (runtime column count support) (#46341)
This PR removes the const generics limitation from the data table component, enabling tables with a dynamic number of columns determined at runtime. **Context:** This is the next infrastructure step split out from the [original CSV preview draft PR](https://github.com/zed-industries/zed/pull/44344). The draft PR remains open as a reference and will continue to be decomposed into smaller, reviewable pieces. **Details:** - Introduces a `TableRow` newtype to enforce column count invariants at runtime, replacing the previous const generic approach. It's api surface is larger than is currently used, as it's planned to be used in CSV feature itself. - Refactors the data table and all usages (including the keymap editor) to work with runtime column counts. - This change is foundational for supporting CSV preview and other features that require flexible, dynamic tables. - Performance impact has not been formally measured, but there is no noticeable slowdown in practice. --- Release Notes: - N/A (internal infrastructure change, no user impact) --------- Co-authored-by: Anthony Eid <anthony@zed.dev> |
||
|
Oleksandr Kholiavko
|
f6f1c64a40 |
Add variable row height mode to table UI element (#46190)
## Add variable row height mode to data table infrastructure This PR introduces support for variable row heights in the data table component, laying the groundwork for more flexible tabular data rendering in Zed. **Context:** This is the first in a series of infrastructure-focused PRs split out from the [original CSV preview draft PR](https://github.com/zed-industries/zed/pull/44344). The draft PR remains open as a reference and will be incrementally decomposed into smaller, reviewable pieces like this one. **Details:** - Adds a variable row height mode to the data table, enabling future features that require rows of differing heights (such as CSV preview and, eventually, database table views). - No user-facing changes; this is an internal refactor to support upcoming functionality. **Thanks:** Big thanks to @Anthony-Eid for pairing sessions and guidance on how to best structure and land these changes incrementally. --- Release Notes: - N/A (internal infrastructure change, no user impact) |
||
|
|
05d73bf013 |
Add experimental LSP-based context retrieval system for edit prediction (#44036)
To do * [x] Default to no context retrieval. Allow opting in to LSP-based retrieval via a setting (for users in `zeta2` feature flag) * [x] Feed this context to models when enabled * [x] Make the zeta2 context view work well with LSP retrieval * [x] Add a UI for the setting (for feature-flagged users) * [x] Ensure Zeta CLI `context` command is usable --- * [ ] Filter out LSP definitions that are too large / entire files (e.g. modules) * [ ] Introduce timeouts * [ ] Test with other LSPs * [ ] Figure out hangs Release Notes: - N/A --------- Co-authored-by: Ben Kunkle <ben@zed.dev> Co-authored-by: Agus Zubiaga <agus@zed.dev> |
||
|
Jason Lee
|
2474fceea7 |
gpui: Unify track_scroll method to receive a reference type (#43518)
Release Notes: - N/A This PR to change the `track_scroll` method to receive a reference type like the [Div#track_scroll](https://docs.rs/gpui/latest/gpui/trait.StatefulInteractiveElement.html#method.track_scroll), [Div#track_focus](https://docs.rs/gpui/latest/gpui/trait.InteractiveElement.html#method.track_focus). ```diff - .track_scroll(self.scroll_handle.clone()) + .track_scroll(&self.scroll_handle) - .vertical_scrollbar_for(self.scroll_handle.clone(), window, cx) + .vertical_scrollbar_for(&self.scroll_handle, window, cx) ``` https://github.com/zed-industries/zed/blob/16a9ea8b45e680a7900eccfd5fa3d2759b12f77f/crates/gpui/src/elements/div.rs#L1088-L1093 https://github.com/zed-industries/zed/blob/16a9ea8b45e680a7900eccfd5fa3d2759b12f77f/crates/gpui/src/elements/div.rs#L613-L620 |
||
|
Danilo Leal
|
4025075995 |
keymap_editor: Adjust some items of the UI (#42876)
- Only showing the "Create" menu item in the right-click context menu for actions that _do not_ contain a binding already assigned to them - Only show the "Clear Input" icon button in the keystroke modal when the input is focused/in recording mode - Add a subtle hover style to the table rows just to make it easier to navigate Release Notes: - N/A |
||
|
Ben Kunkle
|
cc7d4ae740 |
Move Keymap Editor Table component to UI crate (#38157)
Closes #ISSUE Move the data table component created for the Keymap Editor to the UI crate. Additionally includes simplifications to the scrollbar component in UI necessary for the table component to support scrollbar configurations, and a fix for an issue with the table component where when used with the `.row` API instead of `uniform_list` the rows would render on top of each other. Release Notes: - N/A *or* Added/Fixed/Improved ... |