IPCCompiler: Put message classes in the Messages namespace

Applications/DisplayProperties/DisplayProperties.cpp

@@ -224,7 +224,7 @@ void DisplayPropertiesWidget::send_settings_to_window_server(int tab_index)
         GUI::Desktop::the().set_wallpaper(builder.to_string());
     } else if (tab_index == TabIndices::Settings) {
         dbg() << "Attempting to set resolution " << m_selected_resolution;
-        GUI::WindowServerConnection::the().send_sync<WindowServer::SetResolution>(m_selected_resolution);
+        GUI::WindowServerConnection::the().send_sync<Messages::WindowServer::SetResolution>(m_selected_resolution);
     } else {
         dbg() << "Invalid tab index " << tab_index;
     }

Applications/Taskbar/TaskbarButton.cpp

@@ -40,13 +40,13 @@ TaskbarButton::~TaskbarButton()
 
 void TaskbarButton::context_menu_event(GUI::ContextMenuEvent&)
 {
-    GUI::WindowServerConnection::the().post_message(WindowServer::WM_PopupWindowMenu(m_identifier.client_id(), m_identifier.window_id(), screen_relative_rect().location()));
+    GUI::WindowServerConnection::the().post_message(Messages::WindowServer::WM_PopupWindowMenu(m_identifier.client_id(), m_identifier.window_id(), screen_relative_rect().location()));
 }
 
 void TaskbarButton::resize_event(GUI::ResizeEvent& event)
 {
     GUI::WindowServerConnection::the().post_message(
-        WindowServer::WM_SetWindowTaskbarRect(
+        Messages::WindowServer::WM_SetWindowTaskbarRect(
             m_identifier.client_id(),
             m_identifier.window_id(),
             screen_relative_rect()));

Applications/Taskbar/WindowList.cpp

@@ -52,9 +52,9 @@ Window& WindowList::ensure_window(const WindowIdentifier& identifier)
     window->set_button(aid_create_button(identifier));
     window->button()->on_click = [window = window.ptr(), identifier](auto&) {
         if (window->is_minimized() || !window->is_active()) {
-            GUI::WindowServerConnection::the().post_message(WindowServer::WM_SetActiveWindow(identifier.client_id(), identifier.window_id()));
+            GUI::WindowServerConnection::the().post_message(Messages::WindowServer::WM_SetActiveWindow(identifier.client_id(), identifier.window_id()));
         } else {
-            GUI::WindowServerConnection::the().post_message(WindowServer::WM_SetWindowMinimized(identifier.client_id(), identifier.window_id(), true));
+            GUI::WindowServerConnection::the().post_message(Messages::WindowServer::WM_SetWindowMinimized(identifier.client_id(), identifier.window_id(), true));
         }
     };
     auto& window_ref = *window;

DevTools/IPCCompiler/main.cpp

@@ -233,6 +233,7 @@ int main(int argc, char** argv)
     dbg();
 
     for (auto& endpoint : endpoints) {
+        dbg() << "namespace Messages {";
         dbg() << "namespace " << endpoint.name << " {";
         dbg();
 
@@ -445,6 +446,7 @@ int main(int argc, char** argv)
             do_message(message.name, message.inputs, response_name);
         }
         dbg() << "} // namespace " << endpoint.name;
+        dbg() << "} // namespace Messages";
         dbg();
 
         dbg() << "class " << endpoint.name << "Endpoint : public IPC::Endpoint {";
@@ -471,8 +473,8 @@ int main(int argc, char** argv)
         dbg() << "        switch (message_id) {";
         for (auto& message : endpoint.messages) {
             auto do_decode_message = [&](const String& name) {
-                dbg() << "        case (int)" << endpoint.name << "::MessageID::" << name << ":";
+                dbg() << "        case (int)Messages::" << endpoint.name << "::MessageID::" << name << ":";
-                dbg() << "            return " << endpoint.name << "::" << name << "::decode(stream, size_in_bytes);";
+                dbg() << "            return Messages::" << endpoint.name << "::" << name << "::decode(stream, size_in_bytes);";
             };
             do_decode_message(message.name);
             if (message.is_synchronous)
@@ -492,11 +494,11 @@ int main(int argc, char** argv)
         dbg() << "        switch (message.message_id()) {";
         for (auto& message : endpoint.messages) {
             auto do_decode_message = [&](const String& name, bool returns_something) {
-                dbg() << "        case (int)" << endpoint.name << "::MessageID::" << name << ":";
+                dbg() << "        case (int)Messages::" << endpoint.name << "::MessageID::" << name << ":";
                 if (returns_something) {
-                    dbg() << "            return handle(static_cast<const " << endpoint.name << "::" << name << "&>(message));";
+                    dbg() << "            return handle(static_cast<const Messages::" << endpoint.name << "::" << name << "&>(message));";
                 } else {
-                    dbg() << "            handle(static_cast<const " << endpoint.name << "::" << name << "&>(message));";
+                    dbg() << "            handle(static_cast<const Messages::" << endpoint.name << "::" << name << "&>(message));";
                     dbg() << "            return nullptr;";
                 }
             };
@@ -514,7 +516,7 @@ int main(int argc, char** argv)
             String return_type = "void";
             if (message.is_synchronous) {
                 StringBuilder builder;
-                builder.append("OwnPtr<");
+                builder.append("OwnPtr<Messages::");
                 builder.append(endpoint.name);
                 builder.append("::");
                 builder.append(message.name);
@@ -522,7 +524,7 @@ int main(int argc, char** argv)
                 builder.append(">");
                 return_type = builder.to_string();
             }
-            dbg() << "    virtual " << return_type << " handle(const " << endpoint.name << "::" << message.name << "&) = 0;";
+            dbg() << "    virtual " << return_type << " handle(const Messages::" << endpoint.name << "::" << message.name << "&) = 0;";
         }
 
         dbg() << "private:";

Libraries/LibAudio/ClientConnection.cpp

@@ -37,7 +37,7 @@ ClientConnection::ClientConnection()
 
 void ClientConnection::handshake()
 {
-    auto response = send_sync<AudioServer::Greet>();
+    auto response = send_sync<Messages::AudioServer::Greet>();
     set_my_client_id(response->client_id());
 }
 
@@ -45,7 +45,7 @@ void ClientConnection::enqueue(const Buffer& buffer)
 {
     for (;;) {
         const_cast<Buffer&>(buffer).shared_buffer().share_with(server_pid());
-        auto response = send_sync<AudioServer::EnqueueBuffer>(buffer.shared_buffer_id(), buffer.sample_count());
+        auto response = send_sync<Messages::AudioServer::EnqueueBuffer>(buffer.shared_buffer_id(), buffer.sample_count());
         if (response->success())
             break;
         sleep(1);
@@ -55,62 +55,62 @@ void ClientConnection::enqueue(const Buffer& buffer)
 bool ClientConnection::try_enqueue(const Buffer& buffer)
 {
     const_cast<Buffer&>(buffer).shared_buffer().share_with(server_pid());
-    auto response = send_sync<AudioServer::EnqueueBuffer>(buffer.shared_buffer_id(), buffer.sample_count());
+    auto response = send_sync<Messages::AudioServer::EnqueueBuffer>(buffer.shared_buffer_id(), buffer.sample_count());
     return response->success();
 }
 
 bool ClientConnection::get_muted()
 {
-    return send_sync<AudioServer::GetMuted>()->muted();
+    return send_sync<Messages::AudioServer::GetMuted>()->muted();
 }
 
 void ClientConnection::set_muted(bool muted)
 {
-    send_sync<AudioServer::SetMuted>(muted);
+    send_sync<Messages::AudioServer::SetMuted>(muted);
 }
 
 int ClientConnection::get_main_mix_volume()
 {
-    return send_sync<AudioServer::GetMainMixVolume>()->volume();
+    return send_sync<Messages::AudioServer::GetMainMixVolume>()->volume();
 }
 
 void ClientConnection::set_main_mix_volume(int volume)
 {
-    send_sync<AudioServer::SetMainMixVolume>(volume);
+    send_sync<Messages::AudioServer::SetMainMixVolume>(volume);
 }
 
 int ClientConnection::get_remaining_samples()
 {
-    return send_sync<AudioServer::GetRemainingSamples>()->remaining_samples();
+    return send_sync<Messages::AudioServer::GetRemainingSamples>()->remaining_samples();
 }
 
 int ClientConnection::get_played_samples()
 {
-    return send_sync<AudioServer::GetPlayedSamples>()->played_samples();
+    return send_sync<Messages::AudioServer::GetPlayedSamples>()->played_samples();
 }
 
 void ClientConnection::set_paused(bool paused)
 {
-    send_sync<AudioServer::SetPaused>(paused);
+    send_sync<Messages::AudioServer::SetPaused>(paused);
 }
 
 void ClientConnection::clear_buffer(bool paused)
 {
-    send_sync<AudioServer::ClearBuffer>(paused);
+    send_sync<Messages::AudioServer::ClearBuffer>(paused);
 }
 
 int ClientConnection::get_playing_buffer()
 {
-    return send_sync<AudioServer::GetPlayingBuffer>()->buffer_id();
+    return send_sync<Messages::AudioServer::GetPlayingBuffer>()->buffer_id();
 }
 
-void ClientConnection::handle(const AudioClient::FinishedPlayingBuffer& message)
+void ClientConnection::handle(const Messages::AudioClient::FinishedPlayingBuffer& message)
 {
     if (on_finish_playing_buffer)
         on_finish_playing_buffer(message.buffer_id());
 }
 
-void ClientConnection::handle(const AudioClient::MutedStateChanged& message)
+void ClientConnection::handle(const Messages::AudioClient::MutedStateChanged& message)
 {
     if (on_muted_state_change)
         on_muted_state_change(message.muted());

Libraries/LibAudio/ClientConnection.h

@@ -61,8 +61,8 @@ public:
     Function<void(bool muted)> on_muted_state_change;
 
 private:
-    virtual void handle(const AudioClient::FinishedPlayingBuffer&) override;
+    virtual void handle(const Messages::AudioClient::FinishedPlayingBuffer&) override;
-    virtual void handle(const AudioClient::MutedStateChanged&) override;
+    virtual void handle(const Messages::AudioClient::MutedStateChanged&) override;
 };
 
 }

Libraries/LibGUI/GClipboard.cpp

@@ -44,7 +44,7 @@ Clipboard::Clipboard()
 
 Clipboard::DataAndType Clipboard::data_and_type() const
 {
-    auto response = WindowServerConnection::the().send_sync<WindowServer::GetClipboardContents>();
+    auto response = WindowServerConnection::the().send_sync<Messages::WindowServer::GetClipboardContents>();
     if (response->shared_buffer_id() < 0)
         return {};
     auto shared_buffer = SharedBuffer::create_from_shared_buffer_id(response->shared_buffer_id());
@@ -75,7 +75,7 @@ void Clipboard::set_data(const StringView& data, const String& type)
     shared_buffer->seal();
     shared_buffer->share_with(WindowServerConnection::the().server_pid());
 
-    WindowServerConnection::the().send_sync<WindowServer::SetClipboardContents>(shared_buffer->shared_buffer_id(), data.length(), type);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::SetClipboardContents>(shared_buffer->shared_buffer_id(), data.length(), type);
 }
 
 void Clipboard::did_receive_clipboard_contents_changed(Badge<WindowServerConnection>, const String& data_type)

Libraries/LibGUI/GDesktop.cpp

@@ -55,8 +55,8 @@ void Desktop::did_receive_screen_rect(Badge<WindowServerConnection>, const Gfx::
 
 bool Desktop::set_wallpaper(const StringView& path)
 {
-    WindowServerConnection::the().post_message(WindowServer::AsyncSetWallpaper(path));
+    WindowServerConnection::the().post_message(Messages::WindowServer::AsyncSetWallpaper(path));
-    auto ret_val = WindowServerConnection::the().wait_for_specific_message<WindowClient::AsyncSetWallpaperFinished>()->success();
+    auto ret_val = WindowServerConnection::the().wait_for_specific_message<Messages::WindowClient::AsyncSetWallpaperFinished>()->success();
 
     if (ret_val) {
         RefPtr<Core::ConfigFile> config = Core::ConfigFile::get_for_app("WindowManager");
@@ -70,7 +70,7 @@ bool Desktop::set_wallpaper(const StringView& path)
 
 String Desktop::wallpaper() const
 {
-    return WindowServerConnection::the().send_sync<WindowServer::GetWallpaper>()->path();
+    return WindowServerConnection::the().send_sync<Messages::WindowServer::GetWallpaper>()->path();
 }
 
 }

Libraries/LibGUI/GDragOperation.cpp

@@ -56,7 +56,7 @@ DragOperation::Outcome DragOperation::exec()
         bitmap_size = shared_bitmap->size();
     }
 
-    auto response = WindowServerConnection::the().send_sync<WindowServer::StartDrag>(m_text, m_data_type, m_data, bitmap_id, bitmap_size);
+    auto response = WindowServerConnection::the().send_sync<Messages::WindowServer::StartDrag>(m_text, m_data_type, m_data, bitmap_id, bitmap_size);
     if (!response->started()) {
         m_outcome = Outcome::Cancelled;
         return m_outcome;

Libraries/LibGUI/GMenu.cpp

@@ -87,19 +87,19 @@ void Menu::realize_if_needed()
 void Menu::popup(const Gfx::Point& screen_position)
 {
     realize_if_needed();
-    WindowServerConnection::the().post_message(WindowServer::PopupMenu(m_menu_id, screen_position));
+    WindowServerConnection::the().post_message(Messages::WindowServer::PopupMenu(m_menu_id, screen_position));
 }
 
 void Menu::dismiss()
 {
     if (m_menu_id == -1)
         return;
-    WindowServerConnection::the().post_message(WindowServer::DismissMenu(m_menu_id));
+    WindowServerConnection::the().post_message(Messages::WindowServer::DismissMenu(m_menu_id));
 }
 
 int Menu::realize_menu()
 {
-    m_menu_id = WindowServerConnection::the().send_sync<WindowServer::CreateMenu>(m_name)->menu_id();
+    m_menu_id = WindowServerConnection::the().send_sync<Messages::WindowServer::CreateMenu>(m_name)->menu_id();
 
 #ifdef MENU_DEBUG
     dbgprintf("GUI::Menu::realize_menu(): New menu ID: %d\n", m_menu_id);
@@ -110,13 +110,13 @@ int Menu::realize_menu()
         item.set_menu_id({}, m_menu_id);
         item.set_identifier({}, i);
         if (item.type() == MenuItem::Type::Separator) {
-            WindowServerConnection::the().send_sync<WindowServer::AddMenuSeparator>(m_menu_id);
+            WindowServerConnection::the().send_sync<Messages::WindowServer::AddMenuSeparator>(m_menu_id);
             continue;
         }
         if (item.type() == MenuItem::Type::Submenu) {
             auto& submenu = *item.submenu();
             submenu.realize_if_needed();
-            WindowServerConnection::the().send_sync<WindowServer::AddMenuItem>(m_menu_id, i, submenu.menu_id(), submenu.name(), true, false, false, "", -1, false);
+            WindowServerConnection::the().send_sync<Messages::WindowServer::AddMenuItem>(m_menu_id, i, submenu.menu_id(), submenu.name(), true, false, false, "", -1, false);
             continue;
         }
         if (item.type() == MenuItem::Type::Action) {
@@ -138,7 +138,7 @@ int Menu::realize_menu()
             }
             auto shortcut_text = action.shortcut().is_valid() ? action.shortcut().to_string() : String();
             bool exclusive = action.group() && action.group()->is_exclusive() && action.is_checkable();
-            WindowServerConnection::the().send_sync<WindowServer::AddMenuItem>(m_menu_id, i, -1, action.text(), action.is_enabled(), action.is_checkable(), action.is_checkable() ? action.is_checked() : false, shortcut_text, icon_buffer_id, exclusive);
+            WindowServerConnection::the().send_sync<Messages::WindowServer::AddMenuItem>(m_menu_id, i, -1, action.text(), action.is_enabled(), action.is_checkable(), action.is_checkable() ? action.is_checked() : false, shortcut_text, icon_buffer_id, exclusive);
         }
     }
     all_menus().set(m_menu_id, this);
@@ -150,7 +150,7 @@ void Menu::unrealize_menu()
     if (m_menu_id == -1)
         return;
     all_menus().remove(m_menu_id);
-    WindowServerConnection::the().send_sync<WindowServer::DestroyMenu>(m_menu_id);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::DestroyMenu>(m_menu_id);
     m_menu_id = 0;
 }
 

Libraries/LibGUI/GMenuBar.cpp

@@ -45,14 +45,14 @@ void MenuBar::add_menu(NonnullRefPtr<Menu> menu)
 
 int MenuBar::realize_menubar()
 {
-    return WindowServerConnection::the().send_sync<WindowServer::CreateMenubar>()->menubar_id();
+    return WindowServerConnection::the().send_sync<Messages::WindowServer::CreateMenubar>()->menubar_id();
 }
 
 void MenuBar::unrealize_menubar()
 {
     if (m_menubar_id == -1)
         return;
-    WindowServerConnection::the().send_sync<WindowServer::DestroyMenubar>(m_menubar_id);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::DestroyMenubar>(m_menubar_id);
     m_menubar_id = -1;
 }
 
@@ -64,9 +64,9 @@ void MenuBar::notify_added_to_application(Badge<Application>)
     for (auto& menu : m_menus) {
         int menu_id = menu.realize_menu();
         ASSERT(menu_id != -1);
-        WindowServerConnection::the().send_sync<WindowServer::AddMenuToMenubar>(m_menubar_id, menu_id);
+        WindowServerConnection::the().send_sync<Messages::WindowServer::AddMenuToMenubar>(m_menubar_id, menu_id);
     }
-    WindowServerConnection::the().send_sync<WindowServer::SetApplicationMenubar>(m_menubar_id);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::SetApplicationMenubar>(m_menubar_id);
 }
 
 void MenuBar::notify_removed_from_application(Badge<Application>)

Libraries/LibGUI/GMenuItem.cpp

@@ -85,7 +85,7 @@ void MenuItem::update_window_server()
         return;
     auto& action = *m_action;
     auto shortcut_text = action.shortcut().is_valid() ? action.shortcut().to_string() : String();
-    WindowServerConnection::the().send_sync<WindowServer::UpdateMenuItem>(m_menu_id, m_identifier, -1, action.text(), action.is_enabled(), action.is_checkable(), action.is_checkable() ? action.is_checked() : false, shortcut_text);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::UpdateMenuItem>(m_menu_id, m_identifier, -1, action.text(), action.is_enabled(), action.is_checkable(), action.is_checkable() ? action.is_checked() : false, shortcut_text);
 }
 
 }

Libraries/LibGUI/GWindow.cpp

@@ -79,14 +79,14 @@ void Window::move_to_front()
     if (!m_window_id)
         return;
 
-    WindowServerConnection::the().send_sync<WindowServer::MoveWindowToFront>(m_window_id);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::MoveWindowToFront>(m_window_id);
 }
 
 void Window::show()
 {
     if (m_window_id)
         return;
-    auto response = WindowServerConnection::the().send_sync<WindowServer::CreateWindow>(
+    auto response = WindowServerConnection::the().send_sync<Messages::WindowServer::CreateWindow>(
         m_rect_when_windowless,
         m_has_alpha_channel,
         m_modal,
@@ -113,7 +113,7 @@ void Window::hide()
     if (!m_window_id)
         return;
     reified_windows->remove(m_window_id);
-    WindowServerConnection::the().send_sync<WindowServer::DestroyWindow>(m_window_id);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::DestroyWindow>(m_window_id);
     m_window_id = 0;
     m_pending_paint_event_rects.clear();
     m_back_bitmap = nullptr;
@@ -135,21 +135,21 @@ void Window::set_title(const StringView& title)
     m_title_when_windowless = title;
     if (!m_window_id)
         return;
-    WindowServerConnection::the().send_sync<WindowServer::SetWindowTitle>(m_window_id, title);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::SetWindowTitle>(m_window_id, title);
 }
 
 String Window::title() const
 {
     if (!m_window_id)
         return m_title_when_windowless;
-    return WindowServerConnection::the().send_sync<WindowServer::GetWindowTitle>(m_window_id)->title();
+    return WindowServerConnection::the().send_sync<Messages::WindowServer::GetWindowTitle>(m_window_id)->title();
 }
 
 Gfx::Rect Window::rect() const
 {
     if (!m_window_id)
         return m_rect_when_windowless;
-    return WindowServerConnection::the().send_sync<WindowServer::GetWindowRect>(m_window_id)->rect();
+    return WindowServerConnection::the().send_sync<Messages::WindowServer::GetWindowRect>(m_window_id)->rect();
 }
 
 void Window::set_rect(const Gfx::Rect& a_rect)
@@ -160,7 +160,7 @@ void Window::set_rect(const Gfx::Rect& a_rect)
             m_main_widget->resize(m_rect_when_windowless.size());
         return;
     }
-    WindowServerConnection::the().send_sync<WindowServer::SetWindowRect>(m_window_id, a_rect);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::SetWindowRect>(m_window_id, a_rect);
     if (m_back_bitmap && m_back_bitmap->size() != a_rect.size())
         m_back_bitmap = nullptr;
     if (m_front_bitmap && m_front_bitmap->size() != a_rect.size())
@@ -178,7 +178,7 @@ void Window::set_override_cursor(StandardCursor cursor)
 {
     if (!m_window_id)
         return;
-    WindowServerConnection::the().send_sync<WindowServer::SetWindowOverrideCursor>(m_window_id, (u32)cursor);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::SetWindowOverrideCursor>(m_window_id, (u32)cursor);
 }
 
 void Window::event(Core::Event& event)
@@ -267,7 +267,7 @@ void Window::event(Core::Event& event)
             Vector<Gfx::Rect> rects_to_send;
             for (auto& r : rects)
                 rects_to_send.append(r);
-            WindowServerConnection::the().post_message(WindowServer::DidFinishPainting(m_window_id, rects_to_send));
+            WindowServerConnection::the().post_message(Messages::WindowServer::DidFinishPainting(m_window_id, rects_to_send));
         }
         return;
     }
