dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Userland/Services/WindowServer/WindowServer.ipc

156 lines
5.7 KiB
Text
Raw Normal View History

Everywhere: Use IPC include syntax Remove superfluous includes from IPCCompiler's generated output and add include directives in IPC definitions where appropriate.
2021-07-03 01:40:44 -03:00
#include <LibCore/AnonymousBuffer.h>
#include <LibGfx/ShareableBitmap.h>
IPCCompiler: Remove hardcoded endpoint magic, attempt deux This patch removes the IPC endpoint numbers that needed to be specified in the IPC files. Since the string hash is a (hopefully) collision free number that depends on the name of the endpoint, we now use that instead. :^) Additionally, endpoint magic is now treated as a u32, because endpoint numbers were never negative anyway. For cases where the endpoint number does have to be hardcoded (a current case is LookupServer because the endpoint number must be known in LibC), the syntax has been made more explicit to avoid confusing those unfamiliar. To hardcode the endpoint magic, the following syntax is now used: endpoint EndpointName [magic=1234]
2021-04-25 08:19:53 -03:00
endpoint WindowServer
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 05:33:37 -03:00
{
WindowServer+LibGUI: Make menu allocation asynchronous This was only synchronous since WindowServer managed the ID allocation. Doing this on the client side instead allows us to make create_menu() an asynchronous IPC call, removing a bunch of IPC stalls during application startup.
2021-05-17 08:26:40 -03:00
create_menu(i32 menu_id, [UTF8] String menu_title) =|
WindowServer+LibGUI: Make menu and menubar teardown asynchronous Clients don't need to wait for WindowServer to tear down a menu or menubar before continuing.
2021-05-10 06:52:30 -03:00
destroy_menu(i32 menu_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 05:33:37 -03:00
LibGUI, WindowServer: Greatly simplify menubar logic Currently, any number of menubars can be plugged in and out of a window. This is unnecessary complexity, since we only need one menubar on a window. This commit removes most of the logic for dynamically attaching and detaching menubars and makes one menubar always available. The menubar is only considered existent if it has at least a single menu in it (in other words, an empty menubar will not be shown). This commit additionally fixes a bug wherein menus added after a menubar has been attached would not have their rects properly setup, and would therefore appear glitched out on the top left corner of the menubar.
2021-07-29 07:14:12 -03:00
add_menu(i32 window_id, i32 menu_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 05:33:37 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
add_menu_item(
WindowServer+LibGUI: Paint exclusive actions as radio buttons in menus Actions that are checkable and members of a GActionGroup will now be painted with a radio button appearance in menus.
2020-01-08 16:44:41 -03:00
i32 menu_id,
i32 identifier,
i32 submenu_id,
LibIPC: Allow opt-in UTF-8 validation on message parameters You can now mark String message parameters with the [UTF8] attribute. This will cause the generated decoder to perform UTF-8 validation and reject the message if the given parameter is not a valid UTF-8 string. This frees up the receiving side from having to do this validation at a higher level.
2020-05-16 09:11:35 -03:00
[UTF8] String text,
WindowServer+LibGUI: Paint exclusive actions as radio buttons in menus Actions that are checkable and members of a GActionGroup will now be painted with a radio button appearance in menus.
2020-01-08 16:44:41 -03:00
bool enabled,
bool checkable,
bool checked,
WindowServer/LibGUI: Add default menu items and allow default action for context menu By specifying an optional Action for Menu::popup an application can specify what item should be displayed as a default item.
2020-07-10 16:29:21 -03:00
bool is_default,
LibIPC: Allow opt-in UTF-8 validation on message parameters You can now mark String message parameters with the [UTF8] attribute. This will cause the generated decoder to perform UTF-8 validation and reject the message if the given parameter is not a valid UTF-8 string. This frees up the receiving side from having to do this validation at a higher level.
2020-05-16 09:11:35 -03:00
[UTF8] String shortcut,
WindowServer+LibGUI: Send menu item icons as Gfx::ShareableBitmap
2021-01-16 06:59:25 -03:00
Gfx::ShareableBitmap icon,
WindowServer+LibGUI: Make much of menu construction asynchronous Creating a menu/menubar needs to be synchronous because we need the ID from the response, but adding stuff *to* menus (and adding menus to menubars, and menubars to windows) can all be asynchronous. This dramatically reduces the amount of IPC ping-pong played by each GUI application during startup. I measured how long it takes TextEditor to enter the main event loop and it's over 10% faster here. (Down from ~86ms to ~74ms)
2021-05-03 16:27:22 -03:00
bool exclusive) =|
WindowServer+LibGUI: Paint exclusive actions as radio buttons in menus Actions that are checkable and members of a GActionGroup will now be painted with a radio button appearance in menus.
2020-01-08 16:44:41 -03:00
WindowServer+LibGUI: Make much of menu construction asynchronous Creating a menu/menubar needs to be synchronous because we need the ID from the response, but adding stuff *to* menus (and adding menus to menubars, and menubars to windows) can all be asynchronous. This dramatically reduces the amount of IPC ping-pong played by each GUI application during startup. I measured how long it takes TextEditor to enter the main event loop and it's over 10% faster here. (Down from ~86ms to ~74ms)
2021-05-03 16:27:22 -03:00
add_menu_separator(i32 menu_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 05:33:37 -03:00
WindowServer+LibGUI: Make much of menu construction asynchronous Creating a menu/menubar needs to be synchronous because we need the ID from the response, but adding stuff *to* menus (and adding menus to menubars, and menubars to windows) can all be asynchronous. This dramatically reduces the amount of IPC ping-pong played by each GUI application during startup. I measured how long it takes TextEditor to enter the main event loop and it's over 10% faster here. (Down from ~86ms to ~74ms)
2021-05-03 16:27:22 -03:00
update_menu_item(i32 menu_id, i32 identifier, i32 submenu_id, [UTF8] String text, bool enabled, bool checkable, bool checked, bool is_default, [UTF8] String shortcut) =|
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 05:33:37 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
create_window(
WindowServer+LibGUI: Make window creation asynchronous :^) Let clients manage their own window ID's. If you try to create a new window with an existing ID, WindowServer will simply disconnect you for misbehaving. This removes the need for window creation to be synchronous, which means that most GUI applications can now batch their entire GUI initialization sequence without having to block waiting for responses.
2021-06-12 06:55:13 -03:00
i32 window_id,
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 05:57:59 -03:00
Gfx::IntRect rect,
LibGUI+WindowServer: Provide default placement to windows This prevents windows from being opened directly on top of eachother, and provides default behavior for when window position is not specified. The new behavior is as follows: - Windows that have been created without a set position are assigned one by WindowServer. - The assigned position is either offset from the last window that is still in an assigned position, or a default position if no such window is available.
2020-07-30 22:52:45 -03:00
bool auto_position,
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 05:33:37 -03:00
bool has_alpha_channel,
bool modal,
WindowServer+LibGUI: Implement minimizable property to windows
2020-01-04 08:12:02 -03:00
bool minimizable,
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 05:33:37 -03:00
bool resizable,
bool fullscreen,
WindowServer+LibGUI: Add "frameless" window flag This allows you to create windows with no title bar or window frame.
2020-05-01 18:26:32 -03:00
bool frameless,
WindowServer+LibGUI: Add a way to force a window to have a drop shadow
2021-07-04 18:10:53 -03:00
bool forced_shadow,
WindowServer: Add accessory windows Accessory windows are windows that, when activated, will activate their parent and bring all other accessory windows of that parent to the front of the window stack. Accessory windows can only be active input windows. The accessory window's parent is always the active window regardless of whether it is also the active input window. In order to route input correctly, input is now sent to the active input window, which can be any accessory window or their parent, or any regular window.
2020-07-14 22:17:00 -03:00
bool accessory,
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 05:33:37 -03:00
float opacity,
WindowServer: Add support for alpha channel based hit testing This enables implementing non-rectangular window shapes, including non-rectangular window frames.
2021-02-14 20:42:37 -03:00
float alpha_hit_threshold,
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 05:57:59 -03:00
Gfx::IntSize base_size,
Gfx::IntSize size_increment,
WindowServer, LibGUI: Variable minimum window sizes Minimum window size can now be customised and set at runtime via the SetWindowMinimumSize WindowServer message and the set_minimum_size LibGUI::Window method. The default minimum size remains at 50x50. Some behind-the-scenes mechanics had to be added to LibGUI::Window to ensure that the minimum size is remembered if set before the window is shown. WindowServer sends a resize event to the client if it requests a size on create that's smaller than it's minimum size.
2021-02-15 10:59:43 -03:00
Gfx::IntSize minimum_size,
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 17:19:10 -03:00
Optional<Gfx::IntSize> resize_aspect_ratio,
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 05:33:37 -03:00
i32 type,
LibIPC: Allow opt-in UTF-8 validation on message parameters You can now mark String message parameters with the [UTF8] attribute. This will cause the generated decoder to perform UTF-8 validation and reject the message if the given parameter is not a valid UTF-8 string. This frees up the receiving side from having to do this validation at a higher level.
2020-05-16 09:11:35 -03:00
[UTF8] String title,
WindowServer+LibGUI: Allow specifying a "launch origin" for new windows The launch_origin_rect parameter to create_window() specifies where on screen the window was launched from. It's optional, but if you provide it, the new window will have a short wireframe animation from the origin to the initial window frame rect. GUI::Window looks for the "__libgui_launch_origin_rect" environment variable. Put your launch origin rect in there with the format "<x>,<y>,<width>,<height>" and the first GUI::Window shown by the app will use that as the launch origin rect. Also it looks pretty neat, although I'm sure we can improve it. :^)
2021-06-27 12:07:31 -03:00
i32 parent_window_id,
Gfx::IntRect launch_origin_rect) =|
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 05:33:37 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
destroy_window(i32 window_id) => (Vector<i32> destroyed_window_ids)
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 05:33:37 -03:00
WindowServer+LibGUI: Make much of window construction asynchronous Most of the IPC that happens between clients and WindowServer when creating and configuring windows can be asynchronous. This further reduces the amount of ping-ponging played during application startup.
2021-05-03 16:36:36 -03:00
set_window_title(i32 window_id, [UTF8] String title) =|
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
get_window_title(i32 window_id) => ([UTF8] String title)
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 05:33:37 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
set_window_progress(i32 window_id, Optional<i32> progress) =|
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 17:08:26 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
set_window_modified(i32 window_id, bool modified) =|
is_window_modified(i32 window_id) => (bool modified)
WindowServer: Add Window "modified" state This will be used to track which windows contain some kind of unsaved data that the user may want some help remembering to save. :^)
2021-05-01 13:21:34 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
set_window_rect(i32 window_id, Gfx::IntRect rect) => (Gfx::IntRect rect)
get_window_rect(i32 window_id) => (Gfx::IntRect rect)
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 17:16:30 -03:00
WindowServer+LibGUI: Make much of window construction asynchronous Most of the IPC that happens between clients and WindowServer when creating and configuring windows can be asynchronous. This further reduces the amount of ping-ponging played during application startup.
2021-05-03 16:36:36 -03:00
set_window_minimum_size(i32 window_id, Gfx::IntSize size) =|
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
get_window_minimum_size(i32 window_id) => (Gfx::IntSize size)
WindowServer, LibGUI: Variable minimum window sizes Minimum window size can now be customised and set at runtime via the SetWindowMinimumSize WindowServer message and the set_minimum_size LibGUI::Window method. The default minimum size remains at 50x50. Some behind-the-scenes mechanics had to be added to LibGUI::Window to ensure that the minimum size is remembered if set before the window is shown. WindowServer sends a resize event to the client if it requests a size on create that's smaller than it's minimum size.
2021-02-15 10:59:43 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
get_applet_rect_on_screen(i32 window_id) => (Gfx::IntRect rect)
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 05:33:37 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
start_window_resize(i32 window_id) =|
LibGUI+WindowServer: Don't use a WM IPC to initiate own window resize The WM_* IPC messages are intended for "outsider" window management, not for a client's own windows. Make a separate StartWindowResize message for this. This was the only reason that every IPC client had to know its server side client ID.
2021-02-01 07:23:54 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
is_maximized(i32 window_id) => (bool maximized)
LibGUI/WindowServer: Add set_maximized IPC call Add an IPC call to enable the client to manually maximize it's own window.
2021-06-06 16:50:06 -03:00
set_maximized(i32 window_id, bool maximized) =|
WindowServer: Add a new IsMaximized message New message to query window maximized state.
2020-06-18 07:14:00 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
invalidate_rect(i32 window_id, Vector<Gfx::IntRect> rects, bool ignore_occlusion) =|
did_finish_painting(i32 window_id, Vector<Gfx::IntRect> rects) =|
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 05:33:37 -03:00
LibGUI+WindowServer: Introduce new mouse tracking mechanism
2021-09-07 16:04:35 -03:00
set_global_mouse_tracking(bool enabled) =|
WindowServer+LibGUI: Make much of window construction asynchronous Most of the IPC that happens between clients and WindowServer when creating and configuring windows can be asynchronous. This further reduces the amount of ping-ponging played during application startup.
2021-05-03 16:36:36 -03:00
set_window_opacity(i32 window_id, float opacity) =|
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 05:33:37 -03:00
WindowServer+LibGUI: Make much of window construction asynchronous Most of the IPC that happens between clients and WindowServer when creating and configuring windows can be asynchronous. This further reduces the amount of ping-ponging played during application startup.
2021-05-03 16:36:36 -03:00
set_window_alpha_hit_threshold(i32 window_id, float threshold) =|
WindowServer: Add support for alpha channel based hit testing This enables implementing non-rectangular window shapes, including non-rectangular window frames.
2021-02-14 20:42:37 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
set_window_backing_store(i32 window_id, i32 bpp, i32 pitch, IPC::File anon_file, i32 serial, bool has_alpha_channel, Gfx::IntSize size, bool flush_immediately) => ()
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 05:33:37 -03:00
WindowServer+LibGUI: Make much of window construction asynchronous Most of the IPC that happens between clients and WindowServer when creating and configuring windows can be asynchronous. This further reduces the amount of ping-ponging played during application startup.
2021-05-03 16:36:36 -03:00
set_window_has_alpha_channel(i32 window_id, bool has_alpha_channel) =|
WindowServer+LibGUI: Make "move window to front" asynchronous
2021-05-10 07:08:59 -03:00
move_window_to_front(i32 window_id) =|
WindowServer: Make most remaining WindowServer IPC calls async The only remaining sync call from client to server is now the call that switches a window's backing store. That one actually relies on the synchronization to hand over ownership of the backing stores, so it has to stay synchronous for now.
2021-07-04 17:26:24 -03:00
set_fullscreen(i32 window_id, bool fullscreen) =|
set_frameless(i32 window_id, bool frameless) =|
WindowServer+LibGUI: Add a way to force a window to have a drop shadow
2021-07-04 18:10:53 -03:00
set_forced_shadow(i32 window_id, bool shadow) =|
WindowServer: Make popup_menu() an asynchronous IPC call This was already being used asynchronously by LibGUI, which meant that WindowServer would generate a response, and the client would ignore it. This patch simplifies the WindowServer side so it no longer generates the unnecessary response.
2021-05-10 07:10:58 -03:00
popup_menu(i32 menu_id, Gfx::IntPoint screen_position) =|
WindowServer: Make dismiss_menu() an asynchronous IPC call This was already being used asynchronously by LibGUI, which meant that WindowServer would generate a response, and the client would ignore it.
2021-05-10 07:12:37 -03:00
dismiss_menu(i32 menu_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 05:33:37 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
set_wallpaper(String path) =|
LibGUI+WindowServer: Allow applications to set custom cursor bitmaps This will allow e.g PaintBrush to use custom cursors for each tool.
2020-05-15 22:04:09 -03:00
WindowServer: Make set_background_color and set_wallpaper_mode async Both of these were already used asynchonrously by GUI::Desktop.
2021-05-10 07:21:42 -03:00
set_background_color(String background_color) =|
set_wallpaper_mode(String mode) =|
WindowServer: Add methods for set background color and wallpaper mode
2020-03-29 07:32:06 -03:00
WindowServer: Add API to set/get screen layouts This sets the stage so that DisplaySettings can configure the screen layout and set various screen resolutions in one go. It also allows for an easy "atomic" revert of the previous settings.
2021-06-15 00:19:56 -03:00
set_screen_layout(::WindowServer::ScreenLayout screen_layout, bool save) => (bool success, String error_msg)
get_screen_layout() => (::WindowServer::ScreenLayout screen_layout)
save_screen_layout() => (bool success, String error_msg)
WindowServer: Add an Overlay class for flicker-free overlay rendering An Overlay is similar to a transparent window, but has less overhead and does not get rendered within the window stack. Basically, the area that an Overlay occupies forces transparency rendering for any window underneath, which allows us to render them flicker-free. This also adds a new API that allows displaying the screen numbers, e.g. while the user configures the screen layout in DisplaySettings Because other things like drag&drop or the window-size label are not yet converted to use this new mechanism, they will be drawn over the screen-number currently.
2021-06-20 16:23:43 -03:00
show_screen_numbers(bool show) =|
WindowServer: Add API to set/get screen layouts This sets the stage so that DisplaySettings can configure the screen layout and set various screen resolutions in one go. It also allows for an easy "atomic" revert of the previous settings.
2021-06-15 00:19:56 -03:00
WindowServer: Add API to change virtual desktop settings This also adds the ability to query how many virtual desktops are set up, and for the Taskbar to be notified when the active virtual desktop has changed.
2021-06-30 22:12:02 -03:00
apply_virtual_desktop_settings(u32 rows, u32 columns, bool save) => (bool success)
get_virtual_desktop_settings() => (u32 rows, u32 columns, u32 max_rows, u32 max_columns)
WindowServer+LibGUI: Make much of window construction asynchronous Most of the IPC that happens between clients and WindowServer when creating and configuring windows can be asynchronous. This further reduces the amount of ping-ponging played during application startup.
2021-05-03 16:36:36 -03:00
set_window_icon_bitmap(i32 window_id, Gfx::ShareableBitmap icon) =|
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 05:33:37 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
get_wallpaper() => (String path)
WindowServer+LibGUI: Make much of window construction asynchronous Most of the IPC that happens between clients and WindowServer when creating and configuring windows can be asynchronous. This further reduces the amount of ping-ponging played during application startup.
2021-05-03 16:36:36 -03:00
set_window_cursor(i32 window_id, i32 cursor_type) =|
set_window_custom_cursor(i32 window_id, Gfx::ShareableBitmap cursor) =|
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 12:50:23 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
start_drag([UTF8] String text, HashMap<String,ByteBuffer> mime_data, Gfx::ShareableBitmap drag_bitmap) => (bool started)
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 16:05:14 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
set_system_theme(String theme_path, [UTF8] String theme_name) => (bool success)
get_system_theme() => ([UTF8] String theme_name)
refresh_system_theme() =|
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 15:23:57 -03:00
WindowServer: Add IPC calls for controlling cursor theme This commit adds two new IPC calls for WindowServer: apply_cursor_theme and get_cursor_theme.
2021-08-01 12:23:31 -03:00
apply_cursor_theme(String name) =|
get_cursor_theme() => (String name)
WindowServer+LibGUI: Add an IPC API to change the current system fonts This patch adds a set_system_fonts() IPC API that takes the two main font queries as parameters. We'll probably expand this with additional queries when we figure out what they should be. Note that changing the system fonts on a live system mostly takes effect in newly launched programs. This is because GUI::Widget will currently cache a pointer to the Gfx::FontDatabase::default_font() when first constructed. This is something we'll have to fix somehow. Also note that the settings are not yet persisted.
2021-05-21 13:53:03 -03:00
set_system_fonts(String default_font_query, String fixed_width_font_query) => (bool success)
WindowServer+LibGUI: Make much of window construction asynchronous Most of the IPC that happens between clients and WindowServer when creating and configuring windows can be asynchronous. This further reduces the amount of ping-ponging played during application startup.
2021-05-03 16:36:36 -03:00
set_window_base_size_and_size_increment(i32 window_id, Gfx::IntSize base_size, Gfx::IntSize size_increment) =|
set_window_resize_aspect_ratio(i32 window_id, Optional<Gfx::IntSize> resize_aspect_ratio) =|
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 17:13:23 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
enable_display_link() =|
disable_display_link() =|
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 17:46:49 -03:00
WindowServer: Add a new IPC to set the cursor position
2021-07-08 06:29:39 -03:00
set_global_cursor_position(Gfx::IntPoint position) =|
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
get_global_cursor_position() => (Gfx::IntPoint position)
WindowServer: Add a GetGlobalCursorPosition IPC request This tells you where the mouse cursor is in screen coordinates.
2020-12-28 16:48:52 -03:00
WindowServer: Make most remaining WindowServer IPC calls async The only remaining sync call from client to server is now the call that switches a window's backing store. That one actually relies on the synchronization to hand over ownership of the backing stores, so it has to stay synchronous for now.
2021-07-04 17:26:24 -03:00
set_mouse_acceleration(float factor) =|
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
get_mouse_acceleration() => (float factor)
WindowServer: Added IPC requests for getting and setting mouse settings These include the mouse acceleration factor and the scroll length step size.
2020-12-29 18:33:57 -03:00
WindowServer: Make most remaining WindowServer IPC calls async The only remaining sync call from client to server is now the call that switches a window's backing store. That one actually relies on the synchronization to hand over ownership of the backing stores, so it has to stay synchronous for now.
2021-07-04 17:26:24 -03:00
set_scroll_step_size(u32 step_size) =|
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
get_scroll_step_size() => (u32 step_size)
WindowServer: Added IPC requests for getting and setting mouse settings These include the mouse acceleration factor and the scroll length step size.
2020-12-29 18:33:57 -03:00
WindowServer: Enable screen capture to span multiple screens This enables the shot utility to capture all screens or just one, and enables the Magnifier application to track the mouse cursor across multiple screens.
2021-06-19 00:42:25 -03:00
get_screen_bitmap(Optional<Gfx::IntRect> rect, Optional<u32> screen_index) => (Gfx::ShareableBitmap bitmap)
WindowServer+Magnifier: Make Magnifier buttery smooth :^) This patch moves the magnifier rect computation over to the server side to ensure that the mouse cursor position and the screen image never get out of sync.
2021-06-07 05:20:50 -03:00
get_screen_bitmap_around_cursor(Gfx::IntSize size) => (Gfx::ShareableBitmap bitmap)
WindowServer: Add IPC endpoint to get the color under cursor This allows any client to ask the WindowServer to give it the color of the screen bitmap under the cursor. There's currently no way to get the screen bitmap *without* the cursor already drawn on it, so for now we just take a pixel beside the actual cursor position to avoid just getting the cursors color.
2021-09-04 00:14:37 -03:00
get_color_under_cursor() => (Gfx::Color color)
WindowServer: Add an IPC call for taking a screenshot This patch adds Messages::WindowServer::GetScreenBitmap. It returns the currently displayed on-screen bitmap as-is, as a Gfx::ShareableBitmap.
2021-03-26 15:53:49 -03:00
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
pong() =|
WindowServer+MouseSettings: Add ability to configure double-click speed (#5876) This adds a double-click speed slider control to the Mouse Settings panel, and value labels for both the movement speed and double-click speed sliders. To allow for updating and persisting the configured double-click speed through the WindowServer, two IPC calls - `SetDoubleClickSpeed` and `GetDoubleClickSpeed` - have been added.
2021-04-02 11:08:18 -03:00
WindowServer: Make most remaining WindowServer IPC calls async The only remaining sync call from client to server is now the call that switches a window's backing store. That one actually relies on the synchronization to hand over ownership of the backing stores, so it has to stay synchronous for now.
2021-07-04 17:26:24 -03:00
set_double_click_speed(int speed) =|
Userland: Use snake case names in .ipc files This updates all .ipc files to have snake case names for IPC methods.
2021-05-03 10:52:56 -03:00
get_double_click_speed() => (int speed)
WindowServer: Add a GetDesktopDisplayScale IPC request Tells you which scale factor is configured in window manager.
2021-06-05 22:34:33 -03:00
WindowServer: Add initial support for rendering on multiple screens This allows WindowServer to use multiple framebuffer devices and compose the desktop with any arbitrary layout. Currently, it is assumed that it is configured contiguous and non-overlapping, but this should eventually be enforced. To make rendering efficient, each window now also tracks on which screens it needs to be rendered. This way we don't have to iterate all the windows for each screen but instead use the same rendering loop and then only render to the screen (or screens) that the window actually uses.
2021-06-13 09:16:06 -03:00
get_desktop_display_scale(u32 screen_index) => (int desktop_display_scale)
WindowServer+wsctl: Add a simple utility for toggling "flash flush" You can now put the WindowServer into "flash flush" mode by doing: $ wsctl -f 1 To disable it, somewhat obviously: $ wsctl -f 0
2021-07-07 17:54:58 -03:00
set_flash_flush(bool enabled) =|
WindowServer: Add WindowServer::async_set_window_parent_from_client() This allows a client to set the parent for one of its local windows where the parent window is in another client.
2021-07-12 11:35:46 -03:00
set_window_parent_from_client(i32 client_id, i32 parent_id, i32 child_id) =|
WindowServer: Add WindowServer::get_window_rect_from_client() This allows a client to get the rect of a window in another client.
2021-07-17 06:36:51 -03:00
get_window_rect_from_client(i32 client_id, i32 window_id) => (Gfx::IntRect rect)
WindowServer: Let clients mark windows as stealable by specific clients This implements window stealing in WindowServer, which allows clients to mark a window they own as 'stealable' by another client. Indicating that the other client may use it for any purpose. This also updates set_window_parent_from_id so that the client must first mark its window as stealable before allowing other clients to use it as a parent.
2021-07-16 21:41:36 -03:00
add_window_stealing_for_client(i32 client_id, i32 window_id) =|
remove_window_stealing_for_client(i32 client_id, i32 window_id) =|
remove_window_stealing(i32 window_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 05:33:37 -03:00
}
Reference in a new issue Copy permalink