RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 23:57:34 +00:00
Code Issues Activity Actions

WindowServer: Add show desktop toggle IPC call

Browse source 
Differentiates between normal minimization and hidden windows. A window
which is hidden is still minimized, but can be seen as another stage
of being minimized.
This commit is contained in:
ForLoveOfCats 2021-06-28 19:21:35 -04:00 • committed by Gunnar Beutner
parent 62d4b4abf3
commit 271840ca22
7 changed files with 78 additions and 9 deletions
Download patch file Download diff file Expand all files Collapse all files

28
Userland/Services/WindowServer/WMClientConnection.cpp
View file

@ -115,6 +115,34 @@ void WMClientConnection::set_window_minimized(i32 client_id, i32 window_id, bool
WindowManager::the().minimize_windows(window, minimized);
}
void WMClientConnection::toggle_show_desktop()
{
bool should_hide = false;
WindowServer::ClientConnection::for_each_client([&should_hide](auto& client) {
client.for_each_window([&should_hide](Window& window) {
if (window.type() == WindowType::Normal && window.is_minimizable()) {
if (!window.is_hidden() && !window.is_minimized()) {
should_hide = true;
return IterationDecision::Break;
}
}
return IterationDecision::Continue;
});
});
WindowServer::ClientConnection::for_each_client([should_hide](auto& client) {
client.for_each_window([should_hide](Window& window) {
if (window.type() == WindowType::Normal && window.is_minimizable()) {
auto state = window.minimized_state();
if (state == WindowMinimizedState::None || state == WindowMinimizedState::Hidden) {
WindowManager::the().hide_windows(window, should_hide);
}
}
return IterationDecision::Continue;
});
});
}
void WMClientConnection::set_event_mask(u32 event_mask)
{
m_event_mask = event_mask;

1
Userland/Services/WindowServer/WMClientConnection.h
View file

@ -23,6 +23,7 @@ public:
virtual void set_active_window(i32, i32) override;
virtual void set_window_minimized(i32, i32, bool) override;
virtual void toggle_show_desktop() override;
virtual void start_window_resize(i32, i32) override;
virtual void popup_window_menu(i32, i32, Gfx::IntPoint const&) override;
virtual void set_window_taskbar_rect(i32, i32, Gfx::IntRect const&) override;

31
Userland/Services/WindowServer/Window.cpp
View file

@ -267,22 +267,22 @@ void Window::update_window_menu_items()
if (!m_window_menu)
return;
m_window_menu_minimize_item->set_text(m_minimized ? "&Unminimize" : "Mi&nimize");
m_window_menu_minimize_item->set_text(m_minimized_state != WindowMinimizedState::None ? "&Unminimize" : "Mi&nimize");
m_window_menu_minimize_item->set_enabled(m_minimizable);
m_window_menu_maximize_item->set_text(m_maximized ? "&Restore" : "Ma&ximize");
m_window_menu_maximize_item->set_enabled(m_resizable);
m_window_menu_move_item->set_enabled(!m_minimized && !m_maximized && !m_fullscreen);
m_window_menu_move_item->set_enabled(m_minimized_state == WindowMinimizedState::None && !m_maximized && !m_fullscreen);
}
void Window::set_minimized(bool minimized)
{
if (m_minimized == minimized)
if ((m_minimized_state != WindowMinimizedState::None) == minimized)
return;
if (minimized && !m_minimizable)
return;
m_minimized = minimized;
m_minimized_state = minimized ? WindowMinimizedState::Minimized : WindowMinimizedState::None;
update_window_menu_items();
Compositor::the().invalidate_occlusions();
Compositor::the().invalidate_screen(frame().render_rect());
@ -293,6 +293,23 @@ void Window::set_minimized(bool minimized)
WindowManager::the().notify_minimization_state_changed(*this);
}
void Window::set_hidden(bool hidden)
{
if ((m_minimized_state != WindowMinimizedState::None) == hidden)
return;
if (hidden && !m_minimizable)
return;
m_minimized_state = hidden ? WindowMinimizedState::Hidden : WindowMinimizedState::None;
update_window_menu_items();
Compositor::the().invalidate_occlusions();
Compositor::the().invalidate_screen(frame().render_rect());
if (!blocking_modal_window())
start_minimize_animation();
if (!hidden)
request_update({ {}, size() });
WindowManager::the().notify_minimization_state_changed(*this);
}
void Window::set_minimizable(bool minimizable)
{
if (m_minimizable == minimizable)
@ -750,8 +767,8 @@ void Window::handle_window_menu_action(WindowMenuAction action)
{
switch (action) {
case WindowMenuAction::MinimizeOrUnminimize:
WindowManager::the().minimize_windows(*this, !m_minimized);
if (!m_minimized)
WindowManager::the().minimize_windows(*this, m_minimized_state == WindowMinimizedState::None);
if (m_minimized_state == WindowMinimizedState::None)
WindowManager::the().move_to_front_and_make_active(*this);
break;
case WindowMenuAction::MaximizeOrRestore:
@ -791,7 +808,7 @@ void Window::popup_window_menu(const Gfx::IntPoint& position, WindowMenuDefaultA
default_action = WindowMenuDefaultAction::Minimize;
}
m_window_menu_minimize_item->set_default(default_action == WindowMenuDefaultAction::Minimize || default_action == WindowMenuDefaultAction::Unminimize);
m_window_menu_minimize_item->set_icon(m_minimized ? nullptr : &minimize_icon());
m_window_menu_minimize_item->set_icon(m_minimized_state != WindowMinimizedState::None ? nullptr : &minimize_icon());
m_window_menu_maximize_item->set_default(default_action == WindowMenuDefaultAction::Maximize || default_action == WindowMenuDefaultAction::Restore);
m_window_menu_maximize_item->set_icon(m_maximized ? &restore_icon() : &maximize_icon());
m_window_menu_close_item->set_default(default_action == WindowMenuDefaultAction::Close);

13
Userland/Services/WindowServer/Window.h
View file

@ -68,6 +68,12 @@ enum class WindowMenuDefaultAction {
Restore
};
enum class WindowMinimizedState : u32 {
None = 0,
Minimized,
Hidden,
};
class Window final : public Core::Object {
C_OBJECT(Window);
@ -82,8 +88,11 @@ public:
void window_menu_activate_default();
void request_close();
bool is_minimized() const { return m_minimized; }
bool is_minimized() const { return m_minimized_state != WindowMinimizedState::None; }
void set_minimized(bool);
bool is_hidden() const { return m_minimized_state == WindowMinimizedState::Hidden; }
void set_hidden(bool);
WindowMinimizedState minimized_state() const { return m_minimized_state; }
bool is_minimizable() const { return m_type == WindowType::Normal && m_minimizable; }
void set_minimizable(bool);
@ -383,7 +392,7 @@ private:
bool m_frameless { false };
bool m_resizable { false };
Optional<Gfx::IntSize> m_resize_aspect_ratio {};
bool m_minimized { false };
WindowMinimizedState m_minimized_state { WindowMinimizedState::None };
bool m_maximized { false };
bool m_fullscreen { false };
bool m_accessory { false };

12
Userland/Services/WindowServer/WindowManager.cpp
View file

@ -1981,6 +1981,18 @@ void WindowManager::minimize_windows(Window& window, bool minimized)
});
}
void WindowManager::hide_windows(Window& window, bool hidden)
{
for_each_window_in_modal_stack(window, [&](auto& w, bool) {
w.set_hidden(hidden);
if (!hidden)
pick_new_active_window(&window);
return IterationDecision::Continue;
});
}
void WindowManager::maximize_windows(Window& window, bool maximized)
{
for_each_window_in_modal_stack(window, [&](auto& w, bool stack_top) {

1
Userland/Services/WindowServer/WindowManager.h
View file

@ -221,6 +221,7 @@ public:
bool is_menu_doubleclick(Window& window, MouseEvent const& event) const;
void minimize_windows(Window&, bool);
void hide_windows(Window&, bool);
void maximize_windows(Window&, bool);
template<typename Function>

1
Userland/Services/WindowServer/WindowManagerServer.ipc
View file

@ -7,6 +7,7 @@ endpoint WindowManagerServer
set_active_window(i32 client_id, i32 window_id) =|
set_window_minimized(i32 client_id, i32 window_id, bool minimized) =|
toggle_show_desktop() =|
start_window_resize(i32 client_id, i32 window_id) =|
popup_window_menu(i32 client_id, i32 window_id, Gfx::IntPoint screen_position) =|
set_window_taskbar_rect(i32 client_id, i32 window_id, Gfx::IntRect rect) =|