TabWidget.cpp 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708
  1. /*
  2. * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, Peter Elliott <pelliott@serenityos.org>
  4. * Copyright (c) 2022, the SerenityOS developers.
  5. *
  6. * SPDX-License-Identifier: BSD-2-Clause
  7. */
  8. #include <AK/JsonObject.h>
  9. #include <AK/JsonValue.h>
  10. #include <LibGUI/BoxLayout.h>
  11. #include <LibGUI/Painter.h>
  12. #include <LibGUI/TabWidget.h>
  13. #include <LibGUI/Window.h>
  14. #include <LibGfx/Bitmap.h>
  15. #include <LibGfx/Font/Font.h>
  16. #include <LibGfx/Palette.h>
  17. #include <LibGfx/StylePainter.h>
  18. REGISTER_WIDGET(GUI, TabWidget)
  19. namespace GUI {
  20. TabWidget::TabWidget()
  21. {
  22. set_focus_policy(FocusPolicy::NoFocus);
  23. REGISTER_MARGINS_PROPERTY("container_margins", container_margins, set_container_margins);
  24. REGISTER_BOOL_PROPERTY("uniform_tabs", uniform_tabs, set_uniform_tabs);
  25. register_property(
  26. "text_alignment",
  27. [this] { return Gfx::to_string(text_alignment()); },
  28. [this](auto& value) {
  29. auto alignment = Gfx::text_alignment_from_string(value.to_string());
  30. if (alignment.has_value()) {
  31. set_text_alignment(alignment.value());
  32. return true;
  33. }
  34. return false;
  35. });
  36. }
  37. ErrorOr<void> TabWidget::try_add_widget(Widget& widget)
  38. {
  39. m_tabs.append({ widget.title(), nullptr, &widget });
  40. add_child(widget);
  41. update_focus_policy();
  42. if (on_tab_count_change)
  43. on_tab_count_change(m_tabs.size());
  44. return {};
  45. }
  46. void TabWidget::add_widget(Widget& widget)
  47. {
  48. MUST(try_add_widget(widget));
  49. }
  50. void TabWidget::remove_widget(Widget& widget)
  51. {
  52. VERIFY(widget.parent() == this);
  53. auto tab_index = m_tabs.find_if([&widget](auto& entry) { return &widget == entry.widget; }).index();
  54. auto is_active = active_widget() == &widget;
  55. m_tabs.remove(tab_index);
  56. remove_child(widget);
  57. if (is_active && m_tabs.size() > 0) {
  58. auto next_tab_index = tab_index >= m_tabs.size() ? m_tabs.size() - 1 : tab_index;
  59. set_tab_index(next_tab_index);
  60. }
  61. update_focus_policy();
  62. if (on_tab_count_change)
  63. on_tab_count_change(m_tabs.size());
  64. }
  65. void TabWidget::remove_all_tabs_except(Widget& widget)
  66. {
  67. VERIFY(widget.parent() == this);
  68. set_active_widget(&widget);
  69. m_tabs.remove_all_matching([this, &widget](auto& entry) {
  70. bool is_other = &widget != entry.widget;
  71. if (is_other)
  72. remove_child(*entry.widget);
  73. return is_other;
  74. });
  75. VERIFY(m_tabs.size() == 1);
  76. update_focus_policy();
  77. if (on_tab_count_change)
  78. on_tab_count_change(1);
  79. }
  80. void TabWidget::update_focus_policy()
  81. {
  82. FocusPolicy policy;
  83. if (is_bar_visible() && !m_tabs.is_empty())
  84. policy = FocusPolicy::TabFocus;
  85. else
  86. policy = FocusPolicy::NoFocus;
  87. set_focus_policy(policy);
  88. }
  89. void TabWidget::set_active_widget(Widget* widget)
  90. {
  91. if (widget == m_active_widget)
  92. return;
  93. bool active_widget_had_focus = m_active_widget && m_active_widget->has_focus_within();
  94. if (m_active_widget)
  95. m_active_widget->set_visible(false);
  96. m_active_widget = widget;
  97. if (m_active_widget) {
  98. m_active_widget->set_relative_rect(child_rect_for_size(size()));
  99. if (active_widget_had_focus)
  100. m_active_widget->set_focus(true);
  101. m_active_widget->set_visible(true);
  102. deferred_invoke([this] {
  103. if (on_change)
  104. on_change(*m_active_widget);
  105. });
  106. }
  107. update_bar();
  108. }
  109. void TabWidget::set_tab_index(int index)
  110. {
  111. if (m_tabs.at(index).widget == m_active_widget)
  112. return;
  113. set_active_widget(m_tabs.at(index).widget);
  114. update_bar();
  115. }
  116. void TabWidget::resize_event(ResizeEvent& event)
  117. {
  118. if (!m_active_widget)
  119. return;
  120. m_active_widget->set_relative_rect(child_rect_for_size(event.size()));
  121. }
  122. Gfx::IntRect TabWidget::child_rect_for_size(Gfx::IntSize const& size) const
  123. {
  124. Gfx::IntRect rect;
  125. switch (m_tab_position) {
  126. case TabPosition::Top:
  127. 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() } };
  128. break;
  129. case TabPosition::Bottom:
  130. 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() } };
  131. break;
  132. }
  133. if (rect.is_empty())
  134. return {};
  135. return rect;
  136. }
  137. void TabWidget::child_event(Core::ChildEvent& event)
  138. {
  139. if (!event.child() || !is<Widget>(*event.child()))
  140. return Widget::child_event(event);
  141. auto& child = verify_cast<Widget>(*event.child());
  142. if (event.type() == Event::ChildAdded) {
  143. if (!m_active_widget)
  144. set_active_widget(&child);
  145. else if (m_active_widget != &child)
  146. child.set_visible(false);
  147. } else if (event.type() == Event::ChildRemoved) {
  148. if (m_active_widget == &child) {
  149. Widget* new_active_widget = nullptr;
  150. for_each_child_widget([&](auto& new_child) {
  151. new_active_widget = &new_child;
  152. return IterationDecision::Break;
  153. });
  154. set_active_widget(new_active_widget);
  155. }
  156. }
  157. Widget::child_event(event);
  158. }
  159. Gfx::IntRect TabWidget::bar_rect() const
  160. {
  161. switch (m_tab_position) {
  162. case TabPosition::Top:
  163. return { 0, 0, width(), bar_height() };
  164. case TabPosition::Bottom:
  165. return { 0, height() - bar_height(), width(), bar_height() };
  166. }
  167. VERIFY_NOT_REACHED();
  168. }
  169. Gfx::IntRect TabWidget::container_rect() const
  170. {
  171. switch (m_tab_position) {
  172. case TabPosition::Top:
  173. return { 0, bar_height(), width(), height() - bar_height() };
  174. case TabPosition::Bottom:
  175. return { 0, 0, width(), height() - bar_height() };
  176. }
  177. VERIFY_NOT_REACHED();
  178. }
  179. void TabWidget::paint_event(PaintEvent& event)
  180. {
  181. if (!m_bar_visible)
  182. return;
  183. Painter painter(*this);
  184. painter.add_clip_rect(event.rect());
  185. painter.fill_rect(event.rect(), palette().button());
  186. if (!m_container_margins.is_null()) {
  187. Gfx::StylePainter::paint_frame(painter, container_rect(), palette(), Gfx::FrameShape::Container, Gfx::FrameShadow::Raised, 2);
  188. }
  189. auto paint_tab_icon_if_needed = [&](auto& icon, auto& button_rect, auto& text_rect) {
  190. if (!icon)
  191. return;
  192. Gfx::IntRect icon_rect { button_rect.x(), button_rect.y(), 16, 16 };
  193. icon_rect.translate_by(4, 3);
  194. painter.draw_scaled_bitmap(icon_rect, *icon, icon->rect());
  195. text_rect.set_x(icon_rect.right() + 1 + 4);
  196. text_rect.intersect(button_rect);
  197. // We want to be in perfect alignment with the icon rect at all times.
  198. auto icon_rect_difference = icon_rect.top() - text_rect.top();
  199. text_rect.set_top(text_rect.top() + icon_rect_difference);
  200. text_rect.set_height(text_rect.height() - icon_rect_difference);
  201. // ...unless our leftover height after text drawing is uneven, in which
  202. // case we want to bias towards the bottom when the tab position is at
  203. // the top.
  204. if ((text_rect.height() - font().glyph_height()) % 2 != 0 && m_tab_position == TabPosition::Top) {
  205. text_rect.set_top(text_rect.top() + 1);
  206. }
  207. };
  208. for (size_t i = 0; i < m_tabs.size(); ++i) {
  209. if (m_tabs[i].widget == m_active_widget)
  210. continue;
  211. bool hovered = i == m_hovered_tab_index;
  212. auto button_rect = this->button_rect(i);
  213. Gfx::StylePainter::paint_tab_button(painter, button_rect, palette(), false, hovered, m_tabs[i].widget->is_enabled(), m_tab_position == TabPosition::Top, window()->is_active());
  214. // First we get rid of the 1px sheen on the left, then the 2px shadow
  215. // on the right. Finally we shrink 3px from each side.
  216. auto tab_button_content_rect = button_rect.shrunken(2, 0);
  217. tab_button_content_rect.set_width(tab_button_content_rect.width() - 1);
  218. tab_button_content_rect.shrink(6, 0);
  219. if (m_tab_position == TabPosition::Top) {
  220. tab_button_content_rect.set_top(tab_button_content_rect.top() + 1);
  221. tab_button_content_rect.set_height(tab_button_content_rect.height() - 1);
  222. }
  223. paint_tab_icon_if_needed(m_tabs[i].icon, button_rect, tab_button_content_rect);
  224. tab_button_content_rect.set_width(tab_button_content_rect.width() - (m_close_button_enabled ? 16 : 0));
  225. painter.draw_text(tab_button_content_rect, m_tabs[i].title, m_text_alignment, palette().button_text(), Gfx::TextElision::Right);
  226. }
  227. if (m_close_button_enabled) {
  228. for (size_t i = 0; i < m_tabs.size(); ++i) {
  229. if (m_tabs[i].widget == m_active_widget)
  230. continue;
  231. bool hovered_close_button = i == m_hovered_close_button_index;
  232. bool pressed_close_button = i == m_pressed_close_button_index;
  233. auto close_button_rect = this->close_button_rect(i);
  234. if (hovered_close_button)
  235. Gfx::StylePainter::paint_frame(painter, close_button_rect, palette(), Gfx::FrameShape::Box, pressed_close_button ? Gfx::FrameShadow::Sunken : Gfx::FrameShadow::Raised, 1);
  236. Gfx::IntRect icon_rect { close_button_rect.x() + 3, close_button_rect.y() + 3, 6, 6 };
  237. painter.draw_line(icon_rect.top_left(), icon_rect.bottom_right(), palette().button_text());
  238. painter.draw_line(icon_rect.top_right(), icon_rect.bottom_left(), palette().button_text());
  239. }
  240. }
  241. for (size_t i = 0; i < m_tabs.size(); ++i) {
  242. if (m_tabs[i].widget != m_active_widget)
  243. continue;
  244. bool hovered = i == m_hovered_tab_index;
  245. auto button_rect = this->button_rect(i);
  246. if (m_dragging_active_tab)
  247. button_rect.set_x(m_mouse_x - m_grab_offset);
  248. Gfx::StylePainter::paint_tab_button(painter, button_rect, palette(), true, hovered, m_tabs[i].widget->is_enabled(), m_tab_position == TabPosition::Top, window()->is_active());
  249. // First we get rid of the 1px sheen on the left, then the 2px shadow
  250. // on the right. Finally we shrink 3px from each side.
  251. auto tab_button_content_rect = button_rect.shrunken(2, 0);
  252. tab_button_content_rect.set_width(tab_button_content_rect.width() - 1);
  253. tab_button_content_rect.shrink(6, 0);
  254. if (m_tab_position == TabPosition::Top) {
  255. tab_button_content_rect.set_top(tab_button_content_rect.top() + 1);
  256. tab_button_content_rect.set_height(tab_button_content_rect.height() - 1);
  257. }
  258. paint_tab_icon_if_needed(m_tabs[i].icon, button_rect, tab_button_content_rect);
  259. tab_button_content_rect.set_width(tab_button_content_rect.width() - (m_close_button_enabled ? 16 : 0));
  260. painter.draw_text(tab_button_content_rect, m_tabs[i].title, m_text_alignment, palette().button_text(), Gfx::TextElision::Right);
  261. if (is_focused()) {
  262. Gfx::IntRect focus_rect { 0, 0, min(tab_button_content_rect.width(), font().width(m_tabs[i].title)), font().glyph_height() };
  263. focus_rect.align_within(tab_button_content_rect, m_text_alignment);
  264. focus_rect.inflate(6, 4);
  265. painter.draw_focus_rect(focus_rect, palette().focus_outline());
  266. }
  267. if (m_tab_position == TabPosition::Top) {
  268. painter.draw_line(button_rect.bottom_left().translated(1, 1), button_rect.bottom_right().translated(-1, 1), palette().button());
  269. } else if (m_tab_position == TabPosition::Bottom) {
  270. painter.set_pixel(button_rect.top_left().translated(0, -1), palette().threed_highlight());
  271. painter.set_pixel(button_rect.top_right().translated(-1, -1), palette().threed_shadow1());
  272. painter.draw_line(button_rect.top_left().translated(1, -1), button_rect.top_right().translated(-2, -1), palette().button());
  273. painter.draw_line(button_rect.top_left().translated(1, -2), button_rect.top_right().translated(-2, -2), palette().button());
  274. }
  275. break;
  276. }
  277. if (!m_close_button_enabled)
  278. return;
  279. for (size_t i = 0; i < m_tabs.size(); ++i) {
  280. if (m_tabs[i].widget != m_active_widget)
  281. continue;
  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. if (m_dragging_active_tab)
  286. close_button_rect.set_x((m_mouse_x - m_grab_offset) + (close_button_rect.x() - button_rect(i).x()));
  287. if (hovered_close_button)
  288. Gfx::StylePainter::paint_frame(painter, close_button_rect, palette(), Gfx::FrameShape::Box, pressed_close_button ? Gfx::FrameShadow::Sunken : Gfx::FrameShadow::Raised, 1);
  289. Gfx::IntRect icon_rect { close_button_rect.x() + 3, close_button_rect.y() + 3, 6, 6 };
  290. painter.draw_line(icon_rect.top_left(), icon_rect.bottom_right(), palette().button_text());
  291. painter.draw_line(icon_rect.top_right(), icon_rect.bottom_left(), palette().button_text());
  292. }
  293. }
  294. int TabWidget::uniform_tab_width() const
  295. {
  296. int minimum_tab_width = 24;
  297. int maximum_tab_width = 160;
  298. int total_tab_width = m_tabs.size() * maximum_tab_width;
  299. int tab_width = maximum_tab_width;
  300. int available_width = width() - bar_margin() * 2;
  301. if (total_tab_width > available_width)
  302. tab_width = available_width / m_tabs.size();
  303. return max(tab_width, minimum_tab_width);
  304. }
  305. void TabWidget::set_bar_visible(bool bar_visible)
  306. {
  307. m_bar_visible = bar_visible;
  308. if (m_active_widget)
  309. m_active_widget->set_relative_rect(child_rect_for_size(size()));
  310. update_bar();
  311. }
  312. Gfx::IntRect TabWidget::button_rect(size_t index) const
  313. {
  314. int x_offset = bar_margin();
  315. int close_button_offset = m_close_button_enabled ? 16 : 0;
  316. for (size_t i = 0; i < index; ++i) {
  317. auto tab_width = m_uniform_tabs ? uniform_tab_width() : m_tabs[i].width(font()) + close_button_offset;
  318. x_offset += tab_width;
  319. }
  320. Gfx::IntRect rect { x_offset, 0, m_uniform_tabs ? uniform_tab_width() : m_tabs[index].width(font()) + close_button_offset, bar_height() };
  321. if (m_tabs[index].widget != m_active_widget) {
  322. rect.translate_by(0, m_tab_position == TabPosition::Top ? 2 : 0);
  323. rect.set_height(rect.height() - 2);
  324. } else {
  325. rect.translate_by(-2, 0);
  326. rect.set_width(rect.width() + 4);
  327. }
  328. rect.translate_by(bar_rect().location());
  329. return rect;
  330. }
  331. Gfx::IntRect TabWidget::close_button_rect(size_t index) const
  332. {
  333. auto rect = button_rect(index);
  334. Gfx::IntRect close_button_rect { 0, 0, 12, 12 };
  335. if (m_tabs[index].widget == m_active_widget)
  336. close_button_rect.translate_by(rect.right() - 16, rect.top() + (m_tab_position == TabPosition::Top ? 5 : 4));
  337. else
  338. close_button_rect.translate_by(rect.right() - 15, rect.top() + (m_tab_position == TabPosition::Top ? 4 : 3));
  339. return close_button_rect;
  340. }
  341. int TabWidget::TabData::width(Gfx::Font const& font) const
  342. {
  343. auto width = 16 + font.width(title) + (icon ? (16 + 4) : 0);
  344. // NOTE: This needs to always be an odd number, because the button rect
  345. // includes 3px of light and shadow on the left and right edges. If
  346. // the button rect width is not an odd number, the area left for the
  347. // text and the focus rect has an odd number of pixels, and this
  348. // causes the text (and subsequently the focus rect) to not be aligned
  349. // to the center perfectly.
  350. if (width % 2 == 0) {
  351. width++;
  352. }
  353. return width;
  354. }
  355. void TabWidget::mousedown_event(MouseEvent& event)
  356. {
  357. for (size_t i = 0; i < m_tabs.size(); ++i) {
  358. auto button_rect = this->button_rect(i);
  359. auto close_button_rect = this->close_button_rect(i);
  360. if (!button_rect.contains(event.position()))
  361. continue;
  362. if (event.button() == MouseButton::Primary) {
  363. if (m_close_button_enabled && close_button_rect.contains(event.position())) {
  364. m_pressed_close_button_index = i;
  365. update_bar();
  366. return;
  367. }
  368. set_active_widget(m_tabs[i].widget);
  369. drag_tab(i);
  370. } else if (event.button() == MouseButton::Middle) {
  371. auto* widget = m_tabs[i].widget;
  372. deferred_invoke([this, widget] {
  373. if (on_middle_click && widget)
  374. on_middle_click(*widget);
  375. });
  376. }
  377. return;
  378. }
  379. }
  380. void TabWidget::mouseup_event(MouseEvent& event)
  381. {
  382. if (event.button() != MouseButton::Primary)
  383. return;
  384. if (m_dragging_active_tab) {
  385. m_dragging_active_tab = false;
  386. update_bar();
  387. }
  388. if (!m_close_button_enabled || !m_pressed_close_button_index.has_value())
  389. return;
  390. auto close_button_rect = this->close_button_rect(m_pressed_close_button_index.value());
  391. update_bar();
  392. if (close_button_rect.contains(event.position())) {
  393. auto* widget = m_tabs[m_pressed_close_button_index.value()].widget;
  394. deferred_invoke([this, widget] {
  395. if (on_tab_close_click && widget)
  396. on_tab_close_click(*widget);
  397. });
  398. }
  399. m_pressed_close_button_index = {};
  400. }
  401. void TabWidget::mousemove_event(MouseEvent& event)
  402. {
  403. Optional<size_t> hovered_tab = {};
  404. Optional<size_t> hovered_close_button = {};
  405. m_mouse_x = event.position().x();
  406. if (m_dragging_active_tab) {
  407. recalculate_tab_order();
  408. update_bar();
  409. return;
  410. }
  411. for (size_t i = 0; i < m_tabs.size(); ++i) {
  412. auto button_rect = this->button_rect(i);
  413. auto close_button_rect = this->close_button_rect(i);
  414. if (close_button_rect.contains(event.position()))
  415. hovered_close_button = i;
  416. if (!button_rect.contains(event.position()))
  417. continue;
  418. hovered_tab = i;
  419. if (m_tabs[i].widget == m_active_widget)
  420. break;
  421. }
  422. if (!hovered_tab.has_value() && !hovered_close_button.has_value())
  423. return;
  424. m_hovered_tab_index = hovered_tab;
  425. m_hovered_close_button_index = hovered_close_button;
  426. update_bar();
  427. }
  428. void TabWidget::leave_event(Core::Event&)
  429. {
  430. if (m_hovered_tab_index.has_value() || m_hovered_close_button_index.has_value()) {
  431. m_hovered_tab_index = {};
  432. m_hovered_close_button_index = {};
  433. update_bar();
  434. }
  435. }
  436. void TabWidget::update_bar()
  437. {
  438. if (m_tabs.is_empty())
  439. return;
  440. auto invalidation_rect = bar_rect();
  441. invalidation_rect.set_height(invalidation_rect.height() + 1);
  442. update(invalidation_rect);
  443. }
  444. void TabWidget::set_tab_position(TabPosition tab_position)
  445. {
  446. if (m_tab_position == tab_position)
  447. return;
  448. m_tab_position = tab_position;
  449. if (m_active_widget)
  450. m_active_widget->set_relative_rect(child_rect_for_size(size()));
  451. update();
  452. }
  453. Optional<size_t> TabWidget::active_tab_index() const
  454. {
  455. for (size_t i = 0; i < m_tabs.size(); i++) {
  456. if (m_tabs.at(i).widget == m_active_widget)
  457. return i;
  458. }
  459. return {};
  460. }
  461. void TabWidget::set_tab_title(Widget& tab, StringView title)
  462. {
  463. for (auto& t : m_tabs) {
  464. if (t.widget == &tab) {
  465. if (t.title != title) {
  466. t.title = title;
  467. update();
  468. }
  469. return;
  470. }
  471. }
  472. }
  473. void TabWidget::set_tab_icon(Widget& tab, Gfx::Bitmap const* icon)
  474. {
  475. for (auto& t : m_tabs) {
  476. if (t.widget == &tab) {
  477. t.icon = icon;
  478. update();
  479. return;
  480. }
  481. }
  482. }
  483. void TabWidget::activate_next_tab()
  484. {
  485. if (m_tabs.size() <= 1)
  486. return;
  487. auto index = active_tab_index();
  488. if (!index.has_value())
  489. return;
  490. auto next_index = index.value() + 1;
  491. if (next_index >= m_tabs.size())
  492. next_index = 0;
  493. set_active_widget(m_tabs.at(next_index).widget);
  494. }
  495. void TabWidget::activate_previous_tab()
  496. {
  497. if (m_tabs.size() <= 1)
  498. return;
  499. auto index = active_tab_index();
  500. if (!index.has_value())
  501. return;
  502. size_t previous_index = 0;
  503. if (index.value() == 0)
  504. previous_index = m_tabs.size() - 1;
  505. else
  506. previous_index = index.value() - 1;
  507. set_active_widget(m_tabs.at(previous_index).widget);
  508. }
  509. void TabWidget::activate_last_tab()
  510. {
  511. size_t number_of_tabs = m_tabs.size();
  512. if (number_of_tabs == 0)
  513. return;
  514. set_active_widget(m_tabs.at(number_of_tabs - 1).widget);
  515. }
  516. void TabWidget::keydown_event(KeyEvent& event)
  517. {
  518. if (event.ctrl() && event.key() == Key_Tab) {
  519. if (event.shift())
  520. activate_previous_tab();
  521. else
  522. activate_next_tab();
  523. event.accept();
  524. return;
  525. }
  526. if (is_focused()) {
  527. if (!event.modifiers() && event.key() == Key_Left) {
  528. activate_previous_tab();
  529. event.accept();
  530. return;
  531. }
  532. if (!event.modifiers() && event.key() == Key_Right) {
  533. activate_next_tab();
  534. event.accept();
  535. return;
  536. }
  537. }
  538. Widget::keydown_event(event);
  539. }
  540. void TabWidget::context_menu_event(ContextMenuEvent& context_menu_event)
  541. {
  542. for (size_t i = 0; i < m_tabs.size(); ++i) {
  543. auto button_rect = this->button_rect(i);
  544. if (!button_rect.contains(context_menu_event.position()))
  545. continue;
  546. auto* widget = m_tabs[i].widget;
  547. deferred_invoke([this, widget, context_menu_event] {
  548. if (on_context_menu_request && widget)
  549. on_context_menu_request(*widget, context_menu_event);
  550. });
  551. return;
  552. }
  553. }
  554. void TabWidget::doubleclick_event(MouseEvent& mouse_event)
  555. {
  556. for (size_t i = 0; i < m_tabs.size(); ++i) {
  557. auto button_rect = this->button_rect(i);
  558. if (!button_rect.contains(mouse_event.position()))
  559. continue;
  560. if (auto* widget = m_tabs[i].widget) {
  561. deferred_invoke([this, widget] {
  562. if (on_double_click)
  563. on_double_click(*widget);
  564. });
  565. }
  566. return;
  567. }
  568. }
  569. void TabWidget::set_container_margins(GUI::Margins const& margins)
  570. {
  571. m_container_margins = margins;
  572. update();
  573. }
  574. void TabWidget::drag_tab(size_t index)
  575. {
  576. m_dragging_active_tab = m_reorder_allowed;
  577. m_grab_offset = m_mouse_x - button_rect(index).x();
  578. m_hovered_tab_index = {};
  579. m_hovered_close_button_index = {};
  580. }
  581. void TabWidget::recalculate_tab_order()
  582. {
  583. if (!m_dragging_active_tab)
  584. return;
  585. size_t active;
  586. for (active = 0; active < m_tabs.size(); ++active) {
  587. if (m_tabs[active].widget == m_active_widget)
  588. break;
  589. }
  590. size_t target;
  591. for (target = 0; target < active; ++target) {
  592. auto button_rect = this->button_rect(target);
  593. if ((m_mouse_x - m_grab_offset) < button_rect.x()) {
  594. break;
  595. }
  596. }
  597. if (target == active) {
  598. for (target = m_tabs.size() - 1; target > active; --target) {
  599. auto button_rect = this->button_rect(target);
  600. if ((m_mouse_x - m_grab_offset) > button_rect.x()) {
  601. break;
  602. }
  603. }
  604. }
  605. if (active == target)
  606. return;
  607. auto tab = m_tabs.take(active);
  608. m_tabs.insert(target, tab);
  609. update_bar();
  610. }
  611. }