LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-11 01:06:01 +03:00
Code Issues Packages Projects Releases Wiki Activity
c41d340983
ladybird/Userland/Services/WindowServer/ClientConnection.h

169 lines
10 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 11:38:21 +03:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
#pragma once
WindowServer+LibGUI: Add a way to get notified at display refresh rate This patch adds GUI::DisplayLink, a mechanism for registering callbacks that will fire at the display refresh rate. Note that we don't actually know the screen refresh rate, but this is instead completely driven by WindowServer's compositing timer. For all current intents and purposes it does the job well enough. :^)
2020-03-22 23:13:23 +03:00
#include <AK/Badge.h>
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 12:53:16 +03:00
#include <AK/Function.h>
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
#include <AK/HashMap.h>
#include <AK/OwnPtr.h>
#include <AK/WeakPtr.h>
LibCore: Remove leading C from filenames
2020-02-06 17:04:03 +03:00
#include <LibCore/Object.h>
LibGfx: Rename GraphicsBitmap.{cpp,h} => Bitmap.{cpp,h}
2020-02-06 14:07:05 +03:00
#include <LibGfx/Bitmap.h>
LibIPC: Remove leading I from filenames
2020-02-06 16:54:09 +03:00
#include <LibIPC/ClientConnection.h>
WindowServer: Move classes into WindowServer namespace Also remove the leading WS from names and filenames.
2020-02-06 22:03:37 +03:00
#include <WindowServer/Event.h>
LibIPC: Share most of the code between {Client,Server}Connection This patch introduces IPC::Connection which becomes the new base class of ClientConnection and ServerConnection. Most of the functionality has been hoisted up to the base class since almost all of it is useful on both sides. This gives us the ability to send synchronous messages in both directions, which is needed for the WebContent server process. Unlike other servers, WebContent does not mind blocking on a response from its client.
2020-09-12 12:44:00 +03:00
#include <WindowServer/WindowClientEndpoint.h>
WindowServer: Port to the new IPC system This patch introduces code generation for the WindowServer IPC with its clients. The client/server endpoints are defined by the two .ipc files in Servers/WindowServer/: WindowServer.ipc and WindowClient.ipc It now becomes significantly easier to add features and capabilities to WindowServer since you don't have to know nearly as much about all the intricate paths that IPC messages take between LibGUI and WSWindow. The new system also uses significantly less IPC bandwidth since we're now doing packed serialization instead of passing fixed-sized structs of ~600 bytes for each message. Some repaint coalescing optimizations are lost in this conversion and we'll need to look at how to implement those in the new world. The old CoreIPC::Client::Connection and CoreIPC::Server::Connection classes are removed by this patch and replaced by use of ConnectionNG, which will be renamed eventually. Goodbye, old WindowServer IPC. You served us well :^)
2019-12-02 11:33:37 +03:00
#include <WindowServer/WindowServerEndpoint.h>
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
WindowServer: Move classes into WindowServer namespace Also remove the leading WS from names and filenames.
2020-02-06 22:03:37 +03:00
namespace WindowServer {
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
WindowServer+LibGUI: Add a way to get notified at display refresh rate This patch adds GUI::DisplayLink, a mechanism for registering callbacks that will fire at the display refresh rate. Note that we don't actually know the screen refresh rate, but this is instead completely driven by WindowServer's compositing timer. For all current intents and purposes it does the job well enough. :^)
2020-03-22 23:13:23 +03:00
class Compositor;
WindowServer: Move classes into WindowServer namespace Also remove the leading WS from names and filenames.
2020-02-06 22:03:37 +03:00
class Window;
class Menu;
class MenuBar;
class ClientConnection final
LibIPC: Share most of the code between {Client,Server}Connection This patch introduces IPC::Connection which becomes the new base class of ClientConnection and ServerConnection. Most of the functionality has been hoisted up to the base class since almost all of it is useful on both sides. This gives us the ability to send synchronous messages in both directions, which is needed for the WebContent server process. Unlike other servers, WebContent does not mind blocking on a response from its client.
2020-09-12 12:44:00 +03:00
: public IPC::ClientConnection<WindowClientEndpoint, WindowServerEndpoint>
WindowServer: Port to the new IPC system This patch introduces code generation for the WindowServer IPC with its clients. The client/server endpoints are defined by the two .ipc files in Servers/WindowServer/: WindowServer.ipc and WindowClient.ipc It now becomes significantly easier to add features and capabilities to WindowServer since you don't have to know nearly as much about all the intricate paths that IPC messages take between LibGUI and WSWindow. The new system also uses significantly less IPC bandwidth since we're now doing packed serialization instead of passing fixed-sized structs of ~600 bytes for each message. Some repaint coalescing optimizations are lost in this conversion and we'll need to look at how to implement those in the new world. The old CoreIPC::Client::Connection and CoreIPC::Server::Connection classes are removed by this patch and replaced by use of ConnectionNG, which will be renamed eventually. Goodbye, old WindowServer IPC. You served us well :^)
2019-12-02 11:33:37 +03:00
, public WindowServerEndpoint {
WindowServer: Move classes into WindowServer namespace Also remove the leading WS from names and filenames.
2020-02-06 22:03:37 +03:00
C_OBJECT(ClientConnection)
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
public:
WindowServer: Move classes into WindowServer namespace Also remove the leading WS from names and filenames.
2020-02-06 22:03:37 +03:00
~ClientConnection() override;
LibIPC+WindowServer+LibGUI: Detect and highlight unresponsive GUI apps IPC::ClientConnection now tracks the time since the last time we got a message from the client and calls a virtual function on itself after 3 seconds: may_have_become_unresponsive(). Subclasses of ClientConnection can then react to this if they like. We use this mechanism in WindowServer to send out a friendly Ping message to the client. If he doesn't Pong within 1 second, we mark the client as "unresponsive" and recompose all of his windows with a darkened appearance and amended title until he Pongs us. This is a little on the aggressive side and we should figure out a way to wake up less often. Perhaps this could only be done to windows the user is currently interacting with, for example. Anyways, this is pretty cool! :^)
2020-06-11 23:46:49 +03:00
bool is_unresponsive() const { return m_unresponsive; }
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
WindowServer: Move classes into WindowServer namespace Also remove the leading WS from names and filenames.
2020-02-06 22:03:37 +03:00
static ClientConnection* from_client_id(int client_id);
static void for_each_client(Function<void(ClientConnection&)>);
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
WindowServer: Move classes into WindowServer namespace Also remove the leading WS from names and filenames.
2020-02-06 22:03:37 +03:00
MenuBar* app_menubar() { return m_app_menubar.ptr(); }
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
LibGfx: Rename Rect,Point,Size => IntRect,IntPoint,IntSize This fits nicer with FloatRect,FloatPoint,FloatSize and gives a much better visual clue about what type of metric is being used.
2020-06-10 11:57:59 +03:00
void notify_about_new_screen_rect(const Gfx::IntRect&);
WindowServer+LibGUI: Force full window repaints after theme change We were not repainting windows that were occluded at the time of the theme changing. This patch adds a way to bypass occlusion testing when invalidating window rects. Fixes #1249.
2020-02-19 18:45:06 +03:00
void post_paint_message(Window&, bool ignore_occlusion = false);
WindowServer: Broadcast screen rect changes to all clients. GUI clients can now obtain the screen rect via GDesktop::rect().
2019-04-03 18:22:14 +03:00
WindowServer: Move classes into WindowServer namespace Also remove the leading WS from names and filenames.
2020-02-06 22:03:37 +03:00
Menu* find_menu_by_id(int menu_id)
WindowServer+LibGUI: Add support for nested menus It's now possible to add a GMenu as a submenu of another GMenu. Simply use the GMenu::add_submenu(NonnullOwnPtr<GMenu>) API :^) The WindowServer now keeps track of a stack of open menus rather than just one "current menu". This code needs a bit more work, but the basic functionality is now here!
2019-08-28 22:11:53 +03:00
{
LibCore: Make CObject reference-counted Okay, I've spent a whole day on this now, and it finally kinda works! With this patch, CObject and all of its derived classes are reference counted instead of tree-owned. The previous, Qt-like model was nice and familiar, but ultimately also outdated and difficult to reason about. CObject-derived types should now be stored in RefPtr/NonnullRefPtr and each class can be constructed using the forwarding construct() helper: auto widget = GWidget::construct(parent_widget); Note that construct() simply forwards all arguments to an existing constructor. It is inserted into each class by the C_OBJECT macro, see CObject.h to understand how that works. CObject::delete_later() disappears in this patch, as there is no longer a single logical owner of a CObject.
2019-09-22 01:17:53 +03:00
auto menu = m_menus.get(menu_id);
if (!menu.has_value())
return nullptr;
WindowServer: Move classes into WindowServer namespace Also remove the leading WS from names and filenames.
2020-02-06 22:03:37 +03:00
return const_cast<Menu*>(menu.value().ptr());
WindowServer+LibGUI: Add support for nested menus It's now possible to add a GMenu as a submenu of another GMenu. Simply use the GMenu::add_submenu(NonnullOwnPtr<GMenu>) API :^) The WindowServer now keeps track of a stack of open menus rather than just one "current menu". This code needs a bit more work, but the basic functionality is now here!
2019-08-28 22:11:53 +03:00
}
WindowServer: Add const version of Menu::find_menu_by_id(int menu_id) It's a little sad having two diferent versions of this function, but I don't know of any better way to do it. This also gets rid of some const casts down the line.
2020-05-18 13:07:46 +03:00
const Menu* find_menu_by_id(int menu_id) const
{
auto menu = m_menus.get(menu_id);
if (!menu.has_value())
return nullptr;
return menu.value().ptr();
}
WindowServer+LibGUI: Add support for nested menus It's now possible to add a GMenu as a submenu of another GMenu. Simply use the GMenu::add_submenu(NonnullOwnPtr<GMenu>) API :^) The WindowServer now keeps track of a stack of open menus rather than just one "current menu". This code needs a bit more work, but the basic functionality is now here!
2019-08-28 22:11:53 +03:00
WindowServer+LibGUI: Add a way to get notified at display refresh rate This patch adds GUI::DisplayLink, a mechanism for registering callbacks that will fire at the display refresh rate. Note that we don't actually know the screen refresh rate, but this is instead completely driven by WindowServer's compositing timer. For all current intents and purposes it does the job well enough. :^)
2020-03-22 23:13:23 +03:00
void notify_display_link(Badge<Compositor>);
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
private:
LibIPC+Services: Make ClientConnection take socket as NonnullRefPtr This avoids getting into the awkward situation where the socket is still part-owned by main() in multi-instance service. Also it just reads nicer.
2020-07-06 14:23:39 +03:00
explicit ClientConnection(NonnullRefPtr<Core::LocalSocket>, int client_id);
WindowServer: Port to the new IPC system This patch introduces code generation for the WindowServer IPC with its clients. The client/server endpoints are defined by the two .ipc files in Servers/WindowServer/: WindowServer.ipc and WindowClient.ipc It now becomes significantly easier to add features and capabilities to WindowServer since you don't have to know nearly as much about all the intricate paths that IPC messages take between LibGUI and WSWindow. The new system also uses significantly less IPC bandwidth since we're now doing packed serialization instead of passing fixed-sized structs of ~600 bytes for each message. Some repaint coalescing optimizations are lost in this conversion and we'll need to look at how to implement those in the new world. The old CoreIPC::Client::Connection and CoreIPC::Server::Connection classes are removed by this patch and replaced by use of ConnectionNG, which will be renamed eventually. Goodbye, old WindowServer IPC. You served us well :^)
2019-12-02 11:33:37 +03:00
LibIPC+WindowServer+LibGUI: Detect and highlight unresponsive GUI apps IPC::ClientConnection now tracks the time since the last time we got a message from the client and calls a virtual function on itself after 3 seconds: may_have_become_unresponsive(). Subclasses of ClientConnection can then react to this if they like. We use this mechanism in WindowServer to send out a friendly Ping message to the client. If he doesn't Pong within 1 second, we mark the client as "unresponsive" and recompose all of his windows with a darkened appearance and amended title until he Pongs us. This is a little on the aggressive side and we should figure out a way to wake up less often. Perhaps this could only be done to windows the user is currently interacting with, for example. Anyways, this is pretty cool! :^)
2020-06-11 23:46:49 +03:00
// ^ClientConnection
virtual void die() override;
virtual void may_have_become_unresponsive() override;
LibIPC: Only start responsiveness timer after sending client a message Instead of always running the responsiveness timer for IPC clients, we now only start it after sending a message. This avoids waking up otherwise idle clients to do ping/pong busywork.
2020-06-13 14:47:01 +03:00
virtual void did_become_responsive() override;
LibIPC+WindowServer+LibGUI: Detect and highlight unresponsive GUI apps IPC::ClientConnection now tracks the time since the last time we got a message from the client and calls a virtual function on itself after 3 seconds: may_have_become_unresponsive(). Subclasses of ClientConnection can then react to this if they like. We use this mechanism in WindowServer to send out a friendly Ping message to the client. If he doesn't Pong within 1 second, we mark the client as "unresponsive" and recompose all of his windows with a darkened appearance and amended title until he Pongs us. This is a little on the aggressive side and we should figure out a way to wake up less often. Perhaps this could only be done to windows the user is currently interacting with, for example. Anyways, this is pretty cool! :^)
2020-06-11 23:46:49 +03:00
void set_unresponsive(bool);
WindowServer+LibGUI: Automatically close child windows with parent If a window has child windows when it's destroyed, WindowServer will now automatically tear down all of its children as well. This is communicated to the client program through a vector of window ID's included with the response to WindowServer::DestroyWindow. This does feel a little bit awkward, but managing it on the client side also seems a bit awkward.
2020-05-02 00:53:05 +03:00
void destroy_window(Window&, Vector<i32>& destroyed_window_ids);
IPCCompiler: Put message classes in the Messages namespace
2020-02-06 22:20:44 +03:00
virtual OwnPtr<Messages::WindowServer::GreetResponse> handle(const Messages::WindowServer::Greet&) override;
virtual OwnPtr<Messages::WindowServer::CreateMenubarResponse> handle(const Messages::WindowServer::CreateMenubar&) override;
virtual OwnPtr<Messages::WindowServer::DestroyMenubarResponse> handle(const Messages::WindowServer::DestroyMenubar&) override;
virtual OwnPtr<Messages::WindowServer::CreateMenuResponse> handle(const Messages::WindowServer::CreateMenu&) override;
virtual OwnPtr<Messages::WindowServer::DestroyMenuResponse> handle(const Messages::WindowServer::DestroyMenu&) override;
virtual OwnPtr<Messages::WindowServer::AddMenuToMenubarResponse> handle(const Messages::WindowServer::AddMenuToMenubar&) override;
virtual OwnPtr<Messages::WindowServer::SetApplicationMenubarResponse> handle(const Messages::WindowServer::SetApplicationMenubar&) override;
virtual OwnPtr<Messages::WindowServer::AddMenuItemResponse> handle(const Messages::WindowServer::AddMenuItem&) override;
virtual OwnPtr<Messages::WindowServer::AddMenuSeparatorResponse> handle(const Messages::WindowServer::AddMenuSeparator&) override;
virtual OwnPtr<Messages::WindowServer::UpdateMenuItemResponse> handle(const Messages::WindowServer::UpdateMenuItem&) override;
virtual OwnPtr<Messages::WindowServer::CreateWindowResponse> handle(const Messages::WindowServer::CreateWindow&) override;
virtual OwnPtr<Messages::WindowServer::DestroyWindowResponse> handle(const Messages::WindowServer::DestroyWindow&) override;
virtual OwnPtr<Messages::WindowServer::SetWindowTitleResponse> handle(const Messages::WindowServer::SetWindowTitle&) override;
virtual OwnPtr<Messages::WindowServer::GetWindowTitleResponse> handle(const Messages::WindowServer::GetWindowTitle&) override;
WindowServer: Add a new IsMaximized message New message to query window maximized state.
2020-06-18 13:14:00 +03:00
virtual OwnPtr<Messages::WindowServer::IsMaximizedResponse> handle(const Messages::WindowServer::IsMaximized&) override;
IPCCompiler: Put message classes in the Messages namespace
2020-02-06 22:20:44 +03:00
virtual OwnPtr<Messages::WindowServer::SetWindowRectResponse> handle(const Messages::WindowServer::SetWindowRect&) override;
virtual OwnPtr<Messages::WindowServer::GetWindowRectResponse> handle(const Messages::WindowServer::GetWindowRect&) override;
LibGUI+WindowServer: Allow applets to retrieve their location MenuApplet windows can now call rect_in_menubar to return their location in the MenuBar.
2020-07-24 23:16:30 +03:00
virtual OwnPtr<Messages::WindowServer::GetWindowRectInMenubarResponse> handle(const Messages::WindowServer::GetWindowRectInMenubar&) override;
IPCCompiler: Put message classes in the Messages namespace
2020-02-06 22:20:44 +03:00
virtual void handle(const Messages::WindowServer::InvalidateRect&) override;
virtual void handle(const Messages::WindowServer::DidFinishPainting&) override;
virtual OwnPtr<Messages::WindowServer::SetGlobalCursorTrackingResponse> handle(const Messages::WindowServer::SetGlobalCursorTracking&) override;
virtual OwnPtr<Messages::WindowServer::SetWindowOpacityResponse> handle(const Messages::WindowServer::SetWindowOpacity&) override;
virtual OwnPtr<Messages::WindowServer::SetWindowBackingStoreResponse> handle(const Messages::WindowServer::SetWindowBackingStore&) override;
virtual void handle(const Messages::WindowServer::WM_SetActiveWindow&) override;
virtual void handle(const Messages::WindowServer::WM_SetWindowMinimized&) override;
virtual void handle(const Messages::WindowServer::WM_StartWindowResize&) override;
virtual void handle(const Messages::WindowServer::WM_PopupWindowMenu&) override;
virtual OwnPtr<Messages::WindowServer::SetWindowHasAlphaChannelResponse> handle(const Messages::WindowServer::SetWindowHasAlphaChannel&) override;
virtual OwnPtr<Messages::WindowServer::MoveWindowToFrontResponse> handle(const Messages::WindowServer::MoveWindowToFront&) override;
virtual OwnPtr<Messages::WindowServer::SetFullscreenResponse> handle(const Messages::WindowServer::SetFullscreen&) override;
virtual void handle(const Messages::WindowServer::AsyncSetWallpaper&) override;
WindowServer: Add methods for set background color and wallpaper mode
2020-03-29 13:32:06 +03:00
virtual OwnPtr<Messages::WindowServer::SetBackgroundColorResponse> handle(const Messages::WindowServer::SetBackgroundColor&) override;
virtual OwnPtr<Messages::WindowServer::SetWallpaperModeResponse> handle(const Messages::WindowServer::SetWallpaperMode&) override;
IPCCompiler: Put message classes in the Messages namespace
2020-02-06 22:20:44 +03:00
virtual OwnPtr<Messages::WindowServer::GetWallpaperResponse> handle(const Messages::WindowServer::GetWallpaper&) override;
virtual OwnPtr<Messages::WindowServer::SetResolutionResponse> handle(const Messages::WindowServer::SetResolution&) override;
LibGUI+WindowServer: Rename window "override cursor" to just "cursor" Let's just say each window has a cursor, there's not really overriding going on.
2020-09-10 21:55:39 +03:00
virtual OwnPtr<Messages::WindowServer::SetWindowCursorResponse> handle(const Messages::WindowServer::SetWindowCursor&) override;
virtual OwnPtr<Messages::WindowServer::SetWindowCustomCursorResponse> handle(const Messages::WindowServer::SetWindowCustomCursor&) override;
IPCCompiler: Put message classes in the Messages namespace
2020-02-06 22:20:44 +03:00
virtual OwnPtr<Messages::WindowServer::PopupMenuResponse> handle(const Messages::WindowServer::PopupMenu&) override;
virtual OwnPtr<Messages::WindowServer::DismissMenuResponse> handle(const Messages::WindowServer::DismissMenu&) override;
virtual OwnPtr<Messages::WindowServer::SetWindowIconBitmapResponse> handle(const Messages::WindowServer::SetWindowIconBitmap&) override;
virtual void handle(const Messages::WindowServer::WM_SetWindowTaskbarRect&) override;
virtual OwnPtr<Messages::WindowServer::StartDragResponse> handle(const Messages::WindowServer::StartDrag&) override;
WindowServer: Make way for the out-of-process system menu This patch removes the internal system menu from WindowServer and replaces it with two IPC API's: SetSystemMenu(menu_id) SetSystemTheme(theme_path, theme_name) These API's will allow us to complete the SystemMenu program and move it entirely out of process.
2020-02-17 22:05:14 +03:00
virtual OwnPtr<Messages::WindowServer::SetSystemMenuResponse> handle(const Messages::WindowServer::SetSystemMenu&) override;
virtual OwnPtr<Messages::WindowServer::SetSystemThemeResponse> handle(const Messages::WindowServer::SetSystemTheme&) override;
WindowServer+SystemMenu: Check the current system theme on startup
2020-04-21 19:40:27 +03:00
virtual OwnPtr<Messages::WindowServer::GetSystemThemeResponse> handle(const Messages::WindowServer::GetSystemTheme&) override;
WindowServer+LibGUI: Allow changing a window's base size and increment Previously it was only possible to change these window attributes when creating a new window. This patch adds an IPC message that allows you to change them at runtime.
2020-02-24 21:23:57 +03:00
virtual OwnPtr<Messages::WindowServer::SetWindowBaseSizeAndSizeIncrementResponse> handle(const Messages::WindowServer::SetWindowBaseSizeAndSizeIncrement&) override;
LibGUI+WindowServer: Add resize_aspect_ratio() When a resize_aspect_ratio is specified, and window will only be resized to a multiple of that ratio. When resize_aspect_ratio is set, windows cannot be tiled.
2020-08-21 23:19:10 +03:00
virtual OwnPtr<Messages::WindowServer::SetWindowResizeAspectRatioResponse> handle(const Messages::WindowServer::SetWindowResizeAspectRatio&) override;
WindowServer+LibGUI: Add a way to get notified at display refresh rate This patch adds GUI::DisplayLink, a mechanism for registering callbacks that will fire at the display refresh rate. Note that we don't actually know the screen refresh rate, but this is instead completely driven by WindowServer's compositing timer. For all current intents and purposes it does the job well enough. :^)
2020-03-22 23:13:23 +03:00
virtual void handle(const Messages::WindowServer::EnableDisplayLink&) override;
virtual void handle(const Messages::WindowServer::DisableDisplayLink&) override;
WindowServer+LibGUI: Add per-window progress Each window now has an associated progress integer that can be updated via the SetWindowProgress IPC call. This can be used by clients to indicate the progress of ongoing tasks. Any number in the range 0 through 100 indicate a progress percentage. Any other number means "no progress"
2020-05-30 23:08:26 +03:00
virtual void handle(const Messages::WindowServer::SetWindowProgress&) override;
WindowServer, LibGUI: RefreshSystemTheme implementation Adds a mechanism through which windowing clients can re-request an UpdateSystemTheme message. This is currently used in SystemMenu's ShutdownDialog to refresh it's theme when the dialog is instantiated.
2021-01-16 07:56:41 +03:00
virtual void handle(const Messages::WindowServer::RefreshSystemTheme&) override;
LibIPC+WindowServer+LibGUI: Detect and highlight unresponsive GUI apps IPC::ClientConnection now tracks the time since the last time we got a message from the client and calls a virtual function on itself after 3 seconds: may_have_become_unresponsive(). Subclasses of ClientConnection can then react to this if they like. We use this mechanism in WindowServer to send out a friendly Ping message to the client. If he doesn't Pong within 1 second, we mark the client as "unresponsive" and recompose all of his windows with a darkened appearance and amended title until he Pongs us. This is a little on the aggressive side and we should figure out a way to wake up less often. Perhaps this could only be done to windows the user is currently interacting with, for example. Anyways, this is pretty cool! :^)
2020-06-11 23:46:49 +03:00
virtual void handle(const Messages::WindowServer::Pong&) override;
WindowServer: Add a GetGlobalCursorPosition IPC request This tells you where the mouse cursor is in screen coordinates.
2020-12-28 22:48:52 +03:00
virtual OwnPtr<Messages::WindowServer::GetGlobalCursorPositionResponse> handle(const Messages::WindowServer::GetGlobalCursorPosition&) override;
WindowServer: Added IPC requests for getting and setting mouse settings These include the mouse acceleration factor and the scroll length step size.
2020-12-30 00:33:57 +03:00
virtual OwnPtr<Messages::WindowServer::SetMouseAccelerationResponse> handle(const Messages::WindowServer::SetMouseAcceleration&) override;
virtual OwnPtr<Messages::WindowServer::GetMouseAccelerationResponse> handle(const Messages::WindowServer::GetMouseAcceleration&) override;
virtual OwnPtr<Messages::WindowServer::SetScrollStepSizeResponse> handle(const Messages::WindowServer::SetScrollStepSize&) override;
virtual OwnPtr<Messages::WindowServer::GetScrollStepSizeResponse> handle(const Messages::WindowServer::GetScrollStepSize&) override;
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
LibGUI+WindowServer: Inform WindowServer about parent/child windows If a window has another window in its Core::Object ancestor chain, we now communicate that relationship to WindowServer so that it can act with awareness of parent/child windows.
2020-05-01 23:59:38 +03:00
Window* window_from_id(i32 window_id);
WindowServer: Move classes into WindowServer namespace Also remove the leading WS from names and filenames.
2020-02-06 22:03:37 +03:00
HashMap<int, NonnullRefPtr<Window>> m_windows;
HashMap<int, NonnullOwnPtr<MenuBar>> m_menubars;
HashMap<int, NonnullRefPtr<Menu>> m_menus;
WeakPtr<MenuBar> m_app_menubar;
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
LibIPC+WindowServer+LibGUI: Detect and highlight unresponsive GUI apps IPC::ClientConnection now tracks the time since the last time we got a message from the client and calls a virtual function on itself after 3 seconds: may_have_become_unresponsive(). Subclasses of ClientConnection can then react to this if they like. We use this mechanism in WindowServer to send out a friendly Ping message to the client. If he doesn't Pong within 1 second, we mark the client as "unresponsive" and recompose all of his windows with a darkened appearance and amended title until he Pongs us. This is a little on the aggressive side and we should figure out a way to wake up less often. Perhaps this could only be done to windows the user is currently interacting with, for example. Anyways, this is pretty cool! :^)
2020-06-11 23:46:49 +03:00
RefPtr<Core::Timer> m_ping_timer;
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
int m_next_menubar_id { 10000 };
int m_next_menu_id { 20000 };
int m_next_window_id { 1982 };
WindowServer+LibGUI: Add a server-side clipboard. On the client side, use GClipboard's data() and set_data(String) to access the global clipboard. :^)
2019-03-08 15:27:19 +03:00
WindowServer+LibGUI: Add a way to get notified at display refresh rate This patch adds GUI::DisplayLink, a mechanism for registering callbacks that will fire at the display refresh rate. Note that we don't actually know the screen refresh rate, but this is instead completely driven by WindowServer's compositing timer. For all current intents and purposes it does the job well enough. :^)
2020-03-22 23:13:23 +03:00
bool m_has_display_link { false };
LibIPC+WindowServer+LibGUI: Detect and highlight unresponsive GUI apps IPC::ClientConnection now tracks the time since the last time we got a message from the client and calls a virtual function on itself after 3 seconds: may_have_become_unresponsive(). Subclasses of ClientConnection can then react to this if they like. We use this mechanism in WindowServer to send out a friendly Ping message to the client. If he doesn't Pong within 1 second, we mark the client as "unresponsive" and recompose all of his windows with a darkened appearance and amended title until he Pongs us. This is a little on the aggressive side and we should figure out a way to wake up less often. Perhaps this could only be done to windows the user is currently interacting with, for example. Anyways, this is pretty cool! :^)
2020-06-11 23:46:49 +03:00
bool m_unresponsive { false };
WindowServer: Add WSClientConnection class to manage an individual client. This makes both object lifetimes and object ID's a lot easier to understand.
2019-02-14 10:22:47 +03:00
};
WindowServer: Move classes into WindowServer namespace Also remove the leading WS from names and filenames.
2020-02-06 22:03:37 +03:00
}
Reference in New Issue Copy Permalink