mirror of
https://github.com/RGBCube/serenity
synced 2025-05-21 16:55:07 +00:00
9ff1fa1cf3
Keep track of areas that overlays were rendered to when we recompute occlusions. This allows us to then easily figure out areas where overlays were moved from or removed from.
1784 lines
75 KiB
C++
1784 lines
75 KiB
C++
/*
|
|
* Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include "Compositor.h"
|
|
#include "Animation.h"
|
|
#include "ConnectionFromClient.h"
|
|
#include "Event.h"
|
|
#include "EventLoop.h"
|
|
#include "MultiScaleBitmaps.h"
|
|
#include "Screen.h"
|
|
#include "Window.h"
|
|
#include "WindowManager.h"
|
|
#include "WindowSwitcher.h"
|
|
#include <AK/Debug.h>
|
|
#include <AK/Memory.h>
|
|
#include <AK/ScopeGuard.h>
|
|
#include <AK/TemporaryChange.h>
|
|
#include <LibCore/Timer.h>
|
|
#include <LibGfx/AntiAliasingPainter.h>
|
|
#include <LibGfx/Font/Font.h>
|
|
#include <LibGfx/Painter.h>
|
|
#include <LibGfx/StylePainter.h>
|
|
#include <LibThreading/BackgroundAction.h>
|
|
|
|
namespace WindowServer {
|
|
|
|
Compositor& Compositor::the()
|
|
{
|
|
static Compositor s_the;
|
|
return s_the;
|
|
}
|
|
|
|
static WallpaperMode mode_to_enum(DeprecatedString const& name)
|
|
{
|
|
if (name == "Tile")
|
|
return WallpaperMode::Tile;
|
|
if (name == "Stretch")
|
|
return WallpaperMode::Stretch;
|
|
if (name == "Center")
|
|
return WallpaperMode::Center;
|
|
return WallpaperMode::Center;
|
|
}
|
|
|
|
Compositor::Compositor()
|
|
{
|
|
m_display_link_notify_timer = add<Core::Timer>(
|
|
1000 / 60, [this] {
|
|
notify_display_links();
|
|
});
|
|
|
|
m_compose_timer = Core::Timer::create_single_shot(
|
|
1000 / 60,
|
|
[this] {
|
|
compose();
|
|
},
|
|
this)
|
|
.release_value_but_fixme_should_propagate_errors();
|
|
m_compose_timer->start();
|
|
|
|
m_immediate_compose_timer = Core::Timer::create_single_shot(
|
|
0,
|
|
[this] {
|
|
compose();
|
|
},
|
|
this)
|
|
.release_value_but_fixme_should_propagate_errors();
|
|
m_compose_timer->start();
|
|
|
|
init_bitmaps();
|
|
}
|
|
|
|
Gfx::Bitmap const* Compositor::cursor_bitmap_for_screenshot(Badge<ConnectionFromClient>, Screen& screen) const
|
|
{
|
|
if (!m_current_cursor)
|
|
return nullptr;
|
|
return &m_current_cursor->bitmap(screen.scale_factor());
|
|
}
|
|
|
|
Gfx::Bitmap const& Compositor::front_bitmap_for_screenshot(Badge<ConnectionFromClient>, Screen& screen) const
|
|
{
|
|
return *screen.compositor_screen_data().m_front_bitmap;
|
|
}
|
|
|
|
Gfx::Color Compositor::color_at_position(Badge<ConnectionFromClient>, Screen& screen, Gfx::IntPoint position) const
|
|
{
|
|
return screen.compositor_screen_data().m_front_bitmap->get_pixel(position);
|
|
}
|
|
|
|
void CompositorScreenData::init_bitmaps(Compositor& compositor, Screen& screen)
|
|
{
|
|
// Recreate the screen-number overlay as the Screen instances may have changed, or get rid of it if we no longer need it
|
|
if (compositor.showing_screen_numbers()) {
|
|
m_screen_number_overlay = compositor.create_overlay<ScreenNumberOverlay>(screen);
|
|
m_screen_number_overlay->set_enabled(true);
|
|
} else {
|
|
m_screen_number_overlay = nullptr;
|
|
}
|
|
|
|
m_has_flipped = false;
|
|
m_have_flush_rects = false;
|
|
m_buffers_are_flipped = false;
|
|
m_screen_can_set_buffer = screen.can_set_buffer();
|
|
|
|
m_flush_rects.clear_with_capacity();
|
|
m_flush_transparent_rects.clear_with_capacity();
|
|
m_flush_special_rects.clear_with_capacity();
|
|
|
|
auto size = screen.size();
|
|
m_front_bitmap = nullptr;
|
|
m_front_bitmap = Gfx::Bitmap::create_wrapper(Gfx::BitmapFormat::BGRx8888, size, screen.scale_factor(), screen.pitch(), screen.scanline(0, 0)).release_value_but_fixme_should_propagate_errors();
|
|
m_front_painter = make<Gfx::Painter>(*m_front_bitmap);
|
|
m_front_painter->translate(-screen.rect().location());
|
|
|
|
m_back_bitmap = nullptr;
|
|
if (m_screen_can_set_buffer)
|
|
m_back_bitmap = Gfx::Bitmap::create_wrapper(Gfx::BitmapFormat::BGRx8888, size, screen.scale_factor(), screen.pitch(), screen.scanline(1, 0)).release_value_but_fixme_should_propagate_errors();
|
|
else
|
|
m_back_bitmap = Gfx::Bitmap::create(Gfx::BitmapFormat::BGRx8888, size, screen.scale_factor()).release_value_but_fixme_should_propagate_errors();
|
|
m_back_painter = make<Gfx::Painter>(*m_back_bitmap);
|
|
m_back_painter->translate(-screen.rect().location());
|
|
|
|
m_temp_bitmap = nullptr;
|
|
m_temp_bitmap = Gfx::Bitmap::create(Gfx::BitmapFormat::BGRx8888, size, screen.scale_factor()).release_value_but_fixme_should_propagate_errors();
|
|
m_temp_painter = make<Gfx::Painter>(*m_temp_bitmap);
|
|
m_temp_painter->translate(-screen.rect().location());
|
|
|
|
clear_wallpaper_bitmap();
|
|
}
|
|
|
|
void Compositor::init_bitmaps()
|
|
{
|
|
Screen::for_each([&](auto& screen) {
|
|
screen.compositor_screen_data().init_bitmaps(*this, screen);
|
|
return IterationDecision::Continue;
|
|
});
|
|
|
|
invalidate_screen();
|
|
}
|
|
|
|
void Compositor::did_construct_window_manager(Badge<WindowManager>)
|
|
{
|
|
auto& wm = WindowManager::the();
|
|
|
|
m_current_window_stack = &wm.current_window_stack();
|
|
|
|
m_wallpaper_mode = mode_to_enum(g_config->read_entry("Background", "Mode", "Center"));
|
|
m_custom_background_color = Color::from_string(g_config->read_entry("Background", "Color", ""));
|
|
|
|
invalidate_screen();
|
|
invalidate_occlusions();
|
|
compose();
|
|
}
|
|
|
|
Gfx::IntPoint Compositor::window_transition_offset(Window& window)
|
|
{
|
|
if (WindowManager::is_stationary_window_type(window.type()))
|
|
return {};
|
|
|
|
if (window.is_moving_to_another_stack())
|
|
return {};
|
|
|
|
return window.window_stack().transition_offset();
|
|
}
|
|
|
|
void Compositor::compose()
|
|
{
|
|
auto& wm = WindowManager::the();
|
|
|
|
{
|
|
auto& current_cursor = wm.active_cursor();
|
|
if (m_current_cursor != ¤t_cursor) {
|
|
change_cursor(¤t_cursor);
|
|
m_invalidated_cursor = m_invalidated_any = true;
|
|
}
|
|
}
|
|
|
|
if (!m_invalidated_any) {
|
|
// nothing dirtied since the last compose pass.
|
|
return;
|
|
}
|
|
|
|
if (m_occlusions_dirty) {
|
|
m_occlusions_dirty = false;
|
|
recompute_occlusions();
|
|
}
|
|
|
|
// We should have recomputed occlusions if any overlay rects were changed
|
|
VERIFY(!m_overlay_rects_changed);
|
|
|
|
auto dirty_screen_rects = move(m_dirty_screen_rects);
|
|
|
|
bool window_stack_transition_in_progress = m_transitioning_to_window_stack != nullptr;
|
|
|
|
// Mark window regions as dirty that need to be re-rendered
|
|
wm.for_each_visible_window_from_back_to_front([&](Window& window) {
|
|
auto transition_offset = window_transition_offset(window);
|
|
auto frame_rect = window.frame().render_rect();
|
|
auto frame_rect_on_screen = frame_rect.translated(transition_offset);
|
|
for (auto& dirty_rect : dirty_screen_rects.rects()) {
|
|
auto invalidate_rect = dirty_rect.intersected(frame_rect_on_screen);
|
|
if (!invalidate_rect.is_empty()) {
|
|
auto inner_rect_offset = window.rect().location() - frame_rect.location();
|
|
invalidate_rect.translate_by(-(frame_rect.location() + inner_rect_offset + transition_offset));
|
|
window.invalidate_no_notify(invalidate_rect);
|
|
m_invalidated_window = true;
|
|
}
|
|
}
|
|
window.prepare_dirty_rects();
|
|
if (window_stack_transition_in_progress)
|
|
window.dirty_rects().translate_by(transition_offset);
|
|
return IterationDecision::Continue;
|
|
});
|
|
|
|
// Any dirty rects in transparency areas may require windows above or below
|
|
// to also be marked dirty in these areas
|
|
wm.for_each_visible_window_from_back_to_front([&](Window& window) {
|
|
auto& dirty_rects = window.dirty_rects(); // dirty rects have already been adjusted for transition offset!
|
|
if (dirty_rects.is_empty())
|
|
return IterationDecision::Continue;
|
|
auto& affected_transparency_rects = window.affected_transparency_rects();
|
|
if (affected_transparency_rects.is_empty())
|
|
return IterationDecision::Continue;
|
|
// If we have transparency rects that affect others, we better have transparency rects ourselves...
|
|
auto& transparency_rects = window.transparency_rects();
|
|
VERIFY(!transparency_rects.is_empty());
|
|
for (auto& it : affected_transparency_rects) {
|
|
auto& affected_window_dirty_rects = it.key->dirty_rects();
|
|
auto& affected_rects = it.value;
|
|
affected_rects.for_each_intersected(dirty_rects, [&](auto& dirty_rect) {
|
|
affected_window_dirty_rects.add(dirty_rect);
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
|
|
Color background_color = wm.palette().desktop_background();
|
|
if (m_custom_background_color.has_value())
|
|
background_color = m_custom_background_color.value();
|
|
|
|
if constexpr (COMPOSE_DEBUG) {
|
|
dbgln("COMPOSE: invalidated: window: {} cursor: {}, any: {}", m_invalidated_window, m_invalidated_cursor, m_invalidated_any);
|
|
for (auto& r : dirty_screen_rects.rects())
|
|
dbgln("dirty screen: {}", r);
|
|
}
|
|
|
|
auto& cursor_screen = ScreenInput::the().cursor_location_screen();
|
|
|
|
Screen::for_each([&](auto& screen) {
|
|
auto& screen_data = screen.compositor_screen_data();
|
|
screen_data.m_have_flush_rects = false;
|
|
screen_data.m_flush_rects.clear_with_capacity();
|
|
screen_data.m_flush_transparent_rects.clear_with_capacity();
|
|
screen_data.m_flush_special_rects.clear_with_capacity();
|
|
return IterationDecision::Continue;
|
|
});
|
|
|
|
auto cursor_rect = current_cursor_rect();
|
|
|
|
bool need_to_draw_cursor = false;
|
|
Gfx::IntRect previous_cursor_rect;
|
|
Screen* previous_cursor_screen = nullptr;
|
|
auto check_restore_cursor_back = [&](Screen& screen, Gfx::IntRect const& rect) {
|
|
if (&screen == &cursor_screen && !previous_cursor_screen && !need_to_draw_cursor && rect.intersects(cursor_rect)) {
|
|
// Restore what's behind the cursor if anything touches the area of the cursor
|
|
need_to_draw_cursor = true;
|
|
if (cursor_screen.compositor_screen_data().restore_cursor_back(cursor_screen, previous_cursor_rect))
|
|
previous_cursor_screen = &screen;
|
|
}
|
|
};
|
|
|
|
if (&cursor_screen != m_current_cursor_screen) {
|
|
// Cursor moved to another screen, restore on the cursor's background on the previous screen
|
|
need_to_draw_cursor = true;
|
|
if (m_current_cursor_screen) {
|
|
if (m_current_cursor_screen->compositor_screen_data().restore_cursor_back(*m_current_cursor_screen, previous_cursor_rect))
|
|
previous_cursor_screen = m_current_cursor_screen;
|
|
}
|
|
m_current_cursor_screen = &cursor_screen;
|
|
}
|
|
|
|
auto prepare_rect = [&](Screen& screen, Gfx::IntRect const& rect) {
|
|
auto& screen_data = screen.compositor_screen_data();
|
|
dbgln_if(COMPOSE_DEBUG, " -> flush opaque: {}", rect);
|
|
VERIFY(!screen_data.m_flush_rects.intersects(rect));
|
|
VERIFY(!screen_data.m_flush_transparent_rects.intersects(rect));
|
|
screen_data.m_have_flush_rects = true;
|
|
screen_data.m_flush_rects.add(rect);
|
|
check_restore_cursor_back(screen, rect);
|
|
};
|
|
|
|
auto prepare_transparency_rect = [&](Screen& screen, Gfx::IntRect const& rect) {
|
|
auto& screen_data = screen.compositor_screen_data();
|
|
dbgln_if(COMPOSE_DEBUG, " -> flush transparent: {}", rect);
|
|
VERIFY(!screen_data.m_flush_rects.intersects(rect));
|
|
for (auto& r : screen_data.m_flush_transparent_rects.rects()) {
|
|
if (r == rect)
|
|
return;
|
|
}
|
|
|
|
screen_data.m_have_flush_rects = true;
|
|
screen_data.m_flush_transparent_rects.add(rect);
|
|
check_restore_cursor_back(screen, rect);
|
|
};
|
|
|
|
if (!cursor_screen.compositor_screen_data().m_cursor_back_bitmap || m_invalidated_cursor)
|
|
check_restore_cursor_back(cursor_screen, cursor_rect);
|
|
|
|
auto paint_wallpaper = [&](Screen& screen, Gfx::Painter& painter, Gfx::IntRect const& rect, Gfx::IntRect const& screen_rect) {
|
|
if (m_wallpaper) {
|
|
if (m_wallpaper_mode == WallpaperMode::Center) {
|
|
Gfx::IntPoint offset { (screen.width() - m_wallpaper->width()) / 2, (screen.height() - m_wallpaper->height()) / 2 };
|
|
|
|
// FIXME: If the wallpaper is opaque and covers the whole rect, no need to fill with color!
|
|
painter.fill_rect(rect, background_color);
|
|
painter.blit_offset(rect.location(), *m_wallpaper, rect.translated(-screen_rect.location()), offset);
|
|
} else if (m_wallpaper_mode == WallpaperMode::Tile) {
|
|
painter.draw_tiled_bitmap(rect, *m_wallpaper);
|
|
} else if (m_wallpaper_mode == WallpaperMode::Stretch) {
|
|
VERIFY(screen.compositor_screen_data().m_wallpaper_bitmap);
|
|
painter.blit(rect.location(), *screen.compositor_screen_data().m_wallpaper_bitmap, rect.translated(-screen.location()));
|
|
} else {
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
} else {
|
|
painter.fill_rect(rect, background_color);
|
|
}
|
|
};
|
|
|
|
{
|
|
// Paint any desktop wallpaper rects that are not somehow underneath any window transparency
|
|
// rects and outside of any opaque window areas
|
|
m_opaque_wallpaper_rects.for_each_intersected(dirty_screen_rects, [&](auto& render_rect) {
|
|
Screen::for_each([&](auto& screen) {
|
|
auto screen_rect = screen.rect();
|
|
auto screen_render_rect = screen_rect.intersected(render_rect);
|
|
if (!screen_render_rect.is_empty()) {
|
|
dbgln_if(COMPOSE_DEBUG, " render wallpaper opaque: {} on screen #{}", screen_render_rect, screen.index());
|
|
prepare_rect(screen, render_rect);
|
|
auto& back_painter = *screen.compositor_screen_data().m_back_painter;
|
|
paint_wallpaper(screen, back_painter, render_rect, screen_rect);
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
return IterationDecision::Continue;
|
|
});
|
|
m_transparent_wallpaper_rects.for_each_intersected(dirty_screen_rects, [&](auto& render_rect) {
|
|
Screen::for_each([&](auto& screen) {
|
|
auto screen_rect = screen.rect();
|
|
auto screen_render_rect = screen_rect.intersected(render_rect);
|
|
if (!screen_render_rect.is_empty()) {
|
|
dbgln_if(COMPOSE_DEBUG, " render wallpaper transparent: {} on screen #{}", screen_render_rect, screen.index());
|
|
prepare_transparency_rect(screen, render_rect);
|
|
auto& temp_painter = *screen.compositor_screen_data().m_temp_painter;
|
|
paint_wallpaper(screen, temp_painter, render_rect, screen_rect);
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
auto compose_window = [&](Window& window) -> IterationDecision {
|
|
if (window.screens().is_empty()) {
|
|
// This window doesn't intersect with any screens, so there's nothing to render
|
|
return IterationDecision::Continue;
|
|
}
|
|
auto transition_offset = window_transition_offset(window);
|
|
auto frame_rect = window.frame().render_rect().translated(transition_offset);
|
|
auto window_rect = window.rect().translated(transition_offset);
|
|
auto frame_rects = frame_rect.shatter(window_rect);
|
|
|
|
dbgln_if(COMPOSE_DEBUG, " window {} frame rect: {}", window.title(), frame_rect);
|
|
|
|
RefPtr<Gfx::Bitmap> backing_store = window.backing_store();
|
|
auto compose_window_rect = [&](Screen& screen, Gfx::Painter& painter, const Gfx::IntRect& rect) {
|
|
if (!window.is_fullscreen()) {
|
|
rect.for_each_intersected(frame_rects, [&](const Gfx::IntRect& intersected_rect) {
|
|
Gfx::PainterStateSaver saver(painter);
|
|
painter.add_clip_rect(intersected_rect);
|
|
painter.translate(transition_offset);
|
|
dbgln_if(COMPOSE_DEBUG, " render frame: {}", intersected_rect);
|
|
window.frame().paint(screen, painter, intersected_rect.translated(-transition_offset));
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
auto update_window_rect = window_rect.intersected(rect);
|
|
if (update_window_rect.is_empty())
|
|
return;
|
|
|
|
auto clear_window_rect = [&](const Gfx::IntRect& clear_rect) {
|
|
auto fill_color = wm.palette().window();
|
|
if (!window.is_opaque())
|
|
fill_color.set_alpha(255 * window.opacity());
|
|
painter.fill_rect(clear_rect, fill_color);
|
|
};
|
|
|
|
if (!backing_store) {
|
|
clear_window_rect(update_window_rect);
|
|
return;
|
|
}
|
|
|
|
// Decide where we would paint this window's backing store.
|
|
// This is subtly different from widow.rect(), because window
|
|
// size may be different from its backing store size. This
|
|
// happens when the window has been resized and the client
|
|
// has not yet attached a new backing store. In this case,
|
|
// we want to try to blit the backing store at the same place
|
|
// it was previously, and fill the rest of the window with its
|
|
// background color.
|
|
Gfx::IntRect backing_rect;
|
|
backing_rect.set_size(window.backing_store_visible_size());
|
|
switch (WindowManager::the().resize_direction_of_window(window)) {
|
|
case ResizeDirection::None:
|
|
case ResizeDirection::Right:
|
|
case ResizeDirection::Down:
|
|
case ResizeDirection::DownRight:
|
|
backing_rect.set_location(window_rect.location());
|
|
break;
|
|
case ResizeDirection::Left:
|
|
case ResizeDirection::Up:
|
|
case ResizeDirection::UpLeft:
|
|
backing_rect.set_right_without_resize(window_rect.right());
|
|
backing_rect.set_bottom_without_resize(window_rect.bottom());
|
|
break;
|
|
case ResizeDirection::UpRight:
|
|
backing_rect.set_left(window.rect().left());
|
|
backing_rect.set_bottom_without_resize(window_rect.bottom());
|
|
break;
|
|
case ResizeDirection::DownLeft:
|
|
backing_rect.set_right_without_resize(window_rect.right());
|
|
backing_rect.set_top(window_rect.top());
|
|
break;
|
|
default:
|
|
VERIFY_NOT_REACHED();
|
|
break;
|
|
}
|
|
|
|
Gfx::IntRect dirty_rect_in_backing_coordinates = update_window_rect.intersected(backing_rect)
|
|
.translated(-backing_rect.location());
|
|
|
|
if (!dirty_rect_in_backing_coordinates.is_empty()) {
|
|
auto dst = backing_rect.location().translated(dirty_rect_in_backing_coordinates.location());
|
|
|
|
if (window.client() && window.client()->is_unresponsive()) {
|
|
if (window.is_opaque()) {
|
|
painter.blit_filtered(dst, *backing_store, dirty_rect_in_backing_coordinates, [](Color src) {
|
|
return src.to_grayscale().darkened(0.75f);
|
|
});
|
|
} else {
|
|
u8 alpha = 255 * window.opacity();
|
|
painter.blit_filtered(dst, *backing_store, dirty_rect_in_backing_coordinates, [&](Color src) {
|
|
auto color = src.to_grayscale().darkened(0.75f);
|
|
color.set_alpha(alpha);
|
|
return color;
|
|
});
|
|
}
|
|
} else {
|
|
painter.blit(dst, *backing_store, dirty_rect_in_backing_coordinates, window.opacity());
|
|
}
|
|
}
|
|
|
|
for (auto background_rect : update_window_rect.shatter(backing_rect))
|
|
clear_window_rect(background_rect);
|
|
};
|
|
|
|
auto& dirty_rects = window.dirty_rects();
|
|
|
|
if constexpr (COMPOSE_DEBUG) {
|
|
for (auto& dirty_rect : dirty_rects.rects())
|
|
dbgln(" dirty: {}", dirty_rect);
|
|
for (auto& r : window.opaque_rects().rects())
|
|
dbgln(" opaque: {}", r);
|
|
for (auto& r : window.transparency_rects().rects())
|
|
dbgln(" transparent: {}", r);
|
|
}
|
|
|
|
// Render opaque portions directly to the back buffer
|
|
auto& opaque_rects = window.opaque_rects();
|
|
if (!opaque_rects.is_empty()) {
|
|
opaque_rects.for_each_intersected(dirty_rects, [&](const Gfx::IntRect& render_rect) {
|
|
for (auto* screen : window.screens()) {
|
|
auto screen_render_rect = render_rect.intersected(screen->rect());
|
|
if (screen_render_rect.is_empty())
|
|
continue;
|
|
dbgln_if(COMPOSE_DEBUG, " render opaque: {} on screen #{}", screen_render_rect, screen->index());
|
|
|
|
prepare_rect(*screen, screen_render_rect);
|
|
auto& back_painter = *screen->compositor_screen_data().m_back_painter;
|
|
Gfx::PainterStateSaver saver(back_painter);
|
|
back_painter.add_clip_rect(screen_render_rect);
|
|
compose_window_rect(*screen, back_painter, screen_render_rect);
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
// Render the wallpaper for any transparency directly covering
|
|
// the wallpaper
|
|
auto& transparency_wallpaper_rects = window.transparency_wallpaper_rects();
|
|
if (!transparency_wallpaper_rects.is_empty()) {
|
|
transparency_wallpaper_rects.for_each_intersected(dirty_rects, [&](const Gfx::IntRect& render_rect) {
|
|
for (auto* screen : window.screens()) {
|
|
auto screen_rect = screen->rect();
|
|
auto screen_render_rect = render_rect.intersected(screen_rect);
|
|
if (screen_render_rect.is_empty())
|
|
continue;
|
|
dbgln_if(COMPOSE_DEBUG, " render wallpaper: {} on screen #{}", screen_render_rect, screen->index());
|
|
|
|
auto& temp_painter = *screen->compositor_screen_data().m_temp_painter;
|
|
prepare_transparency_rect(*screen, screen_render_rect);
|
|
paint_wallpaper(*screen, temp_painter, screen_render_rect, screen_rect);
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
auto& transparency_rects = window.transparency_rects();
|
|
if (!transparency_rects.is_empty()) {
|
|
transparency_rects.for_each_intersected(dirty_rects, [&](const Gfx::IntRect& render_rect) {
|
|
for (auto* screen : window.screens()) {
|
|
auto screen_rect = screen->rect();
|
|
auto screen_render_rect = render_rect.intersected(screen_rect);
|
|
if (screen_render_rect.is_empty())
|
|
continue;
|
|
dbgln_if(COMPOSE_DEBUG, " render transparent: {} on screen #{}", screen_render_rect, screen->index());
|
|
|
|
prepare_transparency_rect(*screen, screen_render_rect);
|
|
auto& temp_painter = *screen->compositor_screen_data().m_temp_painter;
|
|
Gfx::PainterStateSaver saver(temp_painter);
|
|
temp_painter.add_clip_rect(screen_render_rect);
|
|
compose_window_rect(*screen, temp_painter, screen_render_rect);
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
return IterationDecision::Continue;
|
|
};
|
|
|
|
// Paint the window stack.
|
|
if (m_invalidated_window) {
|
|
auto* fullscreen_window = wm.active_fullscreen_window();
|
|
// FIXME: Remove the !WindowSwitcher::the().is_visible() check when WindowSwitcher is an overlay
|
|
if (fullscreen_window && fullscreen_window->is_opaque() && !WindowSwitcher::the().is_visible()) {
|
|
compose_window(*fullscreen_window);
|
|
fullscreen_window->clear_dirty_rects();
|
|
} else {
|
|
wm.for_each_visible_window_from_back_to_front([&](Window& window) {
|
|
compose_window(window);
|
|
window.clear_dirty_rects();
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
// Check that there are no overlapping transparent and opaque flush rectangles
|
|
VERIFY(![&]() {
|
|
bool is_overlapping = false;
|
|
Screen::for_each([&](auto& screen) {
|
|
auto& screen_data = screen.compositor_screen_data();
|
|
auto& flush_transparent_rects = screen_data.m_flush_transparent_rects;
|
|
auto& flush_rects = screen_data.m_flush_rects;
|
|
for (auto& rect_transparent : flush_transparent_rects.rects()) {
|
|
for (auto& rect_opaque : flush_rects.rects()) {
|
|
if (rect_opaque.intersects(rect_transparent)) {
|
|
dbgln("Transparent rect {} overlaps opaque rect: {}: {}", rect_transparent, rect_opaque, rect_opaque.intersected(rect_transparent));
|
|
is_overlapping = true;
|
|
return IterationDecision::Break;
|
|
}
|
|
}
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
return is_overlapping;
|
|
}());
|
|
|
|
if (!m_overlay_list.is_empty()) {
|
|
// Render everything to the temporary buffer before we copy it back
|
|
render_overlays();
|
|
}
|
|
|
|
// Copy anything rendered to the temporary buffer to the back buffer
|
|
Screen::for_each([&](auto& screen) {
|
|
auto screen_rect = screen.rect();
|
|
auto& screen_data = screen.compositor_screen_data();
|
|
for (auto& rect : screen_data.m_flush_transparent_rects.rects())
|
|
screen_data.m_back_painter->blit(rect.location(), *screen_data.m_temp_bitmap, rect.translated(-screen_rect.location()));
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
m_invalidated_any = false;
|
|
m_invalidated_window = false;
|
|
m_invalidated_cursor = false;
|
|
|
|
if (!m_animations.is_empty()) {
|
|
Screen::for_each([&](auto& screen) {
|
|
auto& screen_data = screen.compositor_screen_data();
|
|
update_animations(screen, screen_data.m_flush_special_rects);
|
|
if (!screen_data.m_flush_special_rects.is_empty())
|
|
screen_data.m_have_flush_rects = true;
|
|
return IterationDecision::Continue;
|
|
});
|
|
// As long as animations are running make sure we keep rendering frames
|
|
m_invalidated_any = true;
|
|
start_compose_async_timer();
|
|
}
|
|
|
|
if (need_to_draw_cursor) {
|
|
auto& screen_data = cursor_screen.compositor_screen_data();
|
|
screen_data.draw_cursor(cursor_screen, cursor_rect);
|
|
}
|
|
|
|
Screen::for_each([&](auto& screen) {
|
|
flush(screen);
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
void Compositor::flush(Screen& screen)
|
|
{
|
|
auto& screen_data = screen.compositor_screen_data();
|
|
|
|
bool device_can_flush_buffers = screen.can_device_flush_buffers();
|
|
if (!screen_data.m_have_flush_rects && (!screen_data.m_screen_can_set_buffer || screen_data.m_has_flipped)) {
|
|
dbgln_if(COMPOSE_DEBUG, "Nothing to flush on screen #{} {}", screen.index(), screen_data.m_have_flush_rects);
|
|
return;
|
|
}
|
|
screen_data.m_have_flush_rects = false;
|
|
|
|
auto screen_rect = screen.rect();
|
|
if (m_flash_flush) {
|
|
Gfx::IntRect bounding_flash;
|
|
for (auto& rect : screen_data.m_flush_rects.rects()) {
|
|
screen_data.m_front_painter->fill_rect(rect, Color::Yellow);
|
|
bounding_flash = bounding_flash.united(rect);
|
|
}
|
|
for (auto& rect : screen_data.m_flush_transparent_rects.rects()) {
|
|
screen_data.m_front_painter->fill_rect(rect, Color::Green);
|
|
bounding_flash = bounding_flash.united(rect);
|
|
}
|
|
if (!bounding_flash.is_empty()) {
|
|
if (screen.can_device_flush_entire_buffer()) {
|
|
screen.flush_display_entire_framebuffer();
|
|
} else if (device_can_flush_buffers) {
|
|
// If the device needs a flush we need to let it know that we
|
|
// modified the front buffer!
|
|
bounding_flash.translate_by(-screen_rect.location());
|
|
screen.flush_display_front_buffer((!screen_data.m_screen_can_set_buffer || !screen_data.m_buffers_are_flipped) ? 0 : 1, bounding_flash);
|
|
}
|
|
usleep(10000);
|
|
}
|
|
}
|
|
|
|
if (device_can_flush_buffers && screen_data.m_screen_can_set_buffer) {
|
|
if (!screen_data.m_has_flipped) {
|
|
// If we have not flipped any buffers before, we should be flushing
|
|
// the entire buffer to make sure that the device has all the bits we wrote
|
|
screen_data.m_flush_rects = { screen.rect() };
|
|
}
|
|
|
|
// If we also support buffer flipping we need to make sure we transfer all
|
|
// updated areas to the device before we flip. We already modified the framebuffer
|
|
// memory, but the device needs to know what areas we actually did update.
|
|
for (auto& rect : screen_data.m_flush_rects.rects())
|
|
screen.queue_flush_display_rect(rect.translated(-screen_rect.location()));
|
|
for (auto& rect : screen_data.m_flush_transparent_rects.rects())
|
|
screen.queue_flush_display_rect(rect.translated(-screen_rect.location()));
|
|
for (auto& rect : screen_data.m_flush_special_rects.rects())
|
|
screen.queue_flush_display_rect(rect.translated(-screen_rect.location()));
|
|
|
|
screen.flush_display((!screen_data.m_screen_can_set_buffer || screen_data.m_buffers_are_flipped) ? 0 : 1);
|
|
}
|
|
|
|
if (screen_data.m_screen_can_set_buffer) {
|
|
screen_data.flip_buffers(screen);
|
|
screen_data.m_has_flipped = true;
|
|
}
|
|
|
|
auto do_flush = [&](Gfx::IntRect rect) {
|
|
VERIFY(screen_rect.contains(rect));
|
|
rect.translate_by(-screen_rect.location());
|
|
|
|
// Almost everything in Compositor is in logical coordinates, with the painters having
|
|
// a scale applied. But this routine accesses the backbuffer pixels directly, so it
|
|
// must work in physical coordinates.
|
|
auto scaled_rect = rect * screen.scale_factor();
|
|
Gfx::ARGB32* front_ptr = screen_data.m_front_bitmap->scanline(scaled_rect.y()) + scaled_rect.x();
|
|
Gfx::ARGB32* back_ptr = screen_data.m_back_bitmap->scanline(scaled_rect.y()) + scaled_rect.x();
|
|
size_t pitch = screen_data.m_back_bitmap->pitch();
|
|
|
|
// NOTE: The meaning of a flush depends on whether we can flip buffers or not.
|
|
//
|
|
// If flipping is supported, flushing means that we've flipped, and now we
|
|
// copy the changed bits from the front buffer to the back buffer, to keep
|
|
// them in sync.
|
|
//
|
|
// If flipping is not supported, flushing means that we copy the changed
|
|
// rects from the backing bitmap to the display framebuffer.
|
|
|
|
Gfx::ARGB32* to_ptr;
|
|
const Gfx::ARGB32* from_ptr;
|
|
|
|
if (screen_data.m_screen_can_set_buffer) {
|
|
to_ptr = back_ptr;
|
|
from_ptr = front_ptr;
|
|
} else {
|
|
to_ptr = front_ptr;
|
|
from_ptr = back_ptr;
|
|
}
|
|
|
|
for (int y = 0; y < scaled_rect.height(); ++y) {
|
|
fast_u32_copy(to_ptr, from_ptr, scaled_rect.width());
|
|
from_ptr = (const Gfx::ARGB32*)((const u8*)from_ptr + pitch);
|
|
to_ptr = (Gfx::ARGB32*)((u8*)to_ptr + pitch);
|
|
}
|
|
if (device_can_flush_buffers) {
|
|
// Whether or not we need to flush buffers, we need to at least track what we modified
|
|
// so that we can flush these areas next time before we flip buffers. Or, if we don't
|
|
// support buffer flipping then we will flush them shortly.
|
|
screen.queue_flush_display_rect(rect);
|
|
}
|
|
};
|
|
for (auto& rect : screen_data.m_flush_rects.rects())
|
|
do_flush(rect);
|
|
for (auto& rect : screen_data.m_flush_transparent_rects.rects())
|
|
do_flush(rect);
|
|
for (auto& rect : screen_data.m_flush_special_rects.rects())
|
|
do_flush(rect);
|
|
if (device_can_flush_buffers && !screen_data.m_screen_can_set_buffer) {
|
|
// If we also support flipping buffers we don't really need to flush these areas right now.
|
|
// Instead, we skip this step and just keep track of them until shortly before the next flip.
|
|
// If we however don't support flipping buffers then we need to flush the changed areas right
|
|
// now so that they can be sent to the device.
|
|
screen.flush_display(screen_data.m_buffers_are_flipped ? 1 : 0);
|
|
}
|
|
}
|
|
|
|
void Compositor::invalidate_screen()
|
|
{
|
|
invalidate_screen(Screen::bounding_rect());
|
|
}
|
|
|
|
void Compositor::invalidate_screen(Gfx::IntRect const& screen_rect)
|
|
{
|
|
m_dirty_screen_rects.add(screen_rect.intersected(Screen::bounding_rect()));
|
|
|
|
if (m_invalidated_any)
|
|
return;
|
|
|
|
m_invalidated_any = true;
|
|
m_invalidated_window = true;
|
|
start_compose_async_timer();
|
|
}
|
|
|
|
void Compositor::invalidate_screen(Gfx::DisjointIntRectSet const& rects)
|
|
{
|
|
m_dirty_screen_rects.add(rects.intersected(Screen::bounding_rect()));
|
|
|
|
if (m_invalidated_any)
|
|
return;
|
|
|
|
m_invalidated_any = true;
|
|
m_invalidated_window = true;
|
|
start_compose_async_timer();
|
|
}
|
|
|
|
void Compositor::invalidate_window()
|
|
{
|
|
if (m_invalidated_window)
|
|
return;
|
|
m_invalidated_window = true;
|
|
m_invalidated_any = true;
|
|
|
|
start_compose_async_timer();
|
|
}
|
|
|
|
void Compositor::start_compose_async_timer()
|
|
{
|
|
// We delay composition by a timer interval, but to not affect latency too
|
|
// much, if a pending compose is not already scheduled, we also schedule an
|
|
// immediate compose the next spin of the event loop.
|
|
if (!m_compose_timer->is_active()) {
|
|
m_compose_timer->start();
|
|
m_immediate_compose_timer->start();
|
|
}
|
|
}
|
|
|
|
bool Compositor::set_background_color(DeprecatedString const& background_color)
|
|
{
|
|
auto color = Color::from_string(background_color);
|
|
if (!color.has_value())
|
|
return false;
|
|
|
|
m_custom_background_color = color;
|
|
|
|
g_config->write_entry("Background", "Color", background_color);
|
|
bool succeeded = !g_config->sync().is_error();
|
|
|
|
if (succeeded) {
|
|
update_wallpaper_bitmap();
|
|
Compositor::invalidate_screen();
|
|
}
|
|
|
|
return succeeded;
|
|
}
|
|
|
|
bool Compositor::set_wallpaper_mode(DeprecatedString const& mode)
|
|
{
|
|
g_config->write_entry("Background", "Mode", mode);
|
|
bool succeeded = !g_config->sync().is_error();
|
|
|
|
if (succeeded) {
|
|
m_wallpaper_mode = mode_to_enum(mode);
|
|
update_wallpaper_bitmap();
|
|
Compositor::invalidate_screen();
|
|
}
|
|
|
|
return succeeded;
|
|
}
|
|
|
|
bool Compositor::set_wallpaper(RefPtr<Gfx::Bitmap const> bitmap)
|
|
{
|
|
if (!bitmap)
|
|
m_wallpaper = nullptr;
|
|
else
|
|
m_wallpaper = bitmap;
|
|
update_wallpaper_bitmap();
|
|
invalidate_screen();
|
|
|
|
return true;
|
|
}
|
|
|
|
void Compositor::update_wallpaper_bitmap()
|
|
{
|
|
Screen::for_each([&](Screen& screen) {
|
|
auto& screen_data = screen.compositor_screen_data();
|
|
if (m_wallpaper_mode != WallpaperMode::Stretch || !m_wallpaper) {
|
|
screen_data.clear_wallpaper_bitmap();
|
|
return IterationDecision::Continue;
|
|
}
|
|
|
|
// See if there is another screen with the same resolution and scale.
|
|
// If so, we can use the same bitmap.
|
|
bool share_bitmap_with_other_screen = false;
|
|
Screen::for_each([&](Screen& screen2) {
|
|
if (&screen == &screen2) {
|
|
// Stop iterating here, we haven't updated wallpaper bitmaps for
|
|
// this screen and the following screens.
|
|
return IterationDecision::Break;
|
|
}
|
|
|
|
if (screen.size() == screen2.size() && screen.scale_factor() == screen2.scale_factor()) {
|
|
auto& screen2_data = screen2.compositor_screen_data();
|
|
|
|
// Use the same bitmap as the other screen
|
|
screen_data.m_wallpaper_bitmap = screen2_data.m_wallpaper_bitmap;
|
|
share_bitmap_with_other_screen = true;
|
|
return IterationDecision::Break;
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
|
|
if (share_bitmap_with_other_screen)
|
|
return IterationDecision::Continue;
|
|
|
|
if (screen.size() == m_wallpaper->size() && screen.scale_factor() == m_wallpaper->scale()) {
|
|
// If the screen size is equal to the wallpaper size, we don't actually need to scale it
|
|
screen_data.m_wallpaper_bitmap = m_wallpaper;
|
|
} else {
|
|
auto bitmap = Gfx::Bitmap::create(Gfx::BitmapFormat::BGRx8888, screen.size(), screen.scale_factor()).release_value_but_fixme_should_propagate_errors();
|
|
|
|
Gfx::Painter painter(*bitmap);
|
|
painter.draw_scaled_bitmap(bitmap->rect(), *m_wallpaper, m_wallpaper->rect());
|
|
|
|
screen_data.m_wallpaper_bitmap = move(bitmap);
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
void CompositorScreenData::clear_wallpaper_bitmap()
|
|
{
|
|
m_wallpaper_bitmap = nullptr;
|
|
}
|
|
|
|
void CompositorScreenData::flip_buffers(Screen& screen)
|
|
{
|
|
VERIFY(m_screen_can_set_buffer);
|
|
swap(m_front_bitmap, m_back_bitmap);
|
|
swap(m_front_painter, m_back_painter);
|
|
screen.set_buffer(m_buffers_are_flipped ? 0 : 1);
|
|
m_buffers_are_flipped = !m_buffers_are_flipped;
|
|
}
|
|
|
|
void Compositor::screen_resolution_changed()
|
|
{
|
|
// Screens may be gone now, invalidate any references to them
|
|
m_current_cursor_screen = nullptr;
|
|
|
|
init_bitmaps();
|
|
invalidate_occlusions();
|
|
overlay_rects_changed();
|
|
update_wallpaper_bitmap();
|
|
compose();
|
|
}
|
|
|
|
Gfx::IntRect Compositor::current_cursor_rect() const
|
|
{
|
|
auto& wm = WindowManager::the();
|
|
auto& current_cursor = m_current_cursor ? *m_current_cursor : wm.active_cursor();
|
|
Gfx::IntRect cursor_rect { ScreenInput::the().cursor_location().translated(-current_cursor.params().hotspot()), current_cursor.size() };
|
|
if (wm.is_cursor_highlight_enabled()) {
|
|
auto highlight_diameter = wm.cursor_highlight_radius() * 2;
|
|
auto inflate_w = highlight_diameter - cursor_rect.width();
|
|
auto inflate_h = highlight_diameter - cursor_rect.height();
|
|
cursor_rect.inflate(inflate_w, inflate_h);
|
|
// Ensures cursor stays in the same location when highlighting is enabled.
|
|
cursor_rect.translate_by(-(inflate_w % 2), -(inflate_h % 2));
|
|
}
|
|
return cursor_rect;
|
|
}
|
|
|
|
void Compositor::invalidate_cursor(bool compose_immediately)
|
|
{
|
|
if (m_invalidated_cursor && !compose_immediately)
|
|
return;
|
|
m_invalidated_cursor = true;
|
|
m_invalidated_any = true;
|
|
|
|
if (compose_immediately)
|
|
compose();
|
|
else
|
|
start_compose_async_timer();
|
|
}
|
|
|
|
void Compositor::change_cursor(Cursor const* cursor)
|
|
{
|
|
if (m_current_cursor == cursor)
|
|
return;
|
|
m_current_cursor = cursor;
|
|
m_current_cursor_frame = 0;
|
|
if (m_cursor_timer) {
|
|
m_cursor_timer->stop();
|
|
m_cursor_timer = nullptr;
|
|
}
|
|
if (cursor && cursor->params().frames() > 1 && cursor->params().frame_ms() != 0) {
|
|
m_cursor_timer = add<Core::Timer>(
|
|
cursor->params().frame_ms(), [this, cursor] {
|
|
if (m_current_cursor != cursor)
|
|
return;
|
|
auto frames = cursor->params().frames();
|
|
if (++m_current_cursor_frame >= frames)
|
|
m_current_cursor_frame = 0;
|
|
invalidate_cursor(true);
|
|
});
|
|
m_cursor_timer->start();
|
|
}
|
|
}
|
|
|
|
void Compositor::render_overlays()
|
|
{
|
|
// NOTE: overlays should always be rendered to the temporary buffer!
|
|
for (auto& overlay : m_overlay_list) {
|
|
for (auto* screen : overlay.m_screens) {
|
|
auto& screen_data = screen->compositor_screen_data();
|
|
auto& painter = screen_data.overlay_painter();
|
|
|
|
auto render_overlay_rect = [&](auto& intersected_overlay_rect) {
|
|
Gfx::PainterStateSaver saver(painter);
|
|
painter.add_clip_rect(intersected_overlay_rect);
|
|
painter.translate(overlay.m_current_rect.location());
|
|
overlay.render(painter, *screen);
|
|
return IterationDecision::Continue;
|
|
};
|
|
|
|
auto const& render_rect = overlay.current_render_rect();
|
|
screen_data.for_each_intersected_flushing_rect(render_rect, render_overlay_rect);
|
|
|
|
// Now render any areas that are not somehow underneath any window or transparency area
|
|
m_transparent_wallpaper_rects.for_each_intersected(render_rect, render_overlay_rect);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Compositor::add_overlay(Overlay& overlay)
|
|
{
|
|
VERIFY(!overlay.m_list_node.is_in_list());
|
|
auto zorder = overlay.zorder();
|
|
bool did_insert = false;
|
|
for (auto& other_overlay : m_overlay_list) {
|
|
if (other_overlay.zorder() > zorder) {
|
|
m_overlay_list.insert_before(other_overlay, overlay);
|
|
did_insert = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!did_insert)
|
|
m_overlay_list.append(overlay);
|
|
|
|
overlay.invalidate();
|
|
overlay_rects_changed();
|
|
}
|
|
|
|
void Compositor::remove_overlay(Overlay& overlay)
|
|
{
|
|
m_overlay_list.remove(overlay);
|
|
|
|
auto last_rendered_rect = overlay.current_render_rect();
|
|
if (!last_rendered_rect.is_empty()) {
|
|
// We need to invalidate the entire area. While recomputing occlusions
|
|
// will detect areas no longer occupied by overlays, if there are other
|
|
// overlays intersecting with the overlay that was removed, then that
|
|
// area would not get re-rendered.
|
|
invalidate_screen(last_rendered_rect);
|
|
}
|
|
|
|
overlay_rects_changed();
|
|
}
|
|
|
|
void CompositorScreenData::draw_cursor(Screen& screen, Gfx::IntRect const& cursor_rect)
|
|
{
|
|
auto& wm = WindowManager::the();
|
|
|
|
if (!m_cursor_back_bitmap || m_cursor_back_bitmap->size() != cursor_rect.size() || m_cursor_back_bitmap->scale() != screen.scale_factor()) {
|
|
m_cursor_back_bitmap = Gfx::Bitmap::create(Gfx::BitmapFormat::BGRx8888, cursor_rect.size(), screen.scale_factor()).release_value_but_fixme_should_propagate_errors();
|
|
m_cursor_back_painter = make<Gfx::Painter>(*m_cursor_back_bitmap);
|
|
}
|
|
|
|
auto& compositor = Compositor::the();
|
|
auto& current_cursor = compositor.m_current_cursor ? *compositor.m_current_cursor : wm.active_cursor();
|
|
auto screen_rect = screen.rect();
|
|
m_cursor_back_painter->blit({ 0, 0 }, *m_back_bitmap, cursor_rect.intersected(screen_rect).translated(-screen_rect.location()));
|
|
auto cursor_src_rect = current_cursor.source_rect(compositor.m_current_cursor_frame);
|
|
auto cursor_blit_pos = current_cursor.rect().centered_within(cursor_rect).location();
|
|
|
|
if (wm.is_cursor_highlight_enabled()) {
|
|
Gfx::AntiAliasingPainter aa_back_painter { *m_back_painter };
|
|
aa_back_painter.fill_ellipse(cursor_rect, wm.cursor_highlight_color());
|
|
}
|
|
m_back_painter->blit(cursor_blit_pos, current_cursor.bitmap(screen.scale_factor()), cursor_src_rect);
|
|
|
|
m_flush_special_rects.add(Gfx::IntRect(cursor_rect.location(), cursor_rect.size()).intersected(screen.rect()));
|
|
m_have_flush_rects = true;
|
|
m_last_cursor_rect = cursor_rect;
|
|
VERIFY(compositor.m_current_cursor_screen == &screen);
|
|
m_cursor_back_is_valid = true;
|
|
}
|
|
|
|
bool CompositorScreenData::restore_cursor_back(Screen& screen, Gfx::IntRect& last_cursor_rect)
|
|
{
|
|
if (!m_cursor_back_is_valid || !m_cursor_back_bitmap || m_cursor_back_bitmap->scale() != m_back_bitmap->scale())
|
|
return false;
|
|
|
|
last_cursor_rect = m_last_cursor_rect.intersected(screen.rect());
|
|
m_back_painter->blit(last_cursor_rect.location(), *m_cursor_back_bitmap, { { 0, 0 }, last_cursor_rect.size() });
|
|
m_flush_special_rects.add(last_cursor_rect.intersected(screen.rect()));
|
|
m_have_flush_rects = true;
|
|
m_cursor_back_is_valid = false;
|
|
return true;
|
|
}
|
|
|
|
void Compositor::update_fonts()
|
|
{
|
|
ScreenNumberOverlay::pick_font();
|
|
}
|
|
|
|
void Compositor::notify_display_links()
|
|
{
|
|
ConnectionFromClient::for_each_client([](auto& client) {
|
|
client.notify_display_link({});
|
|
});
|
|
}
|
|
|
|
void Compositor::increment_display_link_count(Badge<ConnectionFromClient>)
|
|
{
|
|
++m_display_link_count;
|
|
if (m_display_link_count == 1)
|
|
m_display_link_notify_timer->start();
|
|
}
|
|
|
|
void Compositor::decrement_display_link_count(Badge<ConnectionFromClient>)
|
|
{
|
|
VERIFY(m_display_link_count);
|
|
--m_display_link_count;
|
|
if (!m_display_link_count)
|
|
m_display_link_notify_timer->stop();
|
|
}
|
|
|
|
void Compositor::invalidate_current_screen_number_rects()
|
|
{
|
|
Screen::for_each([&](auto& screen) {
|
|
auto& screen_data = screen.compositor_screen_data();
|
|
if (screen_data.m_screen_number_overlay)
|
|
screen_data.m_screen_number_overlay->invalidate();
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
void Compositor::increment_show_screen_number(Badge<ConnectionFromClient>)
|
|
{
|
|
if (m_show_screen_number_count++ == 0) {
|
|
Screen::for_each([&](auto& screen) {
|
|
auto& screen_data = screen.compositor_screen_data();
|
|
VERIFY(!screen_data.m_screen_number_overlay);
|
|
screen_data.m_screen_number_overlay = create_overlay<ScreenNumberOverlay>(screen);
|
|
screen_data.m_screen_number_overlay->set_enabled(true);
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
}
|
|
void Compositor::decrement_show_screen_number(Badge<ConnectionFromClient>)
|
|
{
|
|
if (--m_show_screen_number_count == 0) {
|
|
invalidate_current_screen_number_rects();
|
|
Screen::for_each([&](auto& screen) {
|
|
screen.compositor_screen_data().m_screen_number_overlay = nullptr;
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
}
|
|
|
|
void Compositor::overlays_theme_changed()
|
|
{
|
|
for (auto& overlay : m_overlay_list)
|
|
overlay.theme_changed();
|
|
overlay_rects_changed();
|
|
}
|
|
|
|
void Compositor::overlay_rects_changed()
|
|
{
|
|
if (m_overlay_rects_changed)
|
|
return;
|
|
|
|
m_overlay_rects_changed = true;
|
|
m_invalidated_any = true;
|
|
invalidate_occlusions();
|
|
start_compose_async_timer();
|
|
}
|
|
|
|
void Compositor::recompute_overlay_rects()
|
|
{
|
|
// The purpose of this is to gather all areas that we will render over
|
|
// regular window contents. This effectively just forces those areas to
|
|
// be rendered as transparency areas, which allows us to render these
|
|
// flicker-free.
|
|
swap(m_last_rendered_overlay_rects, m_overlay_rects);
|
|
m_overlay_rects.clear_with_capacity();
|
|
for (auto& overlay : m_overlay_list) {
|
|
auto& render_rect = overlay.rect();
|
|
m_overlay_rects.add(render_rect);
|
|
|
|
// Invalidate areas that are no longer in the rendered area because the overlay was moved.
|
|
auto previous_rects = overlay.current_render_rect().shatter(render_rect);
|
|
for (auto& rect : previous_rects)
|
|
invalidate_screen(rect);
|
|
|
|
// Save the rectangle we are using for rendering from now on
|
|
bool needs_invalidation = overlay.apply_render_rect();
|
|
|
|
// Cache which screens this overlay are rendered on
|
|
overlay.m_screens.clear_with_capacity();
|
|
Screen::for_each([&](auto& screen) {
|
|
if (render_rect.intersects(screen.rect()))
|
|
overlay.m_screens.append(&screen);
|
|
return IterationDecision::Continue;
|
|
});
|
|
|
|
if (needs_invalidation)
|
|
invalidate_screen(render_rect);
|
|
}
|
|
|
|
// Invalidate rects that are not going to get rendered anymore, e.g.
|
|
// because overlays were removed or rectangles were changed
|
|
auto no_longer_rendered_rects = m_last_rendered_overlay_rects.shatter(m_overlay_rects);
|
|
for (auto& rect : no_longer_rendered_rects.rects())
|
|
invalidate_screen(rect);
|
|
}
|
|
|
|
void Compositor::recompute_occlusions()
|
|
{
|
|
auto& wm = WindowManager::the();
|
|
bool is_switcher_visible = wm.m_switcher->is_visible();
|
|
auto never_occlude = [&](WindowStack& window_stack) {
|
|
if (is_switcher_visible) {
|
|
switch (wm.m_switcher->mode()) {
|
|
case WindowSwitcher::Mode::ShowCurrentDesktop:
|
|
// Any window on the currently rendered desktop should not be occluded, even if it's behind
|
|
// another window entirely.
|
|
return &window_stack == m_current_window_stack || &window_stack == m_transitioning_to_window_stack;
|
|
case WindowSwitcher::Mode::ShowAllWindows:
|
|
// The window switcher wants to know about all windows, even those on other desktops
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
wm.for_each_window_stack([&](WindowStack& window_stack) {
|
|
if (&window_stack == m_current_window_stack || &window_stack == m_transitioning_to_window_stack) {
|
|
// We'll calculate precise occlusions for these further down. Changing occlusions right now
|
|
// may trigger an additional unnecessary notification
|
|
} else {
|
|
window_stack.set_all_occluded(!never_occlude(window_stack));
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
|
|
if (m_overlay_rects_changed) {
|
|
m_overlay_rects_changed = false;
|
|
recompute_overlay_rects();
|
|
}
|
|
|
|
if constexpr (OCCLUSIONS_DEBUG) {
|
|
dbgln("OCCLUSIONS:");
|
|
for (auto& rect : m_overlay_rects.rects())
|
|
dbgln(" overlay: {}", rect);
|
|
}
|
|
|
|
bool window_stack_transition_in_progress = m_transitioning_to_window_stack != nullptr;
|
|
auto& main_screen = Screen::main();
|
|
auto* fullscreen_window = wm.active_fullscreen_window();
|
|
// FIXME: Remove the !WindowSwitcher::the().is_visible() check when WindowSwitcher is an overlay
|
|
if (fullscreen_window && !WindowSwitcher::the().is_visible()) {
|
|
// TODO: support fullscreen windows on all screens
|
|
auto screen_rect = main_screen.rect();
|
|
wm.for_each_visible_window_from_front_to_back([&](Window& w) {
|
|
auto& visible_opaque = w.opaque_rects();
|
|
auto& transparency_rects = w.transparency_rects();
|
|
auto& transparency_wallpaper_rects = w.transparency_wallpaper_rects();
|
|
w.affected_transparency_rects().clear();
|
|
w.screens().clear_with_capacity();
|
|
if (&w == fullscreen_window) {
|
|
w.screens().append(&main_screen);
|
|
if (w.is_opaque()) {
|
|
visible_opaque = screen_rect;
|
|
transparency_rects.clear();
|
|
transparency_wallpaper_rects.clear();
|
|
} else {
|
|
visible_opaque.clear();
|
|
transparency_rects = screen_rect;
|
|
transparency_wallpaper_rects = screen_rect;
|
|
}
|
|
} else {
|
|
visible_opaque.clear();
|
|
transparency_rects.clear();
|
|
transparency_wallpaper_rects.clear();
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
|
|
m_opaque_wallpaper_rects.clear();
|
|
}
|
|
// FIXME: Remove the WindowSwitcher::the().is_visible() check when WindowSwitcher is an overlay
|
|
if (!fullscreen_window || WindowSwitcher::the().is_visible() || (fullscreen_window && !fullscreen_window->is_opaque())) {
|
|
Gfx::DisjointIntRectSet remaining_visible_screen_rects;
|
|
remaining_visible_screen_rects.add_many(Screen::rects());
|
|
bool have_transparent = false;
|
|
wm.for_each_visible_window_from_front_to_back([&](Window& w) {
|
|
VERIFY(!w.is_minimized());
|
|
w.transparency_wallpaper_rects().clear();
|
|
auto previous_visible_opaque = move(w.opaque_rects());
|
|
auto previous_visible_transparency = move(w.transparency_rects());
|
|
|
|
auto invalidate_previous_render_rects = [&](Gfx::IntRect const& new_render_rect) {
|
|
if (!previous_visible_opaque.is_empty()) {
|
|
if (new_render_rect.is_empty())
|
|
invalidate_screen(previous_visible_opaque);
|
|
else
|
|
invalidate_screen(previous_visible_opaque.shatter(new_render_rect));
|
|
}
|
|
if (!previous_visible_transparency.is_empty()) {
|
|
if (new_render_rect.is_empty())
|
|
invalidate_screen(previous_visible_transparency);
|
|
else
|
|
invalidate_screen(previous_visible_transparency.shatter(new_render_rect));
|
|
}
|
|
};
|
|
|
|
auto& visible_opaque = w.opaque_rects();
|
|
auto& transparency_rects = w.transparency_rects();
|
|
bool should_invalidate_old = w.should_invalidate_last_rendered_screen_rects();
|
|
|
|
auto& affected_transparency_rects = w.affected_transparency_rects();
|
|
affected_transparency_rects.clear();
|
|
|
|
w.screens().clear_with_capacity();
|
|
|
|
auto transition_offset = window_transition_offset(w);
|
|
auto transparent_frame_render_rects = w.frame().transparent_render_rects();
|
|
auto opaque_frame_render_rects = w.frame().opaque_render_rects();
|
|
if (window_stack_transition_in_progress) {
|
|
transparent_frame_render_rects.translate_by(transition_offset);
|
|
opaque_frame_render_rects.translate_by(transition_offset);
|
|
}
|
|
if (should_invalidate_old) {
|
|
for (auto& rect : opaque_frame_render_rects.rects())
|
|
invalidate_previous_render_rects(rect);
|
|
for (auto& rect : transparent_frame_render_rects.rects())
|
|
invalidate_previous_render_rects(rect);
|
|
}
|
|
|
|
if (auto transparent_render_rects = transparent_frame_render_rects.intersected(remaining_visible_screen_rects); !transparent_render_rects.is_empty())
|
|
transparency_rects = move(transparent_render_rects);
|
|
if (auto opaque_render_rects = opaque_frame_render_rects.intersected(remaining_visible_screen_rects); !opaque_render_rects.is_empty())
|
|
visible_opaque = move(opaque_render_rects);
|
|
|
|
auto render_rect_on_screen = w.frame().render_rect().translated(transition_offset);
|
|
auto visible_window_rects = remaining_visible_screen_rects.intersected(w.rect().translated(transition_offset));
|
|
Gfx::DisjointIntRectSet opaque_covering;
|
|
Gfx::DisjointIntRectSet transparent_covering;
|
|
bool found_this_window = false;
|
|
wm.for_each_visible_window_from_back_to_front([&](Window& w2) {
|
|
if (!found_this_window) {
|
|
if (&w == &w2)
|
|
found_this_window = true;
|
|
return IterationDecision::Continue;
|
|
}
|
|
|
|
VERIFY(!w2.is_minimized());
|
|
|
|
auto w2_render_rect = w2.frame().render_rect();
|
|
auto w2_render_rect_on_screen = w2_render_rect;
|
|
auto w2_transition_offset = window_transition_offset(w2);
|
|
if (window_stack_transition_in_progress)
|
|
w2_render_rect_on_screen.translate_by(w2_transition_offset);
|
|
if (!render_rect_on_screen.intersects(w2_render_rect_on_screen))
|
|
return IterationDecision::Continue;
|
|
|
|
auto opaque_rects = w2.frame().opaque_render_rects();
|
|
auto transparent_rects = w2.frame().transparent_render_rects();
|
|
if (window_stack_transition_in_progress) {
|
|
auto transition_offset_2 = window_transition_offset(w2);
|
|
opaque_rects.translate_by(transition_offset_2);
|
|
transparent_rects.translate_by(transition_offset_2);
|
|
}
|
|
opaque_rects = opaque_rects.intersected(render_rect_on_screen);
|
|
transparent_rects = transparent_rects.intersected(render_rect_on_screen);
|
|
if (opaque_rects.is_empty() && transparent_rects.is_empty())
|
|
return IterationDecision::Continue;
|
|
VERIFY(!opaque_rects.intersects(transparent_rects));
|
|
for (auto& covering : opaque_rects.rects()) {
|
|
opaque_covering.add(covering);
|
|
if (!visible_window_rects.is_empty())
|
|
visible_window_rects = visible_window_rects.shatter(covering);
|
|
if (!visible_opaque.is_empty()) {
|
|
auto uncovered_opaque = visible_opaque.shatter(covering);
|
|
visible_opaque = move(uncovered_opaque);
|
|
}
|
|
if (!transparency_rects.is_empty()) {
|
|
auto uncovered_transparency = transparency_rects.shatter(covering);
|
|
transparency_rects = move(uncovered_transparency);
|
|
}
|
|
if (!transparent_covering.is_empty()) {
|
|
auto uncovered_transparency = transparent_covering.shatter(covering);
|
|
transparent_covering = move(uncovered_transparency);
|
|
}
|
|
}
|
|
if (!transparent_rects.is_empty())
|
|
transparent_covering.add(transparent_rects.shatter(opaque_covering));
|
|
VERIFY(!transparent_covering.intersects(opaque_covering));
|
|
return IterationDecision::Continue;
|
|
});
|
|
VERIFY(opaque_covering.is_empty() || render_rect_on_screen.contains(opaque_covering.rects()));
|
|
if (!m_overlay_rects.is_empty() && m_overlay_rects.intersects(visible_opaque)) {
|
|
// In order to render overlays flicker-free we need to force this area into the
|
|
// temporary transparency rendering buffer
|
|
transparent_covering.add(m_overlay_rects.intersected(visible_opaque));
|
|
}
|
|
if (!transparent_covering.is_empty()) {
|
|
VERIFY(!transparent_covering.intersects(opaque_covering));
|
|
transparency_rects.add(transparent_covering);
|
|
if (!visible_opaque.is_empty()) {
|
|
auto uncovered_opaque = visible_opaque.shatter(transparent_covering);
|
|
visible_opaque = move(uncovered_opaque);
|
|
}
|
|
|
|
// Now that we know what transparency rectangles are immediately covering our window
|
|
// figure out what windows they belong to and add them to the affected transparency rects.
|
|
// We can't do the same with the windows below as we haven't gotten to those yet. These
|
|
// will be determined after we're done with this pass.
|
|
found_this_window = false;
|
|
wm.for_each_visible_window_from_back_to_front([&](Window& w2) {
|
|
if (!found_this_window) {
|
|
if (&w == &w2)
|
|
found_this_window = true;
|
|
return IterationDecision::Continue;
|
|
}
|
|
|
|
auto affected_transparency = transparent_covering.intersected(w2.transparency_rects());
|
|
if (!affected_transparency.is_empty()) {
|
|
auto result = affected_transparency_rects.set(&w2, move(affected_transparency));
|
|
VERIFY(result == AK::HashSetResult::InsertedNewEntry);
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
// This window should not be occluded while the window switcher is interested in it (depending
|
|
// on the mode it's in). If it isn't then determine occlusions based on whether the window
|
|
// rect has any visible areas at all.
|
|
w.set_occluded(never_occlude(w.window_stack()) ? false : visible_window_rects.is_empty());
|
|
|
|
bool have_opaque = !visible_opaque.is_empty();
|
|
if (!transparency_rects.is_empty())
|
|
have_transparent = true;
|
|
if (have_transparent || have_opaque) {
|
|
// Figure out what screens this window is rendered on
|
|
// We gather this information so we can more quickly
|
|
// render the window on each of the screens that it
|
|
// needs to be rendered on.
|
|
Screen::for_each([&](auto& screen) {
|
|
auto screen_rect = screen.rect();
|
|
for (auto& r : visible_opaque.rects()) {
|
|
if (r.intersects(screen_rect)) {
|
|
w.screens().append(&screen);
|
|
return IterationDecision::Continue;
|
|
}
|
|
}
|
|
for (auto& r : transparency_rects.rects()) {
|
|
if (r.intersects(screen_rect)) {
|
|
w.screens().append(&screen);
|
|
return IterationDecision::Continue;
|
|
}
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
if (!visible_opaque.is_empty()) {
|
|
VERIFY(!visible_opaque.intersects(transparency_rects));
|
|
|
|
// Determine visible area for the window below
|
|
remaining_visible_screen_rects = remaining_visible_screen_rects.shatter(visible_opaque);
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
|
|
if (have_transparent) {
|
|
// Also, now that we have completed the first pass we can determine the affected
|
|
// transparency rects below a given window
|
|
wm.for_each_visible_window_from_back_to_front([&](Window& w) {
|
|
// Any area left in remaining_visible_screen_rects will need to be rendered with the wallpaper first
|
|
auto& transparency_rects = w.transparency_rects();
|
|
auto& transparency_wallpaper_rects = w.transparency_wallpaper_rects();
|
|
if (transparency_rects.is_empty()) {
|
|
VERIFY(transparency_wallpaper_rects.is_empty()); // Should have been cleared in the first pass
|
|
} else {
|
|
transparency_wallpaper_rects = remaining_visible_screen_rects.intersected(transparency_rects);
|
|
|
|
if (!transparency_wallpaper_rects.is_empty()) {
|
|
auto remaining_visible = remaining_visible_screen_rects.shatter(transparency_wallpaper_rects);
|
|
remaining_visible_screen_rects = move(remaining_visible);
|
|
}
|
|
}
|
|
|
|
// Figure out the affected transparency rects underneath. First figure out if any transparency is visible at all
|
|
Gfx::DisjointIntRectSet transparent_underneath;
|
|
wm.for_each_visible_window_from_back_to_front([&](Window& w2) {
|
|
if (&w == &w2)
|
|
return IterationDecision::Break;
|
|
auto& opaque_rects2 = w2.opaque_rects();
|
|
if (!opaque_rects2.is_empty()) {
|
|
auto uncovered_transparency = transparent_underneath.shatter(opaque_rects2);
|
|
transparent_underneath = move(uncovered_transparency);
|
|
}
|
|
w2.transparency_rects().for_each_intersected(transparency_rects, [&](auto& rect) {
|
|
transparent_underneath.add(rect);
|
|
return IterationDecision::Continue;
|
|
});
|
|
|
|
return IterationDecision::Continue;
|
|
});
|
|
if (!transparent_underneath.is_empty()) {
|
|
// Now that we know there are some transparency rects underneath that are visible
|
|
// figure out what windows they belong to
|
|
auto& affected_transparency_rects = w.affected_transparency_rects();
|
|
wm.for_each_visible_window_from_back_to_front([&](Window& w2) {
|
|
if (&w == &w2)
|
|
return IterationDecision::Break;
|
|
auto& transparency_rects2 = w2.transparency_rects();
|
|
if (transparency_rects2.is_empty())
|
|
return IterationDecision::Continue;
|
|
|
|
auto affected_transparency = transparent_underneath.intersected(transparency_rects2);
|
|
if (!affected_transparency.is_empty()) {
|
|
auto result = affected_transparency_rects.set(&w2, move(affected_transparency));
|
|
VERIFY(result == AK::HashSetResult::InsertedNewEntry);
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
m_transparent_wallpaper_rects.clear_with_capacity();
|
|
if (!m_overlay_rects.is_empty() && m_overlay_rects.intersects(remaining_visible_screen_rects)) {
|
|
// Check if any overlay rects are remaining that are not somehow above any windows
|
|
m_transparent_wallpaper_rects = m_overlay_rects.intersected(remaining_visible_screen_rects);
|
|
auto remaining_visible_not_covered = remaining_visible_screen_rects.shatter(m_overlay_rects);
|
|
remaining_visible_screen_rects = move(remaining_visible_not_covered);
|
|
}
|
|
|
|
m_opaque_wallpaper_rects = move(remaining_visible_screen_rects);
|
|
}
|
|
|
|
if constexpr (OCCLUSIONS_DEBUG) {
|
|
for (auto& r : m_opaque_wallpaper_rects.rects())
|
|
dbgln(" wallpaper opaque: {}", r);
|
|
}
|
|
|
|
wm.for_each_visible_window_from_back_to_front([&](Window& w) {
|
|
auto window_frame_rect = w.frame().render_rect();
|
|
if (w.is_minimized() || window_frame_rect.is_empty() || w.screens().is_empty())
|
|
return IterationDecision::Continue;
|
|
|
|
if constexpr (OCCLUSIONS_DEBUG) {
|
|
dbgln(" Window {} frame rect: {} rendered on screens: {}", w.title(), window_frame_rect, w.screens().size());
|
|
for (auto& s : w.screens())
|
|
dbgln(" screen: #{}", s->index());
|
|
for (auto& r : w.opaque_rects().rects())
|
|
dbgln(" opaque: {}", r);
|
|
for (auto& r : w.transparency_wallpaper_rects().rects())
|
|
dbgln(" transparent wallpaper: {}", r);
|
|
for (auto& r : w.transparency_rects().rects())
|
|
dbgln(" transparent: {}", r);
|
|
for (auto& it : w.affected_transparency_rects()) {
|
|
dbgln(" affects {}:", it.key->title());
|
|
for (auto& r : it.value.rects())
|
|
dbgln(" transparent: {}", r);
|
|
}
|
|
}
|
|
|
|
VERIFY(!w.opaque_rects().intersects(m_opaque_wallpaper_rects));
|
|
VERIFY(!w.transparency_rects().intersects(m_opaque_wallpaper_rects));
|
|
VERIFY(!w.transparency_wallpaper_rects().intersects(m_opaque_wallpaper_rects));
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
void Compositor::register_animation(Badge<Animation>, Animation& animation)
|
|
{
|
|
VERIFY(!m_animations_running);
|
|
bool was_empty = m_animations.is_empty();
|
|
auto result = m_animations.set(&animation);
|
|
VERIFY(result == AK::HashSetResult::InsertedNewEntry);
|
|
if (was_empty) {
|
|
m_invalidated_any = true;
|
|
start_compose_async_timer();
|
|
}
|
|
}
|
|
|
|
void Compositor::unregister_animation(Badge<Animation>, Animation& animation)
|
|
{
|
|
VERIFY(!m_animations_running);
|
|
bool was_removed = m_animations.remove(&animation);
|
|
VERIFY(was_removed);
|
|
}
|
|
|
|
void Compositor::update_animations(Screen& screen, Gfx::DisjointIntRectSet& flush_rects)
|
|
{
|
|
Vector<NonnullRefPtr<Animation>, 16> finished_animations;
|
|
ScopeGuard call_stop_handlers([&] {
|
|
for (auto& animation : finished_animations)
|
|
animation->call_stop_handler({});
|
|
});
|
|
|
|
TemporaryChange animations_running(m_animations_running, true);
|
|
auto& painter = *screen.compositor_screen_data().m_back_painter;
|
|
// Iterating over the animations using remove_all_matching we can iterate
|
|
// and immediately remove finished animations without having to keep track
|
|
// of them in a separate container.
|
|
m_animations.remove_all_matching([&](auto* animation) {
|
|
VERIFY(animation->is_running());
|
|
if (!animation->update(painter, screen, flush_rects)) {
|
|
// Mark it as removed so that the Animation::on_stop handler doesn't
|
|
// trigger the Animation object from being destroyed, causing it to
|
|
// unregister while we still loop over them.
|
|
animation->was_removed({});
|
|
|
|
finished_animations.append(*animation);
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
void Compositor::create_window_stack_switch_overlay(WindowStack& target_stack)
|
|
{
|
|
stop_window_stack_switch_overlay_timer();
|
|
Screen::for_each([&](auto& screen) {
|
|
auto& screen_data = screen.compositor_screen_data();
|
|
screen_data.m_window_stack_switch_overlay = nullptr; // delete it first
|
|
screen_data.m_window_stack_switch_overlay = create_overlay<WindowStackSwitchOverlay>(screen, target_stack);
|
|
screen_data.m_window_stack_switch_overlay->set_enabled(true);
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
void Compositor::remove_window_stack_switch_overlays()
|
|
{
|
|
Screen::for_each([&](auto& screen) {
|
|
screen.compositor_screen_data().m_window_stack_switch_overlay = nullptr;
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
void Compositor::stop_window_stack_switch_overlay_timer()
|
|
{
|
|
if (m_stack_switch_overlay_timer) {
|
|
// Cancel any timer, we're going to delete the overlay
|
|
m_stack_switch_overlay_timer->stop();
|
|
m_stack_switch_overlay_timer = nullptr;
|
|
}
|
|
}
|
|
|
|
void Compositor::start_window_stack_switch_overlay_timer()
|
|
{
|
|
if (m_stack_switch_overlay_timer) {
|
|
m_stack_switch_overlay_timer->stop();
|
|
m_stack_switch_overlay_timer = nullptr;
|
|
}
|
|
bool have_overlay = false;
|
|
Screen::for_each([&](auto& screen) {
|
|
if (screen.compositor_screen_data().m_window_stack_switch_overlay) {
|
|
have_overlay = true;
|
|
return IterationDecision::Break;
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
if (!have_overlay)
|
|
return;
|
|
m_stack_switch_overlay_timer = Core::Timer::create_single_shot(
|
|
500,
|
|
[this] {
|
|
remove_window_stack_switch_overlays();
|
|
},
|
|
this)
|
|
.release_value_but_fixme_should_propagate_errors();
|
|
m_stack_switch_overlay_timer->start();
|
|
}
|
|
|
|
void Compositor::finish_window_stack_switch()
|
|
{
|
|
VERIFY(m_transitioning_to_window_stack);
|
|
VERIFY(m_current_window_stack);
|
|
VERIFY(m_transitioning_to_window_stack != m_current_window_stack);
|
|
|
|
m_current_window_stack->set_transition_offset({}, {});
|
|
m_transitioning_to_window_stack->set_transition_offset({}, {});
|
|
|
|
auto* previous_window_stack = m_current_window_stack;
|
|
m_current_window_stack = m_transitioning_to_window_stack;
|
|
m_transitioning_to_window_stack = nullptr;
|
|
|
|
m_window_stack_transition_animation = nullptr;
|
|
|
|
auto& wm = WindowManager::the();
|
|
if (!wm.m_switcher->is_visible())
|
|
previous_window_stack->set_all_occluded(true);
|
|
wm.did_switch_window_stack({}, *previous_window_stack, *m_current_window_stack);
|
|
|
|
invalidate_occlusions();
|
|
|
|
// Rather than invalidating the entire we could invalidate all render rectangles
|
|
// that are affected by the transition offset before and after changing it.
|
|
invalidate_screen();
|
|
|
|
start_window_stack_switch_overlay_timer();
|
|
}
|
|
|
|
void Compositor::set_current_window_stack_no_transition(WindowStack& new_window_stack)
|
|
{
|
|
if (m_transitioning_to_window_stack) {
|
|
finish_window_stack_switch();
|
|
VERIFY(!m_window_stack_transition_animation);
|
|
VERIFY(!m_transitioning_to_window_stack);
|
|
}
|
|
if (m_current_window_stack == &new_window_stack)
|
|
return;
|
|
m_current_window_stack = &new_window_stack;
|
|
invalidate_for_window_stack_merge_or_change();
|
|
}
|
|
|
|
void Compositor::invalidate_for_window_stack_merge_or_change()
|
|
{
|
|
invalidate_occlusions();
|
|
invalidate_screen();
|
|
}
|
|
|
|
void Compositor::switch_to_window_stack(WindowStack& new_window_stack, bool show_overlay)
|
|
{
|
|
if (m_transitioning_to_window_stack) {
|
|
if (m_transitioning_to_window_stack == &new_window_stack)
|
|
return;
|
|
// A switch is in progress, but the user is impatient. Finish the transition instantly
|
|
finish_window_stack_switch();
|
|
VERIFY(!m_window_stack_transition_animation);
|
|
// Now switch to the next target as usual
|
|
}
|
|
VERIFY(m_current_window_stack);
|
|
|
|
if (&new_window_stack == m_current_window_stack) {
|
|
// So that the user knows which stack they're on, show the overlay briefly
|
|
if (show_overlay) {
|
|
create_window_stack_switch_overlay(*m_current_window_stack);
|
|
start_window_stack_switch_overlay_timer();
|
|
} else {
|
|
stop_window_stack_switch_overlay_timer();
|
|
remove_window_stack_switch_overlays();
|
|
}
|
|
return;
|
|
}
|
|
VERIFY(!m_transitioning_to_window_stack);
|
|
m_transitioning_to_window_stack = &new_window_stack;
|
|
|
|
auto window_stack_size = Screen::bounding_rect().size();
|
|
|
|
int delta_x = 0;
|
|
if (new_window_stack.column() < m_current_window_stack->column())
|
|
delta_x = window_stack_size.width();
|
|
else if (new_window_stack.column() > m_current_window_stack->column())
|
|
delta_x = -window_stack_size.width();
|
|
int delta_y = 0;
|
|
if (new_window_stack.row() < m_current_window_stack->row())
|
|
delta_y = window_stack_size.height();
|
|
else if (new_window_stack.row() > m_current_window_stack->row()) {
|
|
delta_y = -window_stack_size.height();
|
|
}
|
|
|
|
m_transitioning_to_window_stack->set_transition_offset({}, { -delta_x, -delta_y });
|
|
m_current_window_stack->set_transition_offset({}, {});
|
|
|
|
if (show_overlay) {
|
|
// We start the timer when the animation ends!
|
|
create_window_stack_switch_overlay(*m_transitioning_to_window_stack);
|
|
} else {
|
|
stop_window_stack_switch_overlay_timer();
|
|
remove_window_stack_switch_overlays();
|
|
}
|
|
|
|
VERIFY(!m_window_stack_transition_animation);
|
|
m_window_stack_transition_animation = Animation::create();
|
|
m_window_stack_transition_animation->set_duration(250);
|
|
m_window_stack_transition_animation->on_update = [this, delta_x, delta_y](float progress, Gfx::Painter&, Screen&, Gfx::DisjointIntRectSet&) {
|
|
VERIFY(m_transitioning_to_window_stack);
|
|
VERIFY(m_current_window_stack);
|
|
|
|
// Set transition offset for the window stack we're transitioning out of
|
|
auto previous_transition_offset_from = m_current_window_stack->transition_offset();
|
|
Gfx::IntPoint transition_offset_from { (float)delta_x * progress, (float)delta_y * progress };
|
|
if (previous_transition_offset_from == transition_offset_from)
|
|
return;
|
|
|
|
{
|
|
// we need to render both, the existing dirty rectangles as well as where we're shifting to
|
|
auto translated_dirty_rects = m_dirty_screen_rects.clone();
|
|
auto transition_delta = transition_offset_from - previous_transition_offset_from;
|
|
translated_dirty_rects.translate_by(transition_delta);
|
|
m_dirty_screen_rects.add(translated_dirty_rects.intersected(Screen::bounding_rect()));
|
|
}
|
|
m_current_window_stack->set_transition_offset({}, transition_offset_from);
|
|
|
|
// Set transition offset for the window stack we're transitioning to
|
|
Gfx::IntPoint transition_offset_to { (float)-delta_x * (1.0f - progress), (float)-delta_y * (1.0f - progress) };
|
|
m_transitioning_to_window_stack->set_transition_offset({}, transition_offset_to);
|
|
|
|
invalidate_occlusions();
|
|
|
|
// Rather than invalidating the entire we could invalidate all render rectangles
|
|
// that are affected by the transition offset before and after changing it.
|
|
invalidate_screen();
|
|
};
|
|
|
|
m_window_stack_transition_animation->on_stop = [this] {
|
|
finish_window_stack_switch();
|
|
};
|
|
m_window_stack_transition_animation->start();
|
|
}
|
|
|
|
}
|