Window.cpp 37 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198
  1. /*
  2. * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Debug.h>
  7. #include <AK/HashMap.h>
  8. #include <AK/IDAllocator.h>
  9. #include <AK/JsonObject.h>
  10. #include <AK/NeverDestroyed.h>
  11. #include <AK/ScopeGuard.h>
  12. #include <LibCore/EventLoop.h>
  13. #include <LibCore/MimeData.h>
  14. #include <LibGUI/Action.h>
  15. #include <LibGUI/Application.h>
  16. #include <LibGUI/Desktop.h>
  17. #include <LibGUI/Event.h>
  18. #include <LibGUI/Menubar.h>
  19. #include <LibGUI/Painter.h>
  20. #include <LibGUI/Widget.h>
  21. #include <LibGUI/Window.h>
  22. #include <LibGUI/WindowManagerServerConnection.h>
  23. #include <LibGUI/WindowServerConnection.h>
  24. #include <LibGfx/Bitmap.h>
  25. #include <fcntl.h>
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <unistd.h>
  29. namespace GUI {
  30. static i32 s_next_backing_store_serial;
  31. static IDAllocator s_window_id_allocator;
  32. class WindowBackingStore {
  33. public:
  34. explicit WindowBackingStore(NonnullRefPtr<Gfx::Bitmap> bitmap)
  35. : m_bitmap(move(bitmap))
  36. , m_serial(++s_next_backing_store_serial)
  37. {
  38. }
  39. Gfx::Bitmap& bitmap() { return *m_bitmap; }
  40. const Gfx::Bitmap& bitmap() const { return *m_bitmap; }
  41. Gfx::IntSize size() const { return m_bitmap->size(); }
  42. i32 serial() const { return m_serial; }
  43. private:
  44. NonnullRefPtr<Gfx::Bitmap> m_bitmap;
  45. const i32 m_serial;
  46. };
  47. static NeverDestroyed<HashTable<Window*>> all_windows;
  48. static NeverDestroyed<HashMap<int, Window*>> reified_windows;
  49. Window* Window::from_window_id(int window_id)
  50. {
  51. auto it = reified_windows->find(window_id);
  52. if (it != reified_windows->end())
  53. return (*it).value;
  54. return nullptr;
  55. }
  56. Window::Window(Core::Object* parent)
  57. : Core::Object(parent)
  58. , m_menubar(Menubar::construct())
  59. {
  60. all_windows->set(this);
  61. m_rect_when_windowless = { -5000, -5000, 140, 140 };
  62. m_title_when_windowless = "GUI::Window";
  63. register_property(
  64. "title",
  65. [this] { return title(); },
  66. [this](auto& value) {
  67. set_title(value.to_string());
  68. return true;
  69. });
  70. register_property("visible", [this] { return is_visible(); });
  71. register_property("active", [this] { return is_active(); });
  72. REGISTER_BOOL_PROPERTY("minimizable", is_minimizable, set_minimizable);
  73. REGISTER_BOOL_PROPERTY("resizable", is_resizable, set_resizable);
  74. REGISTER_BOOL_PROPERTY("fullscreen", is_fullscreen, set_fullscreen);
  75. REGISTER_RECT_PROPERTY("rect", rect, set_rect);
  76. REGISTER_SIZE_PROPERTY("base_size", base_size, set_base_size);
  77. REGISTER_SIZE_PROPERTY("size_increment", size_increment, set_size_increment);
  78. }
  79. Window::~Window()
  80. {
  81. all_windows->remove(this);
  82. hide();
  83. }
  84. void Window::close()
  85. {
  86. hide();
  87. if (on_close)
  88. on_close();
  89. }
  90. void Window::move_to_front()
  91. {
  92. if (!is_visible())
  93. return;
  94. WindowServerConnection::the().async_move_window_to_front(m_window_id);
  95. }
  96. void Window::show()
  97. {
  98. if (is_visible())
  99. return;
  100. auto* parent_window = find_parent_window();
  101. m_window_id = s_window_id_allocator.allocate();
  102. Gfx::IntRect launch_origin_rect;
  103. if (auto* launch_origin_rect_string = getenv("__libgui_launch_origin_rect")) {
  104. auto parts = StringView(launch_origin_rect_string).split_view(',');
  105. if (parts.size() == 4) {
  106. launch_origin_rect = Gfx::IntRect {
  107. parts[0].to_int().value_or(0),
  108. parts[1].to_int().value_or(0),
  109. parts[2].to_int().value_or(0),
  110. parts[3].to_int().value_or(0),
  111. };
  112. }
  113. unsetenv("__libgui_launch_origin_rect");
  114. }
  115. WindowServerConnection::the().async_create_window(
  116. m_window_id,
  117. m_rect_when_windowless,
  118. !m_moved_by_client,
  119. m_has_alpha_channel,
  120. m_modal,
  121. m_minimizable,
  122. m_resizable,
  123. m_fullscreen,
  124. m_frameless,
  125. m_forced_shadow,
  126. m_accessory,
  127. m_opacity_when_windowless,
  128. m_alpha_hit_threshold,
  129. m_base_size,
  130. m_size_increment,
  131. m_minimum_size_when_windowless,
  132. m_resize_aspect_ratio,
  133. (i32)m_window_type,
  134. m_title_when_windowless,
  135. parent_window ? parent_window->window_id() : 0,
  136. launch_origin_rect);
  137. m_visible = true;
  138. apply_icon();
  139. m_menubar->for_each_menu([&](Menu& menu) {
  140. menu.realize_menu_if_needed();
  141. WindowServerConnection::the().async_add_menu(m_window_id, menu.menu_id());
  142. return IterationDecision::Continue;
  143. });
  144. reified_windows->set(m_window_id, this);
  145. Application::the()->did_create_window({});
  146. update();
  147. }
  148. Window* Window::find_parent_window()
  149. {
  150. for (auto* ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
  151. if (is<Window>(ancestor))
  152. return static_cast<Window*>(ancestor);
  153. }
  154. return nullptr;
  155. }
  156. void Window::server_did_destroy()
  157. {
  158. reified_windows->remove(m_window_id);
  159. m_window_id = 0;
  160. m_visible = false;
  161. m_pending_paint_event_rects.clear();
  162. m_back_store = nullptr;
  163. m_front_store = nullptr;
  164. m_cursor = Gfx::StandardCursor::None;
  165. }
  166. void Window::hide()
  167. {
  168. if (!is_visible())
  169. return;
  170. auto destroyed_window_ids = WindowServerConnection::the().destroy_window(m_window_id);
  171. server_did_destroy();
  172. for (auto child_window_id : destroyed_window_ids) {
  173. if (auto* window = Window::from_window_id(child_window_id)) {
  174. window->server_did_destroy();
  175. }
  176. }
  177. if (auto* app = Application::the()) {
  178. bool app_has_visible_windows = false;
  179. for (auto& window : *all_windows) {
  180. if (window->is_visible()) {
  181. app_has_visible_windows = true;
  182. break;
  183. }
  184. }
  185. if (!app_has_visible_windows)
  186. app->did_delete_last_window({});
  187. }
  188. }
  189. void Window::set_title(String title)
  190. {
  191. m_title_when_windowless = move(title);
  192. if (!is_visible())
  193. return;
  194. WindowServerConnection::the().async_set_window_title(m_window_id, m_title_when_windowless);
  195. }
  196. String Window::title() const
  197. {
  198. if (!is_visible())
  199. return m_title_when_windowless;
  200. return WindowServerConnection::the().get_window_title(m_window_id);
  201. }
  202. Gfx::IntRect Window::applet_rect_on_screen() const
  203. {
  204. VERIFY(m_window_type == WindowType::Applet);
  205. return WindowServerConnection::the().get_applet_rect_on_screen(m_window_id);
  206. }
  207. Gfx::IntRect Window::rect() const
  208. {
  209. if (!is_visible())
  210. return m_rect_when_windowless;
  211. return WindowServerConnection::the().get_window_rect(m_window_id);
  212. }
  213. void Window::set_rect(const Gfx::IntRect& a_rect)
  214. {
  215. if (a_rect.location() != m_rect_when_windowless.location()) {
  216. m_moved_by_client = true;
  217. }
  218. m_rect_when_windowless = a_rect;
  219. if (!is_visible()) {
  220. if (m_main_widget)
  221. m_main_widget->resize(m_rect_when_windowless.size());
  222. return;
  223. }
  224. auto window_rect = WindowServerConnection::the().set_window_rect(m_window_id, a_rect);
  225. if (m_back_store && m_back_store->size() != window_rect.size())
  226. m_back_store = nullptr;
  227. if (m_front_store && m_front_store->size() != window_rect.size())
  228. m_front_store = nullptr;
  229. if (m_main_widget)
  230. m_main_widget->resize(window_rect.size());
  231. }
  232. Gfx::IntSize Window::minimum_size() const
  233. {
  234. if (!is_visible())
  235. return m_minimum_size_when_windowless;
  236. return WindowServerConnection::the().get_window_minimum_size(m_window_id);
  237. }
  238. void Window::set_minimum_size(const Gfx::IntSize& size)
  239. {
  240. m_minimum_size_modified = true;
  241. m_minimum_size_when_windowless = size;
  242. if (is_visible())
  243. WindowServerConnection::the().async_set_window_minimum_size(m_window_id, size);
  244. }
  245. void Window::center_on_screen()
  246. {
  247. auto window_rect = rect();
  248. window_rect.center_within(Desktop::the().rect());
  249. set_rect(window_rect);
  250. }
  251. void Window::center_within(const Window& other)
  252. {
  253. if (this == &other)
  254. return;
  255. auto window_rect = rect();
  256. window_rect.center_within(other.rect());
  257. set_rect(window_rect);
  258. }
  259. void Window::set_window_type(WindowType window_type)
  260. {
  261. m_window_type = window_type;
  262. if (!m_minimum_size_modified) {
  263. // Apply minimum size defaults.
  264. if (m_window_type == WindowType::Normal || m_window_type == WindowType::ToolWindow)
  265. m_minimum_size_when_windowless = { 50, 50 };
  266. else
  267. m_minimum_size_when_windowless = { 1, 1 };
  268. }
  269. }
  270. void Window::make_window_manager(unsigned event_mask)
  271. {
  272. GUI::WindowManagerServerConnection::the().async_set_event_mask(event_mask);
  273. GUI::WindowManagerServerConnection::the().async_set_manager_window(m_window_id);
  274. }
  275. void Window::set_cursor(Gfx::StandardCursor cursor)
  276. {
  277. if (m_cursor == cursor)
  278. return;
  279. m_cursor = cursor;
  280. m_custom_cursor = nullptr;
  281. update_cursor();
  282. }
  283. void Window::set_cursor(const Gfx::Bitmap& cursor)
  284. {
  285. if (m_custom_cursor == &cursor)
  286. return;
  287. m_cursor = Gfx::StandardCursor::None;
  288. m_custom_cursor = &cursor;
  289. update_cursor();
  290. }
  291. void Window::handle_drop_event(DropEvent& event)
  292. {
  293. if (!m_main_widget)
  294. return;
  295. auto result = m_main_widget->hit_test(event.position());
  296. auto local_event = make<DropEvent>(result.local_position, event.text(), event.mime_data());
  297. VERIFY(result.widget);
  298. result.widget->dispatch_event(*local_event, this);
  299. Application::the()->set_drag_hovered_widget({}, nullptr);
  300. }
  301. void Window::handle_mouse_event(MouseEvent& event)
  302. {
  303. if (m_global_cursor_tracking_widget) {
  304. auto window_relative_rect = m_global_cursor_tracking_widget->window_relative_rect();
  305. Gfx::IntPoint local_point { event.x() - window_relative_rect.x(), event.y() - window_relative_rect.y() };
  306. auto local_event = MouseEvent((Event::Type)event.type(), local_point, event.buttons(), event.button(), event.modifiers(), event.wheel_delta());
  307. m_global_cursor_tracking_widget->dispatch_event(local_event, this);
  308. return;
  309. }
  310. if (m_automatic_cursor_tracking_widget) {
  311. auto window_relative_rect = m_automatic_cursor_tracking_widget->window_relative_rect();
  312. Gfx::IntPoint local_point { event.x() - window_relative_rect.x(), event.y() - window_relative_rect.y() };
  313. auto local_event = MouseEvent((Event::Type)event.type(), local_point, event.buttons(), event.button(), event.modifiers(), event.wheel_delta());
  314. m_automatic_cursor_tracking_widget->dispatch_event(local_event, this);
  315. if (event.buttons() == 0)
  316. m_automatic_cursor_tracking_widget = nullptr;
  317. return;
  318. }
  319. if (!m_main_widget)
  320. return;
  321. auto result = m_main_widget->hit_test(event.position());
  322. auto local_event = MouseEvent((Event::Type)event.type(), result.local_position, event.buttons(), event.button(), event.modifiers(), event.wheel_delta());
  323. VERIFY(result.widget);
  324. set_hovered_widget(result.widget);
  325. if (event.buttons() != 0 && !m_automatic_cursor_tracking_widget)
  326. m_automatic_cursor_tracking_widget = *result.widget;
  327. if (result.widget != m_global_cursor_tracking_widget.ptr())
  328. result.widget->dispatch_event(local_event, this);
  329. if (!m_pending_paint_event_rects.is_empty()) {
  330. MultiPaintEvent paint_event(move(m_pending_paint_event_rects), size());
  331. handle_multi_paint_event(paint_event);
  332. }
  333. }
  334. void Window::handle_multi_paint_event(MultiPaintEvent& event)
  335. {
  336. if (!is_visible())
  337. return;
  338. if (!m_main_widget)
  339. return;
  340. auto rects = event.rects();
  341. if (!m_pending_paint_event_rects.is_empty()) {
  342. // It's possible that there had been some calls to update() that
  343. // haven't been flushed. We can handle these right now, avoiding
  344. // another round trip.
  345. rects.extend(move(m_pending_paint_event_rects));
  346. }
  347. VERIFY(!rects.is_empty());
  348. if (m_back_store && m_back_store->size() != event.window_size()) {
  349. // Eagerly discard the backing store if we learn from this paint event that it needs to be bigger.
  350. // Otherwise we would have to wait for a resize event to tell us. This way we don't waste the
  351. // effort on painting into an undersized bitmap that will be thrown away anyway.
  352. m_back_store = nullptr;
  353. }
  354. bool created_new_backing_store = !m_back_store;
  355. if (!m_back_store) {
  356. m_back_store = create_backing_store(event.window_size());
  357. VERIFY(m_back_store);
  358. } else if (m_double_buffering_enabled) {
  359. bool was_purged = false;
  360. bool bitmap_has_memory = m_back_store->bitmap().set_nonvolatile(was_purged);
  361. if (!bitmap_has_memory) {
  362. // We didn't have enough memory to make the bitmap non-volatile!
  363. // Fall back to single-buffered mode for this window.
  364. // FIXME: Once we have a way to listen for system memory pressure notifications,
  365. // it would be cool to transition back into double-buffered mode once
  366. // the coast is clear.
  367. dbgln("Not enough memory to make backing store non-volatile. Falling back to single-buffered mode.");
  368. m_double_buffering_enabled = false;
  369. m_back_store = move(m_front_store);
  370. created_new_backing_store = true;
  371. } else if (was_purged) {
  372. // The backing store bitmap was cleared, but it does have memory.
  373. // Act as if it's a new backing store so the entire window gets repainted.
  374. created_new_backing_store = true;
  375. }
  376. }
  377. auto rect = rects.first();
  378. if (rect.is_empty() || created_new_backing_store) {
  379. rects.clear();
  380. rects.append({ {}, event.window_size() });
  381. }
  382. for (auto& rect : rects) {
  383. PaintEvent paint_event(rect);
  384. m_main_widget->dispatch_event(paint_event, this);
  385. }
  386. if (m_double_buffering_enabled)
  387. flip(rects);
  388. else if (created_new_backing_store)
  389. set_current_backing_store(*m_back_store, true);
  390. if (is_visible())
  391. WindowServerConnection::the().async_did_finish_painting(m_window_id, rects);
  392. }
  393. void Window::handle_key_event(KeyEvent& event)
  394. {
  395. if (!m_focused_widget && event.type() == Event::KeyDown && event.key() == Key_Tab && !event.ctrl() && !event.alt() && !event.super()) {
  396. focus_a_widget_if_possible(FocusSource::Keyboard);
  397. }
  398. if (m_focused_widget)
  399. return m_focused_widget->dispatch_event(event, this);
  400. if (m_main_widget)
  401. return m_main_widget->dispatch_event(event, this);
  402. }
  403. void Window::handle_resize_event(ResizeEvent& event)
  404. {
  405. auto new_size = event.size();
  406. if (m_back_store && m_back_store->size() != new_size)
  407. m_back_store = nullptr;
  408. if (!m_pending_paint_event_rects.is_empty()) {
  409. m_pending_paint_event_rects.clear_with_capacity();
  410. m_pending_paint_event_rects.append({ {}, new_size });
  411. }
  412. m_rect_when_windowless = { {}, new_size };
  413. if (m_main_widget)
  414. m_main_widget->set_relative_rect({ {}, new_size });
  415. }
  416. void Window::handle_input_entered_or_left_event(Core::Event& event)
  417. {
  418. m_is_active_input = event.type() == Event::WindowInputEntered;
  419. if (on_active_input_change)
  420. on_active_input_change(m_is_active_input);
  421. if (m_main_widget)
  422. m_main_widget->dispatch_event(event, this);
  423. if (m_focused_widget)
  424. m_focused_widget->update();
  425. }
  426. void Window::handle_became_active_or_inactive_event(Core::Event& event)
  427. {
  428. if (event.type() == Event::WindowBecameActive)
  429. Application::the()->window_did_become_active({}, *this);
  430. else
  431. Application::the()->window_did_become_inactive({}, *this);
  432. if (on_active_window_change)
  433. on_active_window_change(event.type() == Event::WindowBecameActive);
  434. if (m_main_widget)
  435. m_main_widget->dispatch_event(event, this);
  436. if (m_focused_widget)
  437. m_focused_widget->update();
  438. }
  439. void Window::handle_close_request()
  440. {
  441. if (on_close_request) {
  442. if (on_close_request() == Window::CloseRequestDecision::StayOpen)
  443. return;
  444. }
  445. close();
  446. }
  447. void Window::handle_theme_change_event(ThemeChangeEvent& event)
  448. {
  449. if (!m_main_widget)
  450. return;
  451. auto dispatch_theme_change = [&](auto& widget, auto recursive) {
  452. widget.dispatch_event(event, this);
  453. widget.for_each_child_widget([&](auto& widget) -> IterationDecision {
  454. widget.dispatch_event(event, this);
  455. recursive(widget, recursive);
  456. return IterationDecision::Continue;
  457. });
  458. };
  459. dispatch_theme_change(*m_main_widget.ptr(), dispatch_theme_change);
  460. }
  461. void Window::handle_fonts_change_event(FontsChangeEvent& event)
  462. {
  463. if (!m_main_widget)
  464. return;
  465. auto dispatch_fonts_change = [&](auto& widget, auto recursive) {
  466. widget.dispatch_event(event, this);
  467. widget.for_each_child_widget([&](auto& widget) -> IterationDecision {
  468. widget.dispatch_event(event, this);
  469. recursive(widget, recursive);
  470. return IterationDecision::Continue;
  471. });
  472. };
  473. dispatch_fonts_change(*m_main_widget.ptr(), dispatch_fonts_change);
  474. }
  475. void Window::handle_screen_rects_change_event(ScreenRectsChangeEvent& event)
  476. {
  477. if (!m_main_widget)
  478. return;
  479. auto dispatch_screen_rects_change = [&](auto& widget, auto recursive) {
  480. widget.dispatch_event(event, this);
  481. widget.for_each_child_widget([&](auto& widget) -> IterationDecision {
  482. widget.dispatch_event(event, this);
  483. recursive(widget, recursive);
  484. return IterationDecision::Continue;
  485. });
  486. };
  487. dispatch_screen_rects_change(*m_main_widget.ptr(), dispatch_screen_rects_change);
  488. screen_rects_change_event(event);
  489. }
  490. void Window::handle_drag_move_event(DragEvent& event)
  491. {
  492. if (!m_main_widget)
  493. return;
  494. auto result = m_main_widget->hit_test(event.position());
  495. VERIFY(result.widget);
  496. Application::the()->set_drag_hovered_widget({}, result.widget, result.local_position, event.mime_types());
  497. // NOTE: Setting the drag hovered widget may have executed arbitrary code, so re-check that the widget is still there.
  498. if (!result.widget)
  499. return;
  500. if (result.widget->has_pending_drop()) {
  501. DragEvent drag_move_event(static_cast<Event::Type>(event.type()), result.local_position, event.mime_types());
  502. result.widget->dispatch_event(drag_move_event, this);
  503. }
  504. }
  505. void Window::enter_event(Core::Event&)
  506. {
  507. }
  508. void Window::leave_event(Core::Event&)
  509. {
  510. }
  511. void Window::handle_entered_event(Core::Event& event)
  512. {
  513. enter_event(event);
  514. }
  515. void Window::handle_left_event(Core::Event& event)
  516. {
  517. set_hovered_widget(nullptr);
  518. Application::the()->set_drag_hovered_widget({}, nullptr);
  519. leave_event(event);
  520. }
  521. void Window::event(Core::Event& event)
  522. {
  523. ScopeGuard guard([&] {
  524. // Accept the event so it doesn't bubble up to parent windows!
  525. event.accept();
  526. });
  527. if (event.type() == Event::Drop)
  528. return handle_drop_event(static_cast<DropEvent&>(event));
  529. if (event.type() == Event::MouseUp || event.type() == Event::MouseDown || event.type() == Event::MouseDoubleClick || event.type() == Event::MouseMove || event.type() == Event::MouseWheel)
  530. return handle_mouse_event(static_cast<MouseEvent&>(event));
  531. if (event.type() == Event::MultiPaint)
  532. return handle_multi_paint_event(static_cast<MultiPaintEvent&>(event));
  533. if (event.type() == Event::KeyUp || event.type() == Event::KeyDown)
  534. return handle_key_event(static_cast<KeyEvent&>(event));
  535. if (event.type() == Event::WindowBecameActive || event.type() == Event::WindowBecameInactive)
  536. return handle_became_active_or_inactive_event(event);
  537. if (event.type() == Event::WindowInputEntered || event.type() == Event::WindowInputLeft)
  538. return handle_input_entered_or_left_event(event);
  539. if (event.type() == Event::WindowCloseRequest)
  540. return handle_close_request();
  541. if (event.type() == Event::WindowEntered)
  542. return handle_entered_event(event);
  543. if (event.type() == Event::WindowLeft)
  544. return handle_left_event(event);
  545. if (event.type() == Event::Resize)
  546. return handle_resize_event(static_cast<ResizeEvent&>(event));
  547. if (event.type() > Event::__Begin_WM_Events && event.type() < Event::__End_WM_Events)
  548. return wm_event(static_cast<WMEvent&>(event));
  549. if (event.type() == Event::DragMove)
  550. return handle_drag_move_event(static_cast<DragEvent&>(event));
  551. if (event.type() == Event::ThemeChange)
  552. return handle_theme_change_event(static_cast<ThemeChangeEvent&>(event));
  553. if (event.type() == Event::FontsChange)
  554. return handle_fonts_change_event(static_cast<FontsChangeEvent&>(event));
  555. if (event.type() == Event::ScreenRectsChange)
  556. return handle_screen_rects_change_event(static_cast<ScreenRectsChangeEvent&>(event));
  557. Core::Object::event(event);
  558. }
  559. bool Window::is_visible() const
  560. {
  561. return m_visible;
  562. }
  563. void Window::update()
  564. {
  565. auto rect = this->rect();
  566. update({ 0, 0, rect.width(), rect.height() });
  567. }
  568. void Window::force_update()
  569. {
  570. if (!is_visible())
  571. return;
  572. auto rect = this->rect();
  573. WindowServerConnection::the().async_invalidate_rect(m_window_id, { { 0, 0, rect.width(), rect.height() } }, true);
  574. }
  575. void Window::update(const Gfx::IntRect& a_rect)
  576. {
  577. if (!is_visible())
  578. return;
  579. for (auto& pending_rect : m_pending_paint_event_rects) {
  580. if (pending_rect.contains(a_rect)) {
  581. dbgln_if(UPDATE_COALESCING_DEBUG, "Ignoring {} since it's contained by pending rect {}", a_rect, pending_rect);
  582. return;
  583. }
  584. }
  585. if (m_pending_paint_event_rects.is_empty()) {
  586. deferred_invoke([this](auto&) {
  587. auto rects = move(m_pending_paint_event_rects);
  588. if (rects.is_empty())
  589. return;
  590. WindowServerConnection::the().async_invalidate_rect(m_window_id, rects, false);
  591. });
  592. }
  593. m_pending_paint_event_rects.append(a_rect);
  594. }
  595. void Window::set_main_widget(Widget* widget)
  596. {
  597. if (m_main_widget == widget)
  598. return;
  599. if (m_main_widget) {
  600. m_main_widget->set_window(nullptr);
  601. remove_child(*m_main_widget);
  602. }
  603. m_main_widget = widget;
  604. if (m_main_widget) {
  605. add_child(*widget);
  606. auto new_window_rect = rect();
  607. if (m_main_widget->min_width() >= 0)
  608. new_window_rect.set_width(max(new_window_rect.width(), m_main_widget->min_width()));
  609. if (m_main_widget->min_height() >= 0)
  610. new_window_rect.set_height(max(new_window_rect.height(), m_main_widget->min_height()));
  611. set_rect(new_window_rect);
  612. m_main_widget->set_relative_rect({ {}, new_window_rect.size() });
  613. m_main_widget->set_window(this);
  614. if (m_main_widget->focus_policy() != FocusPolicy::NoFocus)
  615. m_main_widget->set_focus(true);
  616. }
  617. update();
  618. }
  619. void Window::set_focused_widget(Widget* widget, FocusSource source)
  620. {
  621. if (m_focused_widget == widget)
  622. return;
  623. WeakPtr<Widget> previously_focused_widget = m_focused_widget;
  624. m_focused_widget = widget;
  625. if (!m_focused_widget && m_previously_focused_widget)
  626. m_focused_widget = m_previously_focused_widget;
  627. if (previously_focused_widget) {
  628. Core::EventLoop::current().post_event(*previously_focused_widget, make<FocusEvent>(Event::FocusOut, source));
  629. previously_focused_widget->update();
  630. if (previously_focused_widget && previously_focused_widget->on_focus_change)
  631. previously_focused_widget->on_focus_change(previously_focused_widget->is_focused(), source);
  632. m_previously_focused_widget = previously_focused_widget;
  633. }
  634. if (m_focused_widget) {
  635. Core::EventLoop::current().post_event(*m_focused_widget, make<FocusEvent>(Event::FocusIn, source));
  636. m_focused_widget->update();
  637. if (m_focused_widget && m_focused_widget->on_focus_change)
  638. m_focused_widget->on_focus_change(m_focused_widget->is_focused(), source);
  639. }
  640. }
  641. void Window::set_global_cursor_tracking_widget(Widget* widget)
  642. {
  643. if (widget == m_global_cursor_tracking_widget)
  644. return;
  645. m_global_cursor_tracking_widget = widget;
  646. }
  647. void Window::set_automatic_cursor_tracking_widget(Widget* widget)
  648. {
  649. if (widget == m_automatic_cursor_tracking_widget)
  650. return;
  651. m_automatic_cursor_tracking_widget = widget;
  652. }
  653. void Window::set_has_alpha_channel(bool value)
  654. {
  655. if (m_has_alpha_channel == value)
  656. return;
  657. m_has_alpha_channel = value;
  658. if (!is_visible())
  659. return;
  660. m_pending_paint_event_rects.clear();
  661. m_back_store = nullptr;
  662. m_front_store = nullptr;
  663. WindowServerConnection::the().async_set_window_has_alpha_channel(m_window_id, value);
  664. update();
  665. }
  666. void Window::set_double_buffering_enabled(bool value)
  667. {
  668. VERIFY(!is_visible());
  669. m_double_buffering_enabled = value;
  670. }
  671. void Window::set_opacity(float opacity)
  672. {
  673. m_opacity_when_windowless = opacity;
  674. if (!is_visible())
  675. return;
  676. WindowServerConnection::the().async_set_window_opacity(m_window_id, opacity);
  677. }
  678. void Window::set_alpha_hit_threshold(float threshold)
  679. {
  680. if (threshold < 0.0f)
  681. threshold = 0.0f;
  682. else if (threshold > 1.0f)
  683. threshold = 1.0f;
  684. if (m_alpha_hit_threshold == threshold)
  685. return;
  686. m_alpha_hit_threshold = threshold;
  687. if (!is_visible())
  688. return;
  689. WindowServerConnection::the().async_set_window_alpha_hit_threshold(m_window_id, threshold);
  690. }
  691. void Window::set_hovered_widget(Widget* widget)
  692. {
  693. if (widget == m_hovered_widget)
  694. return;
  695. if (m_hovered_widget)
  696. Core::EventLoop::current().post_event(*m_hovered_widget, make<Event>(Event::Leave));
  697. m_hovered_widget = widget;
  698. if (m_hovered_widget)
  699. Core::EventLoop::current().post_event(*m_hovered_widget, make<Event>(Event::Enter));
  700. auto* app = Application::the();
  701. if (app && app->hover_debugging_enabled())
  702. update();
  703. }
  704. void Window::set_current_backing_store(WindowBackingStore& backing_store, bool flush_immediately)
  705. {
  706. auto& bitmap = backing_store.bitmap();
  707. WindowServerConnection::the().set_window_backing_store(m_window_id, 32, bitmap.pitch(), bitmap.anonymous_buffer().fd(), backing_store.serial(), bitmap.has_alpha_channel(), bitmap.size(), flush_immediately);
  708. }
  709. void Window::flip(const Vector<Gfx::IntRect, 32>& dirty_rects)
  710. {
  711. swap(m_front_store, m_back_store);
  712. set_current_backing_store(*m_front_store);
  713. if (!m_back_store || m_back_store->size() != m_front_store->size()) {
  714. m_back_store = create_backing_store(m_front_store->size());
  715. VERIFY(m_back_store);
  716. memcpy(m_back_store->bitmap().scanline(0), m_front_store->bitmap().scanline(0), m_front_store->bitmap().size_in_bytes());
  717. m_back_store->bitmap().set_volatile();
  718. return;
  719. }
  720. // Copy whatever was painted from the front to the back.
  721. Painter painter(m_back_store->bitmap());
  722. for (auto& dirty_rect : dirty_rects)
  723. painter.blit(dirty_rect.location(), m_front_store->bitmap(), dirty_rect, 1.0f, false);
  724. m_back_store->bitmap().set_volatile();
  725. }
  726. OwnPtr<WindowBackingStore> Window::create_backing_store(const Gfx::IntSize& size)
  727. {
  728. auto format = m_has_alpha_channel ? Gfx::BitmapFormat::BGRA8888 : Gfx::BitmapFormat::BGRx8888;
  729. VERIFY(!size.is_empty());
  730. size_t pitch = Gfx::Bitmap::minimum_pitch(size.width(), format);
  731. size_t size_in_bytes = size.height() * pitch;
  732. auto buffer = Core::AnonymousBuffer::create_with_size(round_up_to_power_of_two(size_in_bytes, PAGE_SIZE));
  733. if (!buffer.is_valid()) {
  734. perror("anon_create");
  735. return {};
  736. }
  737. // FIXME: Plumb scale factor here eventually.
  738. auto bitmap = Gfx::Bitmap::try_create_with_anonymous_buffer(format, move(buffer), size, 1, {});
  739. if (!bitmap) {
  740. VERIFY(size.width() <= INT16_MAX);
  741. VERIFY(size.height() <= INT16_MAX);
  742. return {};
  743. }
  744. return make<WindowBackingStore>(bitmap.release_nonnull());
  745. }
  746. void Window::set_modal(bool modal)
  747. {
  748. VERIFY(!is_visible());
  749. m_modal = modal;
  750. }
  751. void Window::wm_event(WMEvent&)
  752. {
  753. }
  754. void Window::screen_rects_change_event(ScreenRectsChangeEvent&)
  755. {
  756. }
  757. void Window::set_icon(const Gfx::Bitmap* icon)
  758. {
  759. if (m_icon == icon)
  760. return;
  761. Gfx::IntSize icon_size = icon ? icon->size() : Gfx::IntSize(16, 16);
  762. m_icon = Gfx::Bitmap::try_create(Gfx::BitmapFormat::BGRA8888, icon_size);
  763. VERIFY(m_icon);
  764. if (icon) {
  765. Painter painter(*m_icon);
  766. painter.blit({ 0, 0 }, *icon, icon->rect());
  767. }
  768. apply_icon();
  769. }
  770. void Window::apply_icon()
  771. {
  772. if (!m_icon)
  773. return;
  774. if (!is_visible())
  775. return;
  776. WindowServerConnection::the().async_set_window_icon_bitmap(m_window_id, m_icon->to_shareable_bitmap());
  777. }
  778. void Window::start_interactive_resize()
  779. {
  780. WindowServerConnection::the().async_start_window_resize(m_window_id);
  781. }
  782. Vector<Widget&> Window::focusable_widgets(FocusSource source) const
  783. {
  784. if (!m_main_widget)
  785. return {};
  786. HashTable<Widget*> seen_widgets;
  787. Vector<Widget&> collected_widgets;
  788. Function<void(Widget&)> collect_focusable_widgets = [&](auto& widget) {
  789. bool widget_accepts_focus = false;
  790. switch (source) {
  791. case FocusSource::Keyboard:
  792. widget_accepts_focus = has_flag(widget.focus_policy(), FocusPolicy::TabFocus);
  793. break;
  794. case FocusSource::Mouse:
  795. widget_accepts_focus = has_flag(widget.focus_policy(), FocusPolicy::ClickFocus);
  796. break;
  797. case FocusSource::Programmatic:
  798. widget_accepts_focus = widget.focus_policy() != FocusPolicy::NoFocus;
  799. break;
  800. }
  801. if (widget_accepts_focus) {
  802. auto& effective_focus_widget = widget.focus_proxy() ? *widget.focus_proxy() : widget;
  803. if (seen_widgets.set(&effective_focus_widget) == AK::HashSetResult::InsertedNewEntry)
  804. collected_widgets.append(effective_focus_widget);
  805. }
  806. widget.for_each_child_widget([&](auto& child) {
  807. if (!child.is_visible())
  808. return IterationDecision::Continue;
  809. if (!child.is_enabled())
  810. return IterationDecision::Continue;
  811. collect_focusable_widgets(child);
  812. return IterationDecision::Continue;
  813. });
  814. };
  815. collect_focusable_widgets(const_cast<Widget&>(*m_main_widget));
  816. return collected_widgets;
  817. }
  818. void Window::set_fullscreen(bool fullscreen)
  819. {
  820. if (m_fullscreen == fullscreen)
  821. return;
  822. m_fullscreen = fullscreen;
  823. if (!is_visible())
  824. return;
  825. WindowServerConnection::the().async_set_fullscreen(m_window_id, fullscreen);
  826. }
  827. void Window::set_frameless(bool frameless)
  828. {
  829. if (m_frameless == frameless)
  830. return;
  831. m_frameless = frameless;
  832. if (!is_visible())
  833. return;
  834. WindowServerConnection::the().async_set_frameless(m_window_id, frameless);
  835. if (!frameless)
  836. apply_icon();
  837. }
  838. void Window::set_forced_shadow(bool shadow)
  839. {
  840. if (m_forced_shadow == shadow)
  841. return;
  842. m_forced_shadow = shadow;
  843. if (!is_visible())
  844. return;
  845. WindowServerConnection::the().async_set_forced_shadow(m_window_id, shadow);
  846. }
  847. bool Window::is_maximized() const
  848. {
  849. if (!is_visible())
  850. return false;
  851. return WindowServerConnection::the().is_maximized(m_window_id);
  852. }
  853. void Window::set_maximized(bool maximized)
  854. {
  855. VERIFY(m_window_id != 0);
  856. WindowServerConnection::the().async_set_maximized(m_window_id, maximized);
  857. }
  858. void Window::schedule_relayout()
  859. {
  860. if (m_layout_pending)
  861. return;
  862. m_layout_pending = true;
  863. deferred_invoke([this](auto&) {
  864. if (main_widget())
  865. main_widget()->do_layout();
  866. update();
  867. m_layout_pending = false;
  868. });
  869. }
  870. void Window::refresh_system_theme()
  871. {
  872. WindowServerConnection::the().async_refresh_system_theme();
  873. }
  874. void Window::for_each_window(Badge<WindowServerConnection>, Function<void(Window&)> callback)
  875. {
  876. for (auto& e : *reified_windows) {
  877. VERIFY(e.value);
  878. callback(*e.value);
  879. }
  880. }
  881. void Window::update_all_windows(Badge<WindowServerConnection>)
  882. {
  883. for (auto& e : *reified_windows) {
  884. e.value->force_update();
  885. }
  886. }
  887. void Window::notify_state_changed(Badge<WindowServerConnection>, bool minimized, bool occluded)
  888. {
  889. m_visible_for_timer_purposes = !minimized && !occluded;
  890. // When double buffering is enabled, minimization/occlusion means we can mark the front bitmap volatile (in addition to the back bitmap.)
  891. // When double buffering is disabled, there is only the back bitmap (which we can now mark volatile!)
  892. auto& store = m_double_buffering_enabled ? m_front_store : m_back_store;
  893. if (!store)
  894. return;
  895. if (minimized || occluded) {
  896. store->bitmap().set_volatile();
  897. } else {
  898. bool was_purged = false;
  899. bool bitmap_has_memory = store->bitmap().set_nonvolatile(was_purged);
  900. if (!bitmap_has_memory) {
  901. // Not enough memory to make the bitmap non-volatile. Lose the bitmap and schedule an update.
  902. // Let the paint system figure out what to do.
  903. store = nullptr;
  904. update();
  905. } else if (was_purged) {
  906. // The bitmap memory was purged by the kernel, but we have all-new zero-filled pages.
  907. // Schedule an update to regenerate the bitmap.
  908. update();
  909. }
  910. }
  911. }
  912. Action* Window::action_for_key_event(const KeyEvent& event)
  913. {
  914. Shortcut shortcut(event.modifiers(), (KeyCode)event.key());
  915. Action* found_action = nullptr;
  916. for_each_child_of_type<Action>([&](auto& action) {
  917. if (action.shortcut() == shortcut || action.alternate_shortcut() == shortcut) {
  918. found_action = &action;
  919. return IterationDecision::Break;
  920. }
  921. return IterationDecision::Continue;
  922. });
  923. return found_action;
  924. }
  925. void Window::set_base_size(const Gfx::IntSize& base_size)
  926. {
  927. if (m_base_size == base_size)
  928. return;
  929. m_base_size = base_size;
  930. if (is_visible())
  931. WindowServerConnection::the().async_set_window_base_size_and_size_increment(m_window_id, m_base_size, m_size_increment);
  932. }
  933. void Window::set_size_increment(const Gfx::IntSize& size_increment)
  934. {
  935. if (m_size_increment == size_increment)
  936. return;
  937. m_size_increment = size_increment;
  938. if (is_visible())
  939. WindowServerConnection::the().async_set_window_base_size_and_size_increment(m_window_id, m_base_size, m_size_increment);
  940. }
  941. void Window::set_resize_aspect_ratio(const Optional<Gfx::IntSize>& ratio)
  942. {
  943. if (m_resize_aspect_ratio == ratio)
  944. return;
  945. m_resize_aspect_ratio = ratio;
  946. if (is_visible())
  947. WindowServerConnection::the().async_set_window_resize_aspect_ratio(m_window_id, m_resize_aspect_ratio);
  948. }
  949. void Window::did_add_widget(Badge<Widget>, Widget&)
  950. {
  951. if (!m_focused_widget)
  952. focus_a_widget_if_possible(FocusSource::Mouse);
  953. }
  954. void Window::did_remove_widget(Badge<Widget>, Widget& widget)
  955. {
  956. if (m_focused_widget == &widget)
  957. m_focused_widget = nullptr;
  958. if (m_hovered_widget == &widget)
  959. m_hovered_widget = nullptr;
  960. if (m_global_cursor_tracking_widget == &widget)
  961. m_global_cursor_tracking_widget = nullptr;
  962. if (m_automatic_cursor_tracking_widget == &widget)
  963. m_automatic_cursor_tracking_widget = nullptr;
  964. }
  965. void Window::set_progress(Optional<int> progress)
  966. {
  967. VERIFY(m_window_id);
  968. WindowServerConnection::the().async_set_window_progress(m_window_id, progress);
  969. }
  970. void Window::update_cursor()
  971. {
  972. Gfx::StandardCursor new_cursor;
  973. if (m_hovered_widget && m_hovered_widget->override_cursor() != Gfx::StandardCursor::None)
  974. new_cursor = m_hovered_widget->override_cursor();
  975. else
  976. new_cursor = m_cursor;
  977. if (m_effective_cursor == new_cursor)
  978. return;
  979. m_effective_cursor = new_cursor;
  980. if (m_custom_cursor)
  981. WindowServerConnection::the().async_set_window_custom_cursor(m_window_id, m_custom_cursor->to_shareable_bitmap());
  982. else
  983. WindowServerConnection::the().async_set_window_cursor(m_window_id, (u32)m_effective_cursor);
  984. }
  985. void Window::focus_a_widget_if_possible(FocusSource source)
  986. {
  987. auto focusable_widgets = this->focusable_widgets(source);
  988. if (!focusable_widgets.is_empty())
  989. set_focused_widget(&focusable_widgets[0], source);
  990. }
  991. void Window::did_disable_focused_widget(Badge<Widget>)
  992. {
  993. focus_a_widget_if_possible(FocusSource::Mouse);
  994. }
  995. bool Window::is_active() const
  996. {
  997. VERIFY(Application::the());
  998. return this == Application::the()->active_window();
  999. }
  1000. Gfx::Bitmap* Window::back_bitmap()
  1001. {
  1002. return m_back_store ? &m_back_store->bitmap() : nullptr;
  1003. }
  1004. Menu& Window::add_menu(String name)
  1005. {
  1006. Menu& menu = m_menubar->add_menu({}, move(name));
  1007. if (m_window_id) {
  1008. menu.realize_menu_if_needed();
  1009. WindowServerConnection::the().async_add_menu(m_window_id, menu.menu_id());
  1010. }
  1011. return menu;
  1012. }
  1013. bool Window::is_modified() const
  1014. {
  1015. if (!m_window_id)
  1016. return false;
  1017. return WindowServerConnection::the().is_window_modified(m_window_id);
  1018. }
  1019. void Window::set_modified(bool modified)
  1020. {
  1021. if (!m_window_id)
  1022. return;
  1023. WindowServerConnection::the().async_set_window_modified(m_window_id, modified);
  1024. }
  1025. }