@@ -354,7 +354,7 @@ void Window::update(const Gfx::Rect& a_rect)
             Vector<Gfx::Rect> rects_to_send;
             for (auto& r : rects)
                 rects_to_send.append(r);
-            WindowServerConnection::the().post_message(WindowServer::InvalidateRect(m_window_id, rects_to_send));
+            WindowServerConnection::the().post_message(Messages::WindowServer::InvalidateRect(m_window_id, rects_to_send));
         });
     }
     m_pending_paint_event_rects.append(a_rect);
@@ -424,7 +424,7 @@ void Window::set_has_alpha_channel(bool value)
     m_back_bitmap = nullptr;
     m_front_bitmap = nullptr;
 
-    WindowServerConnection::the().send_sync<WindowServer::SetWindowHasAlphaChannel>(m_window_id, value);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::SetWindowHasAlphaChannel>(m_window_id, value);
     update();
 }
 
@@ -439,7 +439,7 @@ void Window::set_opacity(float opacity)
     m_opacity_when_windowless = opacity;
     if (!m_window_id)
         return;
-    WindowServerConnection::the().send_sync<WindowServer::SetWindowOpacity>(m_window_id, opacity);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::SetWindowOpacity>(m_window_id, opacity);
 }
 
 void Window::set_hovered_widget(Widget* widget)
@@ -458,7 +458,7 @@ void Window::set_hovered_widget(Widget* widget)
 
 void Window::set_current_backing_bitmap(Gfx::Bitmap& bitmap, bool flush_immediately)
 {
-    WindowServerConnection::the().send_sync<WindowServer::SetWindowBackingStore>(m_window_id, 32, bitmap.pitch(), bitmap.shared_buffer_id(), bitmap.has_alpha_channel(), bitmap.size(), flush_immediately);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::SetWindowBackingStore>(m_window_id, 32, bitmap.pitch(), bitmap.shared_buffer_id(), bitmap.has_alpha_channel(), bitmap.size(), flush_immediately);
 }
 
 void Window::flip(const Vector<Gfx::Rect, 32>& dirty_rects)
@@ -542,12 +542,12 @@ void Window::apply_icon()
     if (!has_set_process_icon)
         set_process_icon(m_icon->shared_buffer_id());
 
-    WindowServerConnection::the().send_sync<WindowServer::SetWindowIconBitmap>(m_window_id, m_icon->shared_buffer_id(), m_icon->size());
+    WindowServerConnection::the().send_sync<Messages::WindowServer::SetWindowIconBitmap>(m_window_id, m_icon->shared_buffer_id(), m_icon->size());
 }
 
 void Window::start_wm_resize()
 {
-    WindowServerConnection::the().post_message(WindowServer::WM_StartWindowResize(WindowServerConnection::the().my_client_id(), m_window_id));
+    WindowServerConnection::the().post_message(Messages::WindowServer::WM_StartWindowResize(WindowServerConnection::the().my_client_id(), m_window_id));
 }
 
 Vector<Widget*> Window::focusable_widgets() const
@@ -595,7 +595,7 @@ void Window::set_fullscreen(bool fullscreen)
     m_fullscreen = fullscreen;
     if (!m_window_id)
         return;
-    WindowServerConnection::the().send_sync<WindowServer::SetFullscreen>(m_window_id, fullscreen);
+    WindowServerConnection::the().send_sync<Messages::WindowServer::SetFullscreen>(m_window_id, fullscreen);
 }
 
 void Window::schedule_relayout()

Libraries/LibGUI/GWindowServerConnection.cpp

@@ -59,19 +59,19 @@ static void set_system_theme_from_shared_buffer_id(int id)
 
 void WindowServerConnection::handshake()
 {
-    auto response = send_sync<WindowServer::Greet>();
+    auto response = send_sync<Messages::WindowServer::Greet>();
     set_my_client_id(response->client_id());
     set_system_theme_from_shared_buffer_id(response->system_theme_buffer_id());
     Desktop::the().did_receive_screen_rect({}, response->screen_rect());
 }
 
-void WindowServerConnection::handle(const WindowClient::UpdateSystemTheme& message)
+void WindowServerConnection::handle(const Messages::WindowClient::UpdateSystemTheme& message)
 {
     set_system_theme_from_shared_buffer_id(message.system_theme_buffer_id());
     Window::update_all_windows({});
 }
 
-void WindowServerConnection::handle(const WindowClient::Paint& message)
+void WindowServerConnection::handle(const Messages::WindowClient::Paint& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("WID=%d Paint\n", message.window_id());
@@ -80,14 +80,14 @@ void WindowServerConnection::handle(const WindowClient::Paint& message)
         Core::EventLoop::current().post_event(*window, make<MultiPaintEvent>(message.rects(), message.window_size()));
 }
 
-void WindowServerConnection::handle(const WindowClient::WindowResized& message)
+void WindowServerConnection::handle(const Messages::WindowClient::WindowResized& message)
 {
     if (auto* window = Window::from_window_id(message.window_id())) {
         Core::EventLoop::current().post_event(*window, make<ResizeEvent>(message.old_rect().size(), message.new_rect().size()));
     }
 }
 
