jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
3 * Copyright (c) 2021, Peter Elliott <pelliott@serenityos.org>
4 * Copyright (c) 2022, Cameron Youell <cameronyouell@gmail.com>
5 * Copyright (c) 2022, the SerenityOS developers.
6 *
7 * SPDX-License-Identifier: BSD-2-Clause
8 */
9
10#include <AK/GenericShorthands.h>
11#include <AK/JsonValue.h>
12#include <LibGUI/BoxLayout.h>
13#include <LibGUI/Desktop.h>
14#include <LibGUI/Painter.h>
15#include <LibGUI/TabWidget.h>
16#include <LibGUI/Window.h>
17#include <LibGfx/Bitmap.h>
18#include <LibGfx/Font/Font.h>
19#include <LibGfx/Palette.h>
20#include <LibGfx/StylePainter.h>
21
22REGISTER_WIDGET(GUI, TabWidget)
23
24namespace GUI {
25
26TabWidget::TabWidget()
27{
28 set_focus_policy(FocusPolicy::NoFocus);
29
30 REGISTER_MARGINS_PROPERTY("container_margins", container_margins, set_container_margins);
31 REGISTER_BOOL_PROPERTY("show_close_buttons", close_button_enabled, set_close_button_enabled);
32 REGISTER_BOOL_PROPERTY("show_tab_bar", is_bar_visible, set_bar_visible);
33 REGISTER_BOOL_PROPERTY("reorder_allowed", reorder_allowed, set_reorder_allowed);
34 REGISTER_BOOL_PROPERTY("uniform_tabs", uniform_tabs, set_uniform_tabs);
35 REGISTER_ENUM_PROPERTY("tab_position", this->tab_position, set_tab_position, TabPosition,
36 { TabPosition::Top, "Top" },
37 { TabPosition::Bottom, "Bottom" },
38 { TabPosition::Left, "Left" },
39 { TabPosition::Right, "Right" }, );
40
41 register_property(
42 "text_alignment",
43 [this] { return Gfx::to_string(text_alignment()); },
44 [this](auto& value) {
45 auto alignment = Gfx::text_alignment_from_string(value.to_deprecated_string());
46 if (alignment.has_value()) {
47 set_text_alignment(alignment.value());
48 return true;
49 }
50 return false;
51 });
52}
53
54ErrorOr<void> TabWidget::try_add_widget(Widget& widget)
55{
56 TRY(m_tabs.try_append({ widget.title(), nullptr, &widget, false }));
57 TRY(try_add_child(widget));
58 update_focus_policy();
59 if (on_tab_count_change)
60 on_tab_count_change(m_tabs.size());
61 layout_relevant_change_occurred();
62 return {};
63}
64
65void TabWidget::add_widget(Widget& widget)
66{
67 MUST(try_add_widget(widget));
68}
69
70void TabWidget::remove_widget(Widget& widget)
71{
72 VERIFY(widget.parent() == this);
73 auto tab_index = m_tabs.find_if([&widget](auto& entry) { return &widget == entry.widget; }).index();
74
75 auto is_active = active_widget() == &widget;
76 m_tabs.remove(tab_index);
77 remove_child(widget);
78
79 if (is_active && m_tabs.size() > 0) {
80 auto next_tab_index = tab_index >= m_tabs.size() ? m_tabs.size() - 1 : tab_index;
81 set_tab_index(next_tab_index);
82 }
83
84 update_focus_policy();
85 if (on_tab_count_change)
86 on_tab_count_change(m_tabs.size());
87
88 layout_relevant_change_occurred();
89}
90
91void TabWidget::remove_all_tabs_except(Widget& widget)
92{
93 VERIFY(widget.parent() == this);
94 set_active_widget(&widget);
95 m_tabs.remove_all_matching([this, &widget](auto& entry) {
96 bool is_other = &widget != entry.widget;
97 if (is_other)
98 remove_child(*entry.widget);
99 return is_other;
100 });
101 VERIFY(m_tabs.size() == 1);
102 update_focus_policy();
103 if (on_tab_count_change)
104 on_tab_count_change(1);
105
106 layout_relevant_change_occurred();
107}
108
109void TabWidget::update_focus_policy()
110{
111 FocusPolicy policy;
112 if (is_bar_visible() && !m_tabs.is_empty())
113 policy = FocusPolicy::TabFocus;
114 else
115 policy = FocusPolicy::NoFocus;
116 set_focus_policy(policy);
117}
118
119void TabWidget::set_active_widget(Widget* widget)
120{
121 if (widget == m_active_widget)
122 return;
123
124 bool active_widget_had_focus = m_active_widget && m_active_widget->has_focus_within();
125
126 if (m_active_widget)
127 m_active_widget->set_visible(false);
128 m_active_widget = widget;
129 if (m_active_widget) {
130 m_active_widget->set_relative_rect(child_rect_for_size(size()));
131 if (active_widget_had_focus)
132 m_active_widget->set_focus(true);
133 m_active_widget->set_visible(true);
134 deferred_invoke([this] {
135 if (on_change)
136 on_change(*m_active_widget);
137 });
138 }
139
140 layout_relevant_change_occurred();
141
142 update_bar();
143}
144
145void TabWidget::set_tab_index(int index)
146{
147 if (m_tabs.at(index).widget == m_active_widget)
148 return;
149 set_active_widget(m_tabs.at(index).widget);
150
151 update_bar();
152}
153
154void TabWidget::resize_event(ResizeEvent& event)
155{
156 if (!m_active_widget)
157 return;
158 m_active_widget->set_relative_rect(child_rect_for_size(event.size()));
159}
160
161Gfx::IntRect TabWidget::child_rect_for_size(Gfx::IntSize size) const
162{
163 Gfx::IntRect rect;
164 switch (m_tab_position) {
165 case TabPosition::Top:
166 rect = { { m_container_margins.left(), bar_height() + m_container_margins.top() }, { size.width() - m_container_margins.left() - m_container_margins.right(), size.height() - bar_height() - m_container_margins.top() - m_container_margins.bottom() } };
167 break;
168 case TabPosition::Bottom:
169 rect = { { m_container_margins.left(), m_container_margins.top() }, { size.width() - m_container_margins.left() - m_container_margins.right(), size.height() - bar_height() - m_container_margins.top() - m_container_margins.bottom() } };
170 break;
171 case TabPosition::Left:
172 rect = { { get_max_tab_width() + m_container_margins.left(), m_container_margins.top() }, { size.width() - get_max_tab_width() - m_container_margins.left() - m_container_margins.right(), size.height() - m_container_margins.top() - m_container_margins.bottom() } };
173 break;
174 case TabPosition::Right:
175 rect = { { m_container_margins.left(), m_container_margins.top() }, { size.width() - get_max_tab_width() - m_container_margins.left() - m_container_margins.right(), size.height() - m_container_margins.top() - m_container_margins.bottom() } };
176 break;
177 }
178 if (rect.is_empty())
179 return {};
180 return rect;
181}
182
183void TabWidget::child_event(Core::ChildEvent& event)
184{
185 if (!event.child() || !is<Widget>(*event.child()))
186 return Widget::child_event(event);
187 auto& child = verify_cast<Widget>(*event.child());
188 if (event.type() == Event::ChildAdded) {
189 if (!m_active_widget)
190 set_active_widget(&child);
191 else if (m_active_widget != &child)
192 child.set_visible(false);
193 } else if (event.type() == Event::ChildRemoved) {
194 if (m_active_widget == &child) {
195 Widget* new_active_widget = nullptr;
196 for_each_child_widget([&](auto& new_child) {
197 new_active_widget = &new_child;
198 return IterationDecision::Break;
199 });
200 set_active_widget(new_active_widget);
201 }
202 }
203 Widget::child_event(event);
204}
205
206Gfx::IntRect TabWidget::bar_rect() const
207{
208 switch (m_tab_position) {
209 case TabPosition::Top:
210 return { 0, 0, width(), bar_height() };
211 case TabPosition::Bottom:
212 return { 0, height() - bar_height(), width(), bar_height() };
213 case TabPosition::Left:
214 return { 0, 0, get_max_tab_width(), height() };
215 case TabPosition::Right:
216 return { width() - get_max_tab_width(), 0, get_max_tab_width(), height() };
217 }
218 VERIFY_NOT_REACHED();
219}
220
221Gfx::IntRect TabWidget::container_rect() const
222{
223 switch (m_tab_position) {
224 case TabPosition::Top:
225 return { 0, bar_height(), width(), height() - bar_height() };
226 case TabPosition::Bottom:
227 return { 0, 0, width(), height() - bar_height() };
228 case TabPosition::Left:
229 return { get_max_tab_width(), 0, width() - get_max_tab_width(), height() };
230 case TabPosition::Right:
231 return { 0, 0, width() - get_max_tab_width(), height() };
232 }
233 VERIFY_NOT_REACHED();
234}
235
236void TabWidget::paint_event(PaintEvent& event)
237{
238 if (!m_bar_visible)
239 return;
240
241 Painter painter(*this);
242 painter.add_clip_rect(event.rect());
243 painter.fill_rect(event.rect(), palette().button());
244
245 if (!m_container_margins.is_null()) {
246 Gfx::StylePainter::paint_frame(painter, container_rect(), palette(), Gfx::FrameShape::Container, Gfx::FrameShadow::Raised, 2);
247 }
248
249 auto paint_tab_icon_if_needed = [&](auto& icon, auto& button_rect, auto& text_rect) {
250 if (!icon)
251 return;
252 Gfx::IntRect icon_rect { button_rect.x(), button_rect.y(), 16, 16 };
253 icon_rect.translate_by(4, (button_rect.height() / 2) - (icon_rect.height() / 2));
254
255 painter.draw_scaled_bitmap(icon_rect, *icon, icon->rect());
256 text_rect.set_x(icon_rect.right() + 1 + 4);
257 text_rect.intersect(button_rect);
258 };
259
260 bool accented = Desktop::the().system_effects().tab_accents();
261
262 for (size_t i = 0; i < m_tabs.size(); ++i) {
263 if (m_tabs[i].widget == m_active_widget)
264 continue;
265 bool hovered = i == m_hovered_tab_index;
266 auto button_rect = this->button_rect(i);
267 Gfx::StylePainter::paint_tab_button(painter, button_rect, palette(), false, hovered, m_tabs[i].widget->is_enabled(), m_tab_position, window()->is_active(), accented);
268
269 auto tab_button_content_rect = button_rect.shrunken(8, 0);
270
271 paint_tab_icon_if_needed(m_tabs[i].icon, button_rect, tab_button_content_rect);
272 tab_button_content_rect.set_width(tab_button_content_rect.width() - (m_close_button_enabled ? 16 : 0));
273
274 painter.draw_text(tab_button_content_rect, m_tabs[i].title, m_text_alignment, palette().button_text(), Gfx::TextElision::Right);
275 }
276
277 if (m_close_button_enabled) {
278 for (size_t i = 0; i < m_tabs.size(); ++i) {
279 if (m_tabs[i].widget == m_active_widget)
280 continue;
281
282 bool hovered_close_button = i == m_hovered_close_button_index;
283 bool pressed_close_button = i == m_pressed_close_button_index;
284 auto close_button_rect = this->close_button_rect(i);
285
286 if (hovered_close_button)
287 Gfx::StylePainter::paint_frame(painter, close_button_rect, palette(), Gfx::FrameShape::Box, pressed_close_button ? Gfx::FrameShadow::Sunken : Gfx::FrameShadow::Raised, 1);
288
289 Gfx::IntRect icon_rect { close_button_rect.x() + 3, close_button_rect.y() + 3, 6, 6 };
290 if (!m_tabs[i].modified) {
291 painter.draw_line(icon_rect.top_left(), icon_rect.bottom_right(), palette().button_text());
292 painter.draw_line(icon_rect.top_right(), icon_rect.bottom_left(), palette().button_text());
293 } else {
294 painter.draw_line(icon_rect.top_left().moved_right(1), icon_rect.bottom_right().translated(-1, -1), palette().button_text());
295 painter.draw_line(icon_rect.top_right().moved_left(1), icon_rect.bottom_left().translated(1, -1), palette().button_text());
296 painter.draw_line(icon_rect.bottom_left().moved_down(1), icon_rect.bottom_right().moved_down(1), palette().button_text(), 1, Painter::LineStyle::Dotted);
297 }
298 }
299 }
300
301 for (size_t i = 0; i < m_tabs.size(); ++i) {
302 if (m_tabs[i].widget != m_active_widget)
303 continue;
304
305 bool hovered = i == m_hovered_tab_index;
306 auto button_rect = this->button_rect(i);
307
308 if (m_dragging_active_tab) {
309 if (this->has_vertical_tabs())
310 button_rect.set_y(m_mouse_pos - m_grab_offset);
311 else
312 button_rect.set_x(m_mouse_pos - m_grab_offset);
313 }
314
315 auto tab_button_content_rect = button_rect.shrunken(8, 0);
316 Gfx::StylePainter::paint_tab_button(painter, button_rect, palette(), true, hovered, m_tabs[i].widget->is_enabled(), m_tab_position, window()->is_active(), accented);
317
318 paint_tab_icon_if_needed(m_tabs[i].icon, button_rect, tab_button_content_rect);
319 tab_button_content_rect.set_width(tab_button_content_rect.width() - (m_close_button_enabled ? 16 : 0));
320
321 painter.draw_text(tab_button_content_rect, m_tabs[i].title, m_text_alignment, palette().button_text(), Gfx::TextElision::Right);
322
323 if (is_focused()) {
324 Gfx::IntRect focus_rect { 0, 0, min(tab_button_content_rect.width(), font().width(m_tabs[i].title)), font().pixel_size_rounded_up() };
325 focus_rect.align_within(tab_button_content_rect, m_text_alignment);
326 focus_rect.inflate(6, 4);
327
328 painter.draw_focus_rect(focus_rect, palette().focus_outline());
329 }
330
331 if (m_tab_position == TabPosition::Top) {
332 painter.draw_line(button_rect.bottom_left().translated(1, 1), button_rect.bottom_right().translated(-1, 1), palette().button());
333 } else if (m_tab_position == TabPosition::Bottom) {
334 painter.set_pixel(button_rect.top_left().translated(0, -1), palette().threed_highlight());
335 painter.set_pixel(button_rect.top_right().translated(-1, -1), palette().threed_shadow1());
336 painter.draw_line(button_rect.top_left().translated(1, -1), button_rect.top_right().translated(-2, -1), palette().button());
337 painter.draw_line(button_rect.top_left().translated(1, -2), button_rect.top_right().translated(-2, -2), palette().button());
338 }
339 break;
340 }
341
342 if (!m_close_button_enabled)
343 return;
344
345 for (size_t i = 0; i < m_tabs.size(); ++i) {
346 if (m_tabs[i].widget != m_active_widget)
347 continue;
348
349 bool hovered_close_button = i == m_hovered_close_button_index;
350 bool pressed_close_button = i == m_pressed_close_button_index;
351 auto close_button_rect = this->close_button_rect(i);
352
353 if (m_dragging_active_tab) {
354 if (this->has_vertical_tabs())
355 close_button_rect.set_y((m_mouse_pos - m_grab_offset) + (close_button_rect.y() - button_rect(i).y()));
356 else
357 close_button_rect.set_x((m_mouse_pos - m_grab_offset) + (close_button_rect.x() - button_rect(i).x()));
358 }
359
360 if (hovered_close_button)
361 Gfx::StylePainter::paint_frame(painter, close_button_rect, palette(), Gfx::FrameShape::Box, pressed_close_button ? Gfx::FrameShadow::Sunken : Gfx::FrameShadow::Raised, 1);
362
363 Gfx::IntRect icon_rect { close_button_rect.x() + 3, close_button_rect.y() + 3, 6, 6 };
364 if (!m_tabs[i].modified) {
365 painter.draw_line(icon_rect.top_left(), icon_rect.bottom_right(), palette().button_text());
366 painter.draw_line(icon_rect.top_right(), icon_rect.bottom_left(), palette().button_text());
367 } else {
368 painter.draw_line(icon_rect.top_left().moved_right(1), icon_rect.bottom_right().translated(-1, -1), palette().button_text());
369 painter.draw_line(icon_rect.top_right().moved_left(1), icon_rect.bottom_left().translated(1, -1), palette().button_text());
370 painter.draw_line(icon_rect.bottom_left().moved_down(1), icon_rect.bottom_right().moved_down(1), palette().button_text(), 1, Painter::LineStyle::Dotted);
371 }
372 }
373}
374
375int TabWidget::uniform_tab_width() const
376{
377 int total_tab_width = m_tabs.size() * get_max_tab_width();
378 int tab_width = get_max_tab_width();
379
380 if (this->has_vertical_tabs())
381 return tab_width;
382
383 int available_width = width() - bar_margin() * 2;
384 if (total_tab_width > available_width)
385 tab_width = available_width / m_tabs.size();
386 return max(tab_width, m_min_tab_width);
387}
388
389void TabWidget::set_bar_visible(bool bar_visible)
390{
391 m_bar_visible = bar_visible;
392 if (m_active_widget)
393 m_active_widget->set_relative_rect(child_rect_for_size(size()));
394 update_bar();
395}
396
397Gfx::IntRect TabWidget::button_rect(size_t index) const
398{
399 if (this->has_vertical_tabs())
400 return vertical_button_rect(index);
401 return horizontal_button_rect(index);
402}
403
404Gfx::IntRect TabWidget::vertical_button_rect(size_t index) const
405{
406 int offset = bar_margin() + (bar_height() * index);
407 Gfx::IntRect rect { 0, offset, get_max_tab_width() - 1, bar_height() };
408
409 if (m_tabs[index].widget != m_active_widget) {
410 rect.translate_by(m_tab_position == TabPosition::Left ? 2 : 0, 0);
411 rect.set_width(rect.width() - 2);
412 } else {
413 rect.translate_by(0, -2);
414 rect.set_height(rect.height() + 4);
415 }
416
417 rect.translate_by(bar_rect().location());
418 return rect;
419}
420
421Gfx::IntRect TabWidget::horizontal_button_rect(size_t index) const
422{
423 int x_offset = bar_margin();
424 int close_button_offset = m_close_button_enabled ? 16 : 0;
425
426 for (size_t i = 0; i < index; ++i) {
427 auto tab_width = m_uniform_tabs ? uniform_tab_width() : m_tabs[i].width(font()) + close_button_offset;
428 x_offset += tab_width;
429 }
430 Gfx::IntRect rect { x_offset, 0, m_uniform_tabs ? uniform_tab_width() : m_tabs[index].width(font()) + close_button_offset, bar_height() };
431 if (m_tabs[index].widget != m_active_widget) {
432 rect.translate_by(0, m_tab_position == TabPosition::Top ? 2 : 0);
433 rect.set_height(rect.height() - 2);
434 } else {
435 rect.translate_by(-2, 0);
436 rect.set_width(rect.width() + 4);
437 }
438 rect.translate_by(bar_rect().location());
439 return rect;
440}
441
442Gfx::IntRect TabWidget::close_button_rect(size_t index) const
443{
444 auto rect = button_rect(index);
445 Gfx::IntRect close_button_rect { 0, 0, 12, 12 };
446
447 close_button_rect.translate_by(rect.right(), rect.top());
448 close_button_rect.translate_by(-(close_button_rect.width() + 4), (rect.height() / 2) - (close_button_rect.height() / 2));
449
450 return close_button_rect;
451}
452
453int TabWidget::TabData::width(Gfx::Font const& font) const
454{
455 auto width = 16 + static_cast<int>(ceilf(font.width(title))) + (icon ? (16 + 4) : 0);
456 // NOTE: This needs to always be an odd number, because the button rect
457 // includes 3px of light and shadow on the left and right edges. If
458 // the button rect width is not an odd number, the area left for the
459 // text and the focus rect has an odd number of pixels, and this
460 // causes the text (and subsequently the focus rect) to not be aligned
461 // to the center perfectly.
462 if (width % 2 == 0) {
463 width++;
464 }
465
466 return width;
467}
468
469void TabWidget::mousedown_event(MouseEvent& event)
470{
471 for (size_t i = 0; i < m_tabs.size(); ++i) {
472 auto button_rect = this->button_rect(i);
473 auto close_button_rect = this->close_button_rect(i);
474
475 if (!button_rect.contains(event.position()))
476 continue;
477
478 if (event.button() == MouseButton::Primary) {
479 if (m_close_button_enabled && close_button_rect.contains(event.position())) {
480 m_pressed_close_button_index = i;
481 update_bar();
482 return;
483 }
484 set_active_widget(m_tabs[i].widget);
485 drag_tab(i);
486 } else if (event.button() == MouseButton::Middle) {
487 auto* widget = m_tabs[i].widget;
488 deferred_invoke([this, widget] {
489 if (on_middle_click && widget)
490 on_middle_click(*widget);
491 });
492 }
493 return;
494 }
495}
496
497void TabWidget::mouseup_event(MouseEvent& event)
498{
499 if (event.button() != MouseButton::Primary)
500 return;
501
502 if (m_dragging_active_tab) {
503 m_dragging_active_tab = false;
504 update_bar();
505 }
506
507 if (!m_close_button_enabled || !m_pressed_close_button_index.has_value())
508 return;
509
510 auto close_button_rect = this->close_button_rect(m_pressed_close_button_index.value());
511 update_bar();
512
513 if (close_button_rect.contains(event.position())) {
514 auto* widget = m_tabs[m_pressed_close_button_index.value()].widget;
515 deferred_invoke([this, widget] {
516 if (on_tab_close_click && widget)
517 on_tab_close_click(*widget);
518 });
519 }
520 m_pressed_close_button_index = {};
521}
522
523void TabWidget::mousemove_event(MouseEvent& event)
524{
525 Optional<size_t> hovered_tab = {};
526 Optional<size_t> hovered_close_button = {};
527
528 m_mouse_pos = this->has_vertical_tabs() ? event.position().y() : event.position().x();
529 if (m_dragging_active_tab) {
530 recalculate_tab_order();
531 update_bar();
532 return;
533 }
534
535 for (size_t i = 0; i < m_tabs.size(); ++i) {
536 auto button_rect = this->button_rect(i);
537 auto close_button_rect = this->close_button_rect(i);
538
539 if (close_button_rect.contains(event.position()))
540 hovered_close_button = i;
541
542 if (!button_rect.contains(event.position()))
543 continue;
544 hovered_tab = i;
545 if (m_tabs[i].widget == m_active_widget)
546 break;
547 }
548 if (!hovered_tab.has_value() && !hovered_close_button.has_value())
549 return;
550 m_hovered_tab_index = hovered_tab;
551 m_hovered_close_button_index = hovered_close_button;
552 update_bar();
553}
554
555void TabWidget::leave_event(Core::Event&)
556{
557 if (m_hovered_tab_index.has_value() || m_hovered_close_button_index.has_value()) {
558 m_hovered_tab_index = {};
559 m_hovered_close_button_index = {};
560 update_bar();
561 }
562}
563
564void TabWidget::update_bar()
565{
566 if (m_tabs.is_empty())
567 return;
568 auto invalidation_rect = bar_rect();
569 invalidation_rect.set_height(invalidation_rect.height() + 1);
570 update(invalidation_rect);
571}
572
573void TabWidget::set_tab_position(TabPosition tab_position)
574{
575 if (m_tab_position == tab_position)
576 return;
577 m_tab_position = tab_position;
578 if (this->has_vertical_tabs())
579 m_uniform_tabs = true;
580 if (m_active_widget)
581 m_active_widget->set_relative_rect(child_rect_for_size(size()));
582 update();
583}
584
585Optional<size_t> TabWidget::active_tab_index() const
586{
587 for (size_t i = 0; i < m_tabs.size(); i++) {
588 if (m_tabs.at(i).widget == m_active_widget)
589 return i;
590 }
591 return {};
592}
593
594void TabWidget::set_tab_title(Widget& tab, StringView title)
595{
596 for (auto& t : m_tabs) {
597 if (t.widget == &tab) {
598 if (t.title != title) {
599 t.title = title;
600 update();
601 }
602 return;
603 }
604 }
605}
606
607void TabWidget::set_tab_icon(Widget& tab, Gfx::Bitmap const* icon)
608{
609 for (auto& t : m_tabs) {
610 if (t.widget == &tab) {
611 t.icon = icon;
612 update();
613 return;
614 }
615 }
616}
617
618bool TabWidget::is_tab_modified(Widget& tab_input)
619{
620 auto it = m_tabs.find_if([&](auto t) { return t.widget == &tab_input; });
621 if (it.is_end())
622 return false;
623 auto& tab = *it;
624 return tab.modified;
625}
626
627void TabWidget::set_tab_modified(Widget& tab_input, bool modified)
628{
629 auto it = m_tabs.find_if([&](auto t) { return t.widget == &tab_input; });
630 if (it.is_end())
631 return;
632 auto& tab = *it;
633 if (tab.modified != modified) {
634 tab.modified = modified;
635 update();
636 }
637}
638
639bool TabWidget::is_any_tab_modified()
640{
641 return any_of(m_tabs, [](auto& t) { return t.modified; });
642}
643
644void TabWidget::activate_next_tab()
645{
646 if (m_tabs.size() <= 1)
647 return;
648 auto index = active_tab_index();
649 if (!index.has_value())
650 return;
651 auto next_index = index.value() + 1;
652 if (next_index >= m_tabs.size())
653 next_index = 0;
654 set_active_widget(m_tabs.at(next_index).widget);
655}
656
657void TabWidget::activate_previous_tab()
658{
659 if (m_tabs.size() <= 1)
660 return;
661 auto index = active_tab_index();
662 if (!index.has_value())
663 return;
664 size_t previous_index = 0;
665 if (index.value() == 0)
666 previous_index = m_tabs.size() - 1;
667 else
668 previous_index = index.value() - 1;
669 set_active_widget(m_tabs.at(previous_index).widget);
670}
671
672void TabWidget::activate_last_tab()
673{
674 size_t number_of_tabs = m_tabs.size();
675 if (number_of_tabs == 0)
676 return;
677 set_active_widget(m_tabs.at(number_of_tabs - 1).widget);
678}
679
680void TabWidget::keydown_event(KeyEvent& event)
681{
682 if (event.ctrl() && event.key() == Key_Tab) {
683 if (event.shift())
684 activate_previous_tab();
685 else
686 activate_next_tab();
687 event.accept();
688 return;
689 }
690 if (is_focused()) {
691 if (!event.modifiers() && event.key() == Key_Left) {
692 activate_previous_tab();
693 event.accept();
694 return;
695 }
696 if (!event.modifiers() && event.key() == Key_Right) {
697 activate_next_tab();
698 event.accept();
699 return;
700 }
701 }
702 Widget::keydown_event(event);
703}
704
705void TabWidget::context_menu_event(ContextMenuEvent& context_menu_event)
706{
707 for (size_t i = 0; i < m_tabs.size(); ++i) {
708 auto button_rect = this->button_rect(i);
709 if (!button_rect.contains(context_menu_event.position()))
710 continue;
711 auto* widget = m_tabs[i].widget;
712 deferred_invoke([this, widget, context_menu_event] {
713 if (on_context_menu_request && widget)
714 on_context_menu_request(*widget, context_menu_event);
715 });
716 return;
717 }
718}
719
720void TabWidget::doubleclick_event(MouseEvent& mouse_event)
721{
722 for (size_t i = 0; i < m_tabs.size(); ++i) {
723 auto button_rect = this->button_rect(i);
724 if (!button_rect.contains(mouse_event.position()))
725 continue;
726 if (auto* widget = m_tabs[i].widget) {
727 deferred_invoke([this, widget] {
728 if (on_double_click)
729 on_double_click(*widget);
730 });
731 }
732 return;
733 }
734}
735
736void TabWidget::set_container_margins(GUI::Margins const& margins)
737{
738 m_container_margins = margins;
739 layout_relevant_change_occurred();
740 update();
741}
742
743Optional<UISize> TabWidget::calculated_min_size() const
744{
745 if (!m_active_widget)
746 return {};
747 auto content_min_size = m_active_widget->effective_min_size();
748 UIDimension width = MUST(content_min_size.width().shrink_value()), height = MUST(content_min_size.height().shrink_value());
749 width.add_if_int(container_margins().vertical_total()
750 + (first_is_one_of(m_tab_position, TabPosition::Left, TabPosition::Right) ? bar_rect().width() : 0));
751 height.add_if_int(container_margins().vertical_total()
752 + (first_is_one_of(m_tab_position, TabPosition::Top, TabPosition::Bottom) ? bar_rect().height() : 0));
753
754 return UISize { width, height };
755}
756
757Optional<UISize> TabWidget::calculated_preferred_size() const
758{
759 if (!m_active_widget)
760 return {};
761 auto content_preferred_size = m_active_widget->effective_preferred_size();
762 UIDimension width = MUST(content_preferred_size.width().shrink_value()), height = MUST(content_preferred_size.height().shrink_value());
763 width.add_if_int(container_margins().vertical_total()
764 + (first_is_one_of(m_tab_position, TabPosition::Left, TabPosition::Right) ? bar_rect().width() : 0));
765 height.add_if_int(
766 container_margins().vertical_total()
767 + (first_is_one_of(m_tab_position, TabPosition::Top, TabPosition::Bottom) ? bar_rect().height() : 0));
768 return UISize { width, height };
769}
770
771void TabWidget::drag_tab(size_t index)
772{
773 m_dragging_active_tab = m_reorder_allowed;
774 m_grab_offset = m_mouse_pos - (this->has_vertical_tabs() ? button_rect(index).y() : button_rect(index).x());
775 m_hovered_tab_index = {};
776 m_hovered_close_button_index = {};
777}
778
779void TabWidget::recalculate_tab_order()
780{
781 if (!m_dragging_active_tab)
782 return;
783
784 size_t active;
785 for (active = 0; active < m_tabs.size(); ++active) {
786 if (m_tabs[active].widget == m_active_widget)
787 break;
788 }
789
790 size_t target;
791 for (target = 0; target < active; ++target) {
792 auto button_pos = this->has_vertical_tabs() ? (this->button_rect(target)).y() : (this->button_rect(target)).x();
793 if (m_mouse_pos - m_grab_offset < button_pos) {
794 break;
795 }
796 }
797
798 if (target == active) {
799 for (target = m_tabs.size() - 1; target > active; --target) {
800 auto button_pos = this->has_vertical_tabs() ? (this->button_rect(target)).y() : (this->button_rect(target)).x();
801 if (m_mouse_pos - m_grab_offset > button_pos) {
802 break;
803 }
804 }
805 }
806
807 if (active == target)
808 return;
809
810 auto tab = m_tabs.take(active);
811 m_tabs.insert(target, tab);
812 update_bar();
813}
814}