LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-21 02:08:12 +03:00
Code Issues Packages Projects Releases Wiki Activity
799b0a4fa8
ladybird/Servers/WindowServer/WSClientConnection.h

127 lines
7.0 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
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>
WindowServer: Port WindowServer to LibCore. This was pretty straightforward thanks to the work I did separating out LibCore from LibGUI already. :^) - WSMessageLoop now inherits from CEventLoop. - WSMessage now inherits from CEvent. - WSMessageReceiver goes away. Now there is only one event loop in Serenity. Very nice!
2019-04-14 06:15:22 +03:00
#include <LibCore/CObject.h>
LibGfx: Rename GraphicsBitmap.{cpp,h} => Bitmap.{cpp,h}
2020-02-06 14:07:05 +03:00
#include <LibGfx/Bitmap.h>
LibIPC: Move IPC client/server connection templates to LibIPC Move over the CoreIPC::Server and CoreIPC::Client namespace stuff into LibIPC where it will soon becomes LibIPC-style things.
2019-12-02 11:52:07 +03:00
#include <LibIPC/IClientConnection.h>
WindowServer: Rename WSMessage* => WSEvent*. Since I'm on a roll here, I'll just rename WSMessageFoo to WSEventFoo now that these inherit from CEventFoo anyway.
2019-04-14 06:23:37 +03:00
#include <WindowServer/WSEvent.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
class WSWindow;
class WSMenu;
class WSMenuBar;
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
class WSClientConnection final
LibIPC: Put all classes in the IPC namespace and remove the leading I
2020-02-05 21:57:18 +03:00
: public IPC::ClientConnection<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+AudioServer: Add some missing C_OBJECT macros.
2019-07-27 19:43:59 +03:00
C_OBJECT(WSClientConnection)
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:
Port WSClientConnection to CIPCServerSideClient
2019-07-17 11:31:52 +03:00
~WSClientConnection() override;
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
virtual void die() 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
WindowServer: Give a thread boost to the currently active window When the currently active (foreground) window is owned by a client, we now apply a +10 priority boost to the client's main thread. You normally want the window you're interacting with to be responsive, so this little boost allows it to run a bit sooner and more often. :^)
2019-12-30 21:27:58 +03:00
void boost();
void deboost();
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
static WSClientConnection* from_client_id(int client_id);
Port the WindowServer and LibGUI to communicate through local sockets. This is really cool! :^) Apps currently refuse to start if the WindowServer isn't listening on the socket in /wsportal. This makes sense, but I guess it would also be nice to have some sort of "wait for server on startup" mode. This has performance issues, and I'll work on those, but this stuff seems to actually work and I'm very happy with that.
2019-02-14 19:18:35 +03:00
static void for_each_client(Function<void(WSClientConnection&)>);
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
WSMenuBar* app_menubar() { return m_app_menubar.ptr(); }
WindowServer: Add special treatment for modal windows. While a WSClientConnection has a modal window showing, non-modal windows belonging to that client are not sent any events.
2019-03-19 02:52:39 +03:00
bool is_showing_modal_window() const;
LibDraw: Put all classes in the Gfx namespace I started adding things to a Draw namespace, but it somehow felt really wrong seeing Draw::Rect and Draw::Bitmap, etc. So instead, let's rename the library to LibGfx. :^)
2020-02-06 13:56:38 +03:00
void notify_about_new_screen_rect(const Gfx::Rect&);
WindowServer+LibGUI: Store a "data type" with the clipboard content This will allow us to distinguish between different types of data stored on the clipboard.
2019-09-14 10:19:05 +03:00
void notify_about_clipboard_contents_changed();
WindowSerer+LibGUI: Send multiple rects in invalidation/flush messages. This patch moves to sending up to 32 rects at a time when coordinating the painting between WindowServer and its clients. Rects are also merged into a minimal DisjointRectSet on the server side before painting. Interactive resize looks a lot better after this change, since we can usually do all the repainting needed in one go.
2019-04-20 18:19:56 +03:00
void post_paint_message(WSWindow&);
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+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
WSMenu* find_menu_by_id(int menu_id)
{
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;
return const_cast<WSMenu*>(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 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:
LibCore: Put all classes in the Core namespace and remove the leading C I've been wanting to do this for a long time. It's time we start being consistent about how this stuff works. The new convention is: - "LibFoo" is a userspace library that provides the "Foo" namespace. That's it :^) This was pretty tedious to convert and I didn't even start on LibGUI yet. But it's coming up next.
2020-02-02 14:34:39 +03:00
explicit WSClientConnection(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
virtual OwnPtr<WindowServer::GreetResponse> handle(const WindowServer::Greet&) override;
virtual OwnPtr<WindowServer::CreateMenubarResponse> handle(const WindowServer::CreateMenubar&) override;
virtual OwnPtr<WindowServer::DestroyMenubarResponse> handle(const WindowServer::DestroyMenubar&) override;
virtual OwnPtr<WindowServer::CreateMenuResponse> handle(const WindowServer::CreateMenu&) override;
virtual OwnPtr<WindowServer::DestroyMenuResponse> handle(const WindowServer::DestroyMenu&) override;
virtual OwnPtr<WindowServer::AddMenuToMenubarResponse> handle(const WindowServer::AddMenuToMenubar&) override;
virtual OwnPtr<WindowServer::SetApplicationMenubarResponse> handle(const WindowServer::SetApplicationMenubar&) override;
virtual OwnPtr<WindowServer::AddMenuItemResponse> handle(const WindowServer::AddMenuItem&) override;
virtual OwnPtr<WindowServer::AddMenuSeparatorResponse> handle(const WindowServer::AddMenuSeparator&) override;
virtual OwnPtr<WindowServer::UpdateMenuItemResponse> handle(const WindowServer::UpdateMenuItem&) override;
virtual OwnPtr<WindowServer::CreateWindowResponse> handle(const WindowServer::CreateWindow&) override;
virtual OwnPtr<WindowServer::DestroyWindowResponse> handle(const WindowServer::DestroyWindow&) override;
virtual OwnPtr<WindowServer::SetWindowTitleResponse> handle(const WindowServer::SetWindowTitle&) override;
virtual OwnPtr<WindowServer::GetWindowTitleResponse> handle(const WindowServer::GetWindowTitle&) override;
virtual OwnPtr<WindowServer::SetWindowRectResponse> handle(const WindowServer::SetWindowRect&) override;
virtual OwnPtr<WindowServer::GetWindowRectResponse> handle(const WindowServer::GetWindowRect&) override;
virtual void handle(const WindowServer::InvalidateRect&) override;
virtual void handle(const WindowServer::DidFinishPainting&) override;
virtual OwnPtr<WindowServer::SetGlobalCursorTrackingResponse> handle(const WindowServer::SetGlobalCursorTracking&) override;
virtual OwnPtr<WindowServer::SetWindowOpacityResponse> handle(const WindowServer::SetWindowOpacity&) override;
virtual OwnPtr<WindowServer::SetWindowBackingStoreResponse> handle(const WindowServer::SetWindowBackingStore&) override;
virtual OwnPtr<WindowServer::GetClipboardContentsResponse> handle(const WindowServer::GetClipboardContents&) override;
virtual OwnPtr<WindowServer::SetClipboardContentsResponse> handle(const WindowServer::SetClipboardContents&) override;
virtual void handle(const WindowServer::WM_SetActiveWindow&) override;
virtual void handle(const WindowServer::WM_SetWindowMinimized&) override;
virtual void handle(const WindowServer::WM_StartWindowResize&) override;
virtual void handle(const WindowServer::WM_PopupWindowMenu&) override;
virtual OwnPtr<WindowServer::SetWindowHasAlphaChannelResponse> handle(const WindowServer::SetWindowHasAlphaChannel&) override;
virtual OwnPtr<WindowServer::MoveWindowToFrontResponse> handle(const WindowServer::MoveWindowToFront&) override;
virtual OwnPtr<WindowServer::SetFullscreenResponse> handle(const WindowServer::SetFullscreen&) override;
virtual void handle(const WindowServer::AsyncSetWallpaper&) override;
virtual OwnPtr<WindowServer::GetWallpaperResponse> handle(const WindowServer::GetWallpaper&) override;
virtual OwnPtr<WindowServer::SetResolutionResponse> handle(const WindowServer::SetResolution&) override;
virtual OwnPtr<WindowServer::SetWindowOverrideCursorResponse> handle(const WindowServer::SetWindowOverrideCursor&) override;
virtual OwnPtr<WindowServer::PopupMenuResponse> handle(const WindowServer::PopupMenu&) override;
virtual OwnPtr<WindowServer::DismissMenuResponse> handle(const WindowServer::DismissMenu&) override;
virtual OwnPtr<WindowServer::SetWindowIconBitmapResponse> handle(const WindowServer::SetWindowIconBitmap&) override;
WindowServer+Taskbar: Animate window frames on minimize/unminimize We now show a quick window outline animation when going in/out of minimized state. It's a simple 10 frame animation at 60fps, just to give a visual cue of what's happening with the window. The Taskbar sends over the corresponding button rect for each window to the WindowServer using a new WM_SetWindowTaskbarRect message. Note that when unminimizing, we still *show* the window right away, and don't hold off until the animation has finished. This avoids making the desktop feel slow/sluggish. :^)
2019-12-03 23:34:34 +03:00
virtual void handle(const WindowServer::WM_SetWindowTaskbarRect&) override;
LibGUI+WindowServer: Start fleshing out drag&drop functionality This patch enables basic drag&drop between applications. You initiate a drag by creating a GDragOperation object and calling exec() on it. This creates a nested event loop in the calling program that only returns once the drag operation has ended. On the receiving side, you get a call to GWidget::drop_event() with a GDropEvent containing information about the dropped data. The only data passed right now is a piece of text that's also used to visually indicate that a drag is happening (by showing the text in a little box that follows the mouse cursor around.) There are things to fix here, but we're off to a nice start. :^)
2019-12-08 18:50:23 +03:00
virtual OwnPtr<WindowServer::StartDragResponse> handle(const WindowServer::StartDrag&) 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
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
HashMap<int, NonnullRefPtr<WSWindow>> m_windows;
Convert HashMap<Key, OwnPtr<T>> to HashMap<Key, NonnullOwnPtr<T>>. In every case I found, we never wanted to support null entry values. With NonnullOwnPtr, we can encode that at the type level. :^)
2019-07-24 09:42:55 +03:00
HashMap<int, NonnullOwnPtr<WSMenuBar>> m_menubars;
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
HashMap<int, NonnullRefPtr<WSMenu>> m_menus;
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
WeakPtr<WSMenuBar> m_app_menubar;
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
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 19:37:47 +03:00
RefPtr<SharedBuffer> m_last_sent_clipboard_content;
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
};
Reference in New Issue Copy Permalink