Closes#1665
## Description
When `Input::new().font_family("font")` is used, the font hasn't been
applied yet in `Input::render`, therefore the `text_wrapper` will
calculate using the wrong font. This is why it's working when the font
is added to the parent element.
The fix moves the state update to `element` prepaint, where
`window.text_style()` has the correct styles. The only downside is that
there are now one additional state update.
## Screenshot
| Before | After |
| ---------------------------- | --------------------------- |
| <img width="1125" height="246" alt="Screenshot From 2025-11-30
20-03-11"
src="https://github.com/user-attachments/assets/1fa798a7-0b9c-4386-8940-ad5f6734b8a0"
/> | <img width="1125" height="246" alt="Screenshot From 2025-11-30
20-00-23"
src="https://github.com/user-attachments/assets/e970e7bc-1bfa-4a55-a342-3381d1684526"
/> |
## How to Test
Use some wide font, like `IBM Plex Mono`. Apply it to
`Input::new(&some_state).font_family("IBM Plex Mono")` where the input
state has `soft_wrap`. Here is a diff for `textarea_story.rs`.
```diff
diff --git a/crates/story/src/textarea_story.rs b/crates/story/src/textarea_story.rs
index f2c63d44..bd5cbb31 100644
--- a/crates/story/src/textarea_story.rs
+++ b/crates/story/src/textarea_story.rs
@@ -77,9 +77,9 @@ impl TextareaStory {
let textarea_no_wrap = cx.new(|cx| {
InputState::new(window, cx)
- .multi_line(true)
.rows(6)
- .soft_wrap(false)
+ .multi_line(true)
+ .soft_wrap(true)
.default_value("This is a very long line of text to test if the horizontal scrolling function is working properly, and it should not wrap automatically but display a horizontal scrollbar.\nThe second line is also very long text, used to test the horizontal scrolling effect under multiple lines, and you can input more content to test.\nThe third line: Here you can input other long text content that requires horizontal scrolling.\n")
});
@@ -195,7 +185,7 @@ impl Render for TextareaStory {
.child(
section("Auto Grow")
.max_w_md()
- .child(Input::new(&self.textarea_auto_grow)),
+ .child(Input::new(&self.textarea_auto_grow).font_family("IBM Plex Mono")),
)
.child(
section("Auto Grow with No Wrap")
```
## Checklist
- [x] I have read the [CONTRIBUTING](../CONTRIBUTING.md) document and
followed the guidelines.
- [x] Reviewed the changes in this PR and confirmed AI generated code
(If any) is accurate.
- [x] Passed `cargo run` for story tests related to the changes.
- [ ] Tested macOS, Windows and Linux platforms performance (if the
change is platform-specific)
---------
Co-authored-by: Jason Lee <huacnlee@gmail.com>
## Description
This PR fixes an issue where the editor's "reverse cursor" state was not
reset
after completing a text selection. Because the flag remained `true`, the
cursor
could appear on the wrong side of the selection when the next
interaction
started.
## Screenshot
| Before | After |
|--------|--------|
| <video
src="https://github.com/user-attachments/assets/308c5119-52da-4bdb-9a94-36617d957c63"
controls width="360"></video> | <video
src="https://github.com/user-attachments/assets/bf9328b4-96d8-48df-9cc0-99fccaced7c5"
controls width="360"></video> |
## How to Test
`cargo run --example editor`
## Checklist
- [x] I have read the [CONTRIBUTING](../CONTRIBUTING.md) document and
followed the guidelines.
- [ ] Reviewed the changes in this PR and confirmed AI generated code
(If any) is accurate.
- [x] Passed `cargo run` for story tests related to the changes.
- [ ] Tested macOS, Windows and Linux platforms performance (if the
change is platform-specific)
## Screenshot
From `input_story`:
<img width="1069" height="122" alt="Screenshot From 2025-11-28 09-14-03"
src="https://github.com/user-attachments/assets/f14ef2fc-4939-4ceb-be3e-bede492f8602"
/>
## Breaking Changes
- `.multi_line()` was changed to `.multi_line(bool)`.
- Removed pub `InputMode`, this should only for internal.
```diff
InputState::new(window, cx)
- .multi_line()
+ .multi_line(true)
```
## Checklist
- [x] I have read the [CONTRIBUTING](../CONTRIBUTING.md) document and
followed the guidelines.
- [x] Reviewed the changes in this PR and confirmed AI generated code
(If any) is accurate.
- [x] Passed `cargo run` for story tests related to the changes.
- [ ] Tested macOS, Windows and Linux platforms performance (if the
change is platform-specific)
Use cases,
1) In my API client, I have a tree sitter language for the URL input,
<img width="1001" height="162" alt="Image"
src="https://github.com/user-attachments/assets/9771decf-b0b7-4230-8ed6-784a95b72af1"
/>
2) In my SQL editor I want to be able to allow JSON syntax highlighting
for inline editing of json columns,
<img width="501" height="130" alt="Image"
src="https://github.com/user-attachments/assets/f0f879cc-841f-49d2-a23a-2effc3747f38"
/>
---------
Co-authored-by: Jason Lee <huacnlee@gmail.com>
Display the title when only one panel is visible.
## Breaking change
```diff
pub enum PanelStyle {
- Default,
+ #[default]
+ Auto,
TabBar,
}
- dock_area.panel_style(PanelStyle::Default)
+ dock_area.panel_style(PanelStyle::Auto)
```
## Description
1. Add `overflow_scrollbar`, `overflow_y_scrollbar`, `overflow_x_scroll`
to GPUI elements to let them has scrollbars. It is almost like the
`overscroll` but adds the Scrollbar.
2. And adjust the display scrollbar of margining 4px of the container.
3. Add `scrollbar`, `vertical_scrollbar`, `horizontal_scrollbar` with
your own scroll handle.
<img width="1181" height="911" alt="image"
src="https://github.com/user-attachments/assets/8b02cd54-d527-4f22-b9be-f762ede22122"
/>
## Break Changes
- There `Scrollable` trait and it `scrollable` method has been removed.
```diff
- div().id("contents").scrollable(Axis::Vertical)
+ div().id("contents").overflow_y_scrollbar()
```
This PR to improve the Scrollbar API to manage the state in the
internal.
## Break Changes
Describe any breaking changes introduced by this pull request. If none,
remove this section.
- Removed `scrollbar_state` argument from `Scrollbar::new`,
`Scrollbar::both`, `Scrollbar::vertical` and `Scrollbar::horizontal`.
```diff
- Scrollbar::horizontal(&self.scrollbar_state, &self.scroll_handle)
+ Scrollbar::horizontal(&self.scroll_handle)
- Scrollbar::vertical(&self.scrollbar_state, &self.scroll_handle)
+ Scrollbar::vertical(&self.scroll_handle)
```
- Change `struct ScrollbarState` to private, we not need this not.
```diff
- pub struct ScrollbarState {
+ struct ScrollbarState {
```
- Renamed `trait ScrollHandleOffsetable` to `trait ScrollbarHanle`.
```diff
- pub trait ScrollHandleOffsetable {
+ pub trait ScrollbarHanle {
```
- Removed `Scrollbar::both`, now use `Scrollbar::new` instead.
```diff
- Scrollbar::both(&scroll_handle)
+ Scrollbar::new(&scroll_handle)
```
## Description:
This PR adds support for customizing the Switch component's thumb color.
- Changes:
• Added switch_thumb field to ThemeColor and ThemeConfig.
• Updated Switch component to use cx.theme().switch_thumb.
• Config key: switch.thumb.background (falls back to background color if
not set).
Co-authored-by: hl <hl@nmcsoft.com>
## Security Fix
This PR addresses a **LOW** severity vulnerability detected by our
security scanner.
### Security Impact Assessment
| Aspect | Rating | Rationale |
|--------|--------|-----------|
| Impact | Low | In the gpui-component repository, which is a Rust-based
GUI component library for building native apps, tracing log pollution
could allow misleading or polluted logs during application runtime,
potentially aiding in debugging obfuscation or minor information
leakage, but it poses minimal risk as the library focuses on UI
rendering and does not handle sensitive data or network operations
directly. |
| Likelihood | Low | The repository is a client-side GUI component
library, typically deployed in desktop or native applications with
limited network exposure, making exploitation unlikely as attackers
would need to compromise the local app environment first, and log
pollution requires specific conditions not common in this usage context.
|
| Ease of Fix | Easy | Remediation involves updating the
tracing-subscriber dependency in Cargo.lock to a patched version, which
is a straightforward Cargo update with minimal risk of breaking changes
in a component library focused on UI elements rather than core logic. |
### Evidence: Proof-of-Concept Exploitation Demo
**⚠️ For Educational/Security Awareness Only**
This demonstration shows how the vulnerability could be exploited to
help you understand its severity and prioritize remediation.
#### How This Vulnerability Can Be Exploited
The vulnerability in CVE-2025-58160 affects the `tracing-subscriber`
crate, a transitive dependency in this Rust-based UI component library
repository (gpui-component). An attacker with control over input that
influences logging (e.g., via user-provided data or network inputs in an
application built with this library) could exploit this to inject
arbitrary log messages, polluting logs and potentially obscuring
security events or misleading forensic analysis. Since gpui-component is
a library that integrates with GPUI (which uses tracing for logging),
exploitation would occur in downstream applications that enable logging
and process untrusted inputs, allowing log spoofing without direct code
execution.
The vulnerability in CVE-2025-58160 affects the `tracing-subscriber`
crate, a transitive dependency in this Rust-based UI component library
repository (gpui-component). An attacker with control over input that
influences logging (e.g., via user-provided data or network inputs in an
application built with this library) could exploit this to inject
arbitrary log messages, polluting logs and potentially obscuring
security events or misleading forensic analysis. Since gpui-component is
a library that integrates with GPUI (which uses tracing for logging),
exploitation would occur in downstream applications that enable logging
and process untrusted inputs, allowing log spoofing without direct code
execution.
```rust
// Proof-of-Concept: Demonstrating log pollution in an application using gpui-component
// This assumes a downstream app (e.g., a GPUI-based GUI app) that uses gpui-component and enables tracing-subscriber for logging.
// The exploit leverages the vulnerability by injecting malicious log messages via controlled input, such as user text fields or network data.
// Prerequisites: The app must have tracing-subscriber configured (common in GPUI apps for debugging), and the attacker needs a way to influence log inputs (e.g., via a text input in the UI).
use gpui_component::{button::Button, input::Input, Component}; // Import from this repository's library
use gpui::{App, Context, WindowOptions}; // GPUI framework
use tracing_subscriber; // Vulnerable dependency (transitive via GPUI)
use tracing::{info, warn}; // For logging
fn main() {
// Initialize tracing-subscriber (vulnerable version from Cargo.lock)
tracing_subscriber::fmt::init();
// Create a simple GPUI app using gpui-component
App::new().run(|cx: &mut App| {
cx.open_window(WindowOptions::default(), |cx| {
let input = cx.new(|cx| Input::new(cx)); // UI component from gpui-component
let button = cx.new(|cx| Button::new("Submit", cx));
// Simulate attacker-controlled input: Malicious payload to pollute logs
// In a real exploit, this could come from user input, network, or file
let malicious_input = "%0A[ATTACKER] Fake security alert: Unauthorized access detected from IP 192.168.1.100%0A"; // Newline injection for log pollution
// When button is clicked, log the input (vulnerable point)
button.on_click(cx, move |_, cx| {
// This logs the input, allowing pollution if input is controlled
info!("User input: {}", malicious_input);
warn!("Processing complete"); // Additional log for context
});
cx.focus(&input);
});
});
}
// To run this PoC:
// 1. Clone the gpui-component repo and build it as a dependency.
// 2. Create a new Rust project with GPUI and this library as deps.
// 3. Add the above code to main.rs.
// 4. Run with `cargo run`.
// 5. Interact with the UI (e.g., click the button) – check logs for injected messages like "[ATTACKER] Fake security alert...".
// Impact: Logs are polluted, potentially hiding real events or creating false positives in monitoring systems.
```
#### Exploitation Impact Assessment
| Impact Category | Severity | Description |
|-----------------|----------|-------------|
| Data Exposure | Low | Logs could be polluted with fake entries,
potentially masking sensitive information leakage if real logs contain
user data or API keys; however, no direct data theft occurs, as
pollution is limited to log output and doesn't expose underlying data
stores in this UI library context. |
| System Compromise | None | No system access is gained; the
vulnerability only allows log message injection, not code execution,
privilege escalation, or control over the application or host system. |
| Operational Impact | Low | Polluted logs could confuse
monitoring/alerting systems, leading to missed security events or false
alarms, but no service disruption, denial-of-service, or resource
exhaustion is possible in this library's isolated UI component usage. |
| Compliance Risk | Low | Could violate logging integrity requirements
in standards like OWASP Top 10 (A09:2021 - Security Logging and
Monitoring Failures) or SOC2 CC7.1 (monitoring), but impact is minimal
for most regulations unless logs are critical for audits in sensitive
apps (e.g., no direct GDPR or HIPAA violations from log pollution
alone). |
### Vulnerability Details
- **Rule ID**: `CVE-2025-58160`
- **File**: `Cargo.lock`
- **Description**: tracing-subscriber: Tracing log pollution
### Changes Made
This automated fix addresses the vulnerability by applying security best
practices.
### Files Modified
- `Cargo.lock`
### Verification
This fix has been automatically verified through:
- ✅ Build verification
- ✅ Scanner re-scan
- ✅ LLM code review
🤖 This PR was automatically generated.
Co-authored-by: orbisai0security <orbisai0security@users.noreply.github.com>
## Break Change
- The `width`, `border_width` method has been removed from Sidebar, use
`Styled` trait to use `w`, `border` method from GPUI instead.
```diff
Sidebar::left()
- .width(relative(1.))
- .border_width(px(0.))
+ .w(relative(1.))
+ .border_0()
.collapsed(false)
```
This makes use of the `IconNamed` trait and a blanked implementation to
convert anything that implements this to an `Icon`.
This allows for easily defined custom versions of `IconName`, while
minimally changing existing code (essentially only if you previously
made use of the `.path()` method on the `IconName` enum; this now
requires an import of the `IconNamed` trait).
# Example
```rust
use gpui_component::IconNamed;
pub enum IconName {
Encounters,
Monsters,
Spells,
}
impl IconNamed for IconName {
fn path(self) -> gpui::SharedString {
match self {
IconName::Encounters => "icons/encounters.svg",
IconName::Monsters => "icons/monsters.svg",
IconName::Spells => "icons/spells.svg",
}
.into()
}
}
// this allows for the following interactions (works with anything that has the `.icon(icon)` method
Button::new("my-button").icon(IconName::Spells);
Icon::new(IconName::Monsters);
```
If you want to directly "render" a custom `IconName` you must implement
the `RenderOnce` trait and derive `IntoElement` on the `IconName`.
```rust
use gpui::{IntoElement, RenderOnce};
use gpui_component::IconNamed;
#[derive(IntoElement)]
pub enum IconName {
// The same as before
}
impl IconNamed for IconName {
// The same as before
}
impl RenderOnce for IconName {
fn render(self, _: &mut gpui::Window, _: &mut gpui::App) -> impl gpui::IntoElement {
gpui_component::Icon::empty().path(self.path())
}
}
// this allows for the following interaction
div()
.child(IconName::Monsters)
```
Overall I think is an improvement to the existing way to do custom
`IconName` implementations.
I am unsure if this change should also be reflected in the documentation
on the section with "Icons & Assets", though I personally think it would
make sense to highlight this way to do custom versions of `IconName` as
it is considerably less involved than the current approach.
Closes#1627.
---------
Co-authored-by: Jason Lee <huacnlee@gmail.com>
Fixes#1410
## Problem
The `display_title` prop was overriding the default way dropdown option
titles are displayed, causing incorrect rendering of option titles.
**Expected behavior:**
<img width="716" height="944" alt="Expected dropdown display"
src="https://github.com/user-attachments/assets/38926731-32dd-4a16-9d08-7f2eed2c99a4"
/>
**Actual behavior:**
<img width="580" height="974" alt="image"
src="https://github.com/user-attachments/assets/d96b935a-ce4d-462c-a9ce-4995f5c8eeb5"
/>
## Solution
- Revert the `display_title` change that was causing the issue
- Add a `render` function to allow custom rendering of option titles
instead
This approach provides more flexibility for customizing option display
while preserving the default behavior.
cc @stippi
Fix the issue where clicking a button inside a table row can't stop the
click event from propagating to the table, causing the `td` element to
be selected unexpectedly.
