RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 20:07:35 +00:00
Code Issues Activity Actions

Userland: Change IPC funcs to use plain arguments instead of a struct

Browse source 
Instead of having a single overloaded handle method each method gets
its own unique method name now.
This commit is contained in:
Gunnar Beutner 2021-05-02 19:54:34 +02:00 • committed by Andreas Kling
parent d47f15ab8b
commit 065040872f
50 changed files with 897 additions and 839 deletions
Download patch file Download diff file Expand all files Collapse all files

12
Userland/DevTools/HackStudio/LanguageClient.cpp
View file

@ -14,22 +14,22 @@
namespace HackStudio { namespace HackStudio {
void ServerConnection::handle(const Messages::LanguageClient::AutoCompleteSuggestions& message) void ServerConnection::auto_complete_suggestions(const Vector<GUI::AutocompleteProvider::Entry>& suggestions)
{ {
if (!m_current_language_client) { if (!m_current_language_client) {
dbgln("Language Server connection has no attached language client"); dbgln("Language Server connection has no attached language client");
return; return;
} }
m_current_language_client->provide_autocomplete_suggestions(message.suggestions()); m_current_language_client->provide_autocomplete_suggestions(suggestions);
} }
void ServerConnection::handle(const Messages::LanguageClient::DeclarationLocation& message) void ServerConnection::declaration_location(const GUI::AutocompleteProvider::ProjectLocation& location)
{ {
if (!m_current_language_client) { if (!m_current_language_client) {
dbgln("Language Server connection has no attached language client"); dbgln("Language Server connection has no attached language client");
return; return;
} }
m_current_language_client->declaration_found(message.location().file, message.location().line, message.location().column); m_current_language_client->declaration_found(location.file, location.line, location.column);
} }
void ServerConnection::die() void ServerConnection::die()
@ -100,9 +100,9 @@ void LanguageClient::set_active_client()
HashMap<String, NonnullOwnPtr<ServerConnectionWrapper>> ServerConnectionInstances::s_instance_for_language; HashMap<String, NonnullOwnPtr<ServerConnectionWrapper>> ServerConnectionInstances::s_instance_for_language;
void ServerConnection::handle(const Messages::LanguageClient::DeclarationsInDocument& message) void ServerConnection::declarations_in_document(const String& filename, const Vector<GUI::AutocompleteProvider::Declaration>& declarations)
{ {
ProjectDeclarations::the().set_declared_symbols(message.filename(), message.declarations()); ProjectDeclarations::the().set_declared_symbols(filename, declarations);
} }
void LanguageClient::search_declaration(const String& path, size_t line, size_t column) void LanguageClient::search_declaration(const String& path, size_t line, size_t column)

6
Userland/DevTools/HackStudio/LanguageClient.h
View file

@ -47,9 +47,9 @@ public:
virtual void die() override; virtual void die() override;
protected: protected:
virtual void handle(const Messages::LanguageClient::AutoCompleteSuggestions&) override; virtual void auto_complete_suggestions(Vector<GUI::AutocompleteProvider::Entry> const&) override;
virtual void handle(const Messages::LanguageClient::DeclarationLocation&) override; virtual void declaration_location(GUI::AutocompleteProvider::ProjectLocation const&) override;
virtual void handle(const Messages::LanguageClient::DeclarationsInDocument&) override; virtual void declarations_in_document(String const&, Vector<GUI::AutocompleteProvider::Declaration> const&) override;
void set_wrapper(ServerConnectionWrapper& wrapper) { m_wrapper = &wrapper; } void set_wrapper(ServerConnectionWrapper& wrapper) { m_wrapper = &wrapper; }
String m_project_path; String m_project_path;

81
Userland/DevTools/HackStudio/LanguageServers/ClientConnection.cpp
View file

@ -30,10 +30,10 @@ void ClientConnection::die()
exit(0); exit(0);
} }
void ClientConnection::handle(const Messages::LanguageServer::Greet& message) void ClientConnection::greet(String const& project_root)
{ {
m_filedb.set_project_root(message.project_root()); m_filedb.set_project_root(project_root);
if (unveil(message.project_root().characters(), "r") < 0) { if (unveil(project_root.characters(), "r") < 0) {
perror("unveil"); perror("unveil");
exit(1); exit(1);
} }
@ -43,80 +43,79 @@ void ClientConnection::handle(const Messages::LanguageServer::Greet& message)
} }
} }
void ClientConnection::handle(const Messages::LanguageServer::FileOpened& message) void ClientConnection::file_opened(String const& filename, IPC::File const& file)
{ {
if (m_filedb.is_open(message.filename())) { if (m_filedb.is_open(filename)) {
return; return;
} }
m_filedb.add(message.filename(), message.file().take_fd()); m_filedb.add(filename, file.take_fd());
m_autocomplete_engine->file_opened(message.filename()); m_autocomplete_engine->file_opened(filename);
} }
void ClientConnection::handle(const Messages::LanguageServer::FileEditInsertText& message) void ClientConnection::file_edit_insert_text(String const& filename, String const& text, i32 start_line, i32 start_column)
{ {
dbgln_if(LANGUAGE_SERVER_DEBUG, "InsertText for file: {}", message.filename()); dbgln_if(LANGUAGE_SERVER_DEBUG, "InsertText for file: {}", filename);
dbgln_if(LANGUAGE_SERVER_DEBUG, "Text: {}", message.text()); dbgln_if(LANGUAGE_SERVER_DEBUG, "Text: {}", text);
dbgln_if(LANGUAGE_SERVER_DEBUG, "[{}:{}]", message.start_line(), message.start_column()); dbgln_if(LANGUAGE_SERVER_DEBUG, "[{}:{}]", start_line, start_column);
m_filedb.on_file_edit_insert_text(message.filename(), message.text(), message.start_line(), message.start_column()); m_filedb.on_file_edit_insert_text(filename, text, start_line, start_column);
m_autocomplete_engine->on_edit(message.filename()); m_autocomplete_engine->on_edit(filename);
} }
void ClientConnection::handle(const Messages::LanguageServer::FileEditRemoveText& message) void ClientConnection::file_edit_remove_text(String const& filename, i32 start_line, i32 start_column, i32 end_line, i32 end_column)
{ {
dbgln_if(LANGUAGE_SERVER_DEBUG, "RemoveText for file: {}", message.filename()); dbgln_if(LANGUAGE_SERVER_DEBUG, "RemoveText for file: {}", filename);
dbgln_if(LANGUAGE_SERVER_DEBUG, "[{}:{} - {}:{}]", message.start_line(), message.start_column(), message.end_line(), message.end_column()); dbgln_if(LANGUAGE_SERVER_DEBUG, "[{}:{} - {}:{}]", start_line, start_column, end_line, end_column);
m_filedb.on_file_edit_remove_text(message.filename(), message.start_line(), message.start_column(), message.end_line(), message.end_column()); m_filedb.on_file_edit_remove_text(filename, start_line, start_column, end_line, end_column);
m_autocomplete_engine->on_edit(message.filename()); m_autocomplete_engine->on_edit(filename);
} }
void ClientConnection::handle(const Messages::LanguageServer::AutoCompleteSuggestions& message) void ClientConnection::auto_complete_suggestions(GUI::AutocompleteProvider::ProjectLocation const& location)
{ {
dbgln_if(LANGUAGE_SERVER_DEBUG, "AutoCompleteSuggestions for: {} {}:{}", message.location().file, message.location().line, message.location().column); dbgln_if(LANGUAGE_SERVER_DEBUG, "AutoCompleteSuggestions for: {} {}:{}", location.file, location.line, location.column);
auto document = m_filedb.get(message.location().file); auto document = m_filedb.get(location.file);
if (!document) { if (!document) {
dbgln("file {} has not been opened", message.location().file); dbgln("file {} has not been opened", location.file);
return; return;
} }
GUI::TextPosition autocomplete_position = { (size_t)message.location().line, (size_t)max(message.location().column, message.location().column - 1) }; GUI::TextPosition autocomplete_position = { (size_t)location.line, (size_t)max(location.column, location.column - 1) };
Vector<GUI::AutocompleteProvider::Entry> suggestions = m_autocomplete_engine->get_suggestions(message.location().file, autocomplete_position); Vector<GUI::AutocompleteProvider::Entry> suggestions = m_autocomplete_engine->get_suggestions(location.file, autocomplete_position);
post_message(Messages::LanguageClient::AutoCompleteSuggestions(move(suggestions))); post_message(Messages::LanguageClient::AutoCompleteSuggestions(move(suggestions)));
} }
void ClientConnection::handle(const Messages::LanguageServer::SetFileContent& message) void ClientConnection::set_file_content(String const& filename, String const& content)
{ {
dbgln_if(LANGUAGE_SERVER_DEBUG, "SetFileContent: {}", message.filename()); dbgln_if(LANGUAGE_SERVER_DEBUG, "SetFileContent: {}", filename);
auto document = m_filedb.get(message.filename()); auto document = m_filedb.get(filename);
if (!document) { if (!document) {
m_filedb.add(message.filename(), message.content()); m_filedb.add(filename, content);
VERIFY(m_filedb.is_open(message.filename())); VERIFY(m_filedb.is_open(filename));
} else { } else {
const auto& content = message.content();
document->set_text(content.view()); document->set_text(content.view());
} }
VERIFY(m_filedb.is_open(message.filename())); VERIFY(m_filedb.is_open(filename));
m_autocomplete_engine->on_edit(message.filename()); m_autocomplete_engine->on_edit(filename);
} }
void ClientConnection::handle(const Messages::LanguageServer::FindDeclaration& message) void ClientConnection::find_declaration(GUI::AutocompleteProvider::ProjectLocation const& location)
{ {
dbgln_if(LANGUAGE_SERVER_DEBUG, "FindDeclaration: {} {}:{}", message.location().file, message.location().line, message.location().column); dbgln_if(LANGUAGE_SERVER_DEBUG, "FindDeclaration: {} {}:{}", location.file, location.line, location.column);
auto document = m_filedb.get(message.location().file); auto document = m_filedb.get(location.file);
if (!document) { if (!document) {
dbgln("file {} has not been opened", message.location().file); dbgln("file {} has not been opened", location.file);
return; return;
} }
GUI::TextPosition identifier_position = { (size_t)message.location().line, (size_t)message.location().column }; GUI::TextPosition identifier_position = { (size_t)location.line, (size_t)location.column };
auto location = m_autocomplete_engine->find_declaration_of(message.location().file, identifier_position); auto decl_location = m_autocomplete_engine->find_declaration_of(location.file, identifier_position);
if (!location.has_value()) { if (!decl_location.has_value()) {
dbgln("could not find declaration"); dbgln("could not find declaration");
return; return;
} }
dbgln_if(LANGUAGE_SERVER_DEBUG, "declaration location: {} {}:{}", location.value().file, location.value().line, location.value().column); dbgln_if(LANGUAGE_SERVER_DEBUG, "declaration location: {} {}:{}", decl_location.value().file, decl_location.value().line, decl_location.value().column);
post_message(Messages::LanguageClient::DeclarationLocation(GUI::AutocompleteProvider::ProjectLocation { location.value().file, location.value().line, location.value().column })); post_message(Messages::LanguageClient::DeclarationLocation(GUI::AutocompleteProvider::ProjectLocation { decl_location.value().file, decl_location.value().line, decl_location.value().column }));
} }
void ClientConnection::set_declarations_of_document_callback(ClientConnection& instance, const String& filename, Vector<GUI::AutocompleteProvider::Declaration>&& declarations) void ClientConnection::set_declarations_of_document_callback(ClientConnection& instance, const String& filename, Vector<GUI::AutocompleteProvider::Declaration>&& declarations)

16
Userland/DevTools/HackStudio/LanguageServers/ClientConnection.h
View file

@ -29,14 +29,14 @@ public:
virtual void die() override; virtual void die() override;
protected: protected:
virtual void handle(const Messages::LanguageServer::Greet&) override; virtual void greet(String const&) override;
virtual void handle(const Messages::LanguageServer::FileOpened&) override; virtual void file_opened(String const&, IPC::File const&) override;
virtual void handle(const Messages::LanguageServer::FileEditInsertText&) override; virtual void file_edit_insert_text(String const&, String const&, i32, i32) override;
virtual void handle(const Messages::LanguageServer::FileEditRemoveText&) override; virtual void file_edit_remove_text(String const&, i32, i32, i32, i32) override;
virtual void handle(const Messages::LanguageServer::SetFileContent&) override; virtual void set_file_content(String const&, String const&) override;
virtual void handle(const Messages::LanguageServer::AutoCompleteSuggestions&) override; virtual void auto_complete_suggestions(GUI::AutocompleteProvider::ProjectLocation const&) override;
virtual void handle(const Messages::LanguageServer::FindDeclaration&) override; virtual void find_declaration(GUI::AutocompleteProvider::ProjectLocation const&) override;
virtual void handle(const Messages::LanguageServer::SetAutoCompleteMode&) override = 0; virtual void set_auto_complete_mode(String const&) override = 0;
static void set_declarations_of_document_callback(ClientConnection&, const String&, Vector<GUI::AutocompleteProvider::Declaration>&&); static void set_declarations_of_document_callback(ClientConnection&, const String&, Vector<GUI::AutocompleteProvider::Declaration>&&);

6
Userland/DevTools/HackStudio/LanguageServers/Cpp/ClientConnection.h
View file

@ -26,10 +26,10 @@ public:
virtual ~ClientConnection() override = default; virtual ~ClientConnection() override = default;
private: private:
virtual void handle(const Messages::LanguageServer::SetAutoCompleteMode& message) override virtual void set_auto_complete_mode(String const& mode) override
{ {
dbgln_if(CPP_LANGUAGE_SERVER_DEBUG, "SetAutoCompleteMode: {}", message.mode()); dbgln_if(CPP_LANGUAGE_SERVER_DEBUG, "SetAutoCompleteMode: {}", mode);
if (message.mode() == "Parser") if (mode == "Parser")
m_autocomplete_engine = make<ParserAutoComplete>(*this, m_filedb); m_autocomplete_engine = make<ParserAutoComplete>(*this, m_filedb);
else else
m_autocomplete_engine = make<LexerAutoComplete>(*this, m_filedb); m_autocomplete_engine = make<LexerAutoComplete>(*this, m_filedb);

2
Userland/DevTools/HackStudio/LanguageServers/Shell/ClientConnection.h
View file

@ -23,6 +23,6 @@ class ClientConnection final : public LanguageServers::ClientConnection {
virtual ~ClientConnection() override = default; virtual ~ClientConnection() override = default;
private: private:
virtual void handle(const Messages::LanguageServer::SetAutoCompleteMode&) override { } virtual void set_auto_complete_mode(String const&) override { }
}; };
} }

108
Userland/DevTools/IPCCompiler/main.cpp
View file

@ -45,6 +45,21 @@ struct Endpoint {
Vector<Message> messages; Vector<Message> messages;
}; };
static String snake_case(String const& identifier)
{
StringBuilder builder;
bool was_new_word = true;
for (auto ch : identifier) {
if (!builder.is_empty() && isupper(ch) && !was_new_word) {
builder.append('_');
was_new_word = true;
} else if (!isupper(ch))
was_new_word = false;
builder.append(tolower(ch));
}
return builder.to_string();
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
if (argc != 2) { if (argc != 2) {
@ -540,24 +555,38 @@ public:
switch (message.message_id()) { switch (message.message_id()) {
)~~~"); )~~~");
for (auto& message : endpoint.messages) { for (auto& message : endpoint.messages) {
auto do_handle_message = [&](const String& name, bool returns_something) { auto do_handle_message = [&](String const& name, Vector<Parameter> const& parameters, bool returns_something) {
auto message_generator = endpoint_generator.fork(); auto message_generator = endpoint_generator.fork();
StringBuilder argument_generator;
for (size_t i = 0; i < parameters.size(); ++i) {
auto& parameter = parameters[i];
argument_generator.append("request.");
argument_generator.append(parameter.name);
argument_generator.append("()");
if (i != parameters.size() - 1)
argument_generator.append(", ");
}
message_generator.set("message.name", name); message_generator.set("message.name", name);
message_generator.set("message.response_type", message.response_name()); message_generator.set("message.response_type", message.response_name());
message_generator.set("handler_name", snake_case(name));
message_generator.set("arguments", argument_generator.to_string());
message_generator.append(R"~~~( message_generator.append(R"~~~(
case (int)Messages::@endpoint.name@::MessageID::@message.name@: { case (int)Messages::@endpoint.name@::MessageID::@message.name@: {
)~~~"); )~~~");
if (returns_something) { if (returns_something) {
if (message.outputs.is_empty()) { if (message.outputs.is_empty()) {
message_generator.append(R"~~~( message_generator.append(R"~~~(
handle(static_cast<const Messages::@endpoint.name@::@message.name@&>(message)); [[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.name@&>(message);
@handler_name@(@arguments@);
auto response = Messages::@endpoint.name@::@message.response_type@ { }; auto response = Messages::@endpoint.name@::@message.response_type@ { };
return make<IPC::MessageBuffer>(response.encode()); return make<IPC::MessageBuffer>(response.encode());
)~~~"); )~~~");
} else { } else {
message_generator.append(R"~~~( message_generator.append(R"~~~(
auto response = handle(static_cast<const Messages::@endpoint.name@::@message.name@&>(message)); [[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.name@&>(message);
auto response = @handler_name@(@arguments@);
if (!response.valid()) if (!response.valid())
return {}; return {};
return make<IPC::MessageBuffer>(response.encode()); return make<IPC::MessageBuffer>(response.encode());
@ -565,7 +594,8 @@ public:
} }
} else { } else {
message_generator.append(R"~~~( message_generator.append(R"~~~(
handle(static_cast<const Messages::@endpoint.name@::@message.name@&>(message)); [[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.name@&>(message);
@handler_name@(@arguments@);
return {}; return {};
)~~~"); )~~~");
} }
@ -573,9 +603,9 @@ public:
} }
)~~~"); )~~~");
}; };
do_handle_message(message.name, message.is_synchronous); do_handle_message(message.name, message.inputs, message.is_synchronous);
if (message.is_synchronous) if (message.is_synchronous)
do_handle_message(message.response_name(), false); do_handle_message(message.response_name(), message.outputs, false);
} }
endpoint_generator.append(R"~~~( endpoint_generator.append(R"~~~(
default: default:
@ -587,23 +617,61 @@ public:
for (auto& message : endpoint.messages) { for (auto& message : endpoint.messages) {
auto message_generator = endpoint_generator.fork(); auto message_generator = endpoint_generator.fork();
message_generator.set("message.name", message.name); auto do_handle_message_decl = [&](String const& name, Vector<Parameter> const& parameters, bool is_response) {
String return_type = "void";
if (message.is_synchronous && !message.outputs.is_empty() && !is_response) {
StringBuilder builder;
builder.append("Messages::");
builder.append(endpoint.name);
builder.append("::");
builder.append(message.name);
builder.append("Response");
return_type = builder.to_string();
}
message_generator.set("message.complex_return_type", return_type);
String return_type = "void"; message_generator.set("handler_name", snake_case(name));
if (message.is_synchronous && !message.outputs.is_empty()) { message_generator.append(R"~~~(
StringBuilder builder; virtual @message.complex_return_type@ @handler_name@()~~~");
builder.append("Messages::");
builder.append(endpoint.name);
builder.append("::");
builder.append(message.name);
builder.append("Response");
return_type = builder.to_string();
}
message_generator.set("message.complex_return_type", return_type);
message_generator.append(R"~~~( auto make_argument_type = [](String const& type) {
virtual @message.complex_return_type@ handle(const Messages::@endpoint.name@::@message.name@&) = 0; StringBuilder builder;
bool const_ref = true;
if (type == "u8" || type == "i8" || type == "u16" || type == "i16"
|| type == "u32" || type == "i32" || type == "bool" || type == "double"
|| type == "float" || type == "int" || type == "unsigned" || type == "unsigned int")
const_ref = false;
builder.append(type);
if (const_ref)
builder.append(" const&");
return builder.to_string();
};
for (size_t i = 0; i < parameters.size(); ++i) {
auto& parameter = parameters[i];
auto argument_generator = message_generator.fork();
argument_generator.set("argument.type", make_argument_type(parameter.type));
argument_generator.set("argument.name", parameter.name);
argument_generator.append("[[maybe_unused]] @argument.type@ @argument.name@");
if (i != parameters.size() - 1)
argument_generator.append(", ");
}
if (is_response) {
message_generator.append(R"~~~() { };
)~~~"); )~~~");
} else {
message_generator.append(R"~~~() = 0;
)~~~");
}
};
do_handle_message_decl(message.name, message.inputs, false);
if (message.is_synchronous)
do_handle_message_decl(message.response_name(), message.outputs, true);
} }
endpoint_generator.append(R"~~~( endpoint_generator.append(R"~~~(

12
Userland/Libraries/LibAudio/ClientConnection.cpp
View file

@ -80,22 +80,22 @@ int ClientConnection::get_playing_buffer()
return send_sync<Messages::AudioServer::GetPlayingBuffer>()->buffer_id(); return send_sync<Messages::AudioServer::GetPlayingBuffer>()->buffer_id();
} }
void ClientConnection::handle(const Messages::AudioClient::FinishedPlayingBuffer& message) void ClientConnection::finished_playing_buffer(i32 buffer_id)
{ {
if (on_finish_playing_buffer) if (on_finish_playing_buffer)
on_finish_playing_buffer(message.buffer_id()); on_finish_playing_buffer(buffer_id);
} }
void ClientConnection::handle(const Messages::AudioClient::MutedStateChanged& message) void ClientConnection::muted_state_changed(bool muted)
{ {
if (on_muted_state_change) if (on_muted_state_change)
on_muted_state_change(message.muted()); on_muted_state_change(muted);
} }
void ClientConnection::handle(const Messages::AudioClient::MainMixVolumeChanged& message) void ClientConnection::main_mix_volume_changed(i32 volume)
{ {
if (on_main_mix_volume_change) if (on_main_mix_volume_change)
on_main_mix_volume_change(message.volume()); on_main_mix_volume_change(volume);
} }
} }

6
Userland/Libraries/LibAudio/ClientConnection.h
View file

@ -42,9 +42,9 @@ public:
Function<void(int volume)> on_main_mix_volume_change; Function<void(int volume)> on_main_mix_volume_change;
private: private:
virtual void handle(const Messages::AudioClient::FinishedPlayingBuffer&) override; virtual void finished_playing_buffer(i32) override;
virtual void handle(const Messages::AudioClient::MutedStateChanged&) override; virtual void muted_state_changed(bool) override;
virtual void handle(const Messages::AudioClient::MainMixVolumeChanged&) override; virtual void main_mix_volume_changed(i32) override;
}; };
} }

2
Userland/Libraries/LibDesktop/Launcher.cpp
View file

@ -48,7 +48,7 @@ private:
: IPC::ServerConnection<LaunchClientEndpoint, LaunchServerEndpoint>(*this, "/tmp/portal/launch") : IPC::ServerConnection<LaunchClientEndpoint, LaunchServerEndpoint>(*this, "/tmp/portal/launch")
{ {
} }
virtual void handle(const Messages::LaunchClient::Dummy&) override { } virtual void dummy() override { }
}; };
static LaunchServerConnection& connection() static LaunchServerConnection& connection()

6
Userland/Libraries/LibGUI/Clipboard.cpp
View file

@ -27,7 +27,7 @@ private:
: IPC::ServerConnection<ClipboardClientEndpoint, ClipboardServerEndpoint>(*this, "/tmp/portal/clipboard") : IPC::ServerConnection<ClipboardClientEndpoint, ClipboardServerEndpoint>(*this, "/tmp/portal/clipboard")
{ {
} }
virtual void handle(const Messages::ClipboardClient::ClipboardDataChanged&) override; virtual void clipboard_data_changed(String const& mime_type) override;
}; };
Clipboard& Clipboard::the() Clipboard& Clipboard::the()
@ -78,11 +78,11 @@ void Clipboard::set_data(ReadonlyBytes data, const String& type, const HashMap<S
connection().send_sync<Messages::ClipboardServer::SetClipboardData>(move(buffer), type, metadata); connection().send_sync<Messages::ClipboardServer::SetClipboardData>(move(buffer), type, metadata);
} }
void ClipboardServerConnection::handle(const Messages::ClipboardClient::ClipboardDataChanged& message) void ClipboardServerConnection::clipboard_data_changed(String const& mime_type)
{ {
auto& clipboard = Clipboard::the(); auto& clipboard = Clipboard::the();
if (clipboard.on_change) if (clipboard.on_change)
clipboard.on_change(message.mime_type()); clipboard.on_change(mime_type);
} }
RefPtr<Gfx::Bitmap> Clipboard::bitmap() const RefPtr<Gfx::Bitmap> Clipboard::bitmap() const

