1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
use gpui::*;
use gpui::prelude::FluentBuilder;
// ============================================================================
// Events
// ============================================================================
/// Events emitted by TextArea
#[derive(Clone, Debug)]
pub enum TextAreaEvent {
/// The textarea value has changed
Change(String),
/// Submit event (when Enter is pressed without Shift)
Submit(String),
/// Focus event
Focus,
/// Blur event
Blur,
}
// ============================================================================
// TextArea Component
// ============================================================================
/// A multi-line text area component
pub struct TextArea {
/// Current text value
value: String,
/// Cursor position (byte index)
cursor_pos: usize,
/// Placeholder text when empty
placeholder: String,
/// Focus handle for keyboard input
focus_handle: FocusHandle,
/// Whether the textarea is disabled
disabled: bool,
/// Maximum length (None for unlimited)
max_length: Option<usize>,
/// Minimum height in pixels
min_height: f32,
/// Maximum height in pixels (None for unlimited)
max_height: Option<f32>,
/// Custom background color
bg_color: Option<Rgba>,
/// Custom border color (None for default)
custom_border_color: Option<Rgba>,
/// Custom focus border color (None for default)
focus_border_color: Option<Rgba>,
/// Whether to show border
show_border: bool,
}
impl TextArea {
/// Create a new TextArea
pub fn new(cx: &mut Context<Self>) -> Self {
Self {
value: String::new(),
cursor_pos: 0,
placeholder: String::new(),
focus_handle: cx.focus_handle(),
disabled: false,
max_length: None,
min_height: 100.0,
max_height: None,
bg_color: None,
custom_border_color: None,
focus_border_color: None,
show_border: true,
}
}
/// Set the placeholder text
pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
self.placeholder = placeholder.into();
self
}
/// Set the initial value
pub fn value(mut self, value: impl Into<String>) -> Self {
self.value = value.into();
self
}
/// Set disabled state
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self
}
/// Set maximum length
pub fn max_length(mut self, max_length: usize) -> Self {
self.max_length = Some(max_length);
self
}
/// Set minimum height
pub fn min_height(mut self, height: f32) -> Self {
self.min_height = height;
self
}
/// Set maximum height
pub fn max_height(mut self, height: f32) -> Self {
self.max_height = Some(height);
self
}
/// Set custom background color
pub fn bg_color(mut self, color: Rgba) -> Self {
self.bg_color = Some(color);
self
}
/// Set custom border color
pub fn border_color(mut self, color: Rgba) -> Self {
self.custom_border_color = Some(color);
self
}
/// Set custom focus border color
pub fn focus_border_color(mut self, color: Rgba) -> Self {
self.focus_border_color = Some(color);
self
}
/// Remove border
pub fn no_border(mut self) -> Self {
self.show_border = false;
self
}
/// Get the current value
pub fn get_value(&self) -> &str {
&self.value
}
/// Set the value programmatically
pub fn set_value(&mut self, value: String, cx: &mut Context<Self>) {
if let Some(max_len) = self.max_length {
if value.len() > max_len {
return;
}
}
self.cursor_pos = value.len();
self.value = value.clone();
cx.emit(TextAreaEvent::Change(value));
cx.notify();
}
/// Clear the textarea
pub fn clear(&mut self, cx: &mut Context<Self>) {
self.value.clear();
self.cursor_pos = 0;
cx.emit(TextAreaEvent::Change(String::new()));
cx.notify();
}
/// Focus the textarea
pub fn focus(&self, window: &mut Window) {
self.focus_handle.focus(window);
}
fn handle_input(&mut self, text: &str, cx: &mut Context<Self>) {
if self.disabled {
return;
}
// Insert text at cursor position
let before = self.value.chars().take(self.cursor_pos).collect::<String>();
let after = self.value.chars().skip(self.cursor_pos).collect::<String>();
let new_value = format!("{}{}{}", before, text, after);
// Check max length
if let Some(max_len) = self.max_length {
if new_value.chars().count() > max_len {
return;
}
}
self.value = new_value.clone();
self.cursor_pos += text.chars().count();
cx.emit(TextAreaEvent::Change(new_value));
cx.notify();
}
fn handle_backspace(&mut self, cx: &mut Context<Self>) {
if self.disabled || self.cursor_pos == 0 {
return;
}
// Remove character before cursor
let before = self.value.chars().take(self.cursor_pos - 1).collect::<String>();
let after = self.value.chars().skip(self.cursor_pos).collect::<String>();
self.value = format!("{}{}", before, after);
self.cursor_pos -= 1;
cx.emit(TextAreaEvent::Change(self.value.clone()));
cx.notify();
}
fn handle_enter(&mut self, shift_pressed: bool, cx: &mut Context<Self>) {
if self.disabled {
return;
}
if shift_pressed {
// Shift+Enter: insert newline
self.handle_input("\n", cx);
} else {
// Enter: submit
cx.emit(TextAreaEvent::Submit(self.value.clone()));
}
}
fn count_lines(&self) -> usize {
if self.value.is_empty() {
1
} else {
self.value.lines().count().max(1)
}
}
fn calculate_height(&self) -> f32 {
let line_count = self.count_lines();
let line_height = 20.0; // Approximate line height
let padding = 12.0; // Vertical padding
let calculated = (line_count as f32 * line_height) + padding;
// Apply min and max constraints
let height = calculated.max(self.min_height);
if let Some(max_h) = self.max_height {
height.min(max_h)
} else {
height
}
}
}
impl EventEmitter<TextAreaEvent> for TextArea {}
impl Focusable for TextArea {
fn focus_handle(&self, _cx: &App) -> FocusHandle {
self.focus_handle.clone()
}
}
impl Render for TextArea {
fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
let is_focused = self.focus_handle.is_focused(window);
let show_placeholder = self.value.is_empty() && !is_focused;
let disabled = self.disabled;
let placeholder = self.placeholder.clone();
let value = self.value.clone();
let cursor_pos = self.cursor_pos;
let height = self.calculate_height();
// Determine colors based on customization or defaults
let bg_color = if disabled {
self.bg_color.unwrap_or(rgb(0xF5F5F5))
} else {
self.bg_color.unwrap_or(rgb(0xFFFFFF))
};
let border_color = if is_focused {
self.focus_border_color
.or(self.custom_border_color)
.unwrap_or(rgb(0x696FC7))
} else {
self.custom_border_color.unwrap_or(rgb(0xE0E0E0))
};
div()
.id("text-area")
.track_focus(&self.focus_handle)
.on_key_down(cx.listener(|this, event: &KeyDownEvent, _, cx| {
if this.disabled {
return;
}
// Handle special keys
match event.keystroke.key.as_str() {
"backspace" => {
this.handle_backspace(cx);
}
"enter" => {
let shift_pressed = event.keystroke.modifiers.shift;
this.handle_enter(shift_pressed, cx);
}
_ => {
// Handle regular character input
if let Some(ch) = &event.keystroke.key_char {
this.handle_input(ch, cx);
}
}
}
}))
.on_mouse_down(MouseButton::Left, cx.listener(|_this, _, window, cx| {
cx.emit(TextAreaEvent::Focus);
cx.focus_self(window);
// Ensure cursor is visible on focus
cx.notify();
}))
.flex()
.flex_col()
.w_full()
.min_h(px(height))
.p_3()
.bg(bg_color)
.when(self.show_border, |this| {
this.border_1().border_color(border_color)
})
.rounded(px(6.))
.when(!disabled, |this| {
this.cursor(CursorStyle::IBeam)
})
.children([
// Render text with cursor
div()
.flex()
.flex_row()
.items_start()
.w_full()
.text_sm()
.when(show_placeholder, |this| {
this.text_color(rgb(0x999999))
.child(placeholder)
})
.when(!show_placeholder && is_focused && value.is_empty(), |this| {
// Empty and focused: show just cursor
this.child(
div()
.w(px(2.))
.h(px(20.))
.bg(rgb(0x333333))
)
})
.when(!show_placeholder && !value.is_empty(), |this| {
// Split text into lines and find cursor position
let lines: Vec<&str> = value.split('\n').collect();
let mut chars_counted = 0;
let mut cursor_line_idx = 0;
let mut cursor_col = cursor_pos;
// Find which line the cursor is on
for (idx, line) in lines.iter().enumerate() {
let line_len = line.chars().count();
// Check if cursor is within this line (including at the end)
if cursor_pos <= chars_counted + line_len {
cursor_line_idx = idx;
cursor_col = cursor_pos - chars_counted;
break;
}
// +1 for the newline character
chars_counted += line_len + 1;
// If this is the last line and we haven't found the cursor yet
if idx == lines.len() - 1 {
cursor_line_idx = idx;
cursor_col = line_len;
}
}
this.text_color(if disabled {
rgb(0x999999)
} else {
rgb(0x333333)
})
.child(
div()
.flex()
.flex_col()
.items_start()
.w_full()
.children(
lines.iter().enumerate().map(|(line_idx, line)| {
let line_str = line.to_string();
if line_idx == cursor_line_idx {
// This line contains the cursor
let before = line_str.chars().take(cursor_col).collect::<String>();
let after = line_str.chars().skip(cursor_col).collect::<String>();
div()
.flex()
.flex_row()
.items_start()
.child(before)
.when(is_focused && !disabled, |el| {
el.child(
div()
.w(px(2.))
.h(px(20.))
.bg(rgb(0x333333))
.flex_shrink_0()
)
})
.child(after)
} else {
// Regular line without cursor
div()
.flex()
.flex_row()
.child(line_str)
}
})
)
)
})
])
}
}