-void WindowServerConnection::handle(const WindowClient::WindowActivated& message)
+void WindowServerConnection::handle(const Messages::WindowClient::WindowActivated& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("(%d) WID=%d WindowActivated\n", getpid(), message.window_id());
@@ -96,7 +96,7 @@ void WindowServerConnection::handle(const WindowClient::WindowActivated& message
         Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowBecameActive));
 }
 
-void WindowServerConnection::handle(const WindowClient::WindowDeactivated& message)
+void WindowServerConnection::handle(const Messages::WindowClient::WindowDeactivated& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("(%d) WID=%d WindowDeactivated\n", getpid(), message.window_id());
@@ -105,25 +105,25 @@ void WindowServerConnection::handle(const WindowClient::WindowDeactivated& messa
         Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowBecameInactive));
 }
 
-void WindowServerConnection::handle(const WindowClient::WindowCloseRequest& message)
+void WindowServerConnection::handle(const Messages::WindowClient::WindowCloseRequest& message)
 {
     if (auto* window = Window::from_window_id(message.window_id()))
         Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowCloseRequest));
 }
 
-void WindowServerConnection::handle(const WindowClient::WindowEntered& message)
+void WindowServerConnection::handle(const Messages::WindowClient::WindowEntered& message)
 {
     if (auto* window = Window::from_window_id(message.window_id()))
         Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowEntered));
 }
 
-void WindowServerConnection::handle(const WindowClient::WindowLeft& message)
+void WindowServerConnection::handle(const Messages::WindowClient::WindowLeft& message)
 {
     if (auto* window = Window::from_window_id(message.window_id()))
         Core::EventLoop::current().post_event(*window, make<Event>(Event::WindowLeft));
 }
 
-void WindowServerConnection::handle(const WindowClient::KeyDown& message)
+void WindowServerConnection::handle(const Messages::WindowClient::KeyDown& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("WID=%d KeyDown character=0x%02x\n", message.window_id(), message.character());
@@ -156,7 +156,7 @@ void WindowServerConnection::handle(const WindowClient::KeyDown& message)
     Core::EventLoop::current().post_event(*window, move(key_event));
 }
 
-void WindowServerConnection::handle(const WindowClient::KeyUp& message)
+void WindowServerConnection::handle(const Messages::WindowClient::KeyUp& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("WID=%d KeyUp character=0x%02x\n", message.window_id(), message.character());
@@ -191,7 +191,7 @@ MouseButton to_gmousebutton(u32 button)
     }
 }
 