2
Userland/Libraries/LibGUI/Notification.cpp
View file

@ -34,7 +34,7 @@ private:
, m_notification(notification) , m_notification(notification)
{ {
} }
virtual void handle(const Messages::NotificationClient::Dummy&) override { } virtual void dummy() override { }
Notification* m_notification; Notification* m_notification;
}; };

38
Userland/Libraries/LibGUI/WindowManagerServerConnection.cpp
View file

@ -24,40 +24,42 @@ void WindowManagerServerConnection::handshake()
// :^) // :^)
} }
void WindowManagerServerConnection::handle(const Messages::WindowManagerClient::WindowStateChanged& message) void WindowManagerServerConnection::window_state_changed(i32 wm_id, i32 client_id, i32 window_id,
i32 parent_client_id, i32 parent_window_id, bool is_active, bool is_minimized, bool is_modal,
bool is_frameless, i32 window_type, String const& title, Gfx::IntRect const& rect, Optional<i32> const& progress)
{ {
if (auto* window = Window::from_window_id(message.wm_id())) if (auto* window = Window::from_window_id(wm_id))
Core::EventLoop::current().post_event(*window, make<WMWindowStateChangedEvent>(message.client_id(), message.window_id(), message.parent_client_id(), message.parent_window_id(), message.title(), message.rect(), message.is_active(), message.is_modal(), static_cast<WindowType>(message.window_type()), message.is_minimized(), message.is_frameless(), message.progress())); Core::EventLoop::current().post_event(*window, make<WMWindowStateChangedEvent>(client_id, window_id, parent_client_id, parent_window_id, title, rect, is_active, is_modal, static_cast<WindowType>(window_type), is_minimized, is_frameless, progress));
} }
void WindowManagerServerConnection::handle(const Messages::WindowManagerClient::AppletAreaSizeChanged& message) void WindowManagerServerConnection::applet_area_size_changed(i32 wm_id, const Gfx::IntSize& size)
{ {
if (auto* window = Window::from_window_id(message.wm_id())) if (auto* window = Window::from_window_id(wm_id))
Core::EventLoop::current().post_event(*window, make<WMAppletAreaSizeChangedEvent>(message.size())); Core::EventLoop::current().post_event(*window, make<WMAppletAreaSizeChangedEvent>(size));
} }
void WindowManagerServerConnection::handle(const Messages::WindowManagerClient::WindowRectChanged& message) void WindowManagerServerConnection::window_rect_changed(i32 wm_id, i32 client_id, i32 window_id, Gfx::IntRect const& rect)
{ {
if (auto* window = Window::from_window_id(message.wm_id())) if (auto* window = Window::from_window_id(wm_id))
Core::EventLoop::current().post_event(*window, make<WMWindowRectChangedEvent>(message.client_id(), message.window_id(), message.rect())); Core::EventLoop::current().post_event(*window, make<WMWindowRectChangedEvent>(client_id, window_id, rect));
} }
void WindowManagerServerConnection::handle(const Messages::WindowManagerClient::WindowIconBitmapChanged& message) void WindowManagerServerConnection::window_icon_bitmap_changed(i32 wm_id, i32 client_id, i32 window_id, Gfx::ShareableBitmap const& bitmap)
{ {
if (auto* window = Window::from_window_id(message.wm_id())) { if (auto* window = Window::from_window_id(wm_id)) {
Core::EventLoop::current().post_event(*window, make<WMWindowIconBitmapChangedEvent>(message.client_id(), message.window_id(), message.bitmap().bitmap())); Core::EventLoop::current().post_event(*window, make<WMWindowIconBitmapChangedEvent>(client_id, window_id, bitmap.bitmap()));
} }
} }
void WindowManagerServerConnection::handle(const Messages::WindowManagerClient::WindowRemoved& message) void WindowManagerServerConnection::window_removed(i32 wm_id, i32 client_id, i32 window_id)
{ {
if (auto* window = Window::from_window_id(message.wm_id())) if (auto* window = Window::from_window_id(wm_id))
Core::EventLoop::current().post_event(*window, make<WMWindowRemovedEvent>(message.client_id(), message.window_id())); Core::EventLoop::current().post_event(*window, make<WMWindowRemovedEvent>(client_id, window_id));
} }
void WindowManagerServerConnection::handle(const Messages::WindowManagerClient::SuperKeyPressed& message) void WindowManagerServerConnection::super_key_pressed(i32 wm_id)
{ {
if (auto* window = Window::from_window_id(message.wm_id())) if (auto* window = Window::from_window_id(wm_id))
Core::EventLoop::current().post_event(*window, make<WMSuperKeyPressedEvent>(message.wm_id())); Core::EventLoop::current().post_event(*window, make<WMSuperKeyPressedEvent>(wm_id));
} }
} }

12
Userland/Libraries/LibGUI/WindowManagerServerConnection.h
View file

@ -27,12 +27,12 @@ public:
static WindowManagerServerConnection& the(); static WindowManagerServerConnection& the();
private: private:
virtual void handle(const Messages::WindowManagerClient::WindowRemoved&) override; virtual void window_removed(i32, i32, i32) override;
virtual void handle(const Messages::WindowManagerClient::WindowStateChanged&) override; virtual void window_state_changed(i32, i32, i32, i32, i32, bool, bool, bool, bool, i32, String const&, Gfx::IntRect const&, Optional<i32> const&) override;
virtual void handle(const Messages::WindowManagerClient::WindowIconBitmapChanged&) override; virtual void window_icon_bitmap_changed(i32, i32, i32, Gfx::ShareableBitmap const&) override;
virtual void handle(const Messages::WindowManagerClient::WindowRectChanged&) override; virtual void window_rect_changed(i32, i32, i32, Gfx::IntRect const&) override;
virtual void handle(const Messages::WindowManagerClient::AppletAreaSizeChanged&) override; virtual void applet_area_size_changed(i32, Gfx::IntSize const&) override;
virtual void handle(const Messages::WindowManagerClient::SuperKeyPressed&) override; virtual void super_key_pressed(i32) override;
}; };
} }

160
Userland/Libraries/LibGUI/WindowServerConnection.cpp
View file

@ -47,77 +47,77 @@ void WindowServerConnection::handshake()
Desktop::the().did_receive_screen_rect({}, response->screen_rect()); Desktop::the().did_receive_screen_rect({}, response->screen_rect());
} }
void WindowServerConnection::handle(const Messages::WindowClient::UpdateSystemTheme& message) void WindowServerConnection::update_system_theme(Core::AnonymousBuffer const& theme_buffer)
{ {
set_system_theme_from_anonymous_buffer(message.theme_buffer()); set_system_theme_from_anonymous_buffer(theme_buffer);
Window::update_all_windows({}); Window::update_all_windows({});
Window::for_each_window({}, [](auto& window) { Window::for_each_window({}, [](auto& window) {
Core::EventLoop::current().post_event(window, make<ThemeChangeEvent>()); Core::EventLoop::current().post_event(window, make<ThemeChangeEvent>());
}); });
} }
void WindowServerConnection::handle(const Messages::WindowClient::Paint& message) void WindowServerConnection::paint(i32 window_id, Gfx::IntSize const& window_size, Vector<Gfx::IntRect> const& rects)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<MultiPaintEvent>(message.rects(), message.window_size())); Core::EventLoop::current().post_event(*window, make<MultiPaintEvent>(rects, window_size));
} }
void WindowServerConnection::handle(const Messages::WindowClient::WindowResized& message) void WindowServerConnection::window_resized(i32 window_id, Gfx::IntRect const& new_rect)
{ {
if (auto* window = Window::from_window_id(message.window_id())) { if (auto* window = Window::from_window_id(window_id)) {
Core::EventLoop::current().post_event(*window, make<ResizeEvent>(message.new_rect().size())); Core::EventLoop::current().post_event(*window, make<ResizeEvent>(new_rect.size()));
} }
} }
void WindowServerConnection::handle(const Messages::WindowClient::WindowActivated& message) void WindowServerConnection::window_activated(i32 window_id)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowBecameActive)); Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowBecameActive));
} }
void WindowServerConnection::handle(const Messages::WindowClient::WindowDeactivated& message) void WindowServerConnection::window_deactivated(i32 window_id)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowBecameInactive)); Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowBecameInactive));
} }
void WindowServerConnection::handle(const Messages::WindowClient::WindowInputEntered& message) void WindowServerConnection::window_input_entered(i32 window_id)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowInputEntered)); Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowInputEntered));
} }
void WindowServerConnection::handle(const Messages::WindowClient::WindowInputLeft& message) void WindowServerConnection::window_input_left(i32 window_id)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowInputLeft)); Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowInputLeft));
} }
void WindowServerConnection::handle(const Messages::WindowClient::WindowCloseRequest& message) void WindowServerConnection::window_close_request(i32 window_id)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowCloseRequest)); Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowCloseRequest));
} }
void WindowServerConnection::handle(const Messages::WindowClient::WindowEntered& message) void WindowServerConnection::window_entered(i32 window_id)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowEntered)); Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowEntered));
} }
void WindowServerConnection::handle(const Messages::WindowClient::WindowLeft& message) void WindowServerConnection::window_left(i32 window_id)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowLeft)); Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowLeft));
} }
void WindowServerConnection::handle(const Messages::WindowClient::KeyDown& message) void WindowServerConnection::key_down(i32 window_id, u32 code_point, u32 key, u32 modifiers, u32 scancode)
{ {
auto* window = Window::from_window_id(message.window_id()); auto* window = Window::from_window_id(window_id);
if (!window) if (!window)
return; return;
auto key_event = make<KeyEvent>(Event::KeyDown, (KeyCode)message.key(), message.modifiers(), message.code_point(), message.scancode()); auto key_event = make<KeyEvent>(Event::KeyDown, (KeyCode)key, modifiers, code_point, scancode);
Action* action = nullptr; Action* action = nullptr;
dbgln_if(KEYBOARD_SHORTCUTS_DEBUG, "Looking up action for {}", key_event->to_string()); dbgln_if(KEYBOARD_SHORTCUTS_DEBUG, "Looking up action for {}", key_event->to_string());
@ -151,7 +151,7 @@ void WindowServerConnection::handle(const Messages::WindowClient::KeyDown& messa
} }
bool focused_widget_accepts_emoji_input = window->focused_widget() && window->focused_widget()->accepts_emoji_input(); bool focused_widget_accepts_emoji_input = window->focused_widget() && window->focused_widget()->accepts_emoji_input();
if (focused_widget_accepts_emoji_input && (message.modifiers() == (Mod_Ctrl | Mod_Alt)) && message.key() == Key_Space) { if (focused_widget_accepts_emoji_input && (modifiers == (Mod_Ctrl | Mod_Alt)) && key == Key_Space) {
auto emoji_input_dialog = EmojiInputDialog::construct(window); auto emoji_input_dialog = EmojiInputDialog::construct(window);
if (emoji_input_dialog->exec() != EmojiInputDialog::ExecOK) if (emoji_input_dialog->exec() != EmojiInputDialog::ExecOK)
return; return;
@ -159,21 +159,21 @@ void WindowServerConnection::handle(const Messages::WindowClient::KeyDown& messa
key_event->m_modifiers = 0; key_event->m_modifiers = 0;
Utf8View m_utf8_view(emoji_input_dialog->selected_emoji_text().characters()); Utf8View m_utf8_view(emoji_input_dialog->selected_emoji_text().characters());
u32 code_point = *m_utf8_view.begin(); u32 emoji_code_point = *m_utf8_view.begin();
key_event->m_code_point = code_point; key_event->m_code_point = emoji_code_point;
} }
Core::EventLoop::current().post_event(*window, move(key_event)); Core::EventLoop::current().post_event(*window, move(key_event));
} }
void WindowServerConnection::handle(const Messages::WindowClient::KeyUp& message) void WindowServerConnection::key_up(i32 window_id, u32 code_point, u32 key, u32 modifiers, u32 scancode)
{ {
auto* window = Window::from_window_id(message.window_id()); auto* window = Window::from_window_id(window_id);
if (!window) if (!window)
return; return;
auto key_event = make<KeyEvent>(Event::KeyUp, (KeyCode)message.key(), message.modifiers(), message.code_point(), message.scancode()); auto key_event = make<KeyEvent>(Event::KeyUp, (KeyCode)key, modifiers, code_point, scancode);
Core::EventLoop::current().post_event(*window, move(key_event)); Core::EventLoop::current().post_event(*window, move(key_event));
} }
@ -198,69 +198,69 @@ static MouseButton to_gmousebutton(u32 button)
} }
} }
void WindowServerConnection::handle(const Messages::WindowClient::MouseDown& message) void WindowServerConnection::mouse_down(i32 window_id, Gfx::IntPoint const& mouse_position, u32 button, u32 buttons, u32 modifiers, i32 wheel_delta)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseDown, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta())); Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseDown, mouse_position, buttons, to_gmousebutton(button), modifiers, wheel_delta));
} }
void WindowServerConnection::handle(const Messages::WindowClient::MouseUp& message) void WindowServerConnection::mouse_up(i32 window_id, Gfx::IntPoint const& mouse_position, u32 button, u32 buttons, u32 modifiers, i32 wheel_delta)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseUp, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta())); Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseUp, mouse_position, buttons, to_gmousebutton(button), modifiers, wheel_delta));
} }
void WindowServerConnection::handle(const Messages::WindowClient::MouseMove& message) void WindowServerConnection::mouse_move(i32 window_id, Gfx::IntPoint const& mouse_position, u32 button, u32 buttons, u32 modifiers, i32 wheel_delta, bool is_drag, Vector<String> const& mime_types)
{ {
if (auto* window = Window::from_window_id(message.window_id())) { if (auto* window = Window::from_window_id(window_id)) {
if (message.is_drag()) if (is_drag)
Core::EventLoop::current().post_event(*window, make<DragEvent>(Event::DragMove, message.mouse_position(), message.mime_types())); Core::EventLoop::current().post_event(*window, make<DragEvent>(Event::DragMove, mouse_position, mime_types));
else else
Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseMove, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta())); Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseMove, mouse_position, buttons, to_gmousebutton(button), modifiers, wheel_delta));
} }
} }
void WindowServerConnection::handle(const Messages::WindowClient::MouseDoubleClick& message) void WindowServerConnection::mouse_double_click(i32 window_id, Gfx::IntPoint const& mouse_position, u32 button, u32 buttons, u32 modifiers, i32 wheel_delta)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseDoubleClick, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta())); Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseDoubleClick, mouse_position, buttons, to_gmousebutton(button), modifiers, wheel_delta));
} }
void WindowServerConnection::handle(const Messages::WindowClient::MouseWheel& message) void WindowServerConnection::mouse_wheel(i32 window_id, Gfx::IntPoint const& mouse_position, u32 button, u32 buttons, u32 modifiers, i32 wheel_delta)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseWheel, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta())); Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseWheel, mouse_position, buttons, to_gmousebutton(button), modifiers, wheel_delta));
} }
void WindowServerConnection::handle(const Messages::WindowClient::MenuVisibilityDidChange& message) void WindowServerConnection::menu_visibility_did_change(i32 menu_id, bool visible)
{ {
auto* menu = Menu::from_menu_id(message.menu_id()); auto* menu = Menu::from_menu_id(menu_id);
if (!menu) { if (!menu) {
dbgln("EventLoop received visibility change event for invalid menu ID {}", message.menu_id()); dbgln("EventLoop received visibility change event for invalid menu ID {}", menu_id);
return; return;
} }
menu->visibility_did_change({}, message.visible()); menu->visibility_did_change({}, visible);
} }
void WindowServerConnection::handle(const Messages::WindowClient::MenuItemActivated& message) void WindowServerConnection::menu_item_activated(i32 menu_id, u32 identifier)
{ {
auto* menu = Menu::from_menu_id(message.menu_id()); auto* menu = Menu::from_menu_id(menu_id);
if (!menu) { if (!menu) {
dbgln("EventLoop received event for invalid menu ID {}", message.menu_id()); dbgln("EventLoop received event for invalid menu ID {}", menu_id);
return; return;
} }
if (auto* action = menu->action_at(message.identifier())) if (auto* action = menu->action_at(identifier))
action->activate(menu); action->activate(menu);
} }
void WindowServerConnection::handle(Messages::WindowClient::MenuItemEntered const& message) void WindowServerConnection::menu_item_entered(i32 menu_id, u32 identifier)
{ {
auto* menu = Menu::from_menu_id(message.menu_id()); auto* menu = Menu::from_menu_id(menu_id);
if (!menu) { if (!menu) {
dbgln("WindowServerConnection received MenuItemEntered for invalid menu ID {}", message.menu_id()); dbgln("WindowServerConnection received MenuItemEntered for invalid menu ID {}", menu_id);
return; return;
} }
auto* action = menu->action_at(message.identifier()); auto* action = menu->action_at(identifier);
if (!action) if (!action)
return; return;
auto* app = Application::the(); auto* app = Application::the();
@ -269,14 +269,14 @@ void WindowServerConnection::handle(Messages::WindowClient::MenuItemEntered cons
Core::EventLoop::current().post_event(*app, make<ActionEvent>(GUI::Event::ActionEnter, *action)); Core::EventLoop::current().post_event(*app, make<ActionEvent>(GUI::Event::ActionEnter, *action));
} }
void WindowServerConnection::handle(Messages::WindowClient::MenuItemLeft const& message) void WindowServerConnection::menu_item_left(i32 menu_id, u32 identifier)
{ {
auto* menu = Menu::from_menu_id(message.menu_id()); auto* menu = Menu::from_menu_id(menu_id);
if (!menu) { if (!menu) {
dbgln("WindowServerConnection received MenuItemLeft for invalid menu ID {}", message.menu_id()); dbgln("WindowServerConnection received MenuItemLeft for invalid menu ID {}", menu_id);
return; return;
} }
auto* action = menu->action_at(message.identifier()); auto* action = menu->action_at(identifier);
if (!action) if (!action)
return; return;
auto* app = Application::the(); auto* app = Application::the();
@ -285,45 +285,45 @@ void WindowServerConnection::handle(Messages::WindowClient::MenuItemLeft const&
Core::EventLoop::current().post_event(*app, make<ActionEvent>(GUI::Event::ActionLeave, *action)); Core::EventLoop::current().post_event(*app, make<ActionEvent>(GUI::Event::ActionLeave, *action));
} }
void WindowServerConnection::handle(const Messages::WindowClient::ScreenRectChanged& message) void WindowServerConnection::screen_rect_changed(Gfx::IntRect const& rect)
{ {
Desktop::the().did_receive_screen_rect({}, message.rect()); Desktop::the().did_receive_screen_rect({}, rect);
Window::for_each_window({}, [message](auto& window) { Window::for_each_window({}, [rect](auto& window) {
Core::EventLoop::current().post_event(window, make<ScreenRectChangeEvent>(message.rect())); Core::EventLoop::current().post_event(window, make<ScreenRectChangeEvent>(rect));
}); });
} }
void WindowServerConnection::handle(const Messages::WindowClient::AsyncSetWallpaperFinished&) void WindowServerConnection::async_set_wallpaper_finished(bool)
{ {
// This is handled manually by Desktop::set_wallpaper(). // This is handled manually by Desktop::set_wallpaper().
} }
void WindowServerConnection::handle(const Messages::WindowClient::DragDropped& message) void WindowServerConnection::drag_dropped(i32 window_id, Gfx::IntPoint const& mouse_position, String const& text, HashMap<String, ByteBuffer> const& mime_data)
{ {
if (auto* window = Window::from_window_id(message.window_id())) { if (auto* window = Window::from_window_id(window_id)) {
auto mime_data = Core::MimeData::construct(message.mime_data()); auto mime_data_obj = Core::MimeData::construct(mime_data);
Core::EventLoop::current().post_event(*window, make<DropEvent>(message.mouse_position(), message.text(), mime_data)); Core::EventLoop::current().post_event(*window, make<DropEvent>(mouse_position, text, mime_data_obj));
} }
} }
void WindowServerConnection::handle(const Messages::WindowClient::DragAccepted&) void WindowServerConnection::drag_accepted()
{ {
DragOperation::notify_accepted({}); DragOperation::notify_accepted({});
} }
void WindowServerConnection::handle(const Messages::WindowClient::DragCancelled&) void WindowServerConnection::drag_cancelled()
{ {
DragOperation::notify_cancelled({}); DragOperation::notify_cancelled({});
Application::the()->notify_drag_cancelled({}); Application::the()->notify_drag_cancelled({});
} }
void WindowServerConnection::handle(const Messages::WindowClient::WindowStateChanged& message) void WindowServerConnection::window_state_changed(i32 window_id, bool minimized, bool occluded)
{ {
if (auto* window = Window::from_window_id(message.window_id())) if (auto* window = Window::from_window_id(window_id))
window->notify_state_changed({}, message.minimized(), message.occluded()); window->notify_state_changed({}, minimized, occluded);
} }
void WindowServerConnection::handle(const Messages::WindowClient::DisplayLinkNotification&) void WindowServerConnection::display_link_notification()
{ {
if (m_display_link_notification_pending) if (m_display_link_notification_pending)
return; return;
@ -335,7 +335,7 @@ void WindowServerConnection::handle(const Messages::WindowClient::DisplayLinkNot
}); });
} }
void WindowServerConnection::handle(const Messages::WindowClient::Ping&) void WindowServerConnection::ping()
{ {
post_message(Messages::WindowServer::Pong()); post_message(Messages::WindowServer::Pong());
} }

