Widget.cpp 37 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275
  1. /*
  2. * Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2022, the SerenityOS developers.
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include <AK/Assertions.h>
  8. #include <AK/Debug.h>
  9. #include <AK/IterationDecision.h>
  10. #include <AK/JsonObject.h>
  11. #include <AK/NonnullRefPtr.h>
  12. #include <AK/RefPtr.h>
  13. #include <LibGUI/Action.h>
  14. #include <LibGUI/Application.h>
  15. #include <LibGUI/BoxLayout.h>
  16. #include <LibGUI/ConnectionToWindowServer.h>
  17. #include <LibGUI/Event.h>
  18. #include <LibGUI/GML/AST.h>
  19. #include <LibGUI/GML/Parser.h>
  20. #include <LibGUI/Layout.h>
  21. #include <LibGUI/Menu.h>
  22. #include <LibGUI/Painter.h>
  23. #include <LibGUI/TabWidget.h>
  24. #include <LibGUI/Widget.h>
  25. #include <LibGUI/Window.h>
  26. #include <LibGfx/Bitmap.h>
  27. #include <LibGfx/Font/Font.h>
  28. #include <LibGfx/Font/FontDatabase.h>
  29. #include <LibGfx/Palette.h>
  30. #include <LibGfx/SystemTheme.h>
  31. #include <unistd.h>
  32. REGISTER_CORE_OBJECT(GUI, Widget)
  33. namespace GUI {
  34. Widget::Widget()
  35. : Core::Object(nullptr)
  36. , m_background_role(Gfx::ColorRole::Window)
  37. , m_foreground_role(Gfx::ColorRole::WindowText)
  38. , m_font(Gfx::FontDatabase::default_font())
  39. , m_palette(Application::the()->palette().impl())
  40. {
  41. REGISTER_RECT_PROPERTY("relative_rect", relative_rect, set_relative_rect);
  42. REGISTER_BOOL_PROPERTY("fill_with_background_color", fill_with_background_color, set_fill_with_background_color);
  43. REGISTER_BOOL_PROPERTY("visible", is_visible, set_visible);
  44. REGISTER_BOOL_PROPERTY("focused", is_focused, set_focus);
  45. REGISTER_BOOL_PROPERTY("enabled", is_enabled, set_enabled);
  46. REGISTER_DEPRECATED_STRING_PROPERTY("tooltip", tooltip, set_tooltip);
  47. REGISTER_UI_SIZE_PROPERTY("min_size", min_size, set_min_size);
  48. REGISTER_READONLY_UI_SIZE_PROPERTY("effective_min_size", effective_min_size);
  49. REGISTER_UI_SIZE_PROPERTY("max_size", max_size, set_max_size);
  50. REGISTER_UI_SIZE_PROPERTY("preferred_size", preferred_size, set_preferred_size);
  51. REGISTER_READONLY_UI_SIZE_PROPERTY("effective_preferred_size", effective_preferred_size);
  52. REGISTER_INT_PROPERTY("width", width, set_width);
  53. REGISTER_UI_DIMENSION_PROPERTY("min_width", min_width, set_min_width);
  54. REGISTER_UI_DIMENSION_PROPERTY("max_width", max_width, set_max_width);
  55. REGISTER_UI_DIMENSION_PROPERTY("preferred_width", preferred_width, set_preferred_width);
  56. REGISTER_INT_PROPERTY("height", height, set_height);
  57. REGISTER_UI_DIMENSION_PROPERTY("min_height", min_height, set_min_height);
  58. REGISTER_UI_DIMENSION_PROPERTY("max_height", max_height, set_max_height);
  59. REGISTER_UI_DIMENSION_PROPERTY("preferred_height", preferred_height, set_preferred_height);
  60. REGISTER_INT_PROPERTY("fixed_width", dummy_fixed_width, set_fixed_width);
  61. REGISTER_INT_PROPERTY("fixed_height", dummy_fixed_height, set_fixed_height);
  62. REGISTER_SIZE_PROPERTY("fixed_size", dummy_fixed_size, set_fixed_size);
  63. REGISTER_BOOL_PROPERTY("shrink_to_fit", is_shrink_to_fit, set_shrink_to_fit);
  64. REGISTER_INT_PROPERTY("x", x, set_x);
  65. REGISTER_INT_PROPERTY("y", y, set_y);
  66. REGISTER_DEPRECATED_STRING_PROPERTY("font", m_font->family, set_font_family);
  67. REGISTER_INT_PROPERTY("font_size", m_font->presentation_size, set_font_size);
  68. REGISTER_FONT_WEIGHT_PROPERTY("font_weight", m_font->weight, set_font_weight);
  69. REGISTER_DEPRECATED_STRING_PROPERTY("title", title, set_title);
  70. register_property(
  71. "font_type", [this] { return m_font->is_fixed_width() ? "FixedWidth" : "Normal"; },
  72. [this](auto& value) {
  73. if (value.to_deprecated_string() == "FixedWidth") {
  74. set_font_fixed_width(true);
  75. return true;
  76. }
  77. if (value.to_deprecated_string() == "Normal") {
  78. set_font_fixed_width(false);
  79. return true;
  80. }
  81. return false;
  82. });
  83. register_property(
  84. "focus_policy", [this]() -> JsonValue {
  85. auto policy = focus_policy();
  86. if (policy == GUI::FocusPolicy::ClickFocus)
  87. return "ClickFocus";
  88. if (policy == GUI::FocusPolicy::NoFocus)
  89. return "NoFocus";
  90. if (policy == GUI::FocusPolicy::TabFocus)
  91. return "TabFocus";
  92. if (policy == GUI::FocusPolicy::StrongFocus)
  93. return "StrongFocus";
  94. return JsonValue(); },
  95. [this](auto& value) {
  96. if (!value.is_string())
  97. return false;
  98. if (value.as_string() == "ClickFocus") {
  99. set_focus_policy(GUI::FocusPolicy::ClickFocus);
  100. return true;
  101. }
  102. if (value.as_string() == "NoFocus") {
  103. set_focus_policy(GUI::FocusPolicy::NoFocus);
  104. return true;
  105. }
  106. if (value.as_string() == "TabFocus") {
  107. set_focus_policy(GUI::FocusPolicy::TabFocus);
  108. return true;
  109. }
  110. if (value.as_string() == "StrongFocus") {
  111. set_focus_policy(GUI::FocusPolicy::StrongFocus);
  112. return true;
  113. }
  114. return false;
  115. });
  116. register_property(
  117. "foreground_color", [this]() -> JsonValue { return palette().color(foreground_role()).to_deprecated_string(); },
  118. [this](auto& value) {
  119. auto c = Color::from_string(value.to_deprecated_string());
  120. if (c.has_value()) {
  121. auto _palette = palette();
  122. _palette.set_color(foreground_role(), c.value());
  123. set_palette(_palette);
  124. return true;
  125. }
  126. return false;
  127. });
  128. register_property(
  129. "background_color", [this]() -> JsonValue { return palette().color(background_role()).to_deprecated_string(); },
  130. [this](auto& value) {
  131. auto c = Color::from_string(value.to_deprecated_string());
  132. if (c.has_value()) {
  133. auto _palette = palette();
  134. _palette.set_color(background_role(), c.value());
  135. set_palette(_palette);
  136. return true;
  137. }
  138. return false;
  139. });
  140. register_property(
  141. "foreground_role", [this]() -> JsonValue { return Gfx::to_string(foreground_role()); },
  142. [this](auto& value) {
  143. if (!value.is_string())
  144. return false;
  145. auto str = value.as_string();
  146. if (str == "NoRole") {
  147. set_foreground_role(Gfx::ColorRole::NoRole);
  148. return true;
  149. }
  150. #undef __ENUMERATE_COLOR_ROLE
  151. #define __ENUMERATE_COLOR_ROLE(role) \
  152. else if (str == #role) \
  153. { \
  154. set_foreground_role(Gfx::ColorRole::role); \
  155. return true; \
  156. }
  157. ENUMERATE_COLOR_ROLES(__ENUMERATE_COLOR_ROLE)
  158. #undef __ENUMERATE_COLOR_ROLE
  159. return false;
  160. });
  161. register_property(
  162. "background_role", [this]() -> JsonValue { return Gfx::to_string(background_role()); },
  163. [this](auto& value) {
  164. if (!value.is_string())
  165. return false;
  166. auto str = value.as_string();
  167. if (str == "NoRole") {
  168. set_background_role(Gfx::ColorRole::NoRole);
  169. return true;
  170. }
  171. #undef __ENUMERATE_COLOR_ROLE
  172. #define __ENUMERATE_COLOR_ROLE(role) \
  173. else if (str == #role) \
  174. { \
  175. set_background_role(Gfx::ColorRole::role); \
  176. return true; \
  177. }
  178. ENUMERATE_COLOR_ROLES(__ENUMERATE_COLOR_ROLE)
  179. #undef __ENUMERATE_COLOR_ROLE
  180. return false;
  181. });
  182. }
  183. Widget::~Widget() = default;
  184. void Widget::layout_relevant_change_occurred()
  185. {
  186. if (auto* parent = parent_widget())
  187. parent->layout_relevant_change_occurred();
  188. else if (window())
  189. window()->schedule_relayout();
  190. }
  191. void Widget::child_event(Core::ChildEvent& event)
  192. {
  193. if (event.type() == Event::ChildAdded) {
  194. if (event.child() && is<Widget>(*event.child()) && layout()) {
  195. if (event.insertion_before_child() && is<Widget>(event.insertion_before_child()))
  196. layout()->insert_widget_before(verify_cast<Widget>(*event.child()), verify_cast<Widget>(*event.insertion_before_child()));
  197. else
  198. layout()->add_widget(verify_cast<Widget>(*event.child()));
  199. layout_relevant_change_occurred();
  200. }
  201. if (window() && event.child() && is<Widget>(*event.child()))
  202. window()->did_add_widget({}, verify_cast<Widget>(*event.child()));
  203. if (event.child() && is<Widget>(*event.child()) && static_cast<Widget const&>(*event.child()).is_visible()) {
  204. ShowEvent show_event;
  205. event.child()->dispatch_event(show_event);
  206. }
  207. }
  208. if (event.type() == Event::ChildRemoved) {
  209. if (layout()) {
  210. if (event.child() && is<Widget>(*event.child()))
  211. layout()->remove_widget(verify_cast<Widget>(*event.child()));
  212. layout_relevant_change_occurred();
  213. }
  214. if (window() && event.child() && is<Widget>(*event.child()))
  215. window()->did_remove_widget({}, verify_cast<Widget>(*event.child()));
  216. if (event.child() && is<Widget>(*event.child())) {
  217. HideEvent hide_event;
  218. event.child()->dispatch_event(hide_event);
  219. }
  220. update();
  221. }
  222. return Core::Object::child_event(event);
  223. }
  224. void Widget::set_relative_rect(Gfx::IntRect const& a_rect)
  225. {
  226. // Get rid of negative width/height values.
  227. Gfx::IntRect rect = {
  228. a_rect.x(),
  229. a_rect.y(),
  230. max(a_rect.width(), 0),
  231. max(a_rect.height(), 0)
  232. };
  233. if (rect == m_relative_rect)
  234. return;
  235. auto old_rect = m_relative_rect;
  236. bool size_changed = m_relative_rect.size() != rect.size();
  237. m_relative_rect = rect;
  238. if (size_changed) {
  239. ResizeEvent resize_event(rect.size());
  240. event(resize_event);
  241. }
  242. if (auto* parent = parent_widget())
  243. parent->update(old_rect);
  244. update();
  245. }
  246. void Widget::event(Core::Event& event)
  247. {
  248. if (!is_enabled()) {
  249. switch (event.type()) {
  250. case Event::MouseUp:
  251. case Event::MouseDown:
  252. case Event::MouseMove:
  253. case Event::MouseWheel:
  254. case Event::MouseDoubleClick:
  255. case Event::KeyUp:
  256. case Event::KeyDown:
  257. return;
  258. default:
  259. break;
  260. }
  261. }
  262. switch (event.type()) {
  263. case Event::Paint:
  264. return handle_paint_event(static_cast<PaintEvent&>(event));
  265. case Event::Resize:
  266. return handle_resize_event(static_cast<ResizeEvent&>(event));
  267. case Event::FocusIn:
  268. return focusin_event(static_cast<FocusEvent&>(event));
  269. case Event::FocusOut:
  270. return focusout_event(static_cast<FocusEvent&>(event));
  271. case Event::Show:
  272. return show_event(static_cast<ShowEvent&>(event));
  273. case Event::Hide:
  274. return hide_event(static_cast<HideEvent&>(event));
  275. case Event::KeyDown:
  276. return handle_keydown_event(static_cast<KeyEvent&>(event));
  277. case Event::KeyUp:
  278. return keyup_event(static_cast<KeyEvent&>(event));
  279. case Event::MouseMove:
  280. return mousemove_event(static_cast<MouseEvent&>(event));
  281. case Event::MouseDown:
  282. return handle_mousedown_event(static_cast<MouseEvent&>(event));
  283. case Event::MouseDoubleClick:
  284. return handle_mousedoubleclick_event(static_cast<MouseEvent&>(event));
  285. case Event::MouseUp:
  286. return handle_mouseup_event(static_cast<MouseEvent&>(event));
  287. case Event::MouseWheel:
  288. return mousewheel_event(static_cast<MouseEvent&>(event));
  289. case Event::DragEnter:
  290. return drag_enter_event(static_cast<DragEvent&>(event));
  291. case Event::DragMove:
  292. return drag_move_event(static_cast<DragEvent&>(event));
  293. case Event::DragLeave:
  294. return drag_leave_event(static_cast<Event&>(event));
  295. case Event::Drop:
  296. return drop_event(static_cast<DropEvent&>(event));
  297. case Event::ThemeChange:
  298. return theme_change_event(static_cast<ThemeChangeEvent&>(event));
  299. case Event::FontsChange:
  300. return fonts_change_event(static_cast<FontsChangeEvent&>(event));
  301. case Event::Enter:
  302. return handle_enter_event(event);
  303. case Event::Leave:
  304. return handle_leave_event(event);
  305. case Event::EnabledChange:
  306. return change_event(static_cast<Event&>(event));
  307. case Event::ContextMenu:
  308. return context_menu_event(static_cast<ContextMenuEvent&>(event));
  309. case Event::AppletAreaRectChange:
  310. return applet_area_rect_change_event(static_cast<AppletAreaRectChangeEvent&>(event));
  311. default:
  312. return Core::Object::event(event);
  313. }
  314. }
  315. void Widget::handle_keydown_event(KeyEvent& event)
  316. {
  317. keydown_event(event);
  318. if (event.is_accepted())
  319. return;
  320. if (auto action = Action::find_action_for_shortcut(*this, Shortcut(event.modifiers(), event.key()))) {
  321. action->process_event(*window(), event);
  322. if (event.is_accepted())
  323. return;
  324. }
  325. if (event.key() == KeyCode::Key_Menu) {
  326. ContextMenuEvent c_event(window_relative_rect().bottom_right(), screen_relative_rect().bottom_right());
  327. dispatch_event(c_event);
  328. return;
  329. }
  330. event.ignore();
  331. }
  332. void Widget::handle_paint_event(PaintEvent& event)
  333. {
  334. VERIFY(is_visible());
  335. if (!rect().intersects(event.rect())) {
  336. // This widget is not inside the paint event rect.
  337. // Since widgets fully contain their children, we don't need to recurse further.
  338. return;
  339. }
  340. if (fill_with_background_color()) {
  341. Painter painter(*this);
  342. painter.fill_rect(event.rect(), palette().color(background_role()));
  343. }
  344. paint_event(event);
  345. auto children_clip_rect = this->children_clip_rect();
  346. for_each_child_widget([&](auto& child) {
  347. if (!child.is_visible())
  348. return IterationDecision::Continue;
  349. if (child.relative_rect().intersects(event.rect())) {
  350. PaintEvent local_event(event.rect().intersected(children_clip_rect).intersected(child.relative_rect()).translated(-child.relative_position()));
  351. child.dispatch_event(local_event, this);
  352. }
  353. return IterationDecision::Continue;
  354. });
  355. second_paint_event(event);
  356. auto* app = Application::the();
  357. if (app && app->dnd_debugging_enabled() && has_pending_drop()) {
  358. Painter painter(*this);
  359. painter.draw_rect(rect(), Color::Blue);
  360. }
  361. if (app && app->focus_debugging_enabled() && is_focused()) {
  362. Painter painter(*this);
  363. painter.draw_rect(rect(), Color::Cyan);
  364. }
  365. if (app && app->hover_debugging_enabled() && this == window()->hovered_widget()) {
  366. Painter painter(*this);
  367. painter.draw_rect(rect(), Color::Red);
  368. }
  369. if (is_being_inspected()) {
  370. Painter painter(*this);
  371. painter.draw_rect(rect(), Color::Magenta);
  372. }
  373. }
  374. void Widget::set_layout(NonnullRefPtr<Layout> layout)
  375. {
  376. if (m_layout) {
  377. m_layout->notify_disowned({}, *this);
  378. m_layout->remove_from_parent();
  379. }
  380. m_layout = move(layout);
  381. if (m_layout) {
  382. add_child(*m_layout);
  383. m_layout->notify_adopted({}, *this);
  384. do_layout();
  385. } else {
  386. update();
  387. }
  388. layout_relevant_change_occurred();
  389. }
  390. void Widget::do_layout()
  391. {
  392. for_each_child_widget([&](auto& child) {
  393. child.do_layout();
  394. return IterationDecision::Continue;
  395. });
  396. custom_layout();
  397. if (!m_layout)
  398. return;
  399. m_layout->run(*this);
  400. did_layout();
  401. update();
  402. }
  403. void Widget::notify_layout_changed(Badge<Layout>)
  404. {
  405. invalidate_layout();
  406. }
  407. void Widget::handle_resize_event(ResizeEvent& event)
  408. {
  409. resize_event(event);
  410. do_layout();
  411. }
  412. void Widget::handle_mouseup_event(MouseEvent& event)
  413. {
  414. mouseup_event(event);
  415. }
  416. void Widget::handle_mousedown_event(MouseEvent& event)
  417. {
  418. if (has_flag(focus_policy(), FocusPolicy::ClickFocus))
  419. set_focus(true, FocusSource::Mouse);
  420. mousedown_event(event);
  421. if (event.button() == MouseButton::Secondary) {
  422. ContextMenuEvent c_event(event.position(), screen_relative_rect().location().translated(event.position()));
  423. dispatch_event(c_event);
  424. }
  425. }
  426. void Widget::handle_mousedoubleclick_event(MouseEvent& event)
  427. {
  428. doubleclick_event(event);
  429. }
  430. void Widget::handle_enter_event(Core::Event& event)
  431. {
  432. if (auto* window = this->window())
  433. window->update_cursor({});
  434. show_or_hide_tooltip();
  435. enter_event(event);
  436. }
  437. void Widget::handle_leave_event(Core::Event& event)
  438. {
  439. if (auto* window = this->window())
  440. window->update_cursor({});
  441. if (Application::the()->tooltip_source_widget() == this)
  442. Application::the()->hide_tooltip();
  443. leave_event(event);
  444. }
  445. void Widget::doubleclick_event(MouseEvent&)
  446. {
  447. }
  448. void Widget::resize_event(ResizeEvent&)
  449. {
  450. }
  451. void Widget::paint_event(PaintEvent&)
  452. {
  453. }
  454. void Widget::second_paint_event(PaintEvent&)
  455. {
  456. }
  457. void Widget::show_event(ShowEvent&)
  458. {
  459. }
  460. void Widget::hide_event(HideEvent&)
  461. {
  462. }
  463. void Widget::keydown_event(KeyEvent& event)
  464. {
  465. if (!event.alt() && !event.ctrl() && !event.super()) {
  466. if (event.key() == KeyCode::Key_Tab) {
  467. if (event.shift())
  468. focus_previous_widget(FocusSource::Keyboard, false);
  469. else
  470. focus_next_widget(FocusSource::Keyboard, false);
  471. event.accept();
  472. return;
  473. }
  474. if (!event.shift() && (event.key() == KeyCode::Key_Left || event.key() == KeyCode::Key_Up)) {
  475. focus_previous_widget(FocusSource::Keyboard, true);
  476. event.accept();
  477. return;
  478. }
  479. if (!event.shift() && (event.key() == KeyCode::Key_Right || event.key() == KeyCode::Key_Down)) {
  480. focus_next_widget(FocusSource::Keyboard, true);
  481. event.accept();
  482. return;
  483. }
  484. }
  485. event.ignore();
  486. }
  487. void Widget::keyup_event(KeyEvent& event)
  488. {
  489. event.ignore();
  490. }
  491. void Widget::mousedown_event(MouseEvent&)
  492. {
  493. }
  494. void Widget::mouseup_event(MouseEvent&)
  495. {
  496. }
  497. void Widget::mousemove_event(MouseEvent&)
  498. {
  499. }
  500. void Widget::mousewheel_event(MouseEvent& event)
  501. {
  502. event.ignore();
  503. }
  504. void Widget::context_menu_event(ContextMenuEvent& event)
  505. {
  506. event.ignore();
  507. }
  508. void Widget::focusin_event(FocusEvent&)
  509. {
  510. }
  511. void Widget::focusout_event(FocusEvent&)
  512. {
  513. }
  514. void Widget::enter_event(Core::Event&)
  515. {
  516. }
  517. void Widget::leave_event(Core::Event&)
  518. {
  519. }
  520. void Widget::change_event(Event&)
  521. {
  522. }
  523. void Widget::drag_move_event(DragEvent&)
  524. {
  525. }
  526. void Widget::drag_enter_event(DragEvent& event)
  527. {
  528. StringBuilder builder;
  529. builder.join(',', event.mime_types());
  530. dbgln_if(DRAG_DEBUG, "{} {:p} DRAG ENTER @ {}, {}", class_name(), this, event.position(), builder.string_view());
  531. }
  532. void Widget::drag_leave_event(Event&)
  533. {
  534. dbgln_if(DRAG_DEBUG, "{} {:p} DRAG LEAVE", class_name(), this);
  535. }
  536. void Widget::drop_event(DropEvent& event)
  537. {
  538. dbgln_if(DRAG_DEBUG, "{} {:p} DROP @ {}, '{}'", class_name(), this, event.position(), event.text());
  539. event.ignore();
  540. }
  541. void Widget::theme_change_event(ThemeChangeEvent&)
  542. {
  543. }
  544. void Widget::fonts_change_event(FontsChangeEvent&)
  545. {
  546. if (m_default_font)
  547. set_font(nullptr);
  548. }
  549. void Widget::screen_rects_change_event(ScreenRectsChangeEvent&)
  550. {
  551. }
  552. void Widget::applet_area_rect_change_event(AppletAreaRectChangeEvent&)
  553. {
  554. }
  555. void Widget::update()
  556. {
  557. if (rect().is_empty())
  558. return;
  559. update(rect());
  560. for (auto& it : m_focus_delegators) {
  561. if (!it.is_null() && !it->rect().is_empty())
  562. it->update(it->rect());
  563. }
  564. }
  565. void Widget::update(Gfx::IntRect const& rect)
  566. {
  567. if (!is_visible())
  568. return;
  569. if (!updates_enabled())
  570. return;
  571. auto bound_by_widget = rect.intersected(this->rect());
  572. if (bound_by_widget.is_empty())
  573. return;
  574. Window* window = m_window;
  575. Widget* parent = parent_widget();
  576. while (parent) {
  577. if (!parent->updates_enabled())
  578. return;
  579. window = parent->m_window;
  580. parent = parent->parent_widget();
  581. }
  582. if (window)
  583. window->update(bound_by_widget.translated(window_relative_rect().location()));
  584. }
  585. void Widget::repaint()
  586. {
  587. if (rect().is_empty())
  588. return;
  589. repaint(rect());
  590. }
  591. void Widget::repaint(Gfx::IntRect const& rect)
  592. {
  593. auto* window = this->window();
  594. if (!window)
  595. return;
  596. update(rect);
  597. window->flush_pending_paints_immediately();
  598. }
  599. Gfx::IntRect Widget::window_relative_rect() const
  600. {
  601. auto rect = relative_rect();
  602. for (auto* parent = parent_widget(); parent; parent = parent->parent_widget()) {
  603. rect.translate_by(parent->relative_position());
  604. }
  605. return rect;
  606. }
  607. Gfx::IntRect Widget::screen_relative_rect() const
  608. {
  609. auto window_position = window()->window_type() == WindowType::Applet
  610. ? window()->applet_rect_on_screen().location()
  611. : window()->rect().location();
  612. return window_relative_rect().translated(window_position);
  613. }
  614. Widget* Widget::child_at(Gfx::IntPoint point) const
  615. {
  616. for (int i = children().size() - 1; i >= 0; --i) {
  617. if (!is<Widget>(children()[i]))
  618. continue;
  619. auto& child = verify_cast<Widget>(*children()[i]);
  620. if (!child.is_visible())
  621. continue;
  622. if (child.relative_non_grabbable_rect().contains(point))
  623. return const_cast<Widget*>(&child);
  624. }
  625. return nullptr;
  626. }
  627. Widget::HitTestResult Widget::hit_test(Gfx::IntPoint position, ShouldRespectGreediness should_respect_greediness)
  628. {
  629. if (should_respect_greediness == ShouldRespectGreediness::Yes && is_greedy_for_hits())
  630. return { this, position };
  631. if (auto* child = child_at(position))
  632. return child->hit_test(position - child->relative_position());
  633. return { this, position };
  634. }
  635. void Widget::set_window(Window* window)
  636. {
  637. if (m_window == window)
  638. return;
  639. m_window = window;
  640. }
  641. void Widget::set_focus_proxy(Widget* proxy)
  642. {
  643. if (m_focus_proxy == proxy)
  644. return;
  645. if (proxy)
  646. proxy->add_focus_delegator(this);
  647. else if (m_focus_proxy)
  648. m_focus_proxy->remove_focus_delegator(this);
  649. m_focus_proxy = proxy;
  650. }
  651. void Widget::add_focus_delegator(Widget* delegator)
  652. {
  653. m_focus_delegators.remove_all_matching([&](auto& entry) {
  654. return entry.is_null() || entry == delegator;
  655. });
  656. m_focus_delegators.append(delegator);
  657. }
  658. void Widget::remove_focus_delegator(Widget* delegator)
  659. {
  660. m_focus_delegators.remove_first_matching([&](auto& entry) {
  661. return entry == delegator;
  662. });
  663. }
  664. FocusPolicy Widget::focus_policy() const
  665. {
  666. if (m_focus_proxy)
  667. return m_focus_proxy->focus_policy();
  668. return m_focus_policy;
  669. }
  670. void Widget::set_focus_policy(FocusPolicy policy)
  671. {
  672. if (m_focus_proxy)
  673. return m_focus_proxy->set_focus_policy(policy);
  674. m_focus_policy = policy;
  675. }
  676. bool Widget::is_focused() const
  677. {
  678. if (m_focus_proxy)
  679. return m_focus_proxy->is_focused();
  680. auto* win = window();
  681. if (!win)
  682. return false;
  683. if (win->is_focusable())
  684. return win->focused_widget() == this;
  685. return false;
  686. }
  687. void Widget::set_focus(bool focus, FocusSource source)
  688. {
  689. if (m_focus_proxy)
  690. return m_focus_proxy->set_focus(focus, source);
  691. auto* win = window();
  692. if (!win)
  693. return;
  694. if (focus) {
  695. win->set_focused_widget(this, source);
  696. } else {
  697. if (win->focused_widget() == this)
  698. win->set_focused_widget(nullptr, source);
  699. }
  700. }
  701. void Widget::set_font(Gfx::Font const* font)
  702. {
  703. if (m_font.ptr() == font)
  704. return;
  705. if (!font) {
  706. m_font = Gfx::FontDatabase::default_font();
  707. m_default_font = true;
  708. } else {
  709. m_font = *font;
  710. m_default_font = false;
  711. }
  712. did_change_font();
  713. update();
  714. }
  715. void Widget::set_font_family(DeprecatedString const& family)
  716. {
  717. set_font(Gfx::FontDatabase::the().get(family, m_font->presentation_size(), m_font->weight(), m_font->width(), m_font->slope()));
  718. }
  719. void Widget::set_font_size(unsigned size)
  720. {
  721. set_font(Gfx::FontDatabase::the().get(m_font->family(), size, m_font->weight(), m_font->width(), m_font->slope()));
  722. }
  723. void Widget::set_font_weight(unsigned weight)
  724. {
  725. set_font(Gfx::FontDatabase::the().get(m_font->family(), m_font->presentation_size(), weight, m_font->width(), m_font->slope()));
  726. }
  727. void Widget::set_font_fixed_width(bool fixed_width)
  728. {
  729. if (fixed_width)
  730. set_font(Gfx::FontDatabase::the().get(Gfx::FontDatabase::the().default_fixed_width_font().family(), m_font->presentation_size(), m_font->weight(), m_font->width(), m_font->slope()));
  731. else
  732. set_font(Gfx::FontDatabase::the().get(Gfx::FontDatabase::the().default_font().family(), m_font->presentation_size(), m_font->weight(), m_font->width(), m_font->slope()));
  733. }
  734. void Widget::set_min_size(UISize const& size)
  735. {
  736. VERIFY(size.width().is_one_of(SpecialDimension::Regular, SpecialDimension::Shrink));
  737. if (m_min_size == size)
  738. return;
  739. m_min_size = size;
  740. layout_relevant_change_occurred();
  741. }
  742. void Widget::set_max_size(UISize const& size)
  743. {
  744. VERIFY(size.width().is_one_of(SpecialDimension::Regular, SpecialDimension::Grow));
  745. if (m_max_size == size)
  746. return;
  747. m_max_size = size;
  748. layout_relevant_change_occurred();
  749. }
  750. void Widget::set_preferred_size(UISize const& size)
  751. {
  752. if (m_preferred_size == size)
  753. return;
  754. m_preferred_size = size;
  755. layout_relevant_change_occurred();
  756. }
  757. Optional<UISize> Widget::calculated_preferred_size() const
  758. {
  759. if (layout())
  760. return { layout()->preferred_size() };
  761. return {};
  762. }
  763. Optional<UISize> Widget::calculated_min_size() const
  764. {
  765. if (layout())
  766. return { layout()->min_size() };
  767. // Fall back to at least displaying the margins, so the Widget is not 0 size.
  768. auto m = content_margins();
  769. if (!m.is_null())
  770. return UISize { m.left() + m.right(), m.top() + m.bottom() };
  771. return {};
  772. }
  773. void Widget::invalidate_layout()
  774. {
  775. if (window())
  776. window()->schedule_relayout();
  777. }
  778. void Widget::set_visible(bool visible)
  779. {
  780. if (visible == m_visible)
  781. return;
  782. m_visible = visible;
  783. layout_relevant_change_occurred();
  784. if (m_visible)
  785. update();
  786. if (!m_visible && is_focused())
  787. set_focus(false);
  788. if (m_visible) {
  789. ShowEvent e;
  790. event(e);
  791. } else {
  792. HideEvent e;
  793. event(e);
  794. }
  795. }
  796. bool Widget::spans_entire_window_horizontally() const
  797. {
  798. auto* w = window();
  799. if (!w)
  800. return false;
  801. auto* main_widget = w->main_widget();
  802. if (!main_widget)
  803. return false;
  804. if (main_widget == this)
  805. return true;
  806. auto wrr = window_relative_rect();
  807. return wrr.left() == main_widget->rect().left() && wrr.right() == main_widget->rect().right();
  808. }
  809. void Widget::set_enabled(bool enabled)
  810. {
  811. if (m_enabled == enabled)
  812. return;
  813. m_enabled = enabled;
  814. for_each_child_widget([enabled](auto& child) {
  815. child.set_enabled(enabled);
  816. return IterationDecision::Continue;
  817. });
  818. if (!m_enabled && window() && window()->focused_widget() == this) {
  819. window()->did_disable_focused_widget({});
  820. }
  821. if (!m_enabled)
  822. set_override_cursor(Gfx::StandardCursor::None);
  823. Event e(Event::EnabledChange);
  824. event(e);
  825. update();
  826. }
  827. void Widget::move_to_front()
  828. {
  829. auto* parent = parent_widget();
  830. if (!parent)
  831. return;
  832. if (parent->children().size() == 1)
  833. return;
  834. parent->children().remove_first_matching([this](auto& entry) {
  835. return entry == this;
  836. });
  837. parent->children().append(*this);
  838. parent->update();
  839. }
  840. void Widget::move_to_back()
  841. {
  842. auto* parent = parent_widget();
  843. if (!parent)
  844. return;
  845. if (parent->children().size() == 1)
  846. return;
  847. parent->children().remove_first_matching([this](auto& entry) {
  848. return entry == this;
  849. });
  850. parent->children().prepend(*this);
  851. parent->update();
  852. }
  853. bool Widget::is_frontmost() const
  854. {
  855. auto* parent = parent_widget();
  856. if (!parent)
  857. return true;
  858. return parent->children().last() == this;
  859. }
  860. bool Widget::is_backmost() const
  861. {
  862. auto* parent = parent_widget();
  863. if (!parent)
  864. return true;
  865. return parent->children().first() == this;
  866. }
  867. Action* Widget::action_for_shortcut(Shortcut const& shortcut)
  868. {
  869. return Action::find_action_for_shortcut(*this, shortcut);
  870. }
  871. void Widget::set_updates_enabled(bool enabled)
  872. {
  873. if (m_updates_enabled == enabled)
  874. return;
  875. m_updates_enabled = enabled;
  876. if (enabled)
  877. update();
  878. }
  879. void Widget::focus_previous_widget(FocusSource source, bool siblings_only)
  880. {
  881. auto focusable_widgets = window()->focusable_widgets(source);
  882. if (siblings_only)
  883. focusable_widgets.remove_all_matching([this](auto& entry) { return entry.parent() != parent(); });
  884. for (int i = focusable_widgets.size() - 1; i >= 0; --i) {
  885. if (&focusable_widgets[i] != this)
  886. continue;
  887. if (i > 0)
  888. focusable_widgets[i - 1].set_focus(true, source);
  889. else
  890. focusable_widgets.last().set_focus(true, source);
  891. }
  892. }
  893. void Widget::focus_next_widget(FocusSource source, bool siblings_only)
  894. {
  895. auto focusable_widgets = window()->focusable_widgets(source);
  896. if (siblings_only)
  897. focusable_widgets.remove_all_matching([this](auto& entry) { return entry.parent() != parent(); });
  898. for (size_t i = 0; i < focusable_widgets.size(); ++i) {
  899. if (&focusable_widgets[i] != this)
  900. continue;
  901. if (i < focusable_widgets.size() - 1)
  902. focusable_widgets[i + 1].set_focus(true, source);
  903. else
  904. focusable_widgets.first().set_focus(true, source);
  905. }
  906. }
  907. Vector<Widget&> Widget::child_widgets() const
  908. {
  909. Vector<Widget&> widgets;
  910. widgets.ensure_capacity(children().size());
  911. for (auto& child : const_cast<Widget*>(this)->children()) {
  912. if (is<Widget>(*child))
  913. widgets.append(static_cast<Widget&>(*child));
  914. }
  915. return widgets;
  916. }
  917. void Widget::set_palette(Palette& palette)
  918. {
  919. m_palette = palette.impl();
  920. update();
  921. }
  922. void Widget::set_title(DeprecatedString title)
  923. {
  924. m_title = move(title);
  925. layout_relevant_change_occurred();
  926. // For tab widget children, our change in title also affects the parent.
  927. if (parent_widget())
  928. parent_widget()->update();
  929. }
  930. DeprecatedString Widget::title() const
  931. {
  932. return m_title;
  933. }
  934. void Widget::set_background_role(ColorRole role)
  935. {
  936. m_background_role = role;
  937. update();
  938. }
  939. void Widget::set_foreground_role(ColorRole role)
  940. {
  941. m_foreground_role = role;
  942. update();
  943. }
  944. Gfx::Palette Widget::palette() const
  945. {
  946. return Gfx::Palette(*m_palette);
  947. }
  948. void Widget::did_begin_inspection()
  949. {
  950. update();
  951. }
  952. void Widget::did_end_inspection()
  953. {
  954. update();
  955. }
  956. void Widget::set_grabbable_margins(Margins const& margins)
  957. {
  958. if (m_grabbable_margins == margins)
  959. return;
  960. m_grabbable_margins = margins;
  961. layout_relevant_change_occurred();
  962. }
  963. Gfx::IntRect Widget::relative_non_grabbable_rect() const
  964. {
  965. auto rect = relative_rect();
  966. rect.translate_by(m_grabbable_margins.left(), m_grabbable_margins.top());
  967. rect.set_width(rect.width() - (m_grabbable_margins.left() + m_grabbable_margins.right()));
  968. rect.set_height(rect.height() - (m_grabbable_margins.top() + m_grabbable_margins.bottom()));
  969. return rect;
  970. }
  971. void Widget::set_tooltip(DeprecatedString tooltip)
  972. {
  973. m_tooltip = move(tooltip);
  974. if (Application::the()->tooltip_source_widget() == this)
  975. show_or_hide_tooltip();
  976. }
  977. void Widget::show_or_hide_tooltip()
  978. {
  979. if (has_tooltip())
  980. Application::the()->show_tooltip(m_tooltip, this);
  981. else
  982. Application::the()->hide_tooltip();
  983. }
  984. Gfx::IntRect Widget::children_clip_rect() const
  985. {
  986. return rect();
  987. }
  988. void Widget::set_override_cursor(AK::Variant<Gfx::StandardCursor, NonnullRefPtr<Gfx::Bitmap const>> cursor)
  989. {
  990. auto const& are_cursors_the_same = [](auto const& a, auto const& b) {
  991. if (a.template has<Gfx::StandardCursor>() != b.template has<Gfx::StandardCursor>())
  992. return false;
  993. if (a.template has<Gfx::StandardCursor>())
  994. return a.template get<Gfx::StandardCursor>() == b.template get<Gfx::StandardCursor>();
  995. return a.template get<NonnullRefPtr<Gfx::Bitmap const>>().ptr() == b.template get<NonnullRefPtr<Gfx::Bitmap const>>().ptr();
  996. };
  997. if (are_cursors_the_same(m_override_cursor, cursor))
  998. return;
  999. m_override_cursor = move(cursor);
  1000. if (auto* window = this->window()) {
  1001. window->update_cursor({});
  1002. }
  1003. }
  1004. ErrorOr<void> Widget::load_from_gml(StringView gml_string)
  1005. {
  1006. return load_from_gml(gml_string, [](DeprecatedString const& class_name) -> ErrorOr<NonnullRefPtr<Core::Object>> {
  1007. dbgln("Class '{}' not registered", class_name);
  1008. return Error::from_string_literal("Class not registered");
  1009. });
  1010. }
  1011. ErrorOr<void> Widget::load_from_gml(StringView gml_string, UnregisteredChildHandler unregistered_child_handler)
  1012. {
  1013. auto value = TRY(GML::parse_gml(gml_string));
  1014. return load_from_gml_ast(value, unregistered_child_handler);
  1015. }
  1016. ErrorOr<void> Widget::load_from_gml_ast(NonnullRefPtr<GUI::GML::Node const> ast, UnregisteredChildHandler unregistered_child_handler)
  1017. {
  1018. if (is<GUI::GML::GMLFile>(ast.ptr()))
  1019. return load_from_gml_ast(static_cast<GUI::GML::GMLFile const&>(*ast).main_class(), unregistered_child_handler);
  1020. VERIFY(is<GUI::GML::Object>(ast.ptr()));
  1021. auto const& object = static_cast<GUI::GML::Object const&>(*ast);
  1022. object.for_each_property([&](auto key, auto value) {
  1023. set_property(key, value);
  1024. });
  1025. auto layout = object.layout_object();
  1026. if (!layout.is_null()) {
  1027. auto class_name = layout->name();
  1028. if (class_name.is_null()) {
  1029. return Error::from_string_literal("Invalid layout class name");
  1030. }
  1031. auto& layout_class = *Core::ObjectClassRegistration::find("GUI::Layout"sv);
  1032. if (auto* registration = Core::ObjectClassRegistration::find(class_name)) {
  1033. auto layout = TRY(registration->construct());
  1034. if (!registration->is_derived_from(layout_class)) {
  1035. dbgln("Invalid layout class: '{}'", class_name.to_deprecated_string());
  1036. return Error::from_string_literal("Invalid layout class");
  1037. }
  1038. set_layout(static_ptr_cast<Layout>(layout));
  1039. } else {
  1040. dbgln("Unknown layout class: '{}'", class_name.to_deprecated_string());
  1041. return Error::from_string_literal("Unknown layout class");
  1042. }
  1043. layout->for_each_property([&](auto key, auto value) {
  1044. this->layout()->set_property(key, value);
  1045. });
  1046. }
  1047. auto& widget_class = *Core::ObjectClassRegistration::find("GUI::Widget"sv);
  1048. bool is_tab_widget = is<TabWidget>(*this);
  1049. TRY(object.try_for_each_child_object([&](auto const& child_data) -> ErrorOr<void> {
  1050. auto class_name = child_data.name();
  1051. // It is very questionable if this pseudo object should exist, but it works fine like this for now.
  1052. if (class_name == "GUI::Layout::Spacer") {
  1053. if (!this->layout()) {
  1054. return Error::from_string_literal("Specified GUI::Layout::Spacer in GML, but the parent has no Layout.");
  1055. }
  1056. this->layout()->add_spacer();
  1057. } else {
  1058. RefPtr<Core::Object> child;
  1059. if (auto* registration = Core::ObjectClassRegistration::find(class_name)) {
  1060. child = TRY(registration->construct());
  1061. if (!registration->is_derived_from(widget_class)) {
  1062. dbgln("Invalid widget class: '{}'", class_name);
  1063. return Error::from_string_literal("Invalid widget class");
  1064. }
  1065. } else {
  1066. child = TRY(unregistered_child_handler(class_name));
  1067. }
  1068. if (!child)
  1069. return Error::from_string_literal("Unable to construct a Widget class for child");
  1070. add_child(*child);
  1071. // This is possible as we ensure that Widget is a base class above.
  1072. TRY(static_ptr_cast<Widget>(child)->load_from_gml_ast(child_data, unregistered_child_handler));
  1073. if (is_tab_widget) {
  1074. // FIXME: We need to have the child added before loading it so that it can access us. But the TabWidget logic requires the child to not be present yet.
  1075. remove_child(*child);
  1076. reinterpret_cast<TabWidget*>(this)->add_widget(*static_ptr_cast<Widget>(child));
  1077. }
  1078. }
  1079. return {};
  1080. }));
  1081. return {};
  1082. }
  1083. bool Widget::has_focus_within() const
  1084. {
  1085. auto* window = this->window();
  1086. if (!window)
  1087. return false;
  1088. if (!window->focused_widget())
  1089. return false;
  1090. auto& effective_focus_widget = focus_proxy() ? *focus_proxy() : *this;
  1091. return window->focused_widget() == &effective_focus_widget || is_ancestor_of(*window->focused_widget());
  1092. }
  1093. void Widget::set_shrink_to_fit(bool shrink_to_fit)
  1094. {
  1095. // This function is deprecated, and soon to be removed, it is only still here to ease the transition to UIDimensions
  1096. if (shrink_to_fit)
  1097. set_preferred_size(SpecialDimension::Fit);
  1098. }
  1099. bool Widget::has_pending_drop() const
  1100. {
  1101. return Application::the()->pending_drop_widget() == this;
  1102. }
  1103. bool Widget::is_visible_for_timer_purposes() const
  1104. {
  1105. return is_visible() && Object::is_visible_for_timer_purposes();
  1106. }
  1107. ErrorOr<void> Widget::add_spacer()
  1108. {
  1109. VERIFY(layout());
  1110. return layout()->try_add_spacer();
  1111. }
  1112. }