-void WindowServerConnection::handle(const WindowClient::MouseDown& message)
+void WindowServerConnection::handle(const Messages::WindowClient::MouseDown& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("WID=%d MouseDown %d,%d,%d\n", message.window_id(), message.mouse_position().x(), message.mouse_position().y(), message.wheel_delta();
@@ -201,7 +201,7 @@ void WindowServerConnection::handle(const WindowClient::MouseDown& message)
         Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseDown, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
 }
 
-void WindowServerConnection::handle(const WindowClient::MouseUp& message)
+void WindowServerConnection::handle(const Messages::WindowClient::MouseUp& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("WID=%d MouseUp %d,%d,%d\n", message.window_id(), message.mouse_position().x(), message.mouse_position().y(), message.wheel_delta();
@@ -211,7 +211,7 @@ void WindowServerConnection::handle(const WindowClient::MouseUp& message)
         Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseUp, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
 }
 
-void WindowServerConnection::handle(const WindowClient::MouseMove& message)
+void WindowServerConnection::handle(const Messages::WindowClient::MouseMove& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("WID=%d MouseMove %d,%d,%d\n", message.window_id(), message.mouse_position().x(), message.mouse_position().y(), message.wheel_delta();
@@ -221,7 +221,7 @@ void WindowServerConnection::handle(const WindowClient::MouseMove& message)
         Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseMove, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
 }
 
-void WindowServerConnection::handle(const WindowClient::MouseDoubleClick& message)
+void WindowServerConnection::handle(const Messages::WindowClient::MouseDoubleClick& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("WID=%d MouseDoubleClick %d,%d,%d\n", message.window_id(), message.mouse_position().x(), message.mouse_position().y(), message.wheel_delta();
@@ -231,7 +231,7 @@ void WindowServerConnection::handle(const WindowClient::MouseDoubleClick& messag
         Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseDoubleClick, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
 }
 
-void WindowServerConnection::handle(const WindowClient::MouseWheel& message)
+void WindowServerConnection::handle(const Messages::WindowClient::MouseWheel& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("WID=%d MouseWheel %d,%d,%d\n", message.window_id(), message.mouse_position().x(), message.mouse_position().y(), message.wheel_delta();
@@ -241,7 +241,7 @@ void WindowServerConnection::handle(const WindowClient::MouseWheel& message)
         Core::EventLoop::current().post_event(*window, make<MouseEvent>(Event::MouseWheel, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
 }
 
-void WindowServerConnection::handle(const WindowClient::MenuItemActivated& message)
+void WindowServerConnection::handle(const Messages::WindowClient::MenuItemActivated& message)
 {
     auto* menu = Menu::from_menu_id(message.menu_id());
     if (!menu) {
@@ -252,7 +252,7 @@ void WindowServerConnection::handle(const WindowClient::MenuItemActivated& messa
         action->activate(menu);
 }
 
-void WindowServerConnection::handle(const WindowClient::WM_WindowStateChanged& message)
+void WindowServerConnection::handle(const Messages::WindowClient::WM_WindowStateChanged& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("EventLoop: handle_wm_event: %d\n", (int)event.type);
@@ -261,7 +261,7 @@ void WindowServerConnection::handle(const WindowClient::WM_WindowStateChanged& m
         Core::EventLoop::current().post_event(*window, make<WMWindowStateChangedEvent>(message.client_id(), message.window_id(), message.title(), message.rect(), message.is_active(), static_cast<WindowType>(message.window_type()), message.is_minimized()));
 }
 
-void WindowServerConnection::handle(const WindowClient::WM_WindowRectChanged& message)
+void WindowServerConnection::handle(const Messages::WindowClient::WM_WindowRectChanged& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("EventLoop: handle_wm_event: %d\n", (int)event.type);
@@ -270,7 +270,7 @@ void WindowServerConnection::handle(const WindowClient::WM_WindowRectChanged& me
         Core::EventLoop::current().post_event(*window, make<WMWindowRectChangedEvent>(message.client_id(), message.window_id(), message.rect()));
 }
 
-void WindowServerConnection::handle(const WindowClient::WM_WindowIconBitmapChanged& message)
+void WindowServerConnection::handle(const Messages::WindowClient::WM_WindowIconBitmapChanged& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("EventLoop: handle_wm_event: %d\n", (int)event.type);
@@ -279,7 +279,7 @@ void WindowServerConnection::handle(const WindowClient::WM_WindowIconBitmapChang
         Core::EventLoop::current().post_event(*window, make<WMWindowIconBitmapChangedEvent>(message.client_id(), message.window_id(), message.icon_buffer_id(), message.icon_size()));
 }
 
-void WindowServerConnection::handle(const WindowClient::WM_WindowRemoved& message)
+void WindowServerConnection::handle(const Messages::WindowClient::WM_WindowRemoved& message)
 {
 #ifdef GEVENTLOOP_DEBUG
     dbgprintf("EventLoop: handle_wm_event: %d\n", (int)event.type);
@@ -288,38 +288,38 @@ void WindowServerConnection::handle(const WindowClient::WM_WindowRemoved& messag
         Core::EventLoop::current().post_event(*window, make<WMWindowRemovedEvent>(message.client_id(), message.window_id()));
 }
 
-void WindowServerConnection::handle(const WindowClient::ScreenRectChanged& message)
+void WindowServerConnection::handle(const Messages::WindowClient::ScreenRectChanged& message)
 {
     Desktop::the().did_receive_screen_rect({}, message.rect());
 }
 
-void WindowServerConnection::handle(const WindowClient::ClipboardContentsChanged& message)
+void WindowServerConnection::handle(const Messages::WindowClient::ClipboardContentsChanged& message)
 {
     Clipboard::the().did_receive_clipboard_contents_changed({}, message.content_type());
 }
 
-void WindowServerConnection::handle(const WindowClient::AsyncSetWallpaperFinished&)
+void WindowServerConnection::handle(const Messages::WindowClient::AsyncSetWallpaperFinished&)
 {
     // This is handled manually by Desktop::set_wallpaper().
 }
 
-void WindowServerConnection::handle(const WindowClient::DragDropped& message)
+void WindowServerConnection::handle(const Messages::WindowClient::DragDropped& message)
 {
     if (auto* window = Window::from_window_id(message.window_id()))
         Core::EventLoop::current().post_event(*window, make<DropEvent>(message.mouse_position(), message.text(), message.data_type(), message.data()));
 }
 
-void WindowServerConnection::handle(const WindowClient::DragAccepted&)
+void WindowServerConnection::handle(const Messages::WindowClient::DragAccepted&)
 {
     DragOperation::notify_accepted({});
 }
 
-void WindowServerConnection::handle(const WindowClient::DragCancelled&)
+void WindowServerConnection::handle(const Messages::WindowClient::DragCancelled&)
 {
     DragOperation::notify_cancelled({});
 }
 
-void WindowServerConnection::handle(const WindowClient::WindowStateChanged& message)
+void WindowServerConnection::handle(const Messages::WindowClient::WindowStateChanged& message)
 {
     if (auto* window = Window::from_window_id(message.window_id()))
         window->notify_state_changed({}, message.minimized(), message.occluded());

Libraries/LibGUI/GWindowServerConnection.h

@@ -47,33 +47,33 @@ public:
     static WindowServerConnection& the();
 
 private:
-    virtual void handle(const WindowClient::Paint&) override;
+    virtual void handle(const Messages::WindowClient::Paint&) override;
-    virtual void handle(const WindowClient::MouseMove&) override;
+    virtual void handle(const Messages::WindowClient::MouseMove&) override;
-    virtual void handle(const WindowClient::MouseDown&) override;
+    virtual void handle(const Messages::WindowClient::MouseDown&) override;
-    virtual void handle(const WindowClient::MouseDoubleClick&) override;
+    virtual void handle(const Messages::WindowClient::MouseDoubleClick&) override;
-    virtual void handle(const WindowClient::MouseUp&) override;
+    virtual void handle(const Messages::WindowClient::MouseUp&) override;
-    virtual void handle(const WindowClient::MouseWheel&) override;
+    virtual void handle(const Messages::WindowClient::MouseWheel&) override;
-    virtual void handle(const WindowClient::WindowEntered&) override;
+    virtual void handle(const Messages::WindowClient::WindowEntered&) override;
-    virtual void handle(const WindowClient::WindowLeft&) override;
+    virtual void handle(const Messages::WindowClient::WindowLeft&) override;
-    virtual void handle(const WindowClient::KeyDown&) override;
+    virtual void handle(const Messages::WindowClient::KeyDown&) override;
-    virtual void handle(const WindowClient::KeyUp&) override;
+    virtual void handle(const Messages::WindowClient::KeyUp&) override;
-    virtual void handle(const WindowClient::WindowActivated&) override;
+    virtual void handle(const Messages::WindowClient::WindowActivated&) override;
-    virtual void handle(const WindowClient::WindowDeactivated&) override;
+    virtual void handle(const Messages::WindowClient::WindowDeactivated&) override;
-    virtual void handle(const WindowClient::WindowCloseRequest&) override;
+    virtual void handle(const Messages::WindowClient::WindowCloseRequest&) override;
-    virtual void handle(const WindowClient::WindowResized&) override;
+    virtual void handle(const Messages::WindowClient::WindowResized&) override;
-    virtual void handle(const WindowClient::MenuItemActivated&) override;
+    virtual void handle(const Messages::WindowClient::MenuItemActivated&) override;
-    virtual void handle(const WindowClient::ScreenRectChanged&) override;
+    virtual void handle(const Messages::WindowClient::ScreenRectChanged&) override;
-    virtual void handle(const WindowClient::ClipboardContentsChanged&) override;
+    virtual void handle(const Messages::WindowClient::ClipboardContentsChanged&) override;
-    virtual void handle(const WindowClient::WM_WindowRemoved&) override;
+    virtual void handle(const Messages::WindowClient::WM_WindowRemoved&) override;
-    virtual void handle(const WindowClient::WM_WindowStateChanged&) override;
+    virtual void handle(const Messages::WindowClient::WM_WindowStateChanged&) override;
-    virtual void handle(const WindowClient::WM_WindowIconBitmapChanged&) override;
+    virtual void handle(const Messages::WindowClient::WM_WindowIconBitmapChanged&) override;
-    virtual void handle(const WindowClient::WM_WindowRectChanged&) override;
+    virtual void handle(const Messages::WindowClient::WM_WindowRectChanged&) override;
-    virtual void handle(const WindowClient::AsyncSetWallpaperFinished&) override;
+    virtual void handle(const Messages::WindowClient::AsyncSetWallpaperFinished&) override;
-    virtual void handle(const WindowClient::DragDropped&) override;
+    virtual void handle(const Messages::WindowClient::DragDropped&) override;
-    virtual void handle(const WindowClient::DragAccepted&) override;
+    virtual void handle(const Messages::WindowClient::DragAccepted&) override;
-    virtual void handle(const WindowClient::DragCancelled&) override;
+    virtual void handle(const Messages::WindowClient::DragCancelled&) override;
-    virtual void handle(const WindowClient::UpdateSystemTheme&) override;
+    virtual void handle(const Messages::WindowClient::UpdateSystemTheme&) override;
-    virtual void handle(const WindowClient::WindowStateChanged&) override;
+    virtual void handle(const Messages::WindowClient::WindowStateChanged&) override;
 };
 
 }

Libraries/LibProtocol/Client.cpp

@@ -38,18 +38,18 @@ Client::Client()
 
 void Client::handshake()
 {
-    auto response = send_sync<ProtocolServer::Greet>();
+    auto response = send_sync<Messages::ProtocolServer::Greet>();
     set_my_client_id(response->client_id());
 }
 
 bool Client::is_supported_protocol(const String& protocol)
 {
-    return send_sync<ProtocolServer::IsSupportedProtocol>(protocol)->supported();
+    return send_sync<Messages::ProtocolServer::IsSupportedProtocol>(protocol)->supported();
 }
 
 RefPtr<Download> Client::start_download(const String& url)
 {
-    i32 download_id = send_sync<ProtocolServer::StartDownload>(url)->download_id();
+    i32 download_id = send_sync<Messages::ProtocolServer::StartDownload>(url)->download_id();
     auto download = Download::create_from_id({}, *this, download_id);
     m_downloads.set(download_id, download);
     return download;
@@ -59,20 +59,20 @@ bool Client::stop_download(Badge<Download>, Download& download)
 {
     if (!m_downloads.contains(download.id()))
         return false;
-    return send_sync<ProtocolServer::StopDownload>(download.id())->success();
+    return send_sync<Messages::ProtocolServer::StopDownload>(download.id())->success();
 }
 
-void Client::handle(const ProtocolClient::DownloadFinished& message)
+void Client::handle(const Messages::ProtocolClient::DownloadFinished& message)
 {
     RefPtr<Download> download;
     if ((download = m_downloads.get(message.download_id()).value_or(nullptr))) {
         download->did_finish({}, message.success(), message.total_size(), message.shared_buffer_id());
     }
-    send_sync<ProtocolServer::DisownSharedBuffer>(message.shared_buffer_id());
+    send_sync<Messages::ProtocolServer::DisownSharedBuffer>(message.shared_buffer_id());
     m_downloads.remove(message.download_id());
 }
 
-void Client::handle(const ProtocolClient::DownloadProgress& message)
+void Client::handle(const Messages::ProtocolClient::DownloadProgress& message)
 {
     if (auto download = m_downloads.get(message.download_id()).value_or(nullptr)) {
         download->did_progress({}, message.total_size(), message.downloaded_size());

Libraries/LibProtocol/Client.h

@@ -48,8 +48,8 @@ public:
     bool stop_download(Badge<Download>, Download&);
 
 private:
-    virtual void handle(const ProtocolClient::DownloadProgress&) override;
+    virtual void handle(const Messages::ProtocolClient::DownloadProgress&) override;
-    virtual void handle(const ProtocolClient::DownloadFinished&) override;
+    virtual void handle(const Messages::ProtocolClient::DownloadFinished&) override;
 
     HashMap<i32, RefPtr<Download>> m_downloads;
 };

Servers/AudioServer/ASClientConnection.cpp

@@ -66,31 +66,31 @@ void ASClientConnection::die()
 
 void ASClientConnection::did_finish_playing_buffer(Badge<ASBufferQueue>, int buffer_id)
 {
-    post_message(AudioClient::FinishedPlayingBuffer(buffer_id));
+    post_message(Messages::AudioClient::FinishedPlayingBuffer(buffer_id));
 }
 
 void ASClientConnection::did_change_muted_state(Badge<ASMixer>, bool muted)
 {
-    post_message(AudioClient::MutedStateChanged(muted));
+    post_message(Messages::AudioClient::MutedStateChanged(muted));
 }
 
-OwnPtr<AudioServer::GreetResponse> ASClientConnection::handle(const AudioServer::Greet&)
+OwnPtr<Messages::AudioServer::GreetResponse> ASClientConnection::handle(const Messages::AudioServer::Greet&)
 {
-    return make<AudioServer::GreetResponse>(client_id());
+    return make<Messages::AudioServer::GreetResponse>(client_id());
 }
 
-OwnPtr<AudioServer::GetMainMixVolumeResponse> ASClientConnection::handle(const AudioServer::GetMainMixVolume&)
+OwnPtr<Messages::AudioServer::GetMainMixVolumeResponse> ASClientConnection::handle(const Messages::AudioServer::GetMainMixVolume&)
 {
-    return make<AudioServer::GetMainMixVolumeResponse>(m_mixer.main_volume());
+    return make<Messages::AudioServer::GetMainMixVolumeResponse>(m_mixer.main_volume());
 }
 
-OwnPtr<AudioServer::SetMainMixVolumeResponse> ASClientConnection::handle(const AudioServer::SetMainMixVolume& message)
+OwnPtr<Messages::AudioServer::SetMainMixVolumeResponse> ASClientConnection::handle(const Messages::AudioServer::SetMainMixVolume& message)
 {
     m_mixer.set_main_volume(message.volume());
-    return make<AudioServer::SetMainMixVolumeResponse>();
+    return make<Messages::AudioServer::SetMainMixVolumeResponse>();
 }
 
-OwnPtr<AudioServer::EnqueueBufferResponse> ASClientConnection::handle(const AudioServer::EnqueueBuffer& message)
+OwnPtr<Messages::AudioServer::EnqueueBufferResponse> ASClientConnection::handle(const Messages::AudioServer::EnqueueBuffer& message)
 {
     auto shared_buffer = SharedBuffer::create_from_shared_buffer_id(message.buffer_id());
     if (!shared_buffer) {
@@ -103,59 +103,59 @@ OwnPtr<AudioServer::EnqueueBufferResponse> ASClientConnection::handle(const Audi
         m_queue = m_mixer.create_queue(*this);
 
     if (m_queue->is_full())
-        return make<AudioServer::EnqueueBufferResponse>(false);
+        return make<Messages::AudioServer::EnqueueBufferResponse>(false);
 
     m_queue->enqueue(Audio::Buffer::create_with_shared_buffer(*shared_buffer, message.sample_count()));
-    return make<AudioServer::EnqueueBufferResponse>(true);
+    return make<Messages::AudioServer::EnqueueBufferResponse>(true);
 }
 
-OwnPtr<AudioServer::GetRemainingSamplesResponse> ASClientConnection::handle(const AudioServer::GetRemainingSamples&)
+OwnPtr<Messages::AudioServer::GetRemainingSamplesResponse> ASClientConnection::handle(const Messages::AudioServer::GetRemainingSamples&)
 {
     int remaining = 0;
     if (m_queue)
         remaining = m_queue->get_remaining_samples();
 
-    return make<AudioServer::GetRemainingSamplesResponse>(remaining);
+    return make<Messages::AudioServer::GetRemainingSamplesResponse>(remaining);
 }
 
-OwnPtr<AudioServer::GetPlayedSamplesResponse> ASClientConnection::handle(const AudioServer::GetPlayedSamples&)
+OwnPtr<Messages::AudioServer::GetPlayedSamplesResponse> ASClientConnection::handle(const Messages::AudioServer::GetPlayedSamples&)
 {
     int played = 0;
     if (m_queue)
         played = m_queue->get_played_samples();
 
-    return make<AudioServer::GetPlayedSamplesResponse>(played);
+    return make<Messages::AudioServer::GetPlayedSamplesResponse>(played);
 }
 
-OwnPtr<AudioServer::SetPausedResponse> ASClientConnection::handle(const AudioServer::SetPaused& message)
+OwnPtr<Messages::AudioServer::SetPausedResponse> ASClientConnection::handle(const Messages::AudioServer::SetPaused& message)
 {
     if (m_queue)
         m_queue->set_paused(message.paused());
-    return make<AudioServer::SetPausedResponse>();
+    return make<Messages::AudioServer::SetPausedResponse>();
 }
 
-OwnPtr<AudioServer::ClearBufferResponse> ASClientConnection::handle(const AudioServer::ClearBuffer& message)
+OwnPtr<Messages::AudioServer::ClearBufferResponse> ASClientConnection::handle(const Messages::AudioServer::ClearBuffer& message)
 {
     if (m_queue)
         m_queue->clear(message.paused());
-    return make<AudioServer::ClearBufferResponse>();
+    return make<Messages::AudioServer::ClearBufferResponse>();
 }
 
-OwnPtr<AudioServer::GetPlayingBufferResponse> ASClientConnection::handle(const AudioServer::GetPlayingBuffer&)
+OwnPtr<Messages::AudioServer::GetPlayingBufferResponse> ASClientConnection::handle(const Messages::AudioServer::GetPlayingBuffer&)
 {
     int id = -1;
     if (m_queue)
         id = m_queue->get_playing_buffer();
-    return make<AudioServer::GetPlayingBufferResponse>(id);
+    return make<Messages::AudioServer::GetPlayingBufferResponse>(id);
 }
 
-OwnPtr<AudioServer::GetMutedResponse> ASClientConnection::handle(const AudioServer::GetMuted&)
+OwnPtr<Messages::AudioServer::GetMutedResponse> ASClientConnection::handle(const Messages::AudioServer::GetMuted&)
 {
-    return make<AudioServer::GetMutedResponse>(m_mixer.is_muted());
+    return make<Messages::AudioServer::GetMutedResponse>(m_mixer.is_muted());
 }
 
-OwnPtr<AudioServer::SetMutedResponse> ASClientConnection::handle(const AudioServer::SetMuted& message)
+OwnPtr<Messages::AudioServer::SetMutedResponse> ASClientConnection::handle(const Messages::AudioServer::SetMuted& message)
 {
     m_mixer.set_muted(message.muted());
-    return make<AudioServer::SetMutedResponse>();
+    return make<Messages::AudioServer::SetMutedResponse>();
 }

Servers/AudioServer/ASClientConnection.h

@@ -51,17 +51,17 @@ public:
     static void for_each(Function<void(ASClientConnection&)>);
 
 private:
-    virtual OwnPtr<AudioServer::GreetResponse> handle(const AudioServer::Greet&) override;
+    virtual OwnPtr<Messages::AudioServer::GreetResponse> handle(const Messages::AudioServer::Greet&) override;
-    virtual OwnPtr<AudioServer::GetMainMixVolumeResponse> handle(const AudioServer::GetMainMixVolume&) override;
+    virtual OwnPtr<Messages::AudioServer::GetMainMixVolumeResponse> handle(const Messages::AudioServer::GetMainMixVolume&) override;
-    virtual OwnPtr<AudioServer::SetMainMixVolumeResponse> handle(const AudioServer::SetMainMixVolume&) override;
+    virtual OwnPtr<Messages::AudioServer::SetMainMixVolumeResponse> handle(const Messages::AudioServer::SetMainMixVolume&) override;
-    virtual OwnPtr<AudioServer::EnqueueBufferResponse> handle(const AudioServer::EnqueueBuffer&) override;
+    virtual OwnPtr<Messages::AudioServer::EnqueueBufferResponse> handle(const Messages::AudioServer::EnqueueBuffer&) override;
-    virtual OwnPtr<AudioServer::GetRemainingSamplesResponse> handle(const AudioServer::GetRemainingSamples&) override;
+    virtual OwnPtr<Messages::AudioServer::GetRemainingSamplesResponse> handle(const Messages::AudioServer::GetRemainingSamples&) override;
-    virtual OwnPtr<AudioServer::GetPlayedSamplesResponse> handle(const AudioServer::GetPlayedSamples&) override;
+    virtual OwnPtr<Messages::AudioServer::GetPlayedSamplesResponse> handle(const Messages::AudioServer::GetPlayedSamples&) override;
-    virtual OwnPtr<AudioServer::SetPausedResponse> handle(const AudioServer::SetPaused&) override;
+    virtual OwnPtr<Messages::AudioServer::SetPausedResponse> handle(const Messages::AudioServer::SetPaused&) override;
-    virtual OwnPtr<AudioServer::ClearBufferResponse> handle(const AudioServer::ClearBuffer&) override;
+    virtual OwnPtr<Messages::AudioServer::ClearBufferResponse> handle(const Messages::AudioServer::ClearBuffer&) override;
-    virtual OwnPtr<AudioServer::GetPlayingBufferResponse> handle(const AudioServer::GetPlayingBuffer&) override;
+    virtual OwnPtr<Messages::AudioServer::GetPlayingBufferResponse> handle(const Messages::AudioServer::GetPlayingBuffer&) override;
-    virtual OwnPtr<AudioServer::GetMutedResponse> handle(const AudioServer::GetMuted&) override;
+    virtual OwnPtr<Messages::AudioServer::GetMutedResponse> handle(const Messages::AudioServer::GetMuted&) override;
-    virtual OwnPtr<AudioServer::SetMutedResponse> handle(const AudioServer::SetMuted&) override;
+    virtual OwnPtr<Messages::AudioServer::SetMutedResponse> handle(const Messages::AudioServer::SetMuted&) override;
 
     ASMixer& m_mixer;
     RefPtr<ASBufferQueue> m_queue;

Servers/ProtocolServer/PSClientConnection.cpp

@@ -47,30 +47,30 @@ void PSClientConnection::die()
     s_connections.remove(client_id());
 }
 
-OwnPtr<ProtocolServer::IsSupportedProtocolResponse> PSClientConnection::handle(const ProtocolServer::IsSupportedProtocol& message)
+OwnPtr<Messages::ProtocolServer::IsSupportedProtocolResponse> PSClientConnection::handle(const Messages::ProtocolServer::IsSupportedProtocol& message)
 {
     bool supported = Protocol::find_by_name(message.protocol().to_lowercase());
-    return make<ProtocolServer::IsSupportedProtocolResponse>(supported);
+    return make<Messages::ProtocolServer::IsSupportedProtocolResponse>(supported);
 }
 
-OwnPtr<ProtocolServer::StartDownloadResponse> PSClientConnection::handle(const ProtocolServer::StartDownload& message)
+OwnPtr<Messages::ProtocolServer::StartDownloadResponse> PSClientConnection::handle(const Messages::ProtocolServer::StartDownload& message)
 {
     URL url(message.url());
     ASSERT(url.is_valid());
     auto* protocol = Protocol::find_by_name(url.protocol());
     ASSERT(protocol);
     auto download = protocol->start_download(*this, url);
-    return make<ProtocolServer::StartDownloadResponse>(download->id());
+    return make<Messages::ProtocolServer::StartDownloadResponse>(download->id());
 }
 
-OwnPtr<ProtocolServer::StopDownloadResponse> PSClientConnection::handle(const ProtocolServer::StopDownload& message)
+OwnPtr<Messages::ProtocolServer::StopDownloadResponse> PSClientConnection::handle(const Messages::ProtocolServer::StopDownload& message)
 {
     auto* download = Download::find_by_id(message.download_id());
     bool success = false;
     if (download) {
         download->stop();
     }
-    return make<ProtocolServer::StopDownloadResponse>(success);
+    return make<Messages::ProtocolServer::StopDownloadResponse>(success);
 }
 
 void PSClientConnection::did_finish_download(Badge<Download>, Download& download, bool success)
@@ -83,21 +83,21 @@ void PSClientConnection::did_finish_download(Badge<Download>, Download& download
         buffer->share_with(client_pid());
         m_shared_buffers.set(buffer->shared_buffer_id(), buffer);
     }
-    post_message(ProtocolClient::DownloadFinished(download.id(), success, download.total_size(), buffer ? buffer->shared_buffer_id() : -1));
+    post_message(Messages::ProtocolClient::DownloadFinished(download.id(), success, download.total_size(), buffer ? buffer->shared_buffer_id() : -1));
 }
 
 void PSClientConnection::did_progress_download(Badge<Download>, Download& download)
 {
-    post_message(ProtocolClient::DownloadProgress(download.id(), download.total_size(), download.downloaded_size()));
+    post_message(Messages::ProtocolClient::DownloadProgress(download.id(), download.total_size(), download.downloaded_size()));
 }
 
-OwnPtr<ProtocolServer::GreetResponse> PSClientConnection::handle(const ProtocolServer::Greet&)
+OwnPtr<Messages::ProtocolServer::GreetResponse> PSClientConnection::handle(const Messages::ProtocolServer::Greet&)
 {
-    return make<ProtocolServer::GreetResponse>(client_id());
+    return make<Messages::ProtocolServer::GreetResponse>(client_id());
 }
 
-OwnPtr<ProtocolServer::DisownSharedBufferResponse> PSClientConnection::handle(const ProtocolServer::DisownSharedBuffer& message)
+OwnPtr<Messages::ProtocolServer::DisownSharedBufferResponse> PSClientConnection::handle(const Messages::ProtocolServer::DisownSharedBuffer& message)
 {
     m_shared_buffers.remove(message.shared_buffer_id());
-    return make<ProtocolServer::DisownSharedBufferResponse>();
+    return make<Messages::ProtocolServer::DisownSharedBufferResponse>();
 }

Servers/ProtocolServer/PSClientConnection.h

@@ -49,11 +49,11 @@ public:
     void did_progress_download(Badge<Download>, Download&);
 
 private:
-    virtual OwnPtr<ProtocolServer::GreetResponse> handle(const ProtocolServer::Greet&) override;
+    virtual OwnPtr<Messages::ProtocolServer::GreetResponse> handle(const Messages::ProtocolServer::Greet&) override;
-    virtual OwnPtr<ProtocolServer::IsSupportedProtocolResponse> handle(const ProtocolServer::IsSupportedProtocol&) override;
+    virtual OwnPtr<Messages::ProtocolServer::IsSupportedProtocolResponse> handle(const Messages::ProtocolServer::IsSupportedProtocol&) override;
-    virtual OwnPtr<ProtocolServer::StartDownloadResponse> handle(const ProtocolServer::StartDownload&) override;
+    virtual OwnPtr<Messages::ProtocolServer::StartDownloadResponse> handle(const Messages::ProtocolServer::StartDownload&) override;
-    virtual OwnPtr<ProtocolServer::StopDownloadResponse> handle(const ProtocolServer::StopDownload&) override;
+    virtual OwnPtr<Messages::ProtocolServer::StopDownloadResponse> handle(const Messages::ProtocolServer::StopDownload&) override;
-    virtual OwnPtr<ProtocolServer::DisownSharedBufferResponse> handle(const ProtocolServer::DisownSharedBuffer&) override;
+    virtual OwnPtr<Messages::ProtocolServer::DisownSharedBufferResponse> handle(const Messages::ProtocolServer::DisownSharedBuffer&) override;
 
     HashMap<i32, RefPtr<AK::SharedBuffer>> m_shared_buffers;
 };

Servers/WindowServer/ClientConnection.cpp

@@ -92,23 +92,23 @@ void ClientConnection::die()
 
 void ClientConnection::notify_about_new_screen_rect(const Gfx::Rect& rect)
 {
-    post_message(WindowClient::ScreenRectChanged(rect));
+    post_message(Messages::WindowClient::ScreenRectChanged(rect));
 }
 
 void ClientConnection::notify_about_clipboard_contents_changed()
 {
-    post_message(WindowClient::ClipboardContentsChanged(Clipboard::the().data_type()));
+    post_message(Messages::WindowClient::ClipboardContentsChanged(Clipboard::the().data_type()));
 }
 
-OwnPtr<WindowServer::CreateMenubarResponse> ClientConnection::handle(const WindowServer::CreateMenubar&)
+OwnPtr<Messages::WindowServer::CreateMenubarResponse> ClientConnection::handle(const Messages::WindowServer::CreateMenubar&)
 {
     int menubar_id = m_next_menubar_id++;
     auto menubar = make<MenuBar>(*this, menubar_id);
     m_menubars.set(menubar_id, move(menubar));
-    return make<WindowServer::CreateMenubarResponse>(menubar_id);
+    return make<Messages::WindowServer::CreateMenubarResponse>(menubar_id);
 }
 
-OwnPtr<WindowServer::DestroyMenubarResponse> ClientConnection::handle(const WindowServer::DestroyMenubar& message)
+OwnPtr<Messages::WindowServer::DestroyMenubarResponse> ClientConnection::handle(const Messages::WindowServer::DestroyMenubar& message)
 {
     int menubar_id = message.menubar_id();
     auto it = m_menubars.find(menubar_id);
@@ -119,18 +119,18 @@ OwnPtr<WindowServer::DestroyMenubarResponse> ClientConnection::handle(const Wind
     auto& menubar = *(*it).value;
     MenuManager::the().close_menubar(menubar);
     m_menubars.remove(it);
-    return make<WindowServer::DestroyMenubarResponse>();
+    return make<Messages::WindowServer::DestroyMenubarResponse>();
 }
 
-OwnPtr<WindowServer::CreateMenuResponse> ClientConnection::handle(const WindowServer::CreateMenu& message)
+OwnPtr<Messages::WindowServer::CreateMenuResponse> ClientConnection::handle(const Messages::WindowServer::CreateMenu& message)
 {
     int menu_id = m_next_menu_id++;
     auto menu = Menu::construct(this, menu_id, message.menu_title());
     m_menus.set(menu_id, move(menu));
-    return make<WindowServer::CreateMenuResponse>(menu_id);
+    return make<Messages::WindowServer::CreateMenuResponse>(menu_id);
 }
 
-OwnPtr<WindowServer::DestroyMenuResponse> ClientConnection::handle(const WindowServer::DestroyMenu& message)
+OwnPtr<Messages::WindowServer::DestroyMenuResponse> ClientConnection::handle(const Messages::WindowServer::DestroyMenu& message)
 {
     int menu_id = message.menu_id();
     auto it = m_menus.find(menu_id);
@@ -142,10 +142,10 @@ OwnPtr<WindowServer::DestroyMenuResponse> ClientConnection::handle(const WindowS
     menu.close();
     m_menus.remove(it);
     remove_child(menu);
-    return make<WindowServer::DestroyMenuResponse>();
+    return make<Messages::WindowServer::DestroyMenuResponse>();
 }
 
-OwnPtr<WindowServer::SetApplicationMenubarResponse> ClientConnection::handle(const WindowServer::SetApplicationMenubar& message)
+OwnPtr<Messages::WindowServer::SetApplicationMenubarResponse> ClientConnection::handle(const Messages::WindowServer::SetApplicationMenubar& message)
 {
     int menubar_id = message.menubar_id();
     auto it = m_menubars.find(menubar_id);
@@ -156,10 +156,10 @@ OwnPtr<WindowServer::SetApplicationMenubarResponse> ClientConnection::handle(con
     auto& menubar = *(*it).value;
     m_app_menubar = menubar.make_weak_ptr();
     WindowManager::the().notify_client_changed_app_menubar(*this);
-    return make<WindowServer::SetApplicationMenubarResponse>();
+    return make<Messages::WindowServer::SetApplicationMenubarResponse>();
 }
 
-OwnPtr<WindowServer::AddMenuToMenubarResponse> ClientConnection::handle(const WindowServer::AddMenuToMenubar& message)
+OwnPtr<Messages::WindowServer::AddMenuToMenubarResponse> ClientConnection::handle(const Messages::WindowServer::AddMenuToMenubar& message)
 {
     int menubar_id = message.menubar_id();
     int menu_id = message.menu_id();
@@ -176,10 +176,10 @@ OwnPtr<WindowServer::AddMenuToMenubarResponse> ClientConnection::handle(const Wi
     auto& menubar = *(*it).value;
     auto& menu = *(*jt).value;
     menubar.add_menu(menu);
-    return make<WindowServer::AddMenuToMenubarResponse>();
+    return make<Messages::WindowServer::AddMenuToMenubarResponse>();
 }
 
-OwnPtr<WindowServer::AddMenuItemResponse> ClientConnection::handle(const WindowServer::AddMenuItem& message)
+OwnPtr<Messages::WindowServer::AddMenuItemResponse> ClientConnection::handle(const Messages::WindowServer::AddMenuItem& message)
 {
     int menu_id = message.menu_id();
     unsigned identifier = message.identifier();
@@ -201,10 +201,10 @@ OwnPtr<WindowServer::AddMenuItemResponse> ClientConnection::handle(const WindowS
     menu_item->set_submenu_id(message.submenu_id());
     menu_item->set_exclusive(message.exclusive());
     menu.add_item(move(menu_item));
-    return make<WindowServer::AddMenuItemResponse>();
+    return make<Messages::WindowServer::AddMenuItemResponse>();
 }
 
-OwnPtr<WindowServer::PopupMenuResponse> ClientConnection::handle(const WindowServer::PopupMenu& message)
+OwnPtr<Messages::WindowServer::PopupMenuResponse> ClientConnection::handle(const Messages::WindowServer::PopupMenu& message)
 {
     int menu_id = message.menu_id();
     auto position = message.screen_position();
@@ -215,10 +215,10 @@ OwnPtr<WindowServer::PopupMenuResponse> ClientConnection::handle(const WindowSer
     }
     auto& menu = *(*it).value;
     menu.popup(position);
-    return make<WindowServer::PopupMenuResponse>();
+    return make<Messages::WindowServer::PopupMenuResponse>();
 }
 
-OwnPtr<WindowServer::DismissMenuResponse> ClientConnection::handle(const WindowServer::DismissMenu& message)
+OwnPtr<Messages::WindowServer::DismissMenuResponse> ClientConnection::handle(const Messages::WindowServer::DismissMenu& message)
 {
     int menu_id = message.menu_id();
     auto it = m_menus.find(menu_id);
@@ -228,10 +228,10 @@ OwnPtr<WindowServer::DismissMenuResponse> ClientConnection::handle(const WindowS
     }
     auto& menu = *(*it).value;
     menu.close();
-    return make<WindowServer::DismissMenuResponse>();
+    return make<Messages::WindowServer::DismissMenuResponse>();
 }
 
-OwnPtr<WindowServer::UpdateMenuItemResponse> ClientConnection::handle(const WindowServer::UpdateMenuItem& message)
+OwnPtr<Messages::WindowServer::UpdateMenuItemResponse> ClientConnection::handle(const Messages::WindowServer::UpdateMenuItem& message)
 {
     int menu_id = message.menu_id();
     auto it = m_menus.find(menu_id);
@@ -251,10 +251,10 @@ OwnPtr<WindowServer::UpdateMenuItemResponse> ClientConnection::handle(const Wind
     menu_item->set_checkable(message.checkable());
     if (message.checkable())
         menu_item->set_checked(message.checked());
-    return make<WindowServer::UpdateMenuItemResponse>();
+    return make<Messages::WindowServer::UpdateMenuItemResponse>();
 }
 
-OwnPtr<WindowServer::AddMenuSeparatorResponse> ClientConnection::handle(const WindowServer::AddMenuSeparator& message)
+OwnPtr<Messages::WindowServer::AddMenuSeparatorResponse> ClientConnection::handle(const Messages::WindowServer::AddMenuSeparator& message)
 {
     int menu_id = message.menu_id();
     auto it = m_menus.find(menu_id);
@@ -264,10 +264,10 @@ OwnPtr<WindowServer::AddMenuSeparatorResponse> ClientConnection::handle(const Wi
     }
     auto& menu = *(*it).value;
     menu.add_item(make<MenuItem>(menu, MenuItem::Separator));
-    return make<WindowServer::AddMenuSeparatorResponse>();
+    return make<Messages::WindowServer::AddMenuSeparatorResponse>();
 }
 
-OwnPtr<WindowServer::MoveWindowToFrontResponse> ClientConnection::handle(const WindowServer::MoveWindowToFront& message)
+OwnPtr<Messages::WindowServer::MoveWindowToFrontResponse> ClientConnection::handle(const Messages::WindowServer::MoveWindowToFront& message)
 {
     auto it = m_windows.find(message.window_id());
     if (it == m_windows.end()) {
@@ -275,10 +275,10 @@ OwnPtr<WindowServer::MoveWindowToFrontResponse> ClientConnection::handle(const W
         return nullptr;
     }
     WindowManager::the().move_to_front_and_make_active(*(*it).value);
-    return make<WindowServer::MoveWindowToFrontResponse>();
+    return make<Messages::WindowServer::MoveWindowToFrontResponse>();
 }
 
-OwnPtr<WindowServer::SetFullscreenResponse> ClientConnection::handle(const WindowServer::SetFullscreen& message)
+OwnPtr<Messages::WindowServer::SetFullscreenResponse> ClientConnection::handle(const Messages::WindowServer::SetFullscreen& message)
 {
     auto it = m_windows.find(message.window_id());
     if (it == m_windows.end()) {
@@ -286,10 +286,10 @@ OwnPtr<WindowServer::SetFullscreenResponse> ClientConnection::handle(const Windo
         return nullptr;
     }
     it->value->set_fullscreen(message.fullscreen());
-    return make<WindowServer::SetFullscreenResponse>();
+    return make<Messages::WindowServer::SetFullscreenResponse>();
 }
 
-OwnPtr<WindowServer::SetWindowOpacityResponse> ClientConnection::handle(const WindowServer::SetWindowOpacity& message)
+OwnPtr<Messages::WindowServer::SetWindowOpacityResponse> ClientConnection::handle(const Messages::WindowServer::SetWindowOpacity& message)
 {
     auto it = m_windows.find(message.window_id());
     if (it == m_windows.end()) {
@@ -297,28 +297,28 @@ OwnPtr<WindowServer::SetWindowOpacityResponse> ClientConnection::handle(const Wi
         return nullptr;
     }
     it->value->set_opacity(message.opacity());
-    return make<WindowServer::SetWindowOpacityResponse>();
+    return make<Messages::WindowServer::SetWindowOpacityResponse>();
 }
 
-void ClientConnection::handle(const WindowServer::AsyncSetWallpaper& message)
+void ClientConnection::handle(const Messages::WindowServer::AsyncSetWallpaper& message)
 {
     Compositor::the().set_wallpaper(message.path(), [&](bool success) {
-        post_message(WindowClient::AsyncSetWallpaperFinished(success));
+        post_message(Messages::WindowClient::AsyncSetWallpaperFinished(success));
     });
 }
 
-OwnPtr<WindowServer::GetWallpaperResponse> ClientConnection::handle(const WindowServer::GetWallpaper&)
+OwnPtr<Messages::WindowServer::GetWallpaperResponse> ClientConnection::handle(const Messages::WindowServer::GetWallpaper&)
 {
-    return make<WindowServer::GetWallpaperResponse>(Compositor::the().wallpaper_path());
+    return make<Messages::WindowServer::GetWallpaperResponse>(Compositor::the().wallpaper_path());
 }
 
-OwnPtr<WindowServer::SetResolutionResponse> ClientConnection::handle(const WindowServer::SetResolution& message)
+OwnPtr<Messages::WindowServer::SetResolutionResponse> ClientConnection::handle(const Messages::WindowServer::SetResolution& message)
 {
     WindowManager::the().set_resolution(message.resolution().width(), message.resolution().height());
-    return make<WindowServer::SetResolutionResponse>();
+    return make<Messages::WindowServer::SetResolutionResponse>();
 }
 
-OwnPtr<WindowServer::SetWindowTitleResponse> ClientConnection::handle(const WindowServer::SetWindowTitle& message)
+OwnPtr<Messages::WindowServer::SetWindowTitleResponse> ClientConnection::handle(const Messages::WindowServer::SetWindowTitle& message)
 {
     auto it = m_windows.find(message.window_id());
     if (it == m_windows.end()) {
@@ -326,20 +326,20 @@ OwnPtr<WindowServer::SetWindowTitleResponse> ClientConnection::handle(const Wind
         return nullptr;
     }
     it->value->set_title(message.title());
-    return make<WindowServer::SetWindowTitleResponse>();
+    return make<Messages::WindowServer::SetWindowTitleResponse>();
 }
 
-OwnPtr<WindowServer::GetWindowTitleResponse> ClientConnection::handle(const WindowServer::GetWindowTitle& message)
+OwnPtr<Messages::WindowServer::GetWindowTitleResponse> ClientConnection::handle(const Messages::WindowServer::GetWindowTitle& message)
 {
     auto it = m_windows.find(message.window_id());
     if (it == m_windows.end()) {
         did_misbehave("GetWindowTitle: Bad window ID");
         return nullptr;
     }
-    return make<WindowServer::GetWindowTitleResponse>(it->value->title());
+    return make<Messages::WindowServer::GetWindowTitleResponse>(it->value->title());
 }
 
-OwnPtr<WindowServer::SetWindowIconBitmapResponse> ClientConnection::handle(const WindowServer::SetWindowIconBitmap& message)
+OwnPtr<Messages::WindowServer::SetWindowIconBitmapResponse> ClientConnection::handle(const Messages::WindowServer::SetWindowIconBitmap& message)
 {
     auto it = m_windows.find(message.window_id());
     if (it == m_windows.end()) {
@@ -358,10 +358,10 @@ OwnPtr<WindowServer::SetWindowIconBitmapResponse> ClientConnection::handle(const
 
     window.frame().invalidate_title_bar();
     WindowManager::the().tell_wm_listeners_window_icon_changed(window);
-    return make<WindowServer::SetWindowIconBitmapResponse>();
+    return make<Messages::WindowServer::SetWindowIconBitmapResponse>();
 }
 
-OwnPtr<WindowServer::SetWindowRectResponse> ClientConnection::handle(const WindowServer::SetWindowRect& message)
+OwnPtr<Messages::WindowServer::SetWindowRectResponse> ClientConnection::handle(const Messages::WindowServer::SetWindowRect& message)
 {
     int window_id = message.window_id();
     auto it = m_windows.find(window_id);
@@ -376,10 +376,10 @@ OwnPtr<WindowServer::SetWindowRectResponse> ClientConnection::handle(const Windo
     }
     window.set_rect(message.rect());
     window.request_update(message.rect());
-    return make<WindowServer::SetWindowRectResponse>();
+    return make<Messages::WindowServer::SetWindowRectResponse>();
 }
 
-OwnPtr<WindowServer::GetWindowRectResponse> ClientConnection::handle(const WindowServer::GetWindowRect& message)
+OwnPtr<Messages::WindowServer::GetWindowRectResponse> ClientConnection::handle(const Messages::WindowServer::GetWindowRect& message)
 {
     int window_id = message.window_id();
     auto it = m_windows.find(window_id);
@@ -387,10 +387,10 @@ OwnPtr<WindowServer::GetWindowRectResponse> ClientConnection::handle(const Windo
         did_misbehave("GetWindowRect: Bad window ID");
         return nullptr;
     }
-    return make<WindowServer::GetWindowRectResponse>(it->value->rect());
+    return make<Messages::WindowServer::GetWindowRectResponse>(it->value->rect());
 }
 
-OwnPtr<WindowServer::SetClipboardContentsResponse> ClientConnection::handle(const WindowServer::SetClipboardContents& message)
+OwnPtr<Messages::WindowServer::SetClipboardContentsResponse> ClientConnection::handle(const Messages::WindowServer::SetClipboardContents& message)
 {
     auto shared_buffer = SharedBuffer::create_from_shared_buffer_id(message.shared_buffer_id());
     if (!shared_buffer) {
@@ -398,10 +398,10 @@ OwnPtr<WindowServer::SetClipboardContentsResponse> ClientConnection::handle(cons
         return nullptr;
     }
     Clipboard::the().set_data(*shared_buffer, message.content_size(), message.content_type());
-    return make<WindowServer::SetClipboardContentsResponse>();
+    return make<Messages::WindowServer::SetClipboardContentsResponse>();
 }
 
-OwnPtr<WindowServer::GetClipboardContentsResponse> ClientConnection::handle(const WindowServer::GetClipboardContents&)
+OwnPtr<Messages::WindowServer::GetClipboardContentsResponse> ClientConnection::handle(const Messages::WindowServer::GetClipboardContents&)
 {
     auto& clipboard = Clipboard::the();
 
@@ -421,10 +421,10 @@ OwnPtr<WindowServer::GetClipboardContentsResponse> ClientConnection::handle(cons
         //        After we respond to GetClipboardContents, we have to wait for the client to ref the buffer on his side.
         m_last_sent_clipboard_content = move(shared_buffer);
     }
-    return make<WindowServer::GetClipboardContentsResponse>(shared_buffer_id, clipboard.size(), clipboard.data_type());
+    return make<Messages::WindowServer::GetClipboardContentsResponse>(shared_buffer_id, clipboard.size(), clipboard.data_type());
 }
 
-OwnPtr<WindowServer::CreateWindowResponse> ClientConnection::handle(const WindowServer::CreateWindow& message)
+OwnPtr<Messages::WindowServer::CreateWindowResponse> ClientConnection::handle(const Messages::WindowServer::CreateWindow& message)
 {
     int window_id = m_next_window_id++;
     auto window = Window::construct(*this, (WindowType)message.type(), window_id, message.modal(), message.minimizable(), message.resizable(), message.fullscreen());
@@ -440,10 +440,10 @@ OwnPtr<WindowServer::CreateWindowResponse> ClientConnection::handle(const Window
     if (window->type() == WindowType::MenuApplet)
         MenuManager::the().add_applet(*window);
     m_windows.set(window_id, move(window));
-    return make<WindowServer::CreateWindowResponse>(window_id);
+    return make<Messages::WindowServer::CreateWindowResponse>(window_id);
 }
 
-OwnPtr<WindowServer::DestroyWindowResponse> ClientConnection::handle(const WindowServer::DestroyWindow& message)
+OwnPtr<Messages::WindowServer::DestroyWindowResponse> ClientConnection::handle(const Messages::WindowServer::DestroyWindow& message)
 {
     auto it = m_windows.find(message.window_id());
     if (it == m_windows.end()) {
@@ -460,7 +460,7 @@ OwnPtr<WindowServer::DestroyWindowResponse> ClientConnection::handle(const Windo
     ASSERT(it->value.ptr() == &window);
     m_windows.remove(message.window_id());
 
-    return make<WindowServer::DestroyWindowResponse>();
+    return make<Messages::WindowServer::DestroyWindowResponse>();
 }
 
 void ClientConnection::post_paint_message(Window& window)
@@ -469,10 +469,10 @@ void ClientConnection::post_paint_message(Window& window)
     if (window.is_minimized() || window.is_occluded())
         return;
 
-    post_message(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 WindowServer::InvalidateRect& message)
+void ClientConnection::handle(const Messages::WindowServer::InvalidateRect& message)
 {
     auto it = m_windows.find(message.window_id());
     if (it == m_windows.end()) {
@@ -484,7 +484,7 @@ void ClientConnection::handle(const WindowServer::InvalidateRect& message)
         window.request_update(message.rects()[i].intersected({ {}, window.size() }));
 }
 
-void ClientConnection::handle(const WindowServer::DidFinishPainting& message)
+void ClientConnection::handle(const Messages::WindowServer::DidFinishPainting& message)
 {
     int window_id = message.window_id();
     auto it = m_windows.find(window_id);
@@ -499,7 +499,7 @@ void ClientConnection::handle(const WindowServer::DidFinishPainting& message)
     WindowSwitcher::the().refresh_if_needed();
 }
 
-OwnPtr<WindowServer::SetWindowBackingStoreResponse> ClientConnection::handle(const WindowServer::SetWindowBackingStore& message)
+OwnPtr<Messages::WindowServer::SetWindowBackingStoreResponse> ClientConnection::handle(const Messages::WindowServer::SetWindowBackingStore& message)
 {
     int window_id = message.window_id();
     auto it = m_windows.find(window_id);
@@ -513,7 +513,7 @@ OwnPtr<WindowServer::SetWindowBackingStoreResponse> ClientConnection::handle(con
     } else {
         auto shared_buffer = SharedBuffer::create_from_shared_buffer_id(message.shared_buffer_id());
         if (!shared_buffer)
-            return make<WindowServer::SetWindowBackingStoreResponse>();
+            return make<Messages::WindowServer::SetWindowBackingStoreResponse>();
         auto backing_store = Gfx::Bitmap::create_with_shared_buffer(
             message.has_alpha_channel() ? Gfx::Bitmap::Format::RGBA32 : Gfx::Bitmap::Format::RGB32,
             *shared_buffer,
@@ -524,10 +524,10 @@ OwnPtr<WindowServer::SetWindowBackingStoreResponse> ClientConnection::handle(con
     if (message.flush_immediately())
         window.invalidate();
 
-    return make<WindowServer::SetWindowBackingStoreResponse>();
+    return make<Messages::WindowServer::SetWindowBackingStoreResponse>();
 }
 
-OwnPtr<WindowServer::SetGlobalCursorTrackingResponse> ClientConnection::handle(const WindowServer::SetGlobalCursorTracking& message)
+OwnPtr<Messages::WindowServer::SetGlobalCursorTrackingResponse> ClientConnection::handle(const Messages::WindowServer::SetGlobalCursorTracking& message)
 {
     int window_id = message.window_id();
     auto it = m_windows.find(window_id);
@@ -536,10 +536,10 @@ OwnPtr<WindowServer::SetGlobalCursorTrackingResponse> ClientConnection::handle(c
         return nullptr;
     }
     it->value->set_global_cursor_tracking_enabled(message.enabled());
-    return make<WindowServer::SetGlobalCursorTrackingResponse>();
+    return make<Messages::WindowServer::SetGlobalCursorTrackingResponse>();
 }
 
-OwnPtr<WindowServer::SetWindowOverrideCursorResponse> ClientConnection::handle(const WindowServer::SetWindowOverrideCursor& message)
+OwnPtr<Messages::WindowServer::SetWindowOverrideCursorResponse> ClientConnection::handle(const Messages::WindowServer::SetWindowOverrideCursor& message)
 {
     auto it = m_windows.find(message.window_id());
     if (it == m_windows.end()) {
@@ -548,10 +548,10 @@ OwnPtr<WindowServer::SetWindowOverrideCursorResponse> ClientConnection::handle(c
     }
     auto& window = *(*it).value;
     window.set_override_cursor(Cursor::create((StandardCursor)message.cursor_type()));
-    return make<WindowServer::SetWindowOverrideCursorResponse>();
+    return make<Messages::WindowServer::SetWindowOverrideCursorResponse>();
 }
 
-OwnPtr<WindowServer::SetWindowHasAlphaChannelResponse> ClientConnection::handle(const WindowServer::SetWindowHasAlphaChannel& message)
+OwnPtr<Messages::WindowServer::SetWindowHasAlphaChannelResponse> ClientConnection::handle(const Messages::WindowServer::SetWindowHasAlphaChannel& message)
 {
     auto it = m_windows.find(message.window_id());
     if (it == m_windows.end()) {
@@ -559,10 +559,10 @@ OwnPtr<WindowServer::SetWindowHasAlphaChannelResponse> ClientConnection::handle(
         return nullptr;
     }
     it->value->set_has_alpha_channel(message.has_alpha_channel());
-    return make<WindowServer::SetWindowHasAlphaChannelResponse>();
+    return make<Messages::WindowServer::SetWindowHasAlphaChannelResponse>();
 }
 
-void ClientConnection::handle(const WindowServer::WM_SetActiveWindow& message)
+void ClientConnection::handle(const Messages::WindowServer::WM_SetActiveWindow& message)
 {
     auto* client = ClientConnection::from_client_id(message.client_id());
     if (!client) {
@@ -579,7 +579,7 @@ void ClientConnection::handle(const WindowServer::WM_SetActiveWindow& message)
     WindowManager::the().move_to_front_and_make_active(window);
 }
 
-void ClientConnection::handle(const WindowServer::WM_PopupWindowMenu& message)
+void ClientConnection::handle(const Messages::WindowServer::WM_PopupWindowMenu& message)
 {
     auto* client = ClientConnection::from_client_id(message.client_id());
     if (!client) {
@@ -595,7 +595,7 @@ void ClientConnection::handle(const WindowServer::WM_PopupWindowMenu& message)
     window.popup_window_menu(message.screen_position());
 }
 
-void ClientConnection::handle(const WindowServer::WM_StartWindowResize& request)
+void ClientConnection::handle(const Messages::WindowServer::WM_StartWindowResize& request)
 {
     auto* client = ClientConnection::from_client_id(request.client_id());
     if (!client) {
@@ -613,7 +613,7 @@ void ClientConnection::handle(const WindowServer::WM_StartWindowResize& request)
     WindowManager::the().start_window_resize(window, Screen::the().cursor_location(), MouseButton::Left);
 }
 
-void ClientConnection::handle(const WindowServer::WM_SetWindowMinimized& message)
+void ClientConnection::handle(const Messages::WindowServer::WM_SetWindowMinimized& message)
 {
     auto* client = ClientConnection::from_client_id(message.client_id());
     if (!client) {
@@ -629,9 +629,9 @@ void ClientConnection::handle(const WindowServer::WM_SetWindowMinimized& message
     window.set_minimized(message.minimized());
 }
 
-OwnPtr<WindowServer::GreetResponse> ClientConnection::handle(const WindowServer::Greet&)
+OwnPtr<Messages::WindowServer::GreetResponse> ClientConnection::handle(const Messages::WindowServer::Greet&)
 {
-    return make<WindowServer::GreetResponse>(client_id(), Screen::the().rect(), Gfx::current_system_theme_buffer_id());
+    return make<Messages::WindowServer::GreetResponse>(client_id(), Screen::the().rect(), Gfx::current_system_theme_buffer_id());
 }
 
 bool ClientConnection::is_showing_modal_window() const
@@ -644,7 +644,7 @@ bool ClientConnection::is_showing_modal_window() const
     return false;
 }
 
-void ClientConnection::handle(const WindowServer::WM_SetWindowTaskbarRect& message)
+void ClientConnection::handle(const Messages::WindowServer::WM_SetWindowTaskbarRect& message)
 {
     auto* client = ClientConnection::from_client_id(message.client_id());
     if (!client) {
@@ -660,11 +660,11 @@ void ClientConnection::handle(const WindowServer::WM_SetWindowTaskbarRect& messa
     window.set_taskbar_rect(message.rect());
 }
 
-OwnPtr<WindowServer::StartDragResponse> ClientConnection::handle(const WindowServer::StartDrag& message)
+OwnPtr<Messages::WindowServer::StartDragResponse> ClientConnection::handle(const Messages::WindowServer::StartDrag& message)
 {
     auto& wm = WindowManager::the();
     if (wm.dnd_client())
-        return make<WindowServer::StartDragResponse>(false);
+        return make<Messages::WindowServer::StartDragResponse>(false);
 
     RefPtr<Gfx::Bitmap> bitmap;
     if (message.bitmap_id() != -1) {
@@ -678,7 +678,7 @@ OwnPtr<WindowServer::StartDragResponse> ClientConnection::handle(const WindowSer
     }
 
     wm.start_dnd_drag(*this, message.text(), bitmap, message.data_type(), message.data());
-    return make<WindowServer::StartDragResponse>(true);
+    return make<Messages::WindowServer::StartDragResponse>(true);
 }
 
 void ClientConnection::boost()

Servers/WindowServer/ClientConnection.h

@@ -75,45 +75,45 @@ public:
 private:
     explicit ClientConnection(Core::LocalSocket&, int client_id);
 
-    virtual OwnPtr<WindowServer::GreetResponse> handle(const WindowServer::Greet&) override;
+    virtual OwnPtr<Messages::WindowServer::GreetResponse> handle(const Messages::WindowServer::Greet&) override;
-    virtual OwnPtr<WindowServer::CreateMenubarResponse> handle(const WindowServer::CreateMenubar&) override;
+    virtual OwnPtr<Messages::WindowServer::CreateMenubarResponse> handle(const Messages::WindowServer::CreateMenubar&) override;
-    virtual OwnPtr<WindowServer::DestroyMenubarResponse> handle(const WindowServer::DestroyMenubar&) override;
+    virtual OwnPtr<Messages::WindowServer::DestroyMenubarResponse> handle(const Messages::WindowServer::DestroyMenubar&) override;
-    virtual OwnPtr<WindowServer::CreateMenuResponse> handle(const WindowServer::CreateMenu&) override;
+    virtual OwnPtr<Messages::WindowServer::CreateMenuResponse> handle(const Messages::WindowServer::CreateMenu&) override;
-    virtual OwnPtr<WindowServer::DestroyMenuResponse> handle(const WindowServer::DestroyMenu&) override;
+    virtual OwnPtr<Messages::WindowServer::DestroyMenuResponse> handle(const Messages::WindowServer::DestroyMenu&) override;
-    virtual OwnPtr<WindowServer::AddMenuToMenubarResponse> handle(const WindowServer::AddMenuToMenubar&) override;
+    virtual OwnPtr<Messages::WindowServer::AddMenuToMenubarResponse> handle(const Messages::WindowServer::AddMenuToMenubar&) override;
-    virtual OwnPtr<WindowServer::SetApplicationMenubarResponse> handle(const WindowServer::SetApplicationMenubar&) override;
+    virtual OwnPtr<Messages::WindowServer::SetApplicationMenubarResponse> handle(const Messages::WindowServer::SetApplicationMenubar&) override;
-    virtual OwnPtr<WindowServer::AddMenuItemResponse> handle(const WindowServer::AddMenuItem&) override;
+    virtual OwnPtr<Messages::WindowServer::AddMenuItemResponse> handle(const Messages::WindowServer::AddMenuItem&) override;
-    virtual OwnPtr<WindowServer::AddMenuSeparatorResponse> handle(const WindowServer::AddMenuSeparator&) override;
+    virtual OwnPtr<Messages::WindowServer::AddMenuSeparatorResponse> handle(const Messages::WindowServer::AddMenuSeparator&) override;
-    virtual OwnPtr<WindowServer::UpdateMenuItemResponse> handle(const WindowServer::UpdateMenuItem&) override;
+    virtual OwnPtr<Messages::WindowServer::UpdateMenuItemResponse> handle(const Messages::WindowServer::UpdateMenuItem&) override;
-    virtual OwnPtr<WindowServer::CreateWindowResponse> handle(const WindowServer::CreateWindow&) override;
+    virtual OwnPtr<Messages::WindowServer::CreateWindowResponse> handle(const Messages::WindowServer::CreateWindow&) override;
-    virtual OwnPtr<WindowServer::DestroyWindowResponse> handle(const WindowServer::DestroyWindow&) override;
+    virtual OwnPtr<Messages::WindowServer::DestroyWindowResponse> handle(const Messages::WindowServer::DestroyWindow&) override;
-    virtual OwnPtr<WindowServer::SetWindowTitleResponse> handle(const WindowServer::SetWindowTitle&) override;
+    virtual OwnPtr<Messages::WindowServer::SetWindowTitleResponse> handle(const Messages::WindowServer::SetWindowTitle&) override;
-    virtual OwnPtr<WindowServer::GetWindowTitleResponse> handle(const WindowServer::GetWindowTitle&) override;
+    virtual OwnPtr<Messages::WindowServer::GetWindowTitleResponse> handle(const Messages::WindowServer::GetWindowTitle&) override;
-    virtual OwnPtr<WindowServer::SetWindowRectResponse> handle(const WindowServer::SetWindowRect&) override;
+    virtual OwnPtr<Messages::WindowServer::SetWindowRectResponse> handle(const Messages::WindowServer::SetWindowRect&) override;
-    virtual OwnPtr<WindowServer::GetWindowRectResponse> handle(const WindowServer::GetWindowRect&) override;
+    virtual OwnPtr<Messages::WindowServer::GetWindowRectResponse> handle(const Messages::WindowServer::GetWindowRect&) override;
-    virtual void handle(const WindowServer::InvalidateRect&) override;
+    virtual void handle(const Messages::WindowServer::InvalidateRect&) override;
-    virtual void handle(const WindowServer::DidFinishPainting&) override;
+    virtual void handle(const Messages::WindowServer::DidFinishPainting&) override;
-    virtual OwnPtr<WindowServer::SetGlobalCursorTrackingResponse> handle(const WindowServer::SetGlobalCursorTracking&) override;
+    virtual OwnPtr<Messages::WindowServer::SetGlobalCursorTrackingResponse> handle(const Messages::WindowServer::SetGlobalCursorTracking&) override;
-    virtual OwnPtr<WindowServer::SetWindowOpacityResponse> handle(const WindowServer::SetWindowOpacity&) override;
+    virtual OwnPtr<Messages::WindowServer::SetWindowOpacityResponse> handle(const Messages::WindowServer::SetWindowOpacity&) override;
-    virtual OwnPtr<WindowServer::SetWindowBackingStoreResponse> handle(const WindowServer::SetWindowBackingStore&) override;
+    virtual OwnPtr<Messages::WindowServer::SetWindowBackingStoreResponse> handle(const Messages::WindowServer::SetWindowBackingStore&) override;
-    virtual OwnPtr<WindowServer::GetClipboardContentsResponse> handle(const WindowServer::GetClipboardContents&) override;
+    virtual OwnPtr<Messages::WindowServer::GetClipboardContentsResponse> handle(const Messages::WindowServer::GetClipboardContents&) override;
-    virtual OwnPtr<WindowServer::SetClipboardContentsResponse> handle(const WindowServer::SetClipboardContents&) override;
+    virtual OwnPtr<Messages::WindowServer::SetClipboardContentsResponse> handle(const Messages::WindowServer::SetClipboardContents&) override;
-    virtual void handle(const WindowServer::WM_SetActiveWindow&) override;
+    virtual void handle(const Messages::WindowServer::WM_SetActiveWindow&) override;
-    virtual void handle(const WindowServer::WM_SetWindowMinimized&) override;
+    virtual void handle(const Messages::WindowServer::WM_SetWindowMinimized&) override;
-    virtual void handle(const WindowServer::WM_StartWindowResize&) override;
+    virtual void handle(const Messages::WindowServer::WM_StartWindowResize&) override;
-    virtual void handle(const WindowServer::WM_PopupWindowMenu&) override;
+    virtual void handle(const Messages::WindowServer::WM_PopupWindowMenu&) override;
-    virtual OwnPtr<WindowServer::SetWindowHasAlphaChannelResponse> handle(const WindowServer::SetWindowHasAlphaChannel&) override;
+    virtual OwnPtr<Messages::WindowServer::SetWindowHasAlphaChannelResponse> handle(const Messages::WindowServer::SetWindowHasAlphaChannel&) override;
-    virtual OwnPtr<WindowServer::MoveWindowToFrontResponse> handle(const WindowServer::MoveWindowToFront&) override;
+    virtual OwnPtr<Messages::WindowServer::MoveWindowToFrontResponse> handle(const Messages::WindowServer::MoveWindowToFront&) override;
-    virtual OwnPtr<WindowServer::SetFullscreenResponse> handle(const WindowServer::SetFullscreen&) override;
+    virtual OwnPtr<Messages::WindowServer::SetFullscreenResponse> handle(const Messages::WindowServer::SetFullscreen&) override;
-    virtual void handle(const WindowServer::AsyncSetWallpaper&) override;
+    virtual void handle(const Messages::WindowServer::AsyncSetWallpaper&) override;
-    virtual OwnPtr<WindowServer::GetWallpaperResponse> handle(const WindowServer::GetWallpaper&) override;
+    virtual OwnPtr<Messages::WindowServer::GetWallpaperResponse> handle(const Messages::WindowServer::GetWallpaper&) override;
-    virtual OwnPtr<WindowServer::SetResolutionResponse> handle(const WindowServer::SetResolution&) override;
+    virtual OwnPtr<Messages::WindowServer::SetResolutionResponse> handle(const Messages::WindowServer::SetResolution&) override;
-    virtual OwnPtr<WindowServer::SetWindowOverrideCursorResponse> handle(const WindowServer::SetWindowOverrideCursor&) override;
+    virtual OwnPtr<Messages::WindowServer::SetWindowOverrideCursorResponse> handle(const Messages::WindowServer::SetWindowOverrideCursor&) override;
-    virtual OwnPtr<WindowServer::PopupMenuResponse> handle(const WindowServer::PopupMenu&) override;
+    virtual OwnPtr<Messages::WindowServer::PopupMenuResponse> handle(const Messages::WindowServer::PopupMenu&) override;
-    virtual OwnPtr<WindowServer::DismissMenuResponse> handle(const WindowServer::DismissMenu&) override;
+    virtual OwnPtr<Messages::WindowServer::DismissMenuResponse> handle(const Messages::WindowServer::DismissMenu&) override;
-    virtual OwnPtr<WindowServer::SetWindowIconBitmapResponse> handle(const WindowServer::SetWindowIconBitmap&) override;
+    virtual OwnPtr<Messages::WindowServer::SetWindowIconBitmapResponse> handle(const Messages::WindowServer::SetWindowIconBitmap&) override;
-    virtual void handle(const WindowServer::WM_SetWindowTaskbarRect&) override;
+    virtual void handle(const Messages::WindowServer::WM_SetWindowTaskbarRect&) override;
-    virtual OwnPtr<WindowServer::StartDragResponse> handle(const WindowServer::StartDrag&) override;
+    virtual OwnPtr<Messages::WindowServer::StartDragResponse> handle(const Messages::WindowServer::StartDrag&) override;
 
     HashMap<int, NonnullRefPtr<Window>> m_windows;
     HashMap<int, NonnullOwnPtr<MenuBar>> m_menubars;

Servers/WindowServer/Menu.cpp

@@ -470,7 +470,7 @@ void Menu::did_activate(MenuItem& item)
     MenuManager::the().close_bar();
 
     if (m_client)
-        m_client->post_message(WindowClient::MenuItemActivated(m_menu_id, item.identifier()));
+        m_client->post_message(Messages::WindowClient::MenuItemActivated(m_menu_id, item.identifier()));
 }
 
 MenuItem* Menu::item_with_identifier(unsigned identifer)

Servers/WindowServer/Window.cpp

@@ -113,19 +113,19 @@ void Window::handle_mouse_event(const MouseEvent& event)
 
     switch (event.type()) {
     case Event::MouseMove:
-        m_client->post_message(WindowClient::MouseMove(m_window_id, event.position(), (u32)event.button(), event.buttons(), event.modifiers(), event.wheel_delta()));
+        m_client->post_message(Messages::WindowClient::MouseMove(m_window_id, event.position(), (u32)event.button(), event.buttons(), event.modifiers(), event.wheel_delta()));
         break;
     case Event::MouseDown:
-        m_client->post_message(WindowClient::MouseDown(m_window_id, event.position(), (u32)event.button(), event.buttons(), event.modifiers(), event.wheel_delta()));
+        m_client->post_message(Messages::WindowClient::MouseDown(m_window_id, event.position(), (u32)event.button(), event.buttons(), event.modifiers(), event.wheel_delta()));
         break;
     case Event::MouseDoubleClick:
-        m_client->post_message(WindowClient::MouseDoubleClick(m_window_id, event.position(), (u32)event.button(), event.buttons(), event.modifiers(), event.wheel_delta()));
+        m_client->post_message(Messages::WindowClient::MouseDoubleClick(m_window_id, event.position(), (u32)event.button(), event.buttons(), event.modifiers(), event.wheel_delta()));
         break;
     case Event::MouseUp:
-        m_client->post_message(WindowClient::MouseUp(m_window_id, event.position(), (u32)event.button(), event.buttons(), event.modifiers(), event.wheel_delta()));
+        m_client->post_message(Messages::WindowClient::MouseUp(m_window_id, event.position(), (u32)event.button(), event.buttons(), event.modifiers(), event.wheel_delta()));
         break;
     case Event::MouseWheel:
-        m_client->post_message(WindowClient::MouseWheel(m_window_id, event.position(), (u32)event.button(), event.buttons(), event.modifiers(), event.wheel_delta()));
+        m_client->post_message(Messages::WindowClient::MouseWheel(m_window_id, event.position(), (u32)event.button(), event.buttons(), event.modifiers(), event.wheel_delta()));
         break;
     default:
         ASSERT_NOT_REACHED();
@@ -237,37 +237,37 @@ void Window::event(Core::Event& event)
 
     switch (event.type()) {
     case Event::WindowEntered:
-        m_client->post_message(WindowClient::WindowEntered(m_window_id));
+        m_client->post_message(Messages::WindowClient::WindowEntered(m_window_id));
         break;
     case Event::WindowLeft:
-        m_client->post_message(WindowClient::WindowLeft(m_window_id));
+        m_client->post_message(Messages::WindowClient::WindowLeft(m_window_id));
         break;
     case Event::KeyDown:
         m_client->post_message(
-            WindowClient::KeyDown(m_window_id,
+            Messages::WindowClient::KeyDown(m_window_id,
                 (u8) static_cast<const KeyEvent&>(event).character(),
                 (u32) static_cast<const KeyEvent&>(event).key(),
                 static_cast<const KeyEvent&>(event).modifiers()));
         break;
     case Event::KeyUp:
         m_client->post_message(
-            WindowClient::KeyUp(m_window_id,
+            Messages::WindowClient::KeyUp(m_window_id,
                 (u8) static_cast<const KeyEvent&>(event).character(),
                 (u32) static_cast<const KeyEvent&>(event).key(),
                 static_cast<const KeyEvent&>(event).modifiers()));
         break;
     case Event::WindowActivated:
-        m_client->post_message(WindowClient::WindowActivated(m_window_id));
+        m_client->post_message(Messages::WindowClient::WindowActivated(m_window_id));
         break;
     case Event::WindowDeactivated:
-        m_client->post_message(WindowClient::WindowDeactivated(m_window_id));
+        m_client->post_message(Messages::WindowClient::WindowDeactivated(m_window_id));
         break;
     case Event::WindowCloseRequest:
-        m_client->post_message(WindowClient::WindowCloseRequest(m_window_id));
+        m_client->post_message(Messages::WindowClient::WindowCloseRequest(m_window_id));
         break;
     case Event::WindowResized:
         m_client->post_message(
-            WindowClient::WindowResized(
+            Messages::WindowClient::WindowResized(
                 m_window_id,
                 static_cast<const ResizeEvent&>(event).old_rect(),
                 static_cast<const ResizeEvent&>(event).rect()));

Servers/WindowServer/WindowManager.cpp

@@ -213,7 +213,7 @@ void WindowManager::remove_window(Window& window)
         if (!(listener.wm_event_mask() & WMEventMask::WindowRemovals))
             return IterationDecision::Continue;
         if (!window.is_internal())
-            listener.client()->post_message(WindowClient::WM_WindowRemoved(listener.window_id(), window.client_id(), window.window_id()));
+            listener.client()->post_message(Messages::WindowClient::WM_WindowRemoved(listener.window_id(), window.client_id(), window.window_id()));
         return IterationDecision::Continue;
     });
 }
@@ -224,7 +224,7 @@ void WindowManager::tell_wm_listener_about_window(Window& listener, Window& wind
         return;
     if (window.is_internal())
         return;
-    listener.client()->post_message(WindowClient::WM_WindowStateChanged(listener.window_id(), window.client_id(), window.window_id(), window.is_active(), window.is_minimized(), (i32)window.type(), window.title(), window.rect()));
+    listener.client()->post_message(Messages::WindowClient::WM_WindowStateChanged(listener.window_id(), window.client_id(), window.window_id(), window.is_active(), window.is_minimized(), (i32)window.type(), window.title(), window.rect()));
 }
 
 void WindowManager::tell_wm_listener_about_window_rect(Window& listener, Window& window)
@@ -233,7 +233,7 @@ void WindowManager::tell_wm_listener_about_window_rect(Window& listener, Window&
         return;
     if (window.is_internal())
         return;
-    listener.client()->post_message(WindowClient::WM_WindowRectChanged(listener.window_id(), window.client_id(), window.window_id(), window.rect()));
+    listener.client()->post_message(Messages::WindowClient::WM_WindowRectChanged(listener.window_id(), window.client_id(), window.window_id(), window.rect()));
 }
 
 void WindowManager::tell_wm_listener_about_window_icon(Window& listener, Window& window)
@@ -248,7 +248,7 @@ void WindowManager::tell_wm_listener_about_window_icon(Window& listener, Window&
     if (share_buffer_with(window.icon().shared_buffer_id(), listener.client()->client_pid()) < 0) {
         ASSERT_NOT_REACHED();
     }
-    listener.client()->post_message(WindowClient::WM_WindowIconBitmapChanged(listener.window_id(), window.client_id(), window.window_id(), window.icon().shared_buffer_id(), window.icon().size()));
+    listener.client()->post_message(Messages::WindowClient::WM_WindowIconBitmapChanged(listener.window_id(), window.client_id(), window.window_id(), window.icon().shared_buffer_id(), window.icon().size()));
 }
 
 void WindowManager::tell_wm_listeners_window_state_changed(Window& window)
@@ -329,7 +329,7 @@ void WindowManager::notify_minimization_state_changed(Window& window)
     tell_wm_listeners_window_state_changed(window);
 
     if (window.client())
-        window.client()->post_message(WindowClient::WindowStateChanged(window.window_id(), window.is_minimized(), window.is_occluded()));
+        window.client()->post_message(Messages::WindowClient::WindowStateChanged(window.window_id(), window.is_minimized(), window.is_occluded()));
 
     if (window.is_active() && window.is_minimized())
         pick_new_active_window();
@@ -338,7 +338,7 @@ void WindowManager::notify_minimization_state_changed(Window& window)
 void WindowManager::notify_occlusion_state_changed(Window& window)
 {
     if (window.client())
-        window.client()->post_message(WindowClient::WindowStateChanged(window.window_id(), window.is_minimized(), window.is_occluded()));
+        window.client()->post_message(Messages::WindowClient::WindowStateChanged(window.window_id(), window.is_minimized(), window.is_occluded()));
 }
 
 void WindowManager::pick_new_active_window()
@@ -610,13 +610,13 @@ bool WindowManager::process_ongoing_drag(MouseEvent& event, Window*& hovered_win
     });
 
     if (hovered_window) {
-        m_dnd_client->post_message(WindowClient::DragAccepted());
+        m_dnd_client->post_message(Messages::WindowClient::DragAccepted());
         if (hovered_window->client()) {
             auto translated_event = event.translated(-hovered_window->position());
-            hovered_window->client()->post_message(WindowClient::DragDropped(hovered_window->window_id(), translated_event.position(), m_dnd_text, m_dnd_data_type, m_dnd_data));
+            hovered_window->client()->post_message(Messages::WindowClient::DragDropped(hovered_window->window_id(), translated_event.position(), m_dnd_text, m_dnd_data_type, m_dnd_data));
         }
     } else {
-        m_dnd_client->post_message(WindowClient::DragCancelled());
+        m_dnd_client->post_message(Messages::WindowClient::DragCancelled());
     }
 
     end_dnd_drag();
@@ -965,7 +965,7 @@ void WindowManager::event(Core::Event& event)
         m_keyboard_modifiers = key_event.modifiers();
 
         if (key_event.type() == Event::KeyDown && key_event.key() == Key_Escape && m_dnd_client) {
-            m_dnd_client->post_message(WindowClient::DragCancelled());
+            m_dnd_client->post_message(Messages::WindowClient::DragCancelled());
             end_dnd_drag();
             return;
         }
@@ -1275,7 +1275,7 @@ void WindowManager::update_theme(String theme_path, String theme_name)
     for_each_window([&](Window& window) {
         if (window.client()) {
             if (!notified_clients.contains(window.client())) {
-                window.client()->post_message(WindowClient::UpdateSystemTheme(Gfx::current_system_theme_buffer_id()));
+                window.client()->post_message(Messages::WindowClient::UpdateSystemTheme(Gfx::current_system_theme_buffer_id()));
                 notified_clients.set(window.client());
             }
         }