58
Userland/Libraries/LibGUI/WindowServerConnection.h
View file

@ -27,35 +27,35 @@ public:
static WindowServerConnection& the(); static WindowServerConnection& the();
private: private:
virtual void handle(const Messages::WindowClient::Paint&) override; virtual void paint(i32, Gfx::IntSize const&, Vector<Gfx::IntRect> const&) override;
virtual void handle(const Messages::WindowClient::MouseMove&) override; virtual void mouse_move(i32, Gfx::IntPoint const&, u32, u32, u32, i32, bool, Vector<String> const&) override;
virtual void handle(const Messages::WindowClient::MouseDown&) override; virtual void mouse_down(i32, Gfx::IntPoint const&, u32, u32, u32, i32) override;
virtual void handle(const Messages::WindowClient::MouseDoubleClick&) override; virtual void mouse_double_click(i32, Gfx::IntPoint const&, u32, u32, u32, i32) override;
virtual void handle(const Messages::WindowClient::MouseUp&) override; virtual void mouse_up(i32, Gfx::IntPoint const&, u32, u32, u32, i32) override;
virtual void handle(const Messages::WindowClient::MouseWheel&) override; virtual void mouse_wheel(i32, Gfx::IntPoint const&, u32, u32, u32, i32) override;
virtual void handle(const Messages::WindowClient::WindowEntered&) override; virtual void window_entered(i32) override;
virtual void handle(const Messages::WindowClient::WindowLeft&) override; virtual void window_left(i32) override;
virtual void handle(const Messages::WindowClient::KeyDown&) override; virtual void key_down(i32, u32, u32, u32, u32) override;
virtual void handle(const Messages::WindowClient::KeyUp&) override; virtual void key_up(i32, u32, u32, u32, u32) override;
virtual void handle(const Messages::WindowClient::WindowActivated&) override; virtual void window_activated(i32) override;
virtual void handle(const Messages::WindowClient::WindowDeactivated&) override; virtual void window_deactivated(i32) override;
virtual void handle(const Messages::WindowClient::WindowInputEntered&) override; virtual void window_input_entered(i32) override;
virtual void handle(const Messages::WindowClient::WindowInputLeft&) override; virtual void window_input_left(i32) override;
virtual void handle(const Messages::WindowClient::WindowCloseRequest&) override; virtual void window_close_request(i32) override;
virtual void handle(const Messages::WindowClient::WindowResized&) override; virtual void window_resized(i32, Gfx::IntRect const&) override;
virtual void handle(const Messages::WindowClient::MenuItemActivated&) override; virtual void menu_item_activated(i32, u32) override;
virtual void handle(const Messages::WindowClient::MenuItemEntered&) override; virtual void menu_item_entered(i32, u32) override;
virtual void handle(const Messages::WindowClient::MenuItemLeft&) override; virtual void menu_item_left(i32, u32) override;
virtual void handle(const Messages::WindowClient::MenuVisibilityDidChange&) override; virtual void menu_visibility_did_change(i32, bool) override;
virtual void handle(const Messages::WindowClient::ScreenRectChanged&) override; virtual void screen_rect_changed(Gfx::IntRect const&) override;
virtual void handle(const Messages::WindowClient::AsyncSetWallpaperFinished&) override; virtual void async_set_wallpaper_finished(bool) override;
virtual void handle(const Messages::WindowClient::DragDropped&) override; virtual void drag_dropped(i32, Gfx::IntPoint const&, String const&, HashMap<String, ByteBuffer> const&) override;
virtual void handle(const Messages::WindowClient::DragAccepted&) override; virtual void drag_accepted() override;
virtual void handle(const Messages::WindowClient::DragCancelled&) override; virtual void drag_cancelled() override;
virtual void handle(const Messages::WindowClient::UpdateSystemTheme&) override; virtual void update_system_theme(Core::AnonymousBuffer const&) override;
virtual void handle(const Messages::WindowClient::WindowStateChanged&) override; virtual void window_state_changed(i32, bool, bool) override;
virtual void handle(const Messages::WindowClient::DisplayLinkNotification&) override; virtual void display_link_notification() override;
virtual void handle(const Messages::WindowClient::Ping&) override; virtual void ping() override;
bool m_display_link_notification_pending { false }; bool m_display_link_notification_pending { false };
}; };

2
Userland/Libraries/LibImageDecoderClient/Client.cpp
View file

@ -26,7 +26,7 @@ void Client::handshake()
send_sync<Messages::ImageDecoderServer::Greet>(); send_sync<Messages::ImageDecoderServer::Greet>();
} }
void Client::handle(const Messages::ImageDecoderClient::Dummy&) void Client::dummy()
{ {
} }

2
Userland/Libraries/LibImageDecoderClient/Client.h
View file

@ -41,7 +41,7 @@ private:
virtual void die() override; virtual void die() override;
virtual void handle(const Messages::ImageDecoderClient::Dummy&) override; virtual void dummy() override;
}; };
} }

26
Userland/Libraries/LibProtocol/RequestClient.cpp
View file

@ -58,34 +58,34 @@ bool RequestClient::set_certificate(Badge<Request>, Request& request, String cer
return send_sync<Messages::RequestServer::SetCertificate>(request.id(), move(certificate), move(key))->success(); return send_sync<Messages::RequestServer::SetCertificate>(request.id(), move(certificate), move(key))->success();
} }
void RequestClient::handle(const Messages::RequestClient::RequestFinished& message) void RequestClient::request_finished(i32 request_id, bool success, u32 total_size)
{ {
RefPtr<Request> request; RefPtr<Request> request;
if ((request = m_requests.get(message.request_id()).value_or(nullptr))) { if ((request = m_requests.get(request_id).value_or(nullptr))) {
request->did_finish({}, message.success(), message.total_size()); request->did_finish({}, success, total_size);
} }
m_requests.remove(message.request_id()); m_requests.remove(request_id);
} }
void RequestClient::handle(const Messages::RequestClient::RequestProgress& message) void RequestClient::request_progress(i32 request_id, const Optional<u32>& total_size, u32 downloaded_size)
{ {
if (auto request = const_cast<Request*>(m_requests.get(message.request_id()).value_or(nullptr))) { if (auto request = const_cast<Request*>(m_requests.get(request_id).value_or(nullptr))) {
request->did_progress({}, message.total_size(), message.downloaded_size()); request->did_progress({}, total_size, downloaded_size);
} }
} }
void RequestClient::handle(const Messages::RequestClient::HeadersBecameAvailable& message) void RequestClient::headers_became_available(i32 request_id, const IPC::Dictionary& response_headers, const Optional<u32>& status_code)
{ {
if (auto request = const_cast<Request*>(m_requests.get(message.request_id()).value_or(nullptr))) { if (auto request = const_cast<Request*>(m_requests.get(request_id).value_or(nullptr))) {
HashMap<String, String, CaseInsensitiveStringTraits> headers; HashMap<String, String, CaseInsensitiveStringTraits> headers;
message.response_headers().for_each_entry([&](auto& name, auto& value) { headers.set(name, value); }); response_headers.for_each_entry([&](auto& name, auto& value) { headers.set(name, value); });
request->did_receive_headers({}, headers, message.status_code()); request->did_receive_headers({}, headers, status_code);
} }
} }
void RequestClient::handle(const Messages::RequestClient::CertificateRequested& message) void RequestClient::certificate_requested(i32 request_id)
{ {
if (auto request = const_cast<Request*>(m_requests.get(message.request_id()).value_or(nullptr))) { if (auto request = const_cast<Request*>(m_requests.get(request_id).value_or(nullptr))) {
request->did_request_certificates({}); request->did_request_certificates({});
} }
} }

8
Userland/Libraries/LibProtocol/RequestClient.h
View file

@ -33,10 +33,10 @@ public:
private: private:
RequestClient(); RequestClient();
virtual void handle(const Messages::RequestClient::RequestProgress&) override; virtual void request_progress(i32, Optional<u32> const&, u32) override;
virtual void handle(const Messages::RequestClient::RequestFinished&) override; virtual void request_finished(i32, bool, u32) override;
virtual void handle(const Messages::RequestClient::CertificateRequested&) override; virtual void certificate_requested(i32) override;
virtual void handle(const Messages::RequestClient::HeadersBecameAvailable&) override; virtual void headers_became_available(i32, IPC::Dictionary const&, Optional<u32> const&) override;
HashMap<i32, RefPtr<Request>> m_requests; HashMap<i32, RefPtr<Request>> m_requests;
}; };

26
Userland/Libraries/LibProtocol/WebSocketClient.cpp
View file

@ -62,37 +62,37 @@ bool WebSocketClient::set_certificate(Badge<WebSocket>, WebSocket& connection, S
return send_sync<Messages::WebSocketServer::SetCertificate>(connection.id(), move(certificate), move(key))->success(); return send_sync<Messages::WebSocketServer::SetCertificate>(connection.id(), move(certificate), move(key))->success();
} }
void WebSocketClient::handle(const Messages::WebSocketClient::Connected& message) void WebSocketClient::connected(i32 connection_id)
{ {
auto maybe_connection = m_connections.get(message.connection_id()); auto maybe_connection = m_connections.get(connection_id);
if (maybe_connection.has_value()) if (maybe_connection.has_value())
maybe_connection.value()->did_open({}); maybe_connection.value()->did_open({});
} }
void WebSocketClient::handle(const Messages::WebSocketClient::Received& message) void WebSocketClient::received(i32 connection_id, bool is_text, ByteBuffer const& data)
{ {
auto maybe_connection = m_connections.get(message.connection_id()); auto maybe_connection = m_connections.get(connection_id);
if (maybe_connection.has_value()) if (maybe_connection.has_value())
maybe_connection.value()->did_receive({}, message.data(), message.is_text()); maybe_connection.value()->did_receive({}, data, is_text);
} }
void WebSocketClient::handle(const Messages::WebSocketClient::Errored& message) void WebSocketClient::errored(i32 connection_id, i32 message)
{ {
auto maybe_connection = m_connections.get(message.connection_id()); auto maybe_connection = m_connections.get(connection_id);
if (maybe_connection.has_value()) if (maybe_connection.has_value())
maybe_connection.value()->did_error({}, message.message()); maybe_connection.value()->did_error({}, message);
} }
void WebSocketClient::handle(const Messages::WebSocketClient::Closed& message) void WebSocketClient::closed(i32 connection_id, u16 code, String const& reason, bool clean)
{ {
auto maybe_connection = m_connections.get(message.connection_id()); auto maybe_connection = m_connections.get(connection_id);
if (maybe_connection.has_value()) if (maybe_connection.has_value())
maybe_connection.value()->did_close({}, message.code(), message.reason(), message.clean()); maybe_connection.value()->did_close({}, code, reason, clean);
} }
void WebSocketClient::handle(const Messages::WebSocketClient::CertificateRequested& message) void WebSocketClient::certificate_requested(i32 connection_id)
{ {
auto maybe_connection = m_connections.get(message.connection_id()); auto maybe_connection = m_connections.get(connection_id);
if (maybe_connection.has_value()) if (maybe_connection.has_value())
maybe_connection.value()->did_request_certificates({}); maybe_connection.value()->did_request_certificates({});
} }

10
Userland/Libraries/LibProtocol/WebSocketClient.h
View file

@ -33,11 +33,11 @@ public:
private: private:
WebSocketClient(); WebSocketClient();
virtual void handle(const Messages::WebSocketClient::Connected&) override; virtual void connected(i32) override;
virtual void handle(const Messages::WebSocketClient::Received&) override; virtual void received(i32, bool, ByteBuffer const&) override;
virtual void handle(const Messages::WebSocketClient::Errored&) override; virtual void errored(i32, i32) override;
virtual void handle(const Messages::WebSocketClient::Closed&) override; virtual void closed(i32, u16, String const&, bool) override;
virtual void handle(const Messages::WebSocketClient::CertificateRequested&) override; virtual void certificate_requested(i32) override;
HashMap<i32, NonnullRefPtr<WebSocket>> m_connections; HashMap<i32, NonnullRefPtr<WebSocket>> m_connections;
}; };

2
Userland/Libraries/LibSymbolClient/Client.cpp
View file

@ -23,7 +23,7 @@ void Client::handshake()
send_sync<Messages::SymbolServer::Greet>(); send_sync<Messages::SymbolServer::Greet>();
} }
void Client::handle(const Messages::SymbolClient::Dummy&) void Client::dummy()
{ {
} }

2
Userland/Libraries/LibSymbolClient/Client.h
View file

@ -35,7 +35,7 @@ public:
private: private:
Client(); Client();
virtual void handle(const Messages::SymbolClient::Dummy&) override; virtual void dummy() override;
}; };
} }

116
Userland/Libraries/LibWeb/WebContentClient.cpp
View file

@ -29,156 +29,156 @@ void WebContentClient::handshake()
send_sync<Messages::WebContentServer::Greet>(); send_sync<Messages::WebContentServer::Greet>();
} }
void WebContentClient::handle(const Messages::WebContentClient::DidPaint& message) void WebContentClient::did_paint(const Gfx::IntRect&, i32 bitmap_id)
{ {
m_view.notify_server_did_paint({}, message.bitmap_id()); m_view.notify_server_did_paint({}, bitmap_id);
} }
void WebContentClient::handle([[maybe_unused]] const Messages::WebContentClient::DidFinishLoading& message) void WebContentClient::did_finish_loading(URL const& url)
{ {
m_view.notify_server_did_finish_loading({}, message.url()); m_view.notify_server_did_finish_loading({}, url);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidInvalidateContentRect& message) void WebContentClient::did_invalidate_content_rect(Gfx::IntRect const& content_rect)
{ {
dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidInvalidateContentRect! content_rect={}", message.content_rect()); dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidInvalidateContentRect! content_rect={}", content_rect);
// FIXME: Figure out a way to coalesce these messages to reduce unnecessary painting // FIXME: Figure out a way to coalesce these messages to reduce unnecessary painting
m_view.notify_server_did_invalidate_content_rect({}, message.content_rect()); m_view.notify_server_did_invalidate_content_rect({}, content_rect);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidChangeSelection&) void WebContentClient::did_change_selection()
{ {
dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidChangeSelection!"); dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidChangeSelection!");
m_view.notify_server_did_change_selection({}); m_view.notify_server_did_change_selection({});
} }
void WebContentClient::handle(const Messages::WebContentClient::DidRequestCursorChange& message) void WebContentClient::did_request_cursor_change(i32 cursor_type)
{ {
if (message.cursor_type() < 0 || message.cursor_type() >= (i32)Gfx::StandardCursor::__Count) { if (cursor_type < 0 || cursor_type >= (i32)Gfx::StandardCursor::__Count) {
dbgln("DidRequestCursorChange: Bad cursor type"); dbgln("DidRequestCursorChange: Bad cursor type");
return; return;
} }
m_view.notify_server_did_request_cursor_change({}, (Gfx::StandardCursor)message.cursor_type()); m_view.notify_server_did_request_cursor_change({}, (Gfx::StandardCursor)cursor_type);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidLayout& message) void WebContentClient::did_layout(Gfx::IntSize const& content_size)
{ {
dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidLayout! content_size={}", message.content_size()); dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidLayout! content_size={}", content_size);
m_view.notify_server_did_layout({}, message.content_size()); m_view.notify_server_did_layout({}, content_size);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidChangeTitle& message) void WebContentClient::did_change_title(String const& title)
{ {
dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidChangeTitle! title={}", message.title()); dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidChangeTitle! title={}", title);
m_view.notify_server_did_change_title({}, message.title()); m_view.notify_server_did_change_title({}, title);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidRequestScroll& message) void WebContentClient::did_request_scroll(int wheel_delta)
{ {
m_view.notify_server_did_request_scroll({}, message.wheel_delta()); m_view.notify_server_did_request_scroll({}, wheel_delta);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidRequestScrollIntoView& message) void WebContentClient::did_request_scroll_into_view(Gfx::IntRect const& rect)
{ {
dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidRequestScrollIntoView! rect={}", message.rect()); dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidRequestScrollIntoView! rect={}", rect);
m_view.notify_server_did_request_scroll_into_view({}, message.rect()); m_view.notify_server_did_request_scroll_into_view({}, rect);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidEnterTooltipArea& message) void WebContentClient::did_enter_tooltip_area(Gfx::IntPoint const& content_position, String const& title)
{ {
m_view.notify_server_did_enter_tooltip_area({}, message.content_position(), message.title()); m_view.notify_server_did_enter_tooltip_area({}, content_position, title);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidLeaveTooltipArea&) void WebContentClient::did_leave_tooltip_area()
{ {
m_view.notify_server_did_leave_tooltip_area({}); m_view.notify_server_did_leave_tooltip_area({});
} }
void WebContentClient::handle(const Messages::WebContentClient::DidHoverLink& message) void WebContentClient::did_hover_link(URL const& url)
{ {
dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidHoverLink! url={}", message.url()); dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidHoverLink! url={}", url);
m_view.notify_server_did_hover_link({}, message.url()); m_view.notify_server_did_hover_link({}, url);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidUnhoverLink&) void WebContentClient::did_unhover_link()
{ {
dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidUnhoverLink!"); dbgln_if(SPAM_DEBUG, "handle: WebContentClient::DidUnhoverLink!");
m_view.notify_server_did_unhover_link({}); m_view.notify_server_did_unhover_link({});
} }
void WebContentClient::handle(const Messages::WebContentClient::DidClickLink& message) void WebContentClient::did_click_link(URL const& url, String const& target, unsigned modifiers)
{ {
m_view.notify_server_did_click_link({}, message.url(), message.target(), message.modifiers()); m_view.notify_server_did_click_link({}, url, target, modifiers);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidMiddleClickLink& message) void WebContentClient::did_middle_click_link(URL const& url, String const& target, unsigned modifiers)
{ {
m_view.notify_server_did_middle_click_link({}, message.url(), message.target(), message.modifiers()); m_view.notify_server_did_middle_click_link({}, url, target, modifiers);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidStartLoading& message) void WebContentClient::did_start_loading(URL const& url)
{ {
m_view.notify_server_did_start_loading({}, message.url()); m_view.notify_server_did_start_loading({}, url);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidRequestContextMenu& message) void WebContentClient::did_request_context_menu(Gfx::IntPoint const& content_position)
{ {
m_view.notify_server_did_request_context_menu({}, message.content_position()); m_view.notify_server_did_request_context_menu({}, content_position);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidRequestLinkContextMenu& message) void WebContentClient::did_request_link_context_menu(Gfx::IntPoint const& content_position, URL const& url, String const& target, unsigned modifiers)
{ {
m_view.notify_server_did_request_link_context_menu({}, message.content_position(), message.url(), message.target(), message.modifiers()); m_view.notify_server_did_request_link_context_menu({}, content_position, url, target, modifiers);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidRequestImageContextMenu& message) void WebContentClient::did_request_image_context_menu(Gfx::IntPoint const& content_position, URL const& url, String const& target, unsigned modifiers, Gfx::ShareableBitmap const& bitmap)
{ {
m_view.notify_server_did_request_image_context_menu({}, message.content_position(), message.url(), message.target(), message.modifiers(), message.bitmap()); m_view.notify_server_did_request_image_context_menu({}, content_position, url, target, modifiers, bitmap);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidGetSource& message) void WebContentClient::did_get_source(URL const& url, String const& source)
{ {
m_view.notify_server_did_get_source(message.url(), message.source()); m_view.notify_server_did_get_source(url, source);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidJSConsoleOutput& message) void WebContentClient::did_jsconsole_output(String const& method, String const& line)
{ {
m_view.notify_server_did_js_console_output(message.method(), message.line()); m_view.notify_server_did_js_console_output(method, line);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidRequestAlert& message) void WebContentClient::did_request_alert(String const& message)
{ {
m_view.notify_server_did_request_alert({}, message.message()); m_view.notify_server_did_request_alert({}, message);
} }
Messages::WebContentClient::DidRequestConfirmResponse WebContentClient::handle(const Messages::WebContentClient::DidRequestConfirm& message) Messages::WebContentClient::DidRequestConfirmResponse WebContentClient::did_request_confirm(String const& message)
{ {
return m_view.notify_server_did_request_confirm({}, message.message()); return m_view.notify_server_did_request_confirm({}, message);
} }
Messages::WebContentClient::DidRequestPromptResponse WebContentClient::handle(const Messages::WebContentClient::DidRequestPrompt& message) Messages::WebContentClient::DidRequestPromptResponse WebContentClient::did_request_prompt(String const& message, String const& default_)
{ {
return m_view.notify_server_did_request_prompt({}, message.message(), message.default_()); return m_view.notify_server_did_request_prompt({}, message, default_);
} }
void WebContentClient::handle(const Messages::WebContentClient::DidChangeFavicon& message) void WebContentClient::did_change_favicon(Gfx::ShareableBitmap const& favicon)
{ {
if (!message.favicon().is_valid()) { if (!favicon.is_valid()) {
dbgln("DidChangeFavicon: Received invalid favicon"); dbgln("DidChangeFavicon: Received invalid favicon");
return; return;
} }
m_view.notify_server_did_change_favicon(*message.favicon().bitmap()); m_view.notify_server_did_change_favicon(*favicon.bitmap());
} }
Messages::WebContentClient::DidRequestCookieResponse WebContentClient::handle(const Messages::WebContentClient::DidRequestCookie& message) Messages::WebContentClient::DidRequestCookieResponse WebContentClient::did_request_cookie(URL const& url, u8 source)
{ {
return m_view.notify_server_did_request_cookie({}, message.url(), static_cast<Cookie::Source>(message.source())); return m_view.notify_server_did_request_cookie({}, url, static_cast<Cookie::Source>(source));
} }
void WebContentClient::handle(const Messages::WebContentClient::DidSetCookie& message) void WebContentClient::did_set_cookie(URL const& url, Web::Cookie::ParsedCookie const& cookie, u8 source)
{ {
m_view.notify_server_did_set_cookie({}, message.url(), message.cookie(), static_cast<Cookie::Source>(message.source())); m_view.notify_server_did_set_cookie({}, url, cookie, static_cast<Cookie::Source>(source));
} }
} }

54
Userland/Libraries/LibWeb/WebContentClient.h
View file

@ -31,33 +31,33 @@ private:
virtual void die() override; virtual void die() override;
virtual void handle(const Messages::WebContentClient::DidPaint&) override; virtual void did_paint(Gfx::IntRect const&, i32) override;
virtual void handle(const Messages::WebContentClient::DidFinishLoading&) override; virtual void did_finish_loading(URL const&) override;
virtual void handle(const Messages::WebContentClient::DidInvalidateContentRect&) override; virtual void did_invalidate_content_rect(Gfx::IntRect const&) override;
virtual void handle(const Messages::WebContentClient::DidChangeSelection&) override; virtual void did_change_selection() override;
virtual void handle(const Messages::WebContentClient::DidRequestCursorChange&) override; virtual void did_request_cursor_change(i32) override;
virtual void handle(const Messages::WebContentClient::DidLayout&) override; virtual void did_layout(Gfx::IntSize const&) override;
virtual void handle(const Messages::WebContentClient::DidChangeTitle&) override; virtual void did_change_title(String const&) override;
virtual void handle(const Messages::WebContentClient::DidRequestScroll&) override; virtual void did_request_scroll(int) override;
virtual void handle(const Messages::WebContentClient::DidRequestScrollIntoView&) override; virtual void did_request_scroll_into_view(Gfx::IntRect const&) override;
virtual void handle(const Messages::WebContentClient::DidEnterTooltipArea&) override; virtual void did_enter_tooltip_area(Gfx::IntPoint const&, String const&) override;
virtual void handle(const Messages::WebContentClient::DidLeaveTooltipArea&) override; virtual void did_leave_tooltip_area() override;
virtual void handle(const Messages::WebContentClient::DidHoverLink&) override; virtual void did_hover_link(URL const&) override;
virtual void handle(const Messages::WebContentClient::DidUnhoverLink&) override; virtual void did_unhover_link() override;
virtual void handle(const Messages::WebContentClient::DidClickLink&) override; virtual void did_click_link(URL const&, String const&, unsigned) override;
virtual void handle(const Messages::WebContentClient::DidMiddleClickLink&) override; virtual void did_middle_click_link(URL const&, String const&, unsigned) override;
virtual void handle(const Messages::WebContentClient::DidStartLoading&) override; virtual void did_start_loading(URL const&) override;
virtual void handle(const Messages::WebContentClient::DidRequestContextMenu&) override; virtual void did_request_context_menu(Gfx::IntPoint const&) override;
virtual void handle(const Messages::WebContentClient::DidRequestLinkContextMenu&) override; virtual void did_request_link_context_menu(Gfx::IntPoint const&, URL const&, String const&, unsigned) override;
virtual void handle(const Messages::WebContentClient::DidRequestImageContextMenu&) override; virtual void did_request_image_context_menu(Gfx::IntPoint const&, URL const&, String const&, unsigned, Gfx::ShareableBitmap const&) override;
virtual void handle(const Messages::WebContentClient::DidGetSource&) override; virtual void did_get_source(URL const&, String const&) override;
virtual void handle(const Messages::WebContentClient::DidJSConsoleOutput&) override; virtual void did_jsconsole_output(String const&, String const&) override;
virtual void handle(const Messages::WebContentClient::DidChangeFavicon&) override; virtual void did_change_favicon(Gfx::ShareableBitmap const&) override;
virtual void handle(const Messages::WebContentClient::DidRequestAlert&) override; virtual void did_request_alert(String const&) override;
virtual Messages::WebContentClient::DidRequestConfirmResponse handle(const Messages::WebContentClient::DidRequestConfirm&) override; virtual Messages::WebContentClient::DidRequestConfirmResponse did_request_confirm(String const&) override;
virtual Messages::WebContentClient::DidRequestPromptResponse handle(const Messages::WebContentClient::DidRequestPrompt&) override; virtual Messages::WebContentClient::DidRequestPromptResponse did_request_prompt(String const&, String const&) override;
virtual Messages::WebContentClient::DidRequestCookieResponse handle(const Messages::WebContentClient::DidRequestCookie&) override; virtual Messages::WebContentClient::DidRequestCookieResponse did_request_cookie(URL const&, u8) override;
virtual void handle(const Messages::WebContentClient::DidSetCookie&) override; virtual void did_set_cookie(URL const&, Web::Cookie::ParsedCookie const&, u8) override;
OutOfProcessWebView& m_view; OutOfProcessWebView& m_view;
}; };

32
Userland/Services/AudioServer/ClientConnection.cpp
View file

@ -59,21 +59,21 @@ void ClientConnection::did_change_main_mix_volume(Badge<Mixer>, int volume)
post_message(Messages::AudioClient::MainMixVolumeChanged(volume)); post_message(Messages::AudioClient::MainMixVolumeChanged(volume));
} }
void ClientConnection::handle(const Messages::AudioServer::Greet&) void ClientConnection::greet()
{ {
} }
Messages::AudioServer::GetMainMixVolumeResponse ClientConnection::handle(const Messages::AudioServer::GetMainMixVolume&) Messages::AudioServer::GetMainMixVolumeResponse ClientConnection::get_main_mix_volume()
{ {
return m_mixer.main_volume(); return m_mixer.main_volume();
} }
void ClientConnection::handle(const Messages::AudioServer::SetMainMixVolume& message) void ClientConnection::set_main_mix_volume(i32 volume)
{ {
m_mixer.set_main_volume(message.volume()); m_mixer.set_main_volume(volume);
} }
Messages::AudioServer::EnqueueBufferResponse ClientConnection::handle(const Messages::AudioServer::EnqueueBuffer& message) Messages::AudioServer::EnqueueBufferResponse ClientConnection::enqueue_buffer(Core::AnonymousBuffer const& buffer, i32 buffer_id, int sample_count)
{ {
if (!m_queue) if (!m_queue)
m_queue = m_mixer.create_queue(*this); m_queue = m_mixer.create_queue(*this);
@ -81,11 +81,11 @@ Messages::AudioServer::EnqueueBufferResponse ClientConnection::handle(const Mess
if (m_queue->is_full()) if (m_queue->is_full())
return false; return false;
m_queue->enqueue(Audio::Buffer::create_with_anonymous_buffer(message.buffer(), message.buffer_id(), message.sample_count())); m_queue->enqueue(Audio::Buffer::create_with_anonymous_buffer(buffer, buffer_id, sample_count));
return true; return true;
} }
Messages::AudioServer::GetRemainingSamplesResponse ClientConnection::handle(const Messages::AudioServer::GetRemainingSamples&) Messages::AudioServer::GetRemainingSamplesResponse ClientConnection::get_remaining_samples()
{ {
int remaining = 0; int remaining = 0;
if (m_queue) if (m_queue)
@ -94,7 +94,7 @@ Messages::AudioServer::GetRemainingSamplesResponse ClientConnection::handle(cons
return remaining; return remaining;
} }
Messages::AudioServer::GetPlayedSamplesResponse ClientConnection::handle(const Messages::AudioServer::GetPlayedSamples&) Messages::AudioServer::GetPlayedSamplesResponse ClientConnection::get_played_samples()
{ {
int played = 0; int played = 0;
if (m_queue) if (m_queue)
@ -103,19 +103,19 @@ Messages::AudioServer::GetPlayedSamplesResponse ClientConnection::handle(const M
return played; return played;
} }
void ClientConnection::handle(const Messages::AudioServer::SetPaused& message) void ClientConnection::set_paused(bool paused)
{ {
if (m_queue) if (m_queue)
m_queue->set_paused(message.paused()); m_queue->set_paused(paused);
} }
void ClientConnection::handle(const Messages::AudioServer::ClearBuffer& message) void ClientConnection::clear_buffer(bool paused)
{ {
if (m_queue) if (m_queue)
m_queue->clear(message.paused()); m_queue->clear(paused);
} }
Messages::AudioServer::GetPlayingBufferResponse ClientConnection::handle(const Messages::AudioServer::GetPlayingBuffer&) Messages::AudioServer::GetPlayingBufferResponse ClientConnection::get_playing_buffer()
{ {
int id = -1; int id = -1;
if (m_queue) if (m_queue)
@ -123,13 +123,13 @@ Messages::AudioServer::GetPlayingBufferResponse ClientConnection::handle(const M
return id; return id;
} }
Messages::AudioServer::GetMutedResponse ClientConnection::handle(const Messages::AudioServer::GetMuted&) Messages::AudioServer::GetMutedResponse ClientConnection::get_muted()
{ {
return m_mixer.is_muted(); return m_mixer.is_muted();
} }
void ClientConnection::handle(const Messages::AudioServer::SetMuted& message) void ClientConnection::set_muted(bool muted)
{ {
m_mixer.set_muted(message.muted()); m_mixer.set_muted(muted);
} }
} }

22
Userland/Services/AudioServer/ClientConnection.h
View file

@ -36,17 +36,17 @@ public:
static void for_each(Function<void(ClientConnection&)>); static void for_each(Function<void(ClientConnection&)>);
private: private:
virtual void handle(const Messages::AudioServer::Greet&) override; virtual void greet() override;
virtual Messages::AudioServer::GetMainMixVolumeResponse handle(const Messages::AudioServer::GetMainMixVolume&) override; virtual Messages::AudioServer::GetMainMixVolumeResponse get_main_mix_volume() override;
virtual void handle(const Messages::AudioServer::SetMainMixVolume&) override; virtual void set_main_mix_volume(i32) override;
virtual Messages::AudioServer::EnqueueBufferResponse handle(const Messages::AudioServer::EnqueueBuffer&) override; virtual Messages::AudioServer::EnqueueBufferResponse enqueue_buffer(Core::AnonymousBuffer const&, i32, int) override;
virtual Messages::AudioServer::GetRemainingSamplesResponse handle(const Messages::AudioServer::GetRemainingSamples&) override; virtual Messages::AudioServer::GetRemainingSamplesResponse get_remaining_samples() override;
virtual Messages::AudioServer::GetPlayedSamplesResponse handle(const Messages::AudioServer::GetPlayedSamples&) override; virtual Messages::AudioServer::GetPlayedSamplesResponse get_played_samples() override;
virtual void handle(const Messages::AudioServer::SetPaused&) override; virtual void set_paused(bool) override;
virtual void handle(const Messages::AudioServer::ClearBuffer&) override; virtual void clear_buffer(bool) override;
virtual Messages::AudioServer::GetPlayingBufferResponse handle(const Messages::AudioServer::GetPlayingBuffer&) override; virtual Messages::AudioServer::GetPlayingBufferResponse get_playing_buffer() override;
virtual Messages::AudioServer::GetMutedResponse handle(const Messages::AudioServer::GetMuted&) override; virtual Messages::AudioServer::GetMutedResponse get_muted() override;
virtual void handle(const Messages::AudioServer::SetMuted&) override; virtual void set_muted(bool) override;
Mixer& m_mixer; Mixer& m_mixer;
RefPtr<BufferQueue> m_queue; RefPtr<BufferQueue> m_queue;

8
Userland/Services/Clipboard/ClientConnection.cpp
View file

@ -35,16 +35,16 @@ void ClientConnection::die()
s_connections.remove(client_id()); s_connections.remove(client_id());
} }
void ClientConnection::handle(const Messages::ClipboardServer::Greet&) void ClientConnection::greet()
{ {
} }
void ClientConnection::handle(const Messages::ClipboardServer::SetClipboardData& message) void ClientConnection::set_clipboard_data(Core::AnonymousBuffer const& data, String const& mime_type, IPC::Dictionary const& metadata)
{ {
Storage::the().set_data(message.data(), message.mime_type(), message.metadata().entries()); Storage::the().set_data(data, mime_type, metadata.entries());
} }
Messages::ClipboardServer::GetClipboardDataResponse ClientConnection::handle(const Messages::ClipboardServer::GetClipboardData&) Messages::ClipboardServer::GetClipboardDataResponse ClientConnection::get_clipboard_data()
{ {
auto& storage = Storage::the(); auto& storage = Storage::the();
return { storage.buffer(), storage.mime_type(), storage.metadata() }; return { storage.buffer(), storage.mime_type(), storage.metadata() };

6
Userland/Services/Clipboard/ClientConnection.h
View file

@ -30,9 +30,9 @@ public:
void notify_about_clipboard_change(); void notify_about_clipboard_change();
private: private:
virtual void handle(const Messages::ClipboardServer::Greet&) override; virtual void greet() override;
virtual Messages::ClipboardServer::GetClipboardDataResponse handle(const Messages::ClipboardServer::GetClipboardData&) override; virtual Messages::ClipboardServer::GetClipboardDataResponse get_clipboard_data() override;
virtual void handle(const Messages::ClipboardServer::SetClipboardData&) override; virtual void set_clipboard_data(Core::AnonymousBuffer const&, String const&, IPC::Dictionary const&) override;
}; };
} }

5
Userland/Services/ImageDecoder/ClientConnection.cpp
View file

@ -30,13 +30,12 @@ void ClientConnection::die()
exit(0); exit(0);
} }
void ClientConnection::handle(const Messages::ImageDecoderServer::Greet&) void ClientConnection::greet()
{ {
} }
Messages::ImageDecoderServer::DecodeImageResponse ClientConnection::handle(const Messages::ImageDecoderServer::DecodeImage& message) Messages::ImageDecoderServer::DecodeImageResponse ClientConnection::decode_image(Core::AnonymousBuffer const& encoded_buffer)
{ {
auto encoded_buffer = message.data();
if (!encoded_buffer.is_valid()) { if (!encoded_buffer.is_valid()) {
dbgln_if(IMAGE_DECODER_DEBUG, "Encoded data is invalid"); dbgln_if(IMAGE_DECODER_DEBUG, "Encoded data is invalid");
return nullptr; return nullptr;

4
Userland/Services/ImageDecoder/ClientConnection.h
View file

@ -27,8 +27,8 @@ public:
virtual void die() override; virtual void die() override;
private: private:
virtual void handle(const Messages::ImageDecoderServer::Greet&) override; virtual void greet() override;
virtual Messages::ImageDecoderServer::DecodeImageResponse handle(const Messages::ImageDecoderServer::DecodeImage&) override; virtual Messages::ImageDecoderServer::DecodeImageResponse decode_image(Core::AnonymousBuffer const&) override;
}; };
} }

41
Userland/Services/LaunchServer/ClientConnection.cpp
View file

@ -28,18 +28,18 @@ void ClientConnection::die()
s_connections.remove(client_id()); s_connections.remove(client_id());
} }
void ClientConnection::handle(const Messages::LaunchServer::Greet&) void ClientConnection::greet()
{ {
} }
Messages::LaunchServer::OpenURLResponse ClientConnection::handle(const Messages::LaunchServer::OpenURL& request) Messages::LaunchServer::OpenURLResponse ClientConnection::open_url(URL const& url, String const& handler_name)
{ {
if (!m_allowlist.is_empty()) { if (!m_allowlist.is_empty()) {
bool allowed = false; bool allowed = false;
auto request_url_without_fragment = request.url(); auto request_url_without_fragment = url;
request_url_without_fragment.set_fragment({}); request_url_without_fragment.set_fragment({});
for (auto& allowed_handler : m_allowlist) { for (auto& allowed_handler : m_allowlist) {
if (allowed_handler.handler_name == request.handler_name() if (allowed_handler.handler_name == handler_name
&& (allowed_handler.any_url || allowed_handler.urls.contains_slow(request_url_without_fragment))) { && (allowed_handler.any_url || allowed_handler.urls.contains_slow(request_url_without_fragment))) {
allowed = true; allowed = true;
break; break;
@ -47,78 +47,75 @@ Messages::LaunchServer::OpenURLResponse ClientConnection::handle(const Messages:
} }
if (!allowed) { if (!allowed) {
// You are not on the list, go home! // You are not on the list, go home!
did_misbehave(String::formatted("Client requested a combination of handler/URL that was not on the list: '{}' with '{}'", request.handler_name(), request.url()).characters()); did_misbehave(String::formatted("Client requested a combination of handler/URL that was not on the list: '{}' with '{}'", handler_name, url).characters());
return nullptr; return nullptr;
} }
} }
URL url(request.url()); return Launcher::the().open_url(url, handler_name);
return Launcher::the().open_url(url, request.handler_name());
} }
Messages::LaunchServer::GetHandlersForURLResponse ClientConnection::handle(const Messages::LaunchServer::GetHandlersForURL& request) Messages::LaunchServer::GetHandlersForURLResponse ClientConnection::get_handlers_for_url(URL const& url)
{ {
URL url(request.url());
return Launcher::the().handlers_for_url(url); return Launcher::the().handlers_for_url(url);
} }
Messages::LaunchServer::GetHandlersWithDetailsForURLResponse ClientConnection::handle(const Messages::LaunchServer::GetHandlersWithDetailsForURL& request) Messages::LaunchServer::GetHandlersWithDetailsForURLResponse ClientConnection::get_handlers_with_details_for_url(URL const& url)
{ {
URL url(request.url());
return Launcher::the().handlers_with_details_for_url(url); return Launcher::the().handlers_with_details_for_url(url);
} }
void ClientConnection::handle(const Messages::LaunchServer::AddAllowedURL& request) void ClientConnection::add_allowed_url(URL const& url)
{ {
if (m_allowlist_is_sealed) { if (m_allowlist_is_sealed) {
did_misbehave("Got request to add more allowed handlers after list was sealed"); did_misbehave("Got request to add more allowed handlers after list was sealed");
return; return;
} }
if (!request.url().is_valid()) { if (!url.is_valid()) {
did_misbehave("Got request to allow invalid URL"); did_misbehave("Got request to allow invalid URL");
return; return;
} }
m_allowlist.empend(String(), false, Vector<URL> { request.url() }); m_allowlist.empend(String(), false, Vector<URL> { url });
} }
void ClientConnection::handle(const Messages::LaunchServer::AddAllowedHandlerWithAnyURL& request) void ClientConnection::add_allowed_handler_with_any_url(String const& handler_name)
{ {
if (m_allowlist_is_sealed) { if (m_allowlist_is_sealed) {
did_misbehave("Got request to add more allowed handlers after list was sealed"); did_misbehave("Got request to add more allowed handlers after list was sealed");
return; return;
} }
if (request.handler_name().is_empty()) { if (handler_name.is_empty()) {
did_misbehave("Got request to allow empty handler name"); did_misbehave("Got request to allow empty handler name");
return; return;
} }
m_allowlist.empend(request.handler_name(), true, Vector<URL>()); m_allowlist.empend(handler_name, true, Vector<URL>());
} }
void ClientConnection::handle(const Messages::LaunchServer::AddAllowedHandlerWithOnlySpecificURLs& request) void ClientConnection::add_allowed_handler_with_only_specific_urls(String const& handler_name, Vector<URL> const& urls)
{ {
if (m_allowlist_is_sealed) { if (m_allowlist_is_sealed) {
did_misbehave("Got request to add more allowed handlers after list was sealed"); did_misbehave("Got request to add more allowed handlers after list was sealed");
return; return;
} }
if (request.handler_name().is_empty()) { if (handler_name.is_empty()) {
did_misbehave("Got request to allow empty handler name"); did_misbehave("Got request to allow empty handler name");
return; return;
} }
if (request.urls().is_empty()) { if (urls.is_empty()) {
did_misbehave("Got request to allow empty URL list"); did_misbehave("Got request to allow empty URL list");
return; return;
} }
m_allowlist.empend(request.handler_name(), false, request.urls()); m_allowlist.empend(handler_name, false, urls);
} }
void ClientConnection::handle(const Messages::LaunchServer::SealAllowlist&) void ClientConnection::seal_allowlist()
{ {
if (m_allowlist_is_sealed) { if (m_allowlist_is_sealed) {
did_misbehave("Got more than one request to seal the allowed handlers list"); did_misbehave("Got more than one request to seal the allowed handlers list");

16
Userland/Services/LaunchServer/ClientConnection.h
View file

@ -23,14 +23,14 @@ public:
private: private:
explicit ClientConnection(NonnullRefPtr<Core::LocalSocket>, int client_id); explicit ClientConnection(NonnullRefPtr<Core::LocalSocket>, int client_id);
virtual void handle(const Messages::LaunchServer::Greet&) override; virtual void greet() override;
virtual Messages::LaunchServer::OpenURLResponse handle(const Messages::LaunchServer::OpenURL&) override; virtual Messages::LaunchServer::OpenURLResponse open_url(URL const&, String const&) override;
virtual Messages::LaunchServer::GetHandlersForURLResponse handle(const Messages::LaunchServer::GetHandlersForURL&) override; virtual Messages::LaunchServer::GetHandlersForURLResponse get_handlers_for_url(URL const&) override;
virtual Messages::LaunchServer::GetHandlersWithDetailsForURLResponse handle(const Messages::LaunchServer::GetHandlersWithDetailsForURL&) override; virtual Messages::LaunchServer::GetHandlersWithDetailsForURLResponse get_handlers_with_details_for_url(URL const&) override;
virtual void handle(const Messages::LaunchServer::AddAllowedURL&) override; virtual void add_allowed_url(URL const&) override;
virtual void handle(const Messages::LaunchServer::AddAllowedHandlerWithAnyURL&) override; virtual void add_allowed_handler_with_any_url(String const&) override;
virtual void handle(const Messages::LaunchServer::AddAllowedHandlerWithOnlySpecificURLs&) override; virtual void add_allowed_handler_with_only_specific_urls(String const&, Vector<URL> const&) override;
virtual void handle(const Messages::LaunchServer::SealAllowlist&) override; virtual void seal_allowlist() override;
struct AllowlistEntry { struct AllowlistEntry {
String handler_name; String handler_name;

18
Userland/Services/LookupServer/ClientConnection.cpp
View file

@ -28,9 +28,9 @@ void ClientConnection::die()
s_connections.remove(client_id()); s_connections.remove(client_id());
} }
Messages::LookupServer::LookupNameResponse ClientConnection::handle(const Messages::LookupServer::LookupName& message) Messages::LookupServer::LookupNameResponse ClientConnection::lookup_name(String const& name)
{ {
auto answers = LookupServer::the().lookup(message.name(), T_A); auto answers = LookupServer::the().lookup(name, T_A);
if (answers.is_empty()) if (answers.is_empty())
return { 1, Vector<String>() }; return { 1, Vector<String>() };
Vector<String> addresses; Vector<String> addresses;
@ -40,16 +40,16 @@ Messages::LookupServer::LookupNameResponse ClientConnection::handle(const Messag
return { 0, move(addresses) }; return { 0, move(addresses) };
} }
Messages::LookupServer::LookupAddressResponse ClientConnection::handle(const Messages::LookupServer::LookupAddress& message) Messages::LookupServer::LookupAddressResponse ClientConnection::lookup_address(String const& address)
{ {
if (message.address().length() != 4) if (address.length() != 4)
return { 1, String() }; return { 1, String() };
IPv4Address address { (const u8*)message.address().characters() }; IPv4Address ip_address { (const u8*)address.characters() };
auto name = String::formatted("{}.{}.{}.{}.in-addr.arpa", auto name = String::formatted("{}.{}.{}.{}.in-addr.arpa",
address[3], ip_address[3],
address[2], ip_address[2],
address[1], ip_address[1],
address[0]); ip_address[0]);
auto answers = LookupServer::the().lookup(name, T_PTR); auto answers = LookupServer::the().lookup(name, T_PTR);
if (answers.is_empty()) if (answers.is_empty())
return { 1, String() }; return { 1, String() };

4
Userland/Services/LookupServer/ClientConnection.h
View file

@ -26,8 +26,8 @@ public:
virtual void die() override; virtual void die() override;
private: private:
virtual Messages::LookupServer::LookupNameResponse handle(const Messages::LookupServer::LookupName&) override; virtual Messages::LookupServer::LookupNameResponse lookup_name(String const&) override;
virtual Messages::LookupServer::LookupAddressResponse handle(const Messages::LookupServer::LookupAddress&) override; virtual Messages::LookupServer::LookupAddressResponse lookup_address(String const&) override;
}; };
} }

20
Userland/Services/NotificationServer/ClientConnection.cpp
View file

@ -28,17 +28,17 @@ void ClientConnection::die()
s_connections.remove(client_id()); s_connections.remove(client_id());
} }
void ClientConnection::handle(const Messages::NotificationServer::Greet&) void ClientConnection::greet()
{ {
} }
void ClientConnection::handle(const Messages::NotificationServer::ShowNotification& message) void ClientConnection::show_notification(String const& text, String const& title, Gfx::ShareableBitmap const& icon)
{ {
auto window = NotificationWindow::construct(client_id(), message.text(), message.title(), message.icon()); auto window = NotificationWindow::construct(client_id(), text, title, icon);
window->show(); window->show();
} }
void ClientConnection::handle([[maybe_unused]] const Messages::NotificationServer::CloseNotification& message) void ClientConnection::close_notification()
{ {
auto window = NotificationWindow::get_window_by_id(client_id()); auto window = NotificationWindow::get_window_by_id(client_id());
if (window) { if (window) {
@ -46,26 +46,26 @@ void ClientConnection::handle([[maybe_unused]] const Messages::NotificationServe
} }
} }
Messages::NotificationServer::UpdateNotificationIconResponse ClientConnection::handle(const Messages::NotificationServer::UpdateNotificationIcon& message) Messages::NotificationServer::UpdateNotificationIconResponse ClientConnection::update_notification_icon(Gfx::ShareableBitmap const& icon)
{ {
auto window = NotificationWindow::get_window_by_id(client_id()); auto window = NotificationWindow::get_window_by_id(client_id());
if (window) { if (window) {
window->set_image(message.icon()); window->set_image(icon);
} }
return !!window; return !!window;
} }
Messages::NotificationServer::UpdateNotificationTextResponse ClientConnection::handle(const Messages::NotificationServer::UpdateNotificationText& message) Messages::NotificationServer::UpdateNotificationTextResponse ClientConnection::update_notification_text(String const& text, String const& title)
{ {
auto window = NotificationWindow::get_window_by_id(client_id()); auto window = NotificationWindow::get_window_by_id(client_id());
if (window) { if (window) {
window->set_text(message.text()); window->set_text(text);
window->set_title(message.title()); window->set_title(title);
} }
return !!window; return !!window;
} }
Messages::NotificationServer::IsShowingResponse ClientConnection::handle(const Messages::NotificationServer::IsShowing&) Messages::NotificationServer::IsShowingResponse ClientConnection::is_showing()
{ {
auto window = NotificationWindow::get_window_by_id(client_id()); auto window = NotificationWindow::get_window_by_id(client_id());
return !!window; return !!window;

12
Userland/Services/NotificationServer/ClientConnection.h
View file

@ -23,12 +23,12 @@ public:
private: private:
explicit ClientConnection(NonnullRefPtr<Core::LocalSocket>, int client_id); explicit ClientConnection(NonnullRefPtr<Core::LocalSocket>, int client_id);
virtual void handle(const Messages::NotificationServer::Greet&) override; virtual void greet() override;
virtual void handle(const Messages::NotificationServer::ShowNotification&) override; virtual void show_notification(String const&, String const&, Gfx::ShareableBitmap const&) override;
virtual void handle(const Messages::NotificationServer::CloseNotification& message) override; virtual void close_notification() override;
virtual Messages::NotificationServer::UpdateNotificationIconResponse handle(const Messages::NotificationServer::UpdateNotificationIcon& message) override; virtual Messages::NotificationServer::UpdateNotificationIconResponse update_notification_icon(Gfx::ShareableBitmap const&) override;
virtual Messages::NotificationServer::UpdateNotificationTextResponse handle(const Messages::NotificationServer::UpdateNotificationText& message) override; virtual Messages::NotificationServer::UpdateNotificationTextResponse update_notification_text(String const&, String const&) override;
virtual Messages::NotificationServer::IsShowingResponse handle(const Messages::NotificationServer::IsShowing& message) override; virtual Messages::NotificationServer::IsShowingResponse is_showing() override;
}; };
} }

23
Userland/Services/RequestServer/ClientConnection.cpp
View file

@ -31,15 +31,14 @@ void ClientConnection::die()
Core::EventLoop::current().quit(0); Core::EventLoop::current().quit(0);
} }
Messages::RequestServer::IsSupportedProtocolResponse ClientConnection::handle(const Messages::RequestServer::IsSupportedProtocol& message) Messages::RequestServer::IsSupportedProtocolResponse ClientConnection::is_supported_protocol(String const& protocol)
{ {
bool supported = Protocol::find_by_name(message.protocol().to_lowercase()); bool supported = Protocol::find_by_name(protocol.to_lowercase());
return supported; return supported;
} }
Messages::RequestServer::StartRequestResponse ClientConnection::handle(const Messages::RequestServer::StartRequest& message) Messages::RequestServer::StartRequestResponse ClientConnection::start_request(String const& method, URL const& url, IPC::Dictionary const& request_headers, ByteBuffer const& request_body)
{ {
const auto& url = message.url();
if (!url.is_valid()) { if (!url.is_valid()) {
dbgln("StartRequest: Invalid URL requested: '{}'", url); dbgln("StartRequest: Invalid URL requested: '{}'", url);
return { -1, Optional<IPC::File> {} }; return { -1, Optional<IPC::File> {} };
@ -49,7 +48,7 @@ Messages::RequestServer::StartRequestResponse ClientConnection::handle(const Mes
dbgln("StartRequest: No protocol handler for URL: '{}'", url); dbgln("StartRequest: No protocol handler for URL: '{}'", url);
return { -1, Optional<IPC::File> {} }; return { -1, Optional<IPC::File> {} };
} }
auto request = protocol->start_request(*this, message.method(), url, message.request_headers().entries(), message.request_body()); auto request = protocol->start_request(*this, method, url, request_headers.entries(), request_body);
if (!request) { if (!request) {
dbgln("StartRequest: Protocol handler failed to start request: '{}'", url); dbgln("StartRequest: Protocol handler failed to start request: '{}'", url);
return { -1, Optional<IPC::File> {} }; return { -1, Optional<IPC::File> {} };
@ -60,13 +59,13 @@ Messages::RequestServer::StartRequestResponse ClientConnection::handle(const Mes
return { id, IPC::File(fd, IPC::File::CloseAfterSending) }; return { id, IPC::File(fd, IPC::File::CloseAfterSending) };
} }
Messages::RequestServer::StopRequestResponse ClientConnection::handle(const Messages::RequestServer::StopRequest& message) Messages::RequestServer::StopRequestResponse ClientConnection::stop_request(i32 request_id)
{ {
auto* request = const_cast<Request*>(m_requests.get(message.request_id()).value_or(nullptr)); auto* request = const_cast<Request*>(m_requests.get(request_id).value_or(nullptr));
bool success = false; bool success = false;
if (request) { if (request) {
request->stop(); request->stop();
m_requests.remove(message.request_id()); m_requests.remove(request_id);
success = true; success = true;
} }
return success; return success;
@ -100,16 +99,16 @@ void ClientConnection::did_request_certificates(Badge<Request>, Request& request
post_message(Messages::RequestClient::CertificateRequested(request.id())); post_message(Messages::RequestClient::CertificateRequested(request.id()));
} }
void ClientConnection::handle(const Messages::RequestServer::Greet&) void ClientConnection::greet()
{ {
} }
Messages::RequestServer::SetCertificateResponse ClientConnection::handle(const Messages::RequestServer::SetCertificate& message) Messages::RequestServer::SetCertificateResponse ClientConnection::set_certificate(i32 request_id, String const& certificate, String const& key)
{ {
auto* request = const_cast<Request*>(m_requests.get(message.request_id()).value_or(nullptr)); auto* request = const_cast<Request*>(m_requests.get(request_id).value_or(nullptr));
bool success = false; bool success = false;
if (request) { if (request) {
request->set_certificate(message.certificate(), message.key()); request->set_certificate(certificate, key);
success = true; success = true;
} }
return success; return success;

10
Userland/Services/RequestServer/ClientConnection.h
View file

@ -31,11 +31,11 @@ public:
void did_request_certificates(Badge<Request>, Request&); void did_request_certificates(Badge<Request>, Request&);
private: private:
virtual void handle(const Messages::RequestServer::Greet&) override; virtual void greet() override;
virtual Messages::RequestServer::IsSupportedProtocolResponse handle(const Messages::RequestServer::IsSupportedProtocol&) override; virtual Messages::RequestServer::IsSupportedProtocolResponse is_supported_protocol(String const&) override;
virtual Messages::RequestServer::StartRequestResponse handle(const Messages::RequestServer::StartRequest&) override; virtual Messages::RequestServer::StartRequestResponse start_request(String const&, URL const&, IPC::Dictionary const&, ByteBuffer const&) override;
virtual Messages::RequestServer::StopRequestResponse handle(const Messages::RequestServer::StopRequest&) override; virtual Messages::RequestServer::StopRequestResponse stop_request(i32) override;
virtual Messages::RequestServer::SetCertificateResponse handle(const Messages::RequestServer::SetCertificate&) override; virtual Messages::RequestServer::SetCertificateResponse set_certificate(i32, String const&, String const&) override;
HashMap<i32, OwnPtr<Request>> m_requests; HashMap<i32, OwnPtr<Request>> m_requests;
}; };

9
Userland/Services/SymbolServer/ClientConnection.cpp
View file

@ -35,13 +35,12 @@ void ClientConnection::die()
s_connections.remove(client_id()); s_connections.remove(client_id());
} }
void ClientConnection::handle(const Messages::SymbolServer::Greet&) void ClientConnection::greet()
{ {
} }
Messages::SymbolServer::SymbolicateResponse ClientConnection::handle(const Messages::SymbolServer::Symbolicate& message) Messages::SymbolServer::SymbolicateResponse ClientConnection::symbolicate(String const& path, u32 address)
{ {
auto path = message.path();
if (!s_cache.contains(path)) { if (!s_cache.contains(path)) {
auto mapped_file = MappedFile::map(path); auto mapped_file = MappedFile::map(path);
if (mapped_file.is_error()) { if (mapped_file.is_error()) {
@ -68,8 +67,8 @@ Messages::SymbolServer::SymbolicateResponse ClientConnection::handle(const Messa
return { false, String {}, 0, String {}, 0 }; return { false, String {}, 0, String {}, 0 };
u32 offset = 0; u32 offset = 0;
auto symbol = cached_elf->debug_info.elf().symbolicate(message.address(), &offset); auto symbol = cached_elf->debug_info.elf().symbolicate(address, &offset);
auto source_position = cached_elf->debug_info.get_source_position(message.address()); auto source_position = cached_elf->debug_info.get_source_position(address);
String filename; String filename;
u32 line_number = 0; u32 line_number = 0;
if (source_position.has_value()) { if (source_position.has_value()) {

4
Userland/Services/SymbolServer/ClientConnection.h
View file

@ -27,8 +27,8 @@ public:
virtual void die() override; virtual void die() override;
private: private:
virtual void handle(const Messages::SymbolServer::Greet&) override; virtual void greet() override;
virtual Messages::SymbolServer::SymbolicateResponse handle(const Messages::SymbolServer::Symbolicate&) override; virtual Messages::SymbolServer::SymbolicateResponse symbolicate(String const&, u32) override;
}; };
} }

100
Userland/Services/WebContent/ClientConnection.cpp
View file

@ -58,76 +58,76 @@ const Web::Page& ClientConnection::page() const
return m_page_host->page(); return m_page_host->page();
} }
void ClientConnection::handle(const Messages::WebContentServer::Greet&) void ClientConnection::greet()
{ {
} }
void ClientConnection::handle(const Messages::WebContentServer::UpdateSystemTheme& message) void ClientConnection::update_system_theme(const Core::AnonymousBuffer& theme_buffer)
{ {
Gfx::set_system_theme(message.theme_buffer()); Gfx::set_system_theme(theme_buffer);
auto impl = Gfx::PaletteImpl::create_with_anonymous_buffer(message.theme_buffer()); auto impl = Gfx::PaletteImpl::create_with_anonymous_buffer(theme_buffer);
m_page_host->set_palette_impl(*impl); m_page_host->set_palette_impl(*impl);
} }
void ClientConnection::handle(const Messages::WebContentServer::UpdateScreenRect& message) void ClientConnection::update_screen_rect(const Gfx::IntRect& rect)
{ {
m_page_host->set_screen_rect(message.rect()); m_page_host->set_screen_rect(rect);
} }
void ClientConnection::handle(const Messages::WebContentServer::LoadURL& message) void ClientConnection::load_url(const URL& url)
{ {
dbgln_if(SPAM_DEBUG, "handle: WebContentServer::LoadURL: url={}", message.url()); dbgln_if(SPAM_DEBUG, "handle: WebContentServer::LoadURL: url={}", url);
String process_name; String process_name;
if (message.url().host().is_empty()) if (url.host().is_empty())
process_name = "WebContent"; process_name = "WebContent";
else else
process_name = String::formatted("WebContent: {}", message.url().host()); process_name = String::formatted("WebContent: {}", url.host());
pthread_setname_np(pthread_self(), process_name.characters()); pthread_setname_np(pthread_self(), process_name.characters());
page().load(message.url()); page().load(url);
} }
void ClientConnection::handle(const Messages::WebContentServer::LoadHTML& message) void ClientConnection::load_html(const String& html, const URL& url)
{ {
dbgln_if(SPAM_DEBUG, "handle: WebContentServer::LoadHTML: html={}, url={}", message.html(), message.url()); dbgln_if(SPAM_DEBUG, "handle: WebContentServer::LoadHTML: html={}, url={}", html, url);
page().load_html(message.html(), message.url()); page().load_html(html, url);
} }
void ClientConnection::handle(const Messages::WebContentServer::SetViewportRect& message) void ClientConnection::set_viewport_rect(const Gfx::IntRect& rect)
{ {
dbgln_if(SPAM_DEBUG, "handle: WebContentServer::SetViewportRect: rect={}", message.rect()); dbgln_if(SPAM_DEBUG, "handle: WebContentServer::SetViewportRect: rect={}", rect);
m_page_host->set_viewport_rect(message.rect()); m_page_host->set_viewport_rect(rect);
} }
void ClientConnection::handle(const Messages::WebContentServer::AddBackingStore& message) void ClientConnection::add_backing_store(i32 backing_store_id, const Gfx::ShareableBitmap& bitmap)
{ {
m_backing_stores.set(message.backing_store_id(), *message.bitmap().bitmap()); m_backing_stores.set(backing_store_id, *bitmap.bitmap());
} }
void ClientConnection::handle(const Messages::WebContentServer::RemoveBackingStore& message) void ClientConnection::remove_backing_store(i32 backing_store_id)
{ {
m_backing_stores.remove(message.backing_store_id()); m_backing_stores.remove(backing_store_id);
} }
void ClientConnection::handle(const Messages::WebContentServer::Paint& message) void ClientConnection::paint(const Gfx::IntRect& content_rect, i32 backing_store_id)
{ {
for (auto& pending_paint : m_pending_paint_requests) { for (auto& pending_paint : m_pending_paint_requests) {
if (pending_paint.bitmap_id == message.backing_store_id()) { if (pending_paint.bitmap_id == backing_store_id) {
pending_paint.content_rect = message.content_rect(); pending_paint.content_rect = content_rect;
return; return;
} }
} }
auto it = m_backing_stores.find(message.backing_store_id()); auto it = m_backing_stores.find(backing_store_id);
if (it == m_backing_stores.end()) { if (it == m_backing_stores.end()) {
did_misbehave("Client requested paint with backing store ID"); did_misbehave("Client requested paint with backing store ID");
return; return;
} }
auto& bitmap = *it->value; auto& bitmap = *it->value;
m_pending_paint_requests.append({ message.content_rect(), bitmap, message.backing_store_id() }); m_pending_paint_requests.append({ content_rect, bitmap, backing_store_id });
m_paint_flush_timer->start(); m_paint_flush_timer->start();
} }
@ -140,46 +140,46 @@ void ClientConnection::flush_pending_paint_requests()
m_pending_paint_requests.clear(); m_pending_paint_requests.clear();
} }
void ClientConnection::handle(const Messages::WebContentServer::MouseDown& message) void ClientConnection::mouse_down(const Gfx::IntPoint& position, unsigned int button, [[maybe_unused]] unsigned int buttons, unsigned int modifiers)
{ {
page().handle_mousedown(message.position(), message.button(), message.modifiers()); page().handle_mousedown(position, button, modifiers);
} }
void ClientConnection::handle(const Messages::WebContentServer::MouseMove& message) void ClientConnection::mouse_move(const Gfx::IntPoint& position, [[maybe_unused]] unsigned int button, unsigned int buttons, unsigned int modifiers)
{ {
page().handle_mousemove(message.position(), message.buttons(), message.modifiers()); page().handle_mousemove(position, buttons, modifiers);
} }
void ClientConnection::handle(const Messages::WebContentServer::MouseUp& message) void ClientConnection::mouse_up(const Gfx::IntPoint& position, unsigned int button, [[maybe_unused]] unsigned int buttons, unsigned int modifiers)
{ {
page().handle_mouseup(message.position(), message.button(), message.modifiers()); page().handle_mouseup(position, button, modifiers);
} }
void ClientConnection::handle(const Messages::WebContentServer::MouseWheel& message) void ClientConnection::mouse_wheel(const Gfx::IntPoint& position, unsigned int button, [[maybe_unused]] unsigned int buttons, unsigned int modifiers, i32 wheel_delta)
{ {
page().handle_mousewheel(message.position(), message.button(), message.modifiers(), message.wheel_delta()); page().handle_mousewheel(position, button, modifiers, wheel_delta);
} }
void ClientConnection::handle(const Messages::WebContentServer::KeyDown& message) void ClientConnection::key_down(i32 key, unsigned int modifiers, u32 code_point)
{ {
page().handle_keydown((KeyCode)message.key(), message.modifiers(), message.code_point()); page().handle_keydown((KeyCode)key, modifiers, code_point);
} }
void ClientConnection::handle(const Messages::WebContentServer::DebugRequest& message) void ClientConnection::debug_request(const String& request, const String& argument)
{ {
if (message.request() == "dump-dom-tree") { if (request == "dump-dom-tree") {
if (auto* doc = page().main_frame().document()) if (auto* doc = page().main_frame().document())
Web::dump_tree(*doc); Web::dump_tree(*doc);
} }
if (message.request() == "dump-layout-tree") { if (request == "dump-layout-tree") {
if (auto* doc = page().main_frame().document()) { if (auto* doc = page().main_frame().document()) {
if (auto* icb = doc->layout_node()) if (auto* icb = doc->layout_node())
Web::dump_tree(*icb); Web::dump_tree(*icb);
} }
} }
if (message.request() == "dump-style-sheets") { if (request == "dump-style-sheets") {
if (auto* doc = page().main_frame().document()) { if (auto* doc = page().main_frame().document()) {
for (auto& sheet : doc->style_sheets().sheets()) { for (auto& sheet : doc->style_sheets().sheets()) {
Web::dump_sheet(sheet); Web::dump_sheet(sheet);
@ -187,33 +187,33 @@ void ClientConnection::handle(const Messages::WebContentServer::DebugRequest& me
} }
} }
if (message.request() == "collect-garbage") { if (request == "collect-garbage") {
Web::Bindings::main_thread_vm().heap().collect_garbage(JS::Heap::CollectionType::CollectGarbage, true); Web::Bindings::main_thread_vm().heap().collect_garbage(JS::Heap::CollectionType::CollectGarbage, true);
} }
if (message.request() == "set-line-box-borders") { if (request == "set-line-box-borders") {
bool state = message.argument() == "on"; bool state = argument == "on";
m_page_host->set_should_show_line_box_borders(state); m_page_host->set_should_show_line_box_borders(state);
page().main_frame().set_needs_display(page().main_frame().viewport_rect()); page().main_frame().set_needs_display(page().main_frame().viewport_rect());
} }
if (message.request() == "clear-cache") { if (request == "clear-cache") {
Web::ResourceLoader::the().clear_cache(); Web::ResourceLoader::the().clear_cache();
} }
if (message.request() == "spoof-user-agent") { if (request == "spoof-user-agent") {
Web::ResourceLoader::the().set_user_agent(message.argument()); Web::ResourceLoader::the().set_user_agent(argument);
} }
} }
void ClientConnection::handle(const Messages::WebContentServer::GetSource&) void ClientConnection::get_source()
{ {
if (auto* doc = page().main_frame().document()) { if (auto* doc = page().main_frame().document()) {
post_message(Messages::WebContentClient::DidGetSource(doc->url(), doc->source())); post_message(Messages::WebContentClient::DidGetSource(doc->url(), doc->source()));
} }
} }
void ClientConnection::handle(const Messages::WebContentServer::JSConsoleInitialize&) void ClientConnection::jsconsole_initialize()
{ {
if (auto* document = page().main_frame().document()) { if (auto* document = page().main_frame().document()) {
auto interpreter = document->interpreter().make_weak_ptr(); auto interpreter = document->interpreter().make_weak_ptr();
@ -226,10 +226,10 @@ void ClientConnection::handle(const Messages::WebContentServer::JSConsoleInitial
} }
} }
void ClientConnection::handle(const Messages::WebContentServer::JSConsoleInput& message) void ClientConnection::jsconsole_input(const String& js_source)
{ {
if (m_console_client) if (m_console_client)
m_console_client->handle_input(message.js_source()); m_console_client->handle_input(js_source);
} }
} }

36
Userland/Services/WebContent/ClientConnection.h
View file

@ -33,24 +33,24 @@ private:
Web::Page& page(); Web::Page& page();
const Web::Page& page() const; const Web::Page& page() const;
virtual void handle(const Messages::WebContentServer::Greet&) override; virtual void greet() override;
virtual void handle(const Messages::WebContentServer::UpdateSystemTheme&) override; virtual void update_system_theme(Core::AnonymousBuffer const&) override;
virtual void handle(const Messages::WebContentServer::UpdateScreenRect&) override; virtual void update_screen_rect(Gfx::IntRect const&) override;
virtual void handle(const Messages::WebContentServer::LoadURL&) override; virtual void load_url(URL const&) override;
virtual void handle(const Messages::WebContentServer::LoadHTML&) override; virtual void load_html(String const&, URL const&) override;
virtual void handle(const Messages::WebContentServer::Paint&) override; virtual void paint(Gfx::IntRect const&, i32) override;
virtual void handle(const Messages::WebContentServer::SetViewportRect&) override; virtual void set_viewport_rect(Gfx::IntRect const&) override;
virtual void handle(const Messages::WebContentServer::MouseDown&) override; virtual void mouse_down(Gfx::IntPoint const&, unsigned, unsigned, unsigned) override;
virtual void handle(const Messages::WebContentServer::MouseMove&) override; virtual void mouse_move(Gfx::IntPoint const&, unsigned, unsigned, unsigned) override;
virtual void handle(const Messages::WebContentServer::MouseUp&) override; virtual void mouse_up(Gfx::IntPoint const&, unsigned, unsigned, unsigned) override;
virtual void handle(const Messages::WebContentServer::MouseWheel&) override; virtual void mouse_wheel(Gfx::IntPoint const&, unsigned, unsigned, unsigned, i32) override;
virtual void handle(const Messages::WebContentServer::KeyDown&) override; virtual void key_down(i32, unsigned, u32) override;
virtual void handle(const Messages::WebContentServer::AddBackingStore&) override; virtual void add_backing_store(i32, Gfx::ShareableBitmap const&) override;
virtual void handle(const Messages::WebContentServer::RemoveBackingStore&) override; virtual void remove_backing_store(i32) override;
virtual void handle(const Messages::WebContentServer::DebugRequest&) override; virtual void debug_request(String const&, String const&) override;
virtual void handle(const Messages::WebContentServer::GetSource&) override; virtual void get_source() override;
virtual void handle(const Messages::WebContentServer::JSConsoleInitialize&) override; virtual void jsconsole_initialize() override;
virtual void handle(const Messages::WebContentServer::JSConsoleInput&) override; virtual void jsconsole_input(String const&) override;
void flush_pending_paint_requests(); void flush_pending_paint_requests();

37
Userland/Services/WebSocket/ClientConnection.cpp
View file

@ -31,25 +31,25 @@ void ClientConnection::die()
Core::EventLoop::current().quit(0); Core::EventLoop::current().quit(0);
} }
void ClientConnection::handle(const Messages::WebSocketServer::Greet&) void ClientConnection::greet()
{ {
} }
Messages::WebSocketServer::ConnectResponse ClientConnection::handle(const Messages::WebSocketServer::Connect& message) Messages::WebSocketServer::ConnectResponse ClientConnection::connect(URL const& url, String const& origin,
Vector<String> const& protocols, Vector<String> const& extensions, IPC::Dictionary const& additional_request_headers)
{ {
const auto& url = message.url();
if (!url.is_valid()) { if (!url.is_valid()) {
dbgln("WebSocket::Connect: Invalid URL requested: '{}'", url); dbgln("WebSocket::Connect: Invalid URL requested: '{}'", url);
return -1; return -1;
} }
ConnectionInfo connection_info(url); ConnectionInfo connection_info(url);
connection_info.set_origin(message.origin()); connection_info.set_origin(origin);
connection_info.set_protocols(message.protocols()); connection_info.set_protocols(protocols);
connection_info.set_extensions(message.extensions()); connection_info.set_extensions(extensions);
Vector<ConnectionInfo::Header> headers; Vector<ConnectionInfo::Header> headers;
for (const auto& header : message.additional_request_headers().entries()) { for (auto const& header : additional_request_headers.entries()) {
headers.append({ header.key, header.value }); headers.append({ header.key, header.value });
} }
connection_info.set_headers(headers); connection_info.set_headers(headers);
@ -75,38 +75,39 @@ Messages::WebSocketServer::ConnectResponse ClientConnection::handle(const Messag
return id; return id;
} }
Messages::WebSocketServer::ReadyStateResponse ClientConnection::handle(const Messages::WebSocketServer::ReadyState& message) Messages::WebSocketServer::ReadyStateResponse ClientConnection::ready_state(i32 connection_id)
{ {
RefPtr<WebSocket> connection = m_connections.get(message.connection_id()).value_or({}); RefPtr<WebSocket> connection = m_connections.get(connection_id).value_or({});
if (connection) { if (connection) {
return (u32)connection->ready_state(); return (u32)connection->ready_state();
} }
return (u32)ReadyState::Closed; return (u32)ReadyState::Closed;
} }
void ClientConnection::handle(const Messages::WebSocketServer::Send& message) void ClientConnection::send(i32 connection_id, bool is_text, ByteBuffer const& data)
{ {
RefPtr<WebSocket> connection = m_connections.get(message.connection_id()).value_or({}); RefPtr<WebSocket> connection = m_connections.get(connection_id).value_or({});
if (connection && connection->ready_state() == ReadyState::Open) { if (connection && connection->ready_state() == ReadyState::Open) {
Message websocket_message(message.data(), message.is_text()); Message websocket_message(data, is_text);
connection->send(websocket_message); connection->send(websocket_message);
} }
} }
void ClientConnection::handle(const Messages::WebSocketServer::Close& message) void ClientConnection::close(i32 connection_id, u16 code, String const& reason)
{ {
RefPtr<WebSocket> connection = m_connections.get(message.connection_id()).value_or({}); RefPtr<WebSocket> connection = m_connections.get(connection_id).value_or({});
if (connection && connection->ready_state() == ReadyState::Open) if (connection && connection->ready_state() == ReadyState::Open)
connection->close(message.code(), message.reason()); connection->close(code, reason);
} }
Messages::WebSocketServer::SetCertificateResponse ClientConnection::handle(const Messages::WebSocketServer::SetCertificate& message) Messages::WebSocketServer::SetCertificateResponse ClientConnection::set_certificate(i32 connection_id,
[[maybe_unused]] String const& certificate, [[maybe_unused]] String const& key)
{ {
RefPtr<WebSocket> connection = m_connections.get(message.connection_id()).value_or({}); RefPtr<WebSocket> connection = m_connections.get(connection_id).value_or({});
bool success = false; bool success = false;
if (connection) { if (connection) {
// NO OP here // NO OP here
// connection->set_certificate(message.certificate(), message.key()); // connection->set_certificate(certificate, key);
success = true; success = true;
} }
return success; return success;

12
Userland/Services/WebSocket/ClientConnection.h
View file

@ -26,12 +26,12 @@ public:
virtual void die() override; virtual void die() override;
private: private:
virtual void handle(const Messages::WebSocketServer::Greet&) override; virtual void greet() override;
virtual Messages::WebSocketServer::ConnectResponse handle(const Messages::WebSocketServer::Connect&) override; virtual Messages::WebSocketServer::ConnectResponse connect(URL const&, String const&, Vector<String> const&, Vector<String> const&, IPC::Dictionary const&) override;
virtual Messages::WebSocketServer::ReadyStateResponse handle(const Messages::WebSocketServer::ReadyState&) override; virtual Messages::WebSocketServer::ReadyStateResponse ready_state(i32) override;
virtual void handle(const Messages::WebSocketServer::Send&) override; virtual void send(i32, bool, ByteBuffer const&) override;
virtual void handle(const Messages::WebSocketServer::Close&) override; virtual void close(i32, u16, String const&) override;
virtual Messages::WebSocketServer::SetCertificateResponse handle(const Messages::WebSocketServer::SetCertificate&) override; virtual Messages::WebSocketServer::SetCertificateResponse set_certificate(i32, String const&, String const&) override;
void did_connect(i32); void did_connect(i32);
void did_receive_message(i32, Message); void did_receive_message(i32, Message);

352
Userland/Services/WindowServer/ClientConnection.cpp
View file

@ -76,12 +76,12 @@ void ClientConnection::die()
}); });
} }
void ClientConnection::notify_about_new_screen_rect(const Gfx::IntRect& rect) void ClientConnection::notify_about_new_screen_rect(Gfx::IntRect const& rect)
{ {
post_message(Messages::WindowClient::ScreenRectChanged(rect)); post_message(Messages::WindowClient::ScreenRectChanged(rect));
} }
Messages::WindowServer::CreateMenubarResponse ClientConnection::handle(const Messages::WindowServer::CreateMenubar&) Messages::WindowServer::CreateMenubarResponse ClientConnection::create_menubar()
{ {
int menubar_id = m_next_menubar_id++; int menubar_id = m_next_menubar_id++;
auto menubar = Menubar::create(*this, menubar_id); auto menubar = Menubar::create(*this, menubar_id);
@ -89,9 +89,8 @@ Messages::WindowServer::CreateMenubarResponse ClientConnection::handle(const Mes
return menubar_id; return menubar_id;
} }
void ClientConnection::handle(const Messages::WindowServer::DestroyMenubar& message) void ClientConnection::destroy_menubar(i32 menubar_id)
{ {
int menubar_id = message.menubar_id();
auto it = m_menubars.find(menubar_id); auto it = m_menubars.find(menubar_id);
if (it == m_menubars.end()) { if (it == m_menubars.end()) {
did_misbehave("DestroyMenubar: Bad menubar ID"); did_misbehave("DestroyMenubar: Bad menubar ID");
@ -100,17 +99,16 @@ void ClientConnection::handle(const Messages::WindowServer::DestroyMenubar& mess
m_menubars.remove(it); m_menubars.remove(it);
} }
Messages::WindowServer::CreateMenuResponse ClientConnection::handle(const Messages::WindowServer::CreateMenu& message) Messages::WindowServer::CreateMenuResponse ClientConnection::create_menu(String const& menu_title)
{ {
int menu_id = m_next_menu_id++; int menu_id = m_next_menu_id++;
auto menu = Menu::construct(this, menu_id, message.menu_title()); auto menu = Menu::construct(this, menu_id, menu_title);
m_menus.set(menu_id, move(menu)); m_menus.set(menu_id, move(menu));
return menu_id; return menu_id;
} }
void ClientConnection::handle(const Messages::WindowServer::DestroyMenu& message) void ClientConnection::destroy_menu(i32 menu_id)
{ {
int menu_id = message.menu_id();
auto it = m_menus.find(menu_id); auto it = m_menus.find(menu_id);
if (it == m_menus.end()) { if (it == m_menus.end()) {
did_misbehave("DestroyMenu: Bad menu ID"); did_misbehave("DestroyMenu: Bad menu ID");
@ -122,11 +120,11 @@ void ClientConnection::handle(const Messages::WindowServer::DestroyMenu& message
remove_child(menu); remove_child(menu);
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowMenubar& message) void ClientConnection::set_window_menubar(i32 window_id, i32 menubar_id)
{ {
RefPtr<Window> window; RefPtr<Window> window;
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowMenubar: Bad window ID"); did_misbehave("SetWindowMenubar: Bad window ID");
return; return;
@ -134,8 +132,8 @@ void ClientConnection::handle(const Messages::WindowServer::SetWindowMenubar& me
window = it->value; window = it->value;
} }
RefPtr<Menubar> menubar; RefPtr<Menubar> menubar;
if (message.menubar_id() != -1) { if (menubar_id != -1) {
auto it = m_menubars.find(message.menubar_id()); auto it = m_menubars.find(menubar_id);
if (it == m_menubars.end()) { if (it == m_menubars.end()) {
did_misbehave("SetWindowMenubar: Bad menubar ID"); did_misbehave("SetWindowMenubar: Bad menubar ID");
return; return;
@ -145,10 +143,8 @@ void ClientConnection::handle(const Messages::WindowServer::SetWindowMenubar& me
window->set_menubar(menubar); window->set_menubar(menubar);
} }
void ClientConnection::handle(const Messages::WindowServer::AddMenuToMenubar& message) void ClientConnection::add_menu_to_menubar(i32 menubar_id, i32 menu_id)
{ {
int menubar_id = message.menubar_id();
int menu_id = message.menu_id();
auto it = m_menubars.find(menubar_id); auto it = m_menubars.find(menubar_id);
auto jt = m_menus.find(menu_id); auto jt = m_menus.find(menu_id);
if (it == m_menubars.end()) { if (it == m_menubars.end()) {
@ -164,29 +160,28 @@ void ClientConnection::handle(const Messages::WindowServer::AddMenuToMenubar& me
menubar.add_menu(menu); menubar.add_menu(menu);
} }
void ClientConnection::handle(const Messages::WindowServer::AddMenuItem& message) void ClientConnection::add_menu_item(i32 menu_id, i32 identifier, i32 submenu_id,
String const& text, bool enabled, bool checkable, bool checked, bool is_default,
String const& shortcut, Gfx::ShareableBitmap const& icon, bool exclusive)
{ {
int menu_id = message.menu_id();
unsigned identifier = message.identifier();
auto it = m_menus.find(menu_id); auto it = m_menus.find(menu_id);
if (it == m_menus.end()) { if (it == m_menus.end()) {
dbgln("AddMenuItem: Bad menu ID: {}", menu_id); dbgln("AddMenuItem: Bad menu ID: {}", menu_id);
return; return;
} }
auto& menu = *(*it).value; auto& menu = *(*it).value;
auto menu_item = make<MenuItem>(menu, identifier, message.text(), message.shortcut(), message.enabled(), message.checkable(), message.checked()); auto menu_item = make<MenuItem>(menu, identifier, text, shortcut, enabled, checkable, checked);
if (message.is_default()) if (is_default)
menu_item->set_default(true); menu_item->set_default(true);
menu_item->set_icon(message.icon().bitmap()); menu_item->set_icon(icon.bitmap());
menu_item->set_submenu_id(message.submenu_id()); menu_item->set_submenu_id(submenu_id);
menu_item->set_exclusive(message.exclusive()); menu_item->set_exclusive(exclusive);
menu.add_item(move(menu_item)); menu.add_item(move(menu_item));
} }
void ClientConnection::handle(const Messages::WindowServer::PopupMenu& message) void ClientConnection::popup_menu(i32 menu_id, Gfx::IntPoint const& screen_position)
{ {
int menu_id = message.menu_id(); auto position = screen_position;
auto position = message.screen_position();
auto it = m_menus.find(menu_id); auto it = m_menus.find(menu_id);
if (it == m_menus.end()) { if (it == m_menus.end()) {
did_misbehave("PopupMenu: Bad menu ID"); did_misbehave("PopupMenu: Bad menu ID");
@ -196,9 +191,8 @@ void ClientConnection::handle(const Messages::WindowServer::PopupMenu& message)
menu.popup(position); menu.popup(position);
} }
void ClientConnection::handle(const Messages::WindowServer::DismissMenu& message) void ClientConnection::dismiss_menu(i32 menu_id)
{ {
int menu_id = message.menu_id();
auto it = m_menus.find(menu_id); auto it = m_menus.find(menu_id);
if (it == m_menus.end()) { if (it == m_menus.end()) {
did_misbehave("DismissMenu: Bad menu ID"); did_misbehave("DismissMenu: Bad menu ID");
@ -208,32 +202,32 @@ void ClientConnection::handle(const Messages::WindowServer::DismissMenu& message
menu.close(); menu.close();
} }
void ClientConnection::handle(const Messages::WindowServer::UpdateMenuItem& message) void ClientConnection::update_menu_item(i32 menu_id, i32 identifier, [[maybe_unused]] i32 submenu_id,
String const& text, bool enabled, bool checkable, bool checked, bool is_default,
String const& shortcut)
{ {
int menu_id = message.menu_id();
auto it = m_menus.find(menu_id); auto it = m_menus.find(menu_id);
if (it == m_menus.end()) { if (it == m_menus.end()) {
did_misbehave("UpdateMenuItem: Bad menu ID"); did_misbehave("UpdateMenuItem: Bad menu ID");
return; return;
} }
auto& menu = *(*it).value; auto& menu = *(*it).value;
auto* menu_item = menu.item_with_identifier(message.identifier()); auto* menu_item = menu.item_with_identifier(identifier);
if (!menu_item) { if (!menu_item) {
did_misbehave("UpdateMenuItem: Bad menu item identifier"); did_misbehave("UpdateMenuItem: Bad menu item identifier");
return; return;
} }
menu_item->set_text(message.text()); menu_item->set_text(text);
menu_item->set_shortcut_text(message.shortcut()); menu_item->set_shortcut_text(shortcut);
menu_item->set_enabled(message.enabled()); menu_item->set_enabled(enabled);
menu_item->set_checkable(message.checkable()); menu_item->set_checkable(checkable);
menu_item->set_default(message.is_default()); menu_item->set_default(is_default);
if (message.checkable()) if (checkable)
menu_item->set_checked(message.checked()); menu_item->set_checked(checked);
} }
void ClientConnection::handle(const Messages::WindowServer::AddMenuSeparator& message) void ClientConnection::add_menu_separator(i32 menu_id)
{ {
int menu_id = message.menu_id();
auto it = m_menus.find(menu_id); auto it = m_menus.find(menu_id);
if (it == m_menus.end()) { if (it == m_menus.end()) {
did_misbehave("AddMenuSeparator: Bad menu ID"); did_misbehave("AddMenuSeparator: Bad menu ID");
@ -243,9 +237,9 @@ void ClientConnection::handle(const Messages::WindowServer::AddMenuSeparator& me
menu.add_item(make<MenuItem>(menu, MenuItem::Separator)); menu.add_item(make<MenuItem>(menu, MenuItem::Separator));
} }
void ClientConnection::handle(const Messages::WindowServer::MoveWindowToFront& message) void ClientConnection::move_window_to_front(i32 window_id)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("MoveWindowToFront: Bad window ID"); did_misbehave("MoveWindowToFront: Bad window ID");
return; return;
@ -253,77 +247,77 @@ void ClientConnection::handle(const Messages::WindowServer::MoveWindowToFront& m
WindowManager::the().move_to_front_and_make_active(*(*it).value); WindowManager::the().move_to_front_and_make_active(*(*it).value);
} }
void ClientConnection::handle(const Messages::WindowServer::SetFullscreen& message) void ClientConnection::set_fullscreen(i32 window_id, bool fullscreen)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetFullscreen: Bad window ID"); did_misbehave("SetFullscreen: Bad window ID");
return; return;
} }
it->value->set_fullscreen(message.fullscreen()); it->value->set_fullscreen(fullscreen);
} }
void ClientConnection::handle(const Messages::WindowServer::SetFrameless& message) void ClientConnection::set_frameless(i32 window_id, bool frameless)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetFrameless: Bad window ID"); did_misbehave("SetFrameless: Bad window ID");
return; return;
} }
it->value->set_frameless(message.frameless()); it->value->set_frameless(frameless);
WindowManager::the().tell_wms_window_state_changed(*it->value); WindowManager::the().tell_wms_window_state_changed(*it->value);
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowOpacity& message) void ClientConnection::set_window_opacity(i32 window_id, float opacity)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowOpacity: Bad window ID"); did_misbehave("SetWindowOpacity: Bad window ID");
return; return;
} }
it->value->set_opacity(message.opacity()); it->value->set_opacity(opacity);
} }
void ClientConnection::handle(const Messages::WindowServer::AsyncSetWallpaper& message) void ClientConnection::async_set_wallpaper(String const& path)
{ {
Compositor::the().set_wallpaper(message.path(), [&](bool success) { Compositor::the().set_wallpaper(path, [&](bool success) {
post_message(Messages::WindowClient::AsyncSetWallpaperFinished(success)); post_message(Messages::WindowClient::AsyncSetWallpaperFinished(success));
}); });
} }
void ClientConnection::handle(const Messages::WindowServer::SetBackgroundColor& message) void ClientConnection::set_background_color(String const& background_color)
{ {
Compositor::the().set_background_color(message.background_color()); Compositor::the().set_background_color(background_color);
} }
void ClientConnection::handle(const Messages::WindowServer::SetWallpaperMode& message) void ClientConnection::set_wallpaper_mode(String const& mode)
{ {
Compositor::the().set_wallpaper_mode(message.mode()); Compositor::the().set_wallpaper_mode(mode);
} }
Messages::WindowServer::GetWallpaperResponse ClientConnection::handle(const Messages::WindowServer::GetWallpaper&) Messages::WindowServer::GetWallpaperResponse ClientConnection::get_wallpaper()
{ {
return Compositor::the().wallpaper_path(); return Compositor::the().wallpaper_path();
} }
Messages::WindowServer::SetResolutionResponse ClientConnection::handle(const Messages::WindowServer::SetResolution& message) Messages::WindowServer::SetResolutionResponse ClientConnection::set_resolution(Gfx::IntSize const& resolution, int scale_factor)
{ {
return { WindowManager::the().set_resolution(message.resolution().width(), message.resolution().height(), message.scale_factor()), WindowManager::the().resolution(), WindowManager::the().scale_factor() }; return { WindowManager::the().set_resolution(resolution.width(), resolution.height(), scale_factor), WindowManager::the().resolution(), WindowManager::the().scale_factor() };
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowTitle& message) void ClientConnection::set_window_title(i32 window_id, String const& title)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowTitle: Bad window ID"); did_misbehave("SetWindowTitle: Bad window ID");
return; return;
} }
it->value->set_title(message.title()); it->value->set_title(title);
} }
Messages::WindowServer::GetWindowTitleResponse ClientConnection::handle(const Messages::WindowServer::GetWindowTitle& message) Messages::WindowServer::GetWindowTitleResponse ClientConnection::get_window_title(i32 window_id)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("GetWindowTitle: Bad window ID"); did_misbehave("GetWindowTitle: Bad window ID");
return nullptr; return nullptr;
@ -331,9 +325,9 @@ Messages::WindowServer::GetWindowTitleResponse ClientConnection::handle(const Me
return it->value->title(); return it->value->title();
} }
Messages::WindowServer::IsMaximizedResponse ClientConnection::handle(const Messages::WindowServer::IsMaximized& message) Messages::WindowServer::IsMaximizedResponse ClientConnection::is_maximized(i32 window_id)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("IsMaximized: Bad window ID"); did_misbehave("IsMaximized: Bad window ID");
return nullptr; return nullptr;
@ -341,17 +335,17 @@ Messages::WindowServer::IsMaximizedResponse ClientConnection::handle(const Messa
return it->value->is_maximized(); return it->value->is_maximized();
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowIconBitmap& message) void ClientConnection::set_window_icon_bitmap(i32 window_id, Gfx::ShareableBitmap const& icon)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowIconBitmap: Bad window ID"); did_misbehave("SetWindowIconBitmap: Bad window ID");
return; return;
} }
auto& window = *(*it).value; auto& window = *(*it).value;
if (message.icon().is_valid()) { if (icon.is_valid()) {
window.set_icon(*message.icon().bitmap()); window.set_icon(*icon.bitmap());
} else { } else {
window.set_default_icon(); window.set_default_icon();
} }
@ -360,9 +354,8 @@ void ClientConnection::handle(const Messages::WindowServer::SetWindowIconBitmap&
WindowManager::the().tell_wms_window_icon_changed(window); WindowManager::the().tell_wms_window_icon_changed(window);
} }
Messages::WindowServer::SetWindowRectResponse ClientConnection::handle(const Messages::WindowServer::SetWindowRect& message) Messages::WindowServer::SetWindowRectResponse ClientConnection::set_window_rect(i32 window_id, Gfx::IntRect const& rect)
{ {
int window_id = message.window_id();
auto it = m_windows.find(window_id); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowRect: Bad window ID"); did_misbehave("SetWindowRect: Bad window ID");
@ -374,20 +367,19 @@ Messages::WindowServer::SetWindowRectResponse ClientConnection::handle(const Mes
return nullptr; return nullptr;
} }
if (message.rect().location() != window.rect().location()) { if (rect.location() != window.rect().location()) {
window.set_default_positioned(false); window.set_default_positioned(false);
} }
auto rect = message.rect(); auto new_rect = rect;
window.apply_minimum_size(rect); window.apply_minimum_size(new_rect);
window.set_rect(rect); window.set_rect(new_rect);
window.nudge_into_desktop(); window.nudge_into_desktop();
window.request_update(window.rect()); window.request_update(window.rect());
return window.rect(); return window.rect();
} }
Messages::WindowServer::GetWindowRectResponse ClientConnection::handle(const Messages::WindowServer::GetWindowRect& message) Messages::WindowServer::GetWindowRectResponse ClientConnection::get_window_rect(i32 window_id)
{ {
int window_id = message.window_id();
auto it = m_windows.find(window_id); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("GetWindowRect: Bad window ID"); did_misbehave("GetWindowRect: Bad window ID");
@ -396,9 +388,8 @@ Messages::WindowServer::GetWindowRectResponse ClientConnection::handle(const Mes
return it->value->rect(); return it->value->rect();
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowMinimumSize& message) void ClientConnection::set_window_minimum_size(i32 window_id, Gfx::IntSize const& size)
{ {
int window_id = message.window_id();
auto it = m_windows.find(window_id); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowMinimumSize: Bad window ID"); did_misbehave("SetWindowMinimumSize: Bad window ID");
@ -410,7 +401,7 @@ void ClientConnection::handle(const Messages::WindowServer::SetWindowMinimumSize
return; return;
} }
window.set_minimum_size(message.size()); window.set_minimum_size(size);
if (window.width() < window.minimum_size().width() || window.height() < window.minimum_size().height()) { if (window.width() < window.minimum_size().width() || window.height() < window.minimum_size().height()) {
// New minimum size is larger than the current window size, resize accordingly. // New minimum size is larger than the current window size, resize accordingly.
@ -425,9 +416,8 @@ void ClientConnection::handle(const Messages::WindowServer::SetWindowMinimumSize
} }
} }
Messages::WindowServer::GetWindowMinimumSizeResponse ClientConnection::handle(const Messages::WindowServer::GetWindowMinimumSize& message) Messages::WindowServer::GetWindowMinimumSizeResponse ClientConnection::get_window_minimum_size(i32 window_id)
{ {
int window_id = message.window_id();
auto it = m_windows.find(window_id); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("GetWindowMinimumSize: Bad window ID"); did_misbehave("GetWindowMinimumSize: Bad window ID");
@ -436,9 +426,8 @@ Messages::WindowServer::GetWindowMinimumSizeResponse ClientConnection::handle(co
return it->value->minimum_size(); return it->value->minimum_size();
} }
Messages::WindowServer::GetAppletRectOnScreenResponse ClientConnection::handle(const Messages::WindowServer::GetAppletRectOnScreen& message) Messages::WindowServer::GetAppletRectOnScreenResponse ClientConnection::get_applet_rect_on_screen(i32 window_id)
{ {
int window_id = message.window_id();
auto it = m_windows.find(window_id); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("GetAppletRectOnScreen: Bad window ID"); did_misbehave("GetAppletRectOnScreen: Bad window ID");
@ -460,11 +449,15 @@ Window* ClientConnection::window_from_id(i32 window_id)
return it->value.ptr(); return it->value.ptr();
} }
Messages::WindowServer::CreateWindowResponse ClientConnection::handle(const Messages::WindowServer::CreateWindow& message) Messages::WindowServer::CreateWindowResponse ClientConnection::create_window(Gfx::IntRect const& rect,
bool auto_position, bool has_alpha_channel, bool modal, bool minimizable, bool resizable,
bool fullscreen, bool frameless, bool accessory, float opacity, float alpha_hit_threshold,
Gfx::IntSize const& base_size, Gfx::IntSize const& size_increment, Gfx::IntSize const& minimum_size,
Optional<Gfx::IntSize> const& resize_aspect_ratio, i32 type, String const& title, i32 parent_window_id)
{ {
Window* parent_window = nullptr; Window* parent_window = nullptr;
if (message.parent_window_id()) { if (parent_window_id) {
parent_window = window_from_id(message.parent_window_id()); parent_window = window_from_id(parent_window_id);
if (!parent_window) { if (!parent_window) {
did_misbehave("CreateWindow with bad parent_window_id"); did_misbehave("CreateWindow with bad parent_window_id");
return nullptr; return nullptr;
@ -472,19 +465,19 @@ Messages::WindowServer::CreateWindowResponse ClientConnection::handle(const Mess
} }
int window_id = m_next_window_id++; int window_id = m_next_window_id++;
auto window = Window::construct(*this, (WindowType)message.type(), window_id, message.modal(), message.minimizable(), message.frameless(), message.resizable(), message.fullscreen(), message.accessory(), parent_window); auto window = Window::construct(*this, (WindowType)type, window_id, modal, minimizable, frameless, resizable, fullscreen, accessory, parent_window);
window->set_has_alpha_channel(message.has_alpha_channel()); window->set_has_alpha_channel(has_alpha_channel);
window->set_title(message.title()); window->set_title(title);
if (!message.fullscreen()) { if (!fullscreen) {
auto rect = message.rect(); Gfx::IntRect new_rect = rect;
if (message.auto_position() && window->is_movable()) { if (auto_position && window->is_movable()) {
rect = { WindowManager::the().get_recommended_window_position({ 100, 100 }), message.rect().size() }; new_rect = { WindowManager::the().get_recommended_window_position({ 100, 100 }), rect.size() };
window->set_default_positioned(true); window->set_default_positioned(true);
} }
window->set_minimum_size(message.minimum_size()); window->set_minimum_size(minimum_size);
bool did_size_clamp = window->apply_minimum_size(rect); bool did_size_clamp = window->apply_minimum_size(new_rect);
window->set_rect(rect); window->set_rect(new_rect);
window->nudge_into_desktop(); window->nudge_into_desktop();
if (did_size_clamp) if (did_size_clamp)
@ -494,11 +487,11 @@ Messages::WindowServer::CreateWindowResponse ClientConnection::handle(const Mess
window->set_rect(WindowManager::the().desktop_rect()); window->set_rect(WindowManager::the().desktop_rect());
window->recalculate_rect(); window->recalculate_rect();
} }
window->set_opacity(message.opacity()); window->set_opacity(opacity);
window->set_alpha_hit_threshold(message.alpha_hit_threshold()); window->set_alpha_hit_threshold(alpha_hit_threshold);
window->set_size_increment(message.size_increment()); window->set_size_increment(size_increment);
window->set_base_size(message.base_size()); window->set_base_size(base_size);
window->set_resize_aspect_ratio(message.resize_aspect_ratio()); window->set_resize_aspect_ratio(resize_aspect_ratio);
window->invalidate(true, true); window->invalidate(true, true);
if (window->type() == WindowType::Applet) if (window->type() == WindowType::Applet)
AppletManager::the().add_applet(*window); AppletManager::the().add_applet(*window);
@ -532,9 +525,9 @@ void ClientConnection::destroy_window(Window& window, Vector<i32>& destroyed_win
m_windows.remove(window.window_id()); m_windows.remove(window.window_id());
} }
Messages::WindowServer::DestroyWindowResponse ClientConnection::handle(const Messages::WindowServer::DestroyWindow& message) Messages::WindowServer::DestroyWindowResponse ClientConnection::destroy_window(i32 window_id)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("DestroyWindow: Bad window ID"); did_misbehave("DestroyWindow: Bad window ID");
return nullptr; return nullptr;
@ -554,28 +547,27 @@ void ClientConnection::post_paint_message(Window& window, bool ignore_occlusion)
post_message(Messages::WindowClient::Paint(window.window_id(), window.size(), rect_set.rects())); post_message(Messages::WindowClient::Paint(window.window_id(), window.size(), rect_set.rects()));
} }
void ClientConnection::handle(const Messages::WindowServer::InvalidateRect& message) void ClientConnection::invalidate_rect(i32 window_id, Vector<Gfx::IntRect> const& rects, bool ignore_occlusion)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("InvalidateRect: Bad window ID"); did_misbehave("InvalidateRect: Bad window ID");
return; return;
} }
auto& window = *(*it).value; auto& window = *(*it).value;
for (size_t i = 0; i < message.rects().size(); ++i) for (size_t i = 0; i < rects.size(); ++i)
window.request_update(message.rects()[i].intersected({ {}, window.size() }), message.ignore_occlusion()); window.request_update(rects[i].intersected({ {}, window.size() }), ignore_occlusion);
} }
void ClientConnection::handle(const Messages::WindowServer::DidFinishPainting& message) void ClientConnection::did_finish_painting(i32 window_id, Vector<Gfx::IntRect> const& rects)
{ {
int window_id = message.window_id();
auto it = m_windows.find(window_id); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("DidFinishPainting: Bad window ID"); did_misbehave("DidFinishPainting: Bad window ID");
return; return;
} }
auto& window = *(*it).value; auto& window = *(*it).value;
for (auto& rect : message.rects()) for (auto& rect : rects)
window.invalidate(rect); window.invalidate(rect);
if (window.has_alpha_channel() && window.alpha_hit_threshold() > 0.0f) if (window.has_alpha_channel() && window.alpha_hit_threshold() > 0.0f)
WindowManager::the().reevaluate_hovered_window(&window); WindowManager::the().reevaluate_hovered_window(&window);
@ -583,102 +575,102 @@ void ClientConnection::handle(const Messages::WindowServer::DidFinishPainting& m
WindowSwitcher::the().refresh_if_needed(); WindowSwitcher::the().refresh_if_needed();
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowBackingStore& message) void ClientConnection::set_window_backing_store(i32 window_id, [[maybe_unused]] i32 bpp,
[[maybe_unused]] i32 pitch, IPC::File const& anon_file, i32 serial, bool has_alpha_channel,
Gfx::IntSize const& size, bool flush_immediately)
{ {
int window_id = message.window_id();
auto it = m_windows.find(window_id); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowBackingStore: Bad window ID"); did_misbehave("SetWindowBackingStore: Bad window ID");
return; return;
} }
auto& window = *(*it).value; auto& window = *(*it).value;
if (window.last_backing_store() && window.last_backing_store_serial() == message.serial()) { if (window.last_backing_store() && window.last_backing_store_serial() == serial) {
window.swap_backing_stores(); window.swap_backing_stores();
} else { } else {
// FIXME: Plumb scale factor here eventually. // FIXME: Plumb scale factor here eventually.
auto backing_store = Gfx::Bitmap::create_with_anon_fd( auto backing_store = Gfx::Bitmap::create_with_anon_fd(
message.has_alpha_channel() ? Gfx::BitmapFormat::BGRA8888 : Gfx::BitmapFormat::BGRx8888, has_alpha_channel ? Gfx::BitmapFormat::BGRA8888 : Gfx::BitmapFormat::BGRx8888,
message.anon_file().take_fd(), anon_file.take_fd(),
message.size(), size,
1, 1,
{}, {},
Gfx::Bitmap::ShouldCloseAnonymousFile::Yes); Gfx::Bitmap::ShouldCloseAnonymousFile::Yes);
window.set_backing_store(move(backing_store), message.serial()); window.set_backing_store(move(backing_store), serial);
} }
if (message.flush_immediately()) if (flush_immediately)
window.invalidate(false); window.invalidate(false);
} }
void ClientConnection::handle(const Messages::WindowServer::SetGlobalCursorTracking& message) void ClientConnection::set_global_cursor_tracking(i32 window_id, bool enabled)
{ {
int window_id = message.window_id();
auto it = m_windows.find(window_id); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetGlobalCursorTracking: Bad window ID"); did_misbehave("SetGlobalCursorTracking: Bad window ID");
return; return;
} }
it->value->set_global_cursor_tracking_enabled(message.enabled()); it->value->set_global_cursor_tracking_enabled(enabled);
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowCursor& message) void ClientConnection::set_window_cursor(i32 window_id, i32 cursor_type)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowCursor: Bad window ID"); did_misbehave("SetWindowCursor: Bad window ID");
return; return;
} }
auto& window = *(*it).value; auto& window = *(*it).value;
if (message.cursor_type() < 0 || message.cursor_type() >= (i32)Gfx::StandardCursor::__Count) { if (cursor_type < 0 || cursor_type >= (i32)Gfx::StandardCursor::__Count) {
did_misbehave("SetWindowCursor: Bad cursor type"); did_misbehave("SetWindowCursor: Bad cursor type");
return; return;
} }
window.set_cursor(Cursor::create((Gfx::StandardCursor)message.cursor_type())); window.set_cursor(Cursor::create((Gfx::StandardCursor)cursor_type));
if (&window == WindowManager::the().hovered_window()) if (&window == WindowManager::the().hovered_window())
Compositor::the().invalidate_cursor(); Compositor::the().invalidate_cursor();
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowCustomCursor& message) void ClientConnection::set_window_custom_cursor(i32 window_id, Gfx::ShareableBitmap const& cursor)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowCustomCursor: Bad window ID"); did_misbehave("SetWindowCustomCursor: Bad window ID");
return; return;
} }
auto& window = *(*it).value; auto& window = *(*it).value;
if (!message.cursor().is_valid()) { if (!cursor.is_valid()) {
did_misbehave("SetWindowCustomCursor: Bad cursor"); did_misbehave("SetWindowCustomCursor: Bad cursor");
return; return;
} }
window.set_cursor(Cursor::create(*message.cursor().bitmap())); window.set_cursor(Cursor::create(*cursor.bitmap()));
Compositor::the().invalidate_cursor(); Compositor::the().invalidate_cursor();
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowHasAlphaChannel& message) void ClientConnection::set_window_has_alpha_channel(i32 window_id, bool has_alpha_channel)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowHasAlphaChannel: Bad window ID"); did_misbehave("SetWindowHasAlphaChannel: Bad window ID");
return; return;
} }
it->value->set_has_alpha_channel(message.has_alpha_channel()); it->value->set_has_alpha_channel(has_alpha_channel);
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowAlphaHitThreshold& message) void ClientConnection::set_window_alpha_hit_threshold(i32 window_id, float threshold)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowAlphaHitThreshold: Bad window ID"); did_misbehave("SetWindowAlphaHitThreshold: Bad window ID");
return; return;
} }
it->value->set_alpha_hit_threshold(message.threshold()); it->value->set_alpha_hit_threshold(threshold);
} }
void ClientConnection::handle(const Messages::WindowServer::StartWindowResize& request) void ClientConnection::start_window_resize(i32 window_id)
{ {
auto it = m_windows.find(request.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("WM_StartWindowResize: Bad window ID"); did_misbehave("WM_StartWindowResize: Bad window ID");
return; return;
@ -689,60 +681,60 @@ void ClientConnection::handle(const Messages::WindowServer::StartWindowResize& r
WindowManager::the().start_window_resize(window, Screen::the().cursor_location(), MouseButton::Left); WindowManager::the().start_window_resize(window, Screen::the().cursor_location(), MouseButton::Left);
} }
Messages::WindowServer::GreetResponse ClientConnection::handle(const Messages::WindowServer::Greet&) Messages::WindowServer::GreetResponse ClientConnection::greet()
{ {
return { Screen::the().rect(), Gfx::current_system_theme_buffer() }; return { Screen::the().rect(), Gfx::current_system_theme_buffer() };
} }
Messages::WindowServer::StartDragResponse ClientConnection::handle(const Messages::WindowServer::StartDrag& message) Messages::WindowServer::StartDragResponse ClientConnection::start_drag(String const& text, HashMap<String, ByteBuffer> const& mime_data, Gfx::ShareableBitmap const& drag_bitmap)
{ {
auto& wm = WindowManager::the(); auto& wm = WindowManager::the();
if (wm.dnd_client()) if (wm.dnd_client())
return false; return false;
wm.start_dnd_drag(*this, message.text(), message.drag_bitmap().bitmap(), Core::MimeData::construct(message.mime_data())); wm.start_dnd_drag(*this, text, drag_bitmap.bitmap(), Core::MimeData::construct(mime_data));
return true; return true;
} }
Messages::WindowServer::SetSystemThemeResponse ClientConnection::handle(const Messages::WindowServer::SetSystemTheme& message) Messages::WindowServer::SetSystemThemeResponse ClientConnection::set_system_theme(String const& theme_path, String const& theme_name)
{ {
bool success = WindowManager::the().update_theme(message.theme_path(), message.theme_name()); bool success = WindowManager::the().update_theme(theme_path, theme_name);
return success; return success;
} }
Messages::WindowServer::GetSystemThemeResponse ClientConnection::handle(const Messages::WindowServer::GetSystemTheme&) Messages::WindowServer::GetSystemThemeResponse ClientConnection::get_system_theme()
{ {
auto wm_config = Core::ConfigFile::open("/etc/WindowServer.ini"); auto wm_config = Core::ConfigFile::open("/etc/WindowServer.ini");
auto name = wm_config->read_entry("Theme", "Name"); auto name = wm_config->read_entry("Theme", "Name");
return name; return name;
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowBaseSizeAndSizeIncrement& message) void ClientConnection::set_window_base_size_and_size_increment(i32 window_id, Gfx::IntSize const& base_size, Gfx::IntSize const& size_increment)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowBaseSizeAndSizeIncrementResponse: Bad window ID"); did_misbehave("SetWindowBaseSizeAndSizeIncrementResponse: Bad window ID");
return; return;
} }
auto& window = *it->value; auto& window = *it->value;
window.set_base_size(message.base_size()); window.set_base_size(base_size);
window.set_size_increment(message.size_increment()); window.set_size_increment(size_increment);
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowResizeAspectRatio& message) void ClientConnection::set_window_resize_aspect_ratio(i32 window_id, Optional<Gfx::IntSize> const& resize_aspect_ratio)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowResizeAspectRatioResponse: Bad window ID"); did_misbehave("SetWindowResizeAspectRatioResponse: Bad window ID");
return; return;
} }
auto& window = *it->value; auto& window = *it->value;
window.set_resize_aspect_ratio(message.resize_aspect_ratio()); window.set_resize_aspect_ratio(resize_aspect_ratio);
} }
void ClientConnection::handle(const Messages::WindowServer::EnableDisplayLink&) void ClientConnection::enable_display_link()
{ {
if (m_has_display_link) if (m_has_display_link)
return; return;
@ -750,7 +742,7 @@ void ClientConnection::handle(const Messages::WindowServer::EnableDisplayLink&)
Compositor::the().increment_display_link_count({}); Compositor::the().increment_display_link_count({});
} }
void ClientConnection::handle(const Messages::WindowServer::DisableDisplayLink&) void ClientConnection::disable_display_link()
{ {
if (!m_has_display_link) if (!m_has_display_link)
return; return;
@ -766,72 +758,72 @@ void ClientConnection::notify_display_link(Badge<Compositor>)
post_message(Messages::WindowClient::DisplayLinkNotification()); post_message(Messages::WindowClient::DisplayLinkNotification());
} }
void ClientConnection::handle(const Messages::WindowServer::SetWindowProgress& message) void ClientConnection::set_window_progress(i32 window_id, Optional<i32> const& progress)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowProgress with bad window ID"); did_misbehave("SetWindowProgress with bad window ID");
return; return;
} }
it->value->set_progress(message.progress()); it->value->set_progress(progress);
} }
void ClientConnection::handle(const Messages::WindowServer::RefreshSystemTheme&) void ClientConnection::refresh_system_theme()
{ {
// Post the client an UpdateSystemTheme message to refresh its theme. // Post the client an UpdateSystemTheme message to refresh its theme.
post_message(Messages::WindowClient::UpdateSystemTheme(Gfx::current_system_theme_buffer())); post_message(Messages::WindowClient::UpdateSystemTheme(Gfx::current_system_theme_buffer()));
} }
void ClientConnection::handle(const Messages::WindowServer::Pong&) void ClientConnection::pong()
{ {
m_ping_timer = nullptr; m_ping_timer = nullptr;
set_unresponsive(false); set_unresponsive(false);
} }
Messages::WindowServer::GetGlobalCursorPositionResponse ClientConnection::handle(const Messages::WindowServer::GetGlobalCursorPosition&) Messages::WindowServer::GetGlobalCursorPositionResponse ClientConnection::get_global_cursor_position()
{ {
return Screen::the().cursor_location(); return Screen::the().cursor_location();
} }
void ClientConnection::handle(const Messages::WindowServer::SetMouseAcceleration& message) void ClientConnection::set_mouse_acceleration(float factor)
{ {
double factor = message.factor(); double dbl_factor = (double)factor;
if (factor < mouse_accel_min || factor > mouse_accel_max) { if (dbl_factor < mouse_accel_min || dbl_factor > mouse_accel_max) {
did_misbehave("SetMouseAcceleration with bad acceleration factor"); did_misbehave("SetMouseAcceleration with bad acceleration factor");
return; return;
} }
WindowManager::the().set_acceleration_factor(factor); WindowManager::the().set_acceleration_factor(dbl_factor);
} }
Messages::WindowServer::GetMouseAccelerationResponse ClientConnection::handle(const Messages::WindowServer::GetMouseAcceleration&) Messages::WindowServer::GetMouseAccelerationResponse ClientConnection::get_mouse_acceleration()
{ {
return Screen::the().acceleration_factor(); return Screen::the().acceleration_factor();
} }
void ClientConnection::handle(const Messages::WindowServer::SetScrollStepSize& message) void ClientConnection::set_scroll_step_size(u32 step_size)
{ {
if (message.step_size() < scroll_step_size_min) { if (step_size < scroll_step_size_min) {
did_misbehave("SetScrollStepSize with bad scroll step size"); did_misbehave("SetScrollStepSize with bad scroll step size");
return; return;
} }
WindowManager::the().set_scroll_step_size(message.step_size()); WindowManager::the().set_scroll_step_size(step_size);
} }
Messages::WindowServer::GetScrollStepSizeResponse ClientConnection::handle(const Messages::WindowServer::GetScrollStepSize&) Messages::WindowServer::GetScrollStepSizeResponse ClientConnection::get_scroll_step_size()
{ {
return Screen::the().scroll_step_size(); return Screen::the().scroll_step_size();
} }
void ClientConnection::handle(const Messages::WindowServer::SetDoubleClickSpeed& message) void ClientConnection::set_double_click_speed(i32 speed)
{ {
if (message.speed() < double_click_speed_min || message.speed() > double_click_speed_max) { if (speed < double_click_speed_min || speed > double_click_speed_max) {
did_misbehave("SetDoubleClickSpeed with bad speed"); did_misbehave("SetDoubleClickSpeed with bad speed");
return; return;
} }
WindowManager::the().set_double_click_speed(message.speed()); WindowManager::the().set_double_click_speed(speed);
} }
Messages::WindowServer::GetDoubleClickSpeedResponse ClientConnection::handle(const Messages::WindowServer::GetDoubleClickSpeed&) Messages::WindowServer::GetDoubleClickSpeedResponse ClientConnection::get_double_click_speed()
{ {
return WindowManager::the().double_click_speed(); return WindowManager::the().double_click_speed();
} }
@ -867,15 +859,15 @@ void ClientConnection::did_become_responsive()
set_unresponsive(false); set_unresponsive(false);
} }
Messages::WindowServer::GetScreenBitmapResponse ClientConnection::handle(const Messages::WindowServer::GetScreenBitmap&) Messages::WindowServer::GetScreenBitmapResponse ClientConnection::get_screen_bitmap()
{ {
auto& bitmap = Compositor::the().front_bitmap_for_screenshot({}); auto& bitmap = Compositor::the().front_bitmap_for_screenshot({});
return bitmap.to_shareable_bitmap(); return bitmap.to_shareable_bitmap();
} }
Messages::WindowServer::IsWindowModifiedResponse ClientConnection::handle(Messages::WindowServer::IsWindowModified const& message) Messages::WindowServer::IsWindowModifiedResponse ClientConnection::is_window_modified(i32 window_id)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("IsWindowModified: Bad window ID"); did_misbehave("IsWindowModified: Bad window ID");
return nullptr; return nullptr;
@ -884,15 +876,15 @@ Messages::WindowServer::IsWindowModifiedResponse ClientConnection::handle(Messag
return window.is_modified(); return window.is_modified();
} }
void ClientConnection::handle(Messages::WindowServer::SetWindowModified const& message) void ClientConnection::set_window_modified(i32 window_id, bool modified)
{ {
auto it = m_windows.find(message.window_id()); auto it = m_windows.find(window_id);
if (it == m_windows.end()) { if (it == m_windows.end()) {
did_misbehave("SetWindowModified: Bad window ID"); did_misbehave("SetWindowModified: Bad window ID");
return; return;
} }
auto& window = *it->value; auto& window = *it->value;
window.set_modified(message.modified()); window.set_modified(modified);
} }
} }

124
Userland/Services/WindowServer/ClientConnection.h
View file

@ -87,67 +87,69 @@ private:
void set_unresponsive(bool); void set_unresponsive(bool);
void destroy_window(Window&, Vector<i32>& destroyed_window_ids); void destroy_window(Window&, Vector<i32>& destroyed_window_ids);
virtual Messages::WindowServer::GreetResponse handle(const Messages::WindowServer::Greet&) override; virtual Messages::WindowServer::GreetResponse greet() override;
virtual Messages::WindowServer::CreateMenubarResponse handle(const Messages::WindowServer::CreateMenubar&) override; virtual Messages::WindowServer::CreateMenubarResponse create_menubar() override;
virtual void handle(const Messages::WindowServer::DestroyMenubar&) override; virtual void destroy_menubar(i32) override;
virtual Messages::WindowServer::CreateMenuResponse handle(const Messages::WindowServer::CreateMenu&) override; virtual Messages::WindowServer::CreateMenuResponse create_menu(String const&) override;
virtual void handle(const Messages::WindowServer::DestroyMenu&) override; virtual void destroy_menu(i32) override;
virtual void handle(const Messages::WindowServer::AddMenuToMenubar&) override; virtual void add_menu_to_menubar(i32, i32) override;
virtual void handle(const Messages::WindowServer::SetWindowMenubar&) override; virtual void set_window_menubar(i32, i32) override;
virtual void handle(const Messages::WindowServer::AddMenuItem&) override; virtual void add_menu_item(i32, i32, i32, String const&, bool, bool, bool, bool, String const&, Gfx::ShareableBitmap const&, bool) override;
virtual void handle(const Messages::WindowServer::AddMenuSeparator&) override; virtual void add_menu_separator(i32) override;
virtual void handle(const Messages::WindowServer::UpdateMenuItem&) override; virtual void update_menu_item(i32, i32, i32, String const&, bool, bool, bool, bool, String const&) override;
virtual Messages::WindowServer::CreateWindowResponse handle(const Messages::WindowServer::CreateWindow&) override; virtual Messages::WindowServer::CreateWindowResponse create_window(Gfx::IntRect const&, bool, bool, bool,
virtual Messages::WindowServer::DestroyWindowResponse handle(const Messages::WindowServer::DestroyWindow&) override; bool, bool, bool, bool, bool, float, float, Gfx::IntSize const&, Gfx::IntSize const&, Gfx::IntSize const&,
virtual void handle(const Messages::WindowServer::SetWindowTitle&) override; Optional<Gfx::IntSize> const&, i32, String const&, i32) override;
virtual Messages::WindowServer::GetWindowTitleResponse handle(const Messages::WindowServer::GetWindowTitle&) override; virtual Messages::WindowServer::DestroyWindowResponse destroy_window(i32) override;
virtual Messages::WindowServer::IsMaximizedResponse handle(const Messages::WindowServer::IsMaximized&) override; virtual void set_window_title(i32, String const&) override;
virtual void handle(const Messages::WindowServer::StartWindowResize&) override; virtual Messages::WindowServer::GetWindowTitleResponse get_window_title(i32) override;
virtual Messages::WindowServer::SetWindowRectResponse handle(const Messages::WindowServer::SetWindowRect&) override; virtual Messages::WindowServer::IsMaximizedResponse is_maximized(i32) override;
virtual Messages::WindowServer::GetWindowRectResponse handle(const Messages::WindowServer::GetWindowRect&) override; virtual void start_window_resize(i32) override;
virtual void handle(const Messages::WindowServer::SetWindowMinimumSize&) override; virtual Messages::WindowServer::SetWindowRectResponse set_window_rect(i32, Gfx::IntRect const&) override;
virtual Messages::WindowServer::GetWindowMinimumSizeResponse handle(const Messages::WindowServer::GetWindowMinimumSize&) override; virtual Messages::WindowServer::GetWindowRectResponse get_window_rect(i32) override;
virtual Messages::WindowServer::GetAppletRectOnScreenResponse handle(const Messages::WindowServer::GetAppletRectOnScreen&) override; virtual void set_window_minimum_size(i32, Gfx::IntSize const&) override;
virtual void handle(const Messages::WindowServer::InvalidateRect&) override; virtual Messages::WindowServer::GetWindowMinimumSizeResponse get_window_minimum_size(i32) override;
virtual void handle(const Messages::WindowServer::DidFinishPainting&) override; virtual Messages::WindowServer::GetAppletRectOnScreenResponse get_applet_rect_on_screen(i32) override;
virtual void handle(const Messages::WindowServer::SetGlobalCursorTracking&) override; virtual void invalidate_rect(i32, Vector<Gfx::IntRect> const&, bool) override;
virtual void handle(const Messages::WindowServer::SetWindowOpacity&) override; virtual void did_finish_painting(i32, Vector<Gfx::IntRect> const&) override;
virtual void handle(const Messages::WindowServer::SetWindowBackingStore&) override; virtual void set_global_cursor_tracking(i32, bool) override;
virtual void handle(const Messages::WindowServer::SetWindowHasAlphaChannel&) override; virtual void set_window_opacity(i32, float) override;
virtual void handle(const Messages::WindowServer::SetWindowAlphaHitThreshold&) override; virtual void set_window_backing_store(i32, i32, i32, IPC::File const&, i32, bool, Gfx::IntSize const&, bool) override;
virtual void handle(const Messages::WindowServer::MoveWindowToFront&) override; virtual void set_window_has_alpha_channel(i32, bool) override;
virtual void handle(const Messages::WindowServer::SetFullscreen&) override; virtual void set_window_alpha_hit_threshold(i32, float) override;
virtual void handle(const Messages::WindowServer::SetFrameless&) override; virtual void move_window_to_front(i32) override;
virtual void handle(const Messages::WindowServer::AsyncSetWallpaper&) override; virtual void set_fullscreen(i32, bool) override;
virtual void handle(const Messages::WindowServer::SetBackgroundColor&) override; virtual void set_frameless(i32, bool) override;
virtual void handle(const Messages::WindowServer::SetWallpaperMode&) override; virtual void async_set_wallpaper(String const&) override;
virtual Messages::WindowServer::GetWallpaperResponse handle(const Messages::WindowServer::GetWallpaper&) override; virtual void set_background_color(String const&) override;
virtual Messages::WindowServer::SetResolutionResponse handle(const Messages::WindowServer::SetResolution&) override; virtual void set_wallpaper_mode(String const&) override;
virtual void handle(const Messages::WindowServer::SetWindowCursor&) override; virtual Messages::WindowServer::GetWallpaperResponse get_wallpaper() override;
virtual void handle(const Messages::WindowServer::SetWindowCustomCursor&) override; virtual Messages::WindowServer::SetResolutionResponse set_resolution(Gfx::IntSize const&, int) override;
virtual void handle(const Messages::WindowServer::PopupMenu&) override; virtual void set_window_cursor(i32, i32) override;
virtual void handle(const Messages::WindowServer::DismissMenu&) override; virtual void set_window_custom_cursor(i32, Gfx::ShareableBitmap const&) override;
virtual void handle(const Messages::WindowServer::SetWindowIconBitmap&) override; virtual void popup_menu(i32, Gfx::IntPoint const&) override;
virtual Messages::WindowServer::StartDragResponse handle(const Messages::WindowServer::StartDrag&) override; virtual void dismiss_menu(i32) override;
virtual Messages::WindowServer::SetSystemThemeResponse handle(const Messages::WindowServer::SetSystemTheme&) override; virtual void set_window_icon_bitmap(i32, Gfx::ShareableBitmap const&) override;
virtual Messages::WindowServer::GetSystemThemeResponse handle(const Messages::WindowServer::GetSystemTheme&) override; virtual Messages::WindowServer::StartDragResponse start_drag(String const&, HashMap<String, ByteBuffer> const&, Gfx::ShareableBitmap const&) override;
virtual void handle(const Messages::WindowServer::SetWindowBaseSizeAndSizeIncrement&) override; virtual Messages::WindowServer::SetSystemThemeResponse set_system_theme(String const&, String const&) override;
virtual void handle(const Messages::WindowServer::SetWindowResizeAspectRatio&) override; virtual Messages::WindowServer::GetSystemThemeResponse get_system_theme() override;
virtual void handle(const Messages::WindowServer::EnableDisplayLink&) override; virtual void set_window_base_size_and_size_increment(i32, Gfx::IntSize const&, Gfx::IntSize const&) override;
virtual void handle(const Messages::WindowServer::DisableDisplayLink&) override; virtual void set_window_resize_aspect_ratio(i32, Optional<Gfx::IntSize> const&) override;
virtual void handle(const Messages::WindowServer::SetWindowProgress&) override; virtual void enable_display_link() override;
virtual void handle(const Messages::WindowServer::RefreshSystemTheme&) override; virtual void disable_display_link() override;
virtual void handle(const Messages::WindowServer::Pong&) override; virtual void set_window_progress(i32, Optional<i32> const&) override;
virtual Messages::WindowServer::GetGlobalCursorPositionResponse handle(const Messages::WindowServer::GetGlobalCursorPosition&) override; virtual void refresh_system_theme() override;
virtual void handle(const Messages::WindowServer::SetMouseAcceleration&) override; virtual void pong() override;
virtual Messages::WindowServer::GetMouseAccelerationResponse handle(const Messages::WindowServer::GetMouseAcceleration&) override; virtual Messages::WindowServer::GetGlobalCursorPositionResponse get_global_cursor_position() override;
virtual void handle(const Messages::WindowServer::SetScrollStepSize&) override; virtual void set_mouse_acceleration(float) override;
virtual Messages::WindowServer::GetScrollStepSizeResponse handle(const Messages::WindowServer::GetScrollStepSize&) override; virtual Messages::WindowServer::GetMouseAccelerationResponse get_mouse_acceleration() override;
virtual Messages::WindowServer::GetScreenBitmapResponse handle(const Messages::WindowServer::GetScreenBitmap&) override; virtual void set_scroll_step_size(u32) override;
virtual void handle(const Messages::WindowServer::SetDoubleClickSpeed&) override; virtual Messages::WindowServer::GetScrollStepSizeResponse get_scroll_step_size() override;
virtual Messages::WindowServer::GetDoubleClickSpeedResponse handle(const Messages::WindowServer::GetDoubleClickSpeed&) override; virtual Messages::WindowServer::GetScreenBitmapResponse get_screen_bitmap() override;
virtual void handle(Messages::WindowServer::SetWindowModified const&) override; virtual void set_double_click_speed(i32) override;
virtual Messages::WindowServer::IsWindowModifiedResponse handle(Messages::WindowServer::IsWindowModified const&) override; virtual Messages::WindowServer::GetDoubleClickSpeedResponse get_double_click_speed() override;
virtual void set_window_modified(i32, bool) override;
virtual Messages::WindowServer::IsWindowModifiedResponse is_window_modified(i32) override;
Window* window_from_id(i32 window_id); Window* window_from_id(i32 window_id);

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

@ -33,7 +33,7 @@ void WMClientConnection::die()
}); });
} }
void WMClientConnection::handle(const Messages::WindowManagerServer::SetAppletAreaPosition& message) void WMClientConnection::set_applet_area_position(Gfx::IntPoint const& position)
{ {
if (m_window_id < 0) { if (m_window_id < 0) {
did_misbehave("SetAppletAreaPosition: WM didn't assign window as manager yet"); did_misbehave("SetAppletAreaPosition: WM didn't assign window as manager yet");
@ -41,17 +41,17 @@ void WMClientConnection::handle(const Messages::WindowManagerServer::SetAppletAr
return; return;
} }
AppletManager::the().set_position(message.position()); AppletManager::the().set_position(position);
} }
void WMClientConnection::handle(const Messages::WindowManagerServer::SetActiveWindow& message) void WMClientConnection::set_active_window(i32 client_id, i32 window_id)
{ {
auto* client = WindowServer::ClientConnection::from_client_id(message.client_id()); auto* client = WindowServer::ClientConnection::from_client_id(client_id);
if (!client) { if (!client) {
did_misbehave("SetActiveWindow: Bad client ID"); did_misbehave("SetActiveWindow: Bad client ID");
return; return;
} }
auto it = client->m_windows.find(message.window_id()); auto it = client->m_windows.find(window_id);
if (it == client->m_windows.end()) { if (it == client->m_windows.end()) {
did_misbehave("SetActiveWindow: Bad window ID"); did_misbehave("SetActiveWindow: Bad window ID");
return; return;
@ -61,34 +61,34 @@ void WMClientConnection::handle(const Messages::WindowManagerServer::SetActiveWi
WindowManager::the().move_to_front_and_make_active(window); WindowManager::the().move_to_front_and_make_active(window);
} }
void WMClientConnection::handle(const Messages::WindowManagerServer::PopupWindowMenu& message) void WMClientConnection::popup_window_menu(i32 client_id, i32 window_id, Gfx::IntPoint const& screen_position)
{ {
auto* client = WindowServer::ClientConnection::from_client_id(message.client_id()); auto* client = WindowServer::ClientConnection::from_client_id(client_id);
if (!client) { if (!client) {
did_misbehave("PopupWindowMenu: Bad client ID"); did_misbehave("PopupWindowMenu: Bad client ID");
return; return;
} }
auto it = client->m_windows.find(message.window_id()); auto it = client->m_windows.find(window_id);
if (it == client->m_windows.end()) { if (it == client->m_windows.end()) {
did_misbehave("PopupWindowMenu: Bad window ID"); did_misbehave("PopupWindowMenu: Bad window ID");
return; return;
} }
auto& window = *(*it).value; auto& window = *(*it).value;
if (auto* modal_window = window.blocking_modal_window()) { if (auto* modal_window = window.blocking_modal_window()) {
modal_window->popup_window_menu(message.screen_position(), WindowMenuDefaultAction::BasedOnWindowState); modal_window->popup_window_menu(screen_position, WindowMenuDefaultAction::BasedOnWindowState);
} else { } else {
window.popup_window_menu(message.screen_position(), WindowMenuDefaultAction::BasedOnWindowState); window.popup_window_menu(screen_position, WindowMenuDefaultAction::BasedOnWindowState);
} }
} }
void WMClientConnection::handle(const Messages::WindowManagerServer::StartWindowResize& request) void WMClientConnection::start_window_resize(i32 client_id, i32 window_id)
{ {
auto* client = WindowServer::ClientConnection::from_client_id(request.client_id()); auto* client = WindowServer::ClientConnection::from_client_id(client_id);
if (!client) { if (!client) {
did_misbehave("WM_StartWindowResize: Bad client ID"); did_misbehave("WM_StartWindowResize: Bad client ID");
return; return;
} }
auto it = client->m_windows.find(request.window_id()); auto it = client->m_windows.find(window_id);
if (it == client->m_windows.end()) { if (it == client->m_windows.end()) {
did_misbehave("WM_StartWindowResize: Bad window ID"); did_misbehave("WM_StartWindowResize: Bad window ID");
return; return;
@ -99,52 +99,52 @@ void WMClientConnection::handle(const Messages::WindowManagerServer::StartWindow
WindowManager::the().start_window_resize(window, Screen::the().cursor_location(), MouseButton::Left); WindowManager::the().start_window_resize(window, Screen::the().cursor_location(), MouseButton::Left);
} }
void WMClientConnection::handle(const Messages::WindowManagerServer::SetWindowMinimized& message) void WMClientConnection::set_window_minimized(i32 client_id, i32 window_id, bool minimized)
{ {
auto* client = WindowServer::ClientConnection::from_client_id(message.client_id()); auto* client = WindowServer::ClientConnection::from_client_id(client_id);
if (!client) { if (!client) {
did_misbehave("WM_SetWindowMinimized: Bad client ID"); did_misbehave("WM_SetWindowMinimized: Bad client ID");
return; return;
} }
auto it = client->m_windows.find(message.window_id()); auto it = client->m_windows.find(window_id);
if (it == client->m_windows.end()) { if (it == client->m_windows.end()) {
did_misbehave("WM_SetWindowMinimized: Bad window ID"); did_misbehave("WM_SetWindowMinimized: Bad window ID");
return; return;
} }
auto& window = *(*it).value; auto& window = *(*it).value;
WindowManager::the().minimize_windows(window, message.minimized()); WindowManager::the().minimize_windows(window, minimized);
} }
void WMClientConnection::handle(const Messages::WindowManagerServer::SetEventMask& message) void WMClientConnection::set_event_mask(u32 event_mask)
{ {
m_event_mask = message.event_mask(); m_event_mask = event_mask;
} }
void WMClientConnection::handle(const Messages::WindowManagerServer::SetManagerWindow& message) void WMClientConnection::set_manager_window(i32 window_id)
{ {
m_window_id = message.window_id(); m_window_id = window_id;
// Let the window manager know that we obtained a manager window, and should // Let the window manager know that we obtained a manager window, and should
// receive information about other windows. // receive information about other windows.
WindowManager::the().greet_window_manager(*this); WindowManager::the().greet_window_manager(*this);
} }
void WMClientConnection::handle(const Messages::WindowManagerServer::SetWindowTaskbarRect& message) void WMClientConnection::set_window_taskbar_rect(i32 client_id, i32 window_id, Gfx::IntRect const& rect)
{ {
// Because the Taskbar (which should be the only user of this API) does not own the // Because the Taskbar (which should be the only user of this API) does not own the
// window or the client id, there is a possibility that it may send this message for // window or the client id, there is a possibility that it may send this message for
// a window or client that may have been destroyed already. This is not an error, // a window or client that may have been destroyed already. This is not an error,
// and we should not call did_misbehave() for either. // and we should not call did_misbehave() for either.
auto* client = WindowServer::ClientConnection::from_client_id(message.client_id()); auto* client = WindowServer::ClientConnection::from_client_id(client_id);
if (!client) if (!client)
return; return;
auto it = client->m_windows.find(message.window_id()); auto it = client->m_windows.find(window_id);
if (it == client->m_windows.end()) if (it == client->m_windows.end())
return; return;
auto& window = *(*it).value; auto& window = *(*it).value;
window.set_taskbar_rect(message.rect()); window.set_taskbar_rect(rect);
} }
} }

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

@ -22,14 +22,14 @@ class WMClientConnection final
public: public:
~WMClientConnection() override; ~WMClientConnection() override;
virtual void handle(const Messages::WindowManagerServer::SetActiveWindow&) override; virtual void set_active_window(i32, i32) override;
virtual void handle(const Messages::WindowManagerServer::SetWindowMinimized&) override; virtual void set_window_minimized(i32, i32, bool) override;
virtual void handle(const Messages::WindowManagerServer::StartWindowResize&) override; virtual void start_window_resize(i32, i32) override;
virtual void handle(const Messages::WindowManagerServer::PopupWindowMenu&) override; virtual void popup_window_menu(i32, i32, Gfx::IntPoint const&) override;
virtual void handle(const Messages::WindowManagerServer::SetWindowTaskbarRect&) override; virtual void set_window_taskbar_rect(i32, i32, Gfx::IntRect const&) override;
virtual void handle(const Messages::WindowManagerServer::SetAppletAreaPosition&) override; virtual void set_applet_area_position(Gfx::IntPoint const&) override;
virtual void handle(const Messages::WindowManagerServer::SetEventMask&) override; virtual void set_event_mask(u32) override;
virtual void handle(const Messages::WindowManagerServer::SetManagerWindow&) override; virtual void set_manager_window(i32) override;
unsigned event_mask() const { return m_event_mask; } unsigned event_mask() const { return m_event_mask; }
int window_id() const { return m_window_id; } int window_id() const { return m_window_id; }