RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 15:28:11 +00:00
Code Issues Activity Actions

WindowServer: Rename GUI_Foo to WSAPI_Foo.

Browse source
This commit is contained in:
Andreas Kling 2019-02-15 09:17:18 +01:00
parent a54cd84c59
commit 29c49356e3
16 changed files with 204 additions and 204 deletions
Download patch file Download diff file Expand all files Collapse all files

70
LibGUI/GEventLoop.cpp
View file

@ -112,7 +112,7 @@ void GEventLoop::post_event(GObject* receiver, OwnPtr<GEvent>&& event)
m_queued_events.append({ receiver, move(event) });
}
void GEventLoop::handle_paint_event(const GUI_ServerMessage& event, GWindow& window)
void GEventLoop::handle_paint_event(const WSAPI_ServerMessage& event, GWindow& window)
{
#ifdef GEVENTLOOP_DEBUG
dbgprintf("WID=%x Paint [%d,%d %dx%d]\n", event.window_id, event.paint.rect.location.x, event.paint.rect.location.y, event.paint.rect.size.width, event.paint.rect.size.height);
@ -120,25 +120,25 @@ void GEventLoop::handle_paint_event(const GUI_ServerMessage& event, GWindow& win
post_event(&window, make<GPaintEvent>(event.paint.rect));
}
void GEventLoop::handle_window_activation_event(const GUI_ServerMessage& event, GWindow& window)
void GEventLoop::handle_window_activation_event(const WSAPI_ServerMessage& event, GWindow& window)
{
#ifdef GEVENTLOOP_DEBUG
dbgprintf("WID=%x WindowActivation\n", event.window_id);
#endif
post_event(&window, make<GEvent>(event.type == GUI_ServerMessage::Type::WindowActivated ? GEvent::WindowBecameActive : GEvent::WindowBecameInactive));
post_event(&window, make<GEvent>(event.type == WSAPI_ServerMessage::Type::WindowActivated ? GEvent::WindowBecameActive : GEvent::WindowBecameInactive));
}
void GEventLoop::handle_window_close_request_event(const GUI_ServerMessage&, GWindow& window)
void GEventLoop::handle_window_close_request_event(const WSAPI_ServerMessage&, GWindow& window)
{
post_event(&window, make<GEvent>(GEvent::WindowCloseRequest));
}
void GEventLoop::handle_key_event(const GUI_ServerMessage& event, GWindow& window)
void GEventLoop::handle_key_event(const WSAPI_ServerMessage& event, GWindow& window)
{
#ifdef GEVENTLOOP_DEBUG
dbgprintf("WID=%x KeyEvent character=0x%b\n", event.window_id, event.key.character);
#endif
auto key_event = make<GKeyEvent>(event.type == GUI_ServerMessage::Type::KeyDown ? GEvent::KeyDown : GEvent::KeyUp, event.key.key);
auto key_event = make<GKeyEvent>(event.type == WSAPI_ServerMessage::Type::KeyDown ? GEvent::KeyDown : GEvent::KeyUp, event.key.key);
key_event->m_alt = event.key.alt;
key_event->m_ctrl = event.key.ctrl;
key_event->m_shift = event.key.shift;
@ -147,32 +147,32 @@ void GEventLoop::handle_key_event(const GUI_ServerMessage& event, GWindow& windo
post_event(&window, move(key_event));
}
void GEventLoop::handle_mouse_event(const GUI_ServerMessage& event, GWindow& window)
void GEventLoop::handle_mouse_event(const WSAPI_ServerMessage& event, GWindow& window)
{
#ifdef GEVENTLOOP_DEBUG
dbgprintf("WID=%x MouseEvent %d,%d\n", event.window_id, event.mouse.position.x, event.mouse.position.y);
#endif
GMouseEvent::Type type;
switch (event.type) {
case GUI_ServerMessage::Type::MouseMove: type = GEvent::MouseMove; break;
case GUI_ServerMessage::Type::MouseUp: type = GEvent::MouseUp; break;
case GUI_ServerMessage::Type::MouseDown: type = GEvent::MouseDown; break;
case WSAPI_ServerMessage::Type::MouseMove: type = GEvent::MouseMove; break;
case WSAPI_ServerMessage::Type::MouseUp: type = GEvent::MouseUp; break;
case WSAPI_ServerMessage::Type::MouseDown: type = GEvent::MouseDown; break;
default: ASSERT_NOT_REACHED(); break;
}
GMouseButton button { GMouseButton::None };
switch (event.mouse.button) {
case GUI_MouseButton::NoButton: button = GMouseButton::None; break;
case GUI_MouseButton::Left: button = GMouseButton::Left; break;
case GUI_MouseButton::Right: button = GMouseButton::Right; break;
case GUI_MouseButton::Middle: button = GMouseButton::Middle; break;
case WSAPI_MouseButton::NoButton: button = GMouseButton::None; break;
case WSAPI_MouseButton::Left: button = GMouseButton::Left; break;
case WSAPI_MouseButton::Right: button = GMouseButton::Right; break;
case WSAPI_MouseButton::Middle: button = GMouseButton::Middle; break;
default: ASSERT_NOT_REACHED(); break;
}
post_event(&window, make<GMouseEvent>(type, event.mouse.position, event.mouse.buttons, button));
}
void GEventLoop::handle_menu_event(const GUI_ServerMessage& event)
void GEventLoop::handle_menu_event(const WSAPI_ServerMessage& event)
{
if (event.type == GUI_ServerMessage::Type::MenuItemActivated) {
if (event.type == WSAPI_ServerMessage::Type::MenuItemActivated) {
auto* menu = GMenu::from_menu_id(event.menu.menu_id);
if (!menu) {
dbgprintf("GEventLoop received event for invalid window ID %d\n", event.window_id);
@ -253,7 +253,7 @@ void GEventLoop::wait_for_event()
auto unprocessed_events = move(m_unprocessed_messages);
for (auto& event : unprocessed_events) {
if (event.type == GUI_ServerMessage::Error) {
if (event.type == WSAPI_ServerMessage::Error) {
dbgprintf("GEventLoop got error message from server\n");
dbgprintf(" - error message: %s\n", String(event.text, event.text_length).characters());
exit(1);
@ -261,7 +261,7 @@ void GEventLoop::wait_for_event()
}
switch (event.type) {
case GUI_ServerMessage::MenuItemActivated:
case WSAPI_ServerMessage::MenuItemActivated:
handle_menu_event(event);
continue;
default:
@ -274,23 +274,23 @@ void GEventLoop::wait_for_event()
continue;
}
switch (event.type) {
case GUI_ServerMessage::Type::Paint:
case WSAPI_ServerMessage::Type::Paint:
handle_paint_event(event, *window);
break;
case GUI_ServerMessage::Type::MouseDown:
case GUI_ServerMessage::Type::MouseUp:
case GUI_ServerMessage::Type::MouseMove:
case WSAPI_ServerMessage::Type::MouseDown:
case WSAPI_ServerMessage::Type::MouseUp:
case WSAPI_ServerMessage::Type::MouseMove:
handle_mouse_event(event, *window);
break;
case GUI_ServerMessage::Type::WindowActivated:
case GUI_ServerMessage::Type::WindowDeactivated:
case WSAPI_ServerMessage::Type::WindowActivated:
case WSAPI_ServerMessage::Type::WindowDeactivated:
handle_window_activation_event(event, *window);
break;
case GUI_ServerMessage::Type::WindowCloseRequest:
case WSAPI_ServerMessage::Type::WindowCloseRequest:
handle_window_close_request_event(event, *window);
break;
case GUI_ServerMessage::Type::KeyDown:
case GUI_ServerMessage::Type::KeyUp:
case WSAPI_ServerMessage::Type::KeyDown:
case WSAPI_ServerMessage::Type::KeyUp:
handle_key_event(event, *window);
break;
default:
@ -302,8 +302,8 @@ void GEventLoop::wait_for_event()
bool GEventLoop::drain_messages_from_server()
{
for (;;) {
GUI_ServerMessage message;
ssize_t nread = read(m_event_fd, &message, sizeof(GUI_ServerMessage));
WSAPI_ServerMessage message;
ssize_t nread = read(m_event_fd, &message, sizeof(WSAPI_ServerMessage));
if (nread < 0) {
perror("read");
exit(1);
@ -376,13 +376,13 @@ void GEventLoop::unregister_notifier(Badge<GNotifier>, GNotifier& notifier)
m_notifiers.remove(&notifier);
}
bool GEventLoop::post_message_to_server(const GUI_ClientMessage& message)
bool GEventLoop::post_message_to_server(const WSAPI_ClientMessage& message)
{
int nwritten = write(m_event_fd, &message, sizeof(GUI_ClientMessage));
return nwritten == sizeof(GUI_ClientMessage);
int nwritten = write(m_event_fd, &message, sizeof(WSAPI_ClientMessage));
return nwritten == sizeof(WSAPI_ClientMessage);
}
bool GEventLoop::wait_for_specific_event(GUI_ServerMessage::Type type, GUI_ServerMessage& event)
bool GEventLoop::wait_for_specific_event(WSAPI_ServerMessage::Type type, WSAPI_ServerMessage& event)
{
for (;;) {
fd_set rfds;
@ -404,12 +404,12 @@ bool GEventLoop::wait_for_specific_event(GUI_ServerMessage::Type type, GUI_Serve
}
}
GUI_ServerMessage GEventLoop::sync_request(const GUI_ClientMessage& request, GUI_ServerMessage::Type response_type)
WSAPI_ServerMessage GEventLoop::sync_request(const WSAPI_ClientMessage& request, WSAPI_ServerMessage::Type response_type)
{
bool success = post_message_to_server(request);
ASSERT(success);
GUI_ServerMessage response;
WSAPI_ServerMessage response;
success = GEventLoop::main().wait_for_specific_event(response_type, response);
ASSERT(success);
return response;

20
LibGUI/GEventLoop.h
View file

@ -34,20 +34,20 @@ public:
void exit(int);
bool post_message_to_server(const GUI_ClientMessage&);
bool wait_for_specific_event(GUI_ServerMessage::Type, GUI_ServerMessage&);
bool post_message_to_server(const WSAPI_ClientMessage&);
bool wait_for_specific_event(WSAPI_ServerMessage::Type, WSAPI_ServerMessage&);
GUI_ServerMessage sync_request(const GUI_ClientMessage& request, GUI_ServerMessage::Type response_type);
WSAPI_ServerMessage sync_request(const WSAPI_ClientMessage& request, WSAPI_ServerMessage::Type response_type);
private:
void wait_for_event();
bool drain_messages_from_server();
void handle_paint_event(const GUI_ServerMessage&, GWindow&);
void handle_mouse_event(const GUI_ServerMessage&, GWindow&);
void handle_key_event(const GUI_ServerMessage&, GWindow&);
void handle_window_activation_event(const GUI_ServerMessage&, GWindow&);
void handle_window_close_request_event(const GUI_ServerMessage&, GWindow&);
void handle_menu_event(const GUI_ServerMessage&);
void handle_paint_event(const WSAPI_ServerMessage&, GWindow&);
void handle_mouse_event(const WSAPI_ServerMessage&, GWindow&);
void handle_key_event(const WSAPI_ServerMessage&, GWindow&);
void handle_window_activation_event(const WSAPI_ServerMessage&, GWindow&);
void handle_window_close_request_event(const WSAPI_ServerMessage&, GWindow&);
void handle_menu_event(const WSAPI_ServerMessage&);
void get_next_timer_expiration(timeval&);
struct QueuedEvent {
@ -56,7 +56,7 @@ private:
};
Vector<QueuedEvent> m_queued_events;
Vector<GUI_ServerMessage> m_unprocessed_messages;
Vector<WSAPI_ServerMessage> m_unprocessed_messages;
int m_event_fd { -1 };
bool m_running { false };

24
LibGUI/GMenu.cpp
View file

@ -41,34 +41,34 @@ void GMenu::add_separator()
int GMenu::realize_menu()
{
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::CreateMenu;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::CreateMenu;
ASSERT(m_name.length() < sizeof(request.text));
strcpy(request.text, m_name.characters());
request.text_length = m_name.length();
auto response = GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidCreateMenu);
auto response = GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidCreateMenu);
m_menu_id = response.menu.menu_id;
ASSERT(m_menu_id > 0);
for (size_t i = 0; i < m_items.size(); ++i) {
auto& item = *m_items[i];
if (item.type() == GMenuItem::Separator) {
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::AddMenuSeparator;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::AddMenuSeparator;
request.menu.menu_id = m_menu_id;
GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidAddMenuSeparator);
GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidAddMenuSeparator);
continue;
}
if (item.type() == GMenuItem::Action) {
auto& action = *item.action();
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::AddMenuItem;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::AddMenuItem;
request.menu.menu_id = m_menu_id;
request.menu.identifier = i;
ASSERT(action.text().length() < sizeof(request.text));
strcpy(request.text, action.text().characters());
request.text_length = action.text().length();
GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidAddMenuItem);
GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidAddMenuItem);
}
}
all_menus().set(m_menu_id, this);
@ -80,10 +80,10 @@ void GMenu::unrealize_menu()
if (!m_menu_id)
return;
all_menus().remove(m_menu_id);
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::DestroyMenu;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::DestroyMenu;
request.menu.menu_id = m_menu_id;
GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidDestroyMenu);
GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidDestroyMenu);
m_menu_id = 0;
}

24
LibGUI/GMenuBar.cpp
View file

@ -17,9 +17,9 @@ void GMenuBar::add_menu(OwnPtr<GMenu>&& menu)
int GMenuBar::realize_menubar()
{
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::CreateMenubar;
GUI_ServerMessage response = GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidCreateMenubar);
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::CreateMenubar;
WSAPI_ServerMessage response = GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidCreateMenubar);
return response.menu.menubar_id;
}
@ -27,10 +27,10 @@ void GMenuBar::unrealize_menubar()
{
if (!m_menubar_id)
return;
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::DestroyMenubar;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::DestroyMenubar;
request.menu.menubar_id = m_menubar_id;
GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidDestroyMenubar);
GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidDestroyMenubar);
m_menubar_id = 0;
}
@ -43,16 +43,16 @@ void GMenuBar::notify_added_to_application(Badge<GApplication>)
ASSERT(menu);
int menu_id = menu->realize_menu();
ASSERT(menu_id > 0);
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::AddMenuToMenubar;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::AddMenuToMenubar;
request.menu.menubar_id = m_menubar_id;
request.menu.menu_id = menu_id;
GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidAddMenuToMenubar);
GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidAddMenuToMenubar);
}
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::SetApplicationMenubar;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::SetApplicationMenubar;
request.menu.menubar_id = m_menubar_id;
GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidSetApplicationMenubar);
GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidSetApplicationMenubar);
}
void GMenuBar::notify_removed_from_application(Badge<GApplication>)

42
LibGUI/GWindow.cpp
View file

@ -55,14 +55,14 @@ void GWindow::show()
if (m_window_id)
return;
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::CreateWindow;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::CreateWindow;
request.window_id = m_window_id;
request.window.rect = m_rect_when_windowless;
ASSERT(m_title_when_windowless.length() < sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters());
request.text_length = m_title_when_windowless.length();
auto response = GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidCreateWindow);
auto response = GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidCreateWindow);
m_window_id = response.window_id;
windows().set(m_window_id, this);
@ -74,8 +74,8 @@ void GWindow::hide()
if (!m_window_id)
return;
windows().remove(m_window_id);
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::DestroyWindow;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::DestroyWindow;
request.window_id = m_window_id;
ASSERT(m_title_when_windowless.length() < sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters());
@ -89,8 +89,8 @@ void GWindow::set_title(String&& title)
if (!m_window_id)
return;
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::SetWindowTitle;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::SetWindowTitle;
request.window_id = m_window_id;
ASSERT(m_title_when_windowless.length() < sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters());
@ -103,13 +103,13 @@ String GWindow::title() const
if (!m_window_id)
return m_title_when_windowless;
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::GetWindowTitle;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::GetWindowTitle;
request.window_id = m_window_id;
ASSERT(m_title_when_windowless.length() < sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters());
request.text_length = m_title_when_windowless.length();
auto response = GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidGetWindowTitle);
auto response = GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidGetWindowTitle);
return String(response.text, response.text_length);
}
@ -118,10 +118,10 @@ Rect GWindow::rect() const
if (!m_window_id)
return m_rect_when_windowless;
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::GetWindowRect;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::GetWindowRect;
request.window_id = m_window_id;
auto response = GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidGetWindowRect);
auto response = GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidGetWindowRect);
ASSERT(response.window_id == m_window_id);
return response.window.rect;
}
@ -131,8 +131,8 @@ void GWindow::set_rect(const Rect& a_rect)
m_rect_when_windowless = a_rect;
if (!m_window_id)
return;
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::SetWindowRect;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::SetWindowRect;
request.window_id = m_window_id;
request.window.rect = a_rect;
GEventLoop::main().post_message_to_server(request);
@ -170,8 +170,8 @@ void GWindow::event(GEvent& event)
rect = m_main_widget->rect();
m_main_widget->event(*make<GPaintEvent>(rect));
if (m_window_id) {
GUI_ClientMessage message;
message.type = GUI_ClientMessage::Type::DidFinishPainting;
WSAPI_ClientMessage message;
message.type = WSAPI_ClientMessage::Type::DidFinishPainting;
message.window_id = m_window_id;
message.window.rect = rect;
GEventLoop::main().post_message_to_server(message);
@ -223,8 +223,8 @@ void GWindow::update(const Rect& a_rect)
}
m_pending_paint_event_rects.append(a_rect);
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::InvalidateRect;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::InvalidateRect;
request.window_id = m_window_id;
request.window.rect = a_rect;
GEventLoop::main().post_message_to_server(request);
@ -272,8 +272,8 @@ void GWindow::set_global_cursor_tracking_widget(GWidget* widget)
return;
m_global_cursor_tracking_widget = widget ? widget->make_weak_ptr() : nullptr;
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::SetGlobalCursorTracking;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::SetGlobalCursorTracking;
request.window_id = m_window_id;
request.value = widget != nullptr;
// FIXME: What if the cursor moves out of our interest range before the server can handle this?

10
SharedGraphics/Painter.cpp
View file

@ -26,10 +26,10 @@ Painter::Painter(GraphicsBitmap& bitmap)
Painter::Painter(GWidget& widget)
: m_font(&widget.font())
{
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::GetWindowBackingStore;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::GetWindowBackingStore;
request.window_id = widget.window()->window_id();
auto response = GEventLoop::main().sync_request(request, GUI_ServerMessage::DidGetWindowBackingStore);
auto response = GEventLoop::main().sync_request(request, WSAPI_ServerMessage::DidGetWindowBackingStore);
m_backing_store_id = response.backing.backing_store_id;
m_target = GraphicsBitmap::create_wrapper(response.backing.size, response.backing.pixels);
@ -53,8 +53,8 @@ Painter::~Painter()
#ifdef USERLAND
m_target = nullptr;
if (m_backing_store_id) {
GUI_ClientMessage request;
request.type = GUI_ClientMessage::Type::ReleaseWindowBackingStore;
WSAPI_ClientMessage request;
request.type = WSAPI_ClientMessage::Type::ReleaseWindowBackingStore;
request.backing.backing_store_id = m_backing_store_id;
GEventLoop::main().post_message_to_server(request);
}

6
SharedGraphics/Point.h
View file

@ -3,13 +3,13 @@
#include <AK/AKString.h>
class Rect;
struct GUI_Point;
struct WSAPI_Point;
class Point {
public:
Point() { }
Point(int x, int y) : m_x(x) , m_y(y) { }
Point(const GUI_Point&);
Point(const WSAPI_Point&);
int x() const { return m_x; }
int y() const { return m_y; }
@ -48,7 +48,7 @@ public:
return !(*this == other);
}
operator GUI_Point() const;
operator WSAPI_Point() const;
String to_string() const { return String::format("[%d,%d]", x(), y()); }
private:

6
SharedGraphics/Rect.h
View file

@ -4,7 +4,7 @@
#include "Size.h"
#include <AK/AKString.h>
struct GUI_Rect;
struct WSAPI_Rect;
class Rect {
public:
@ -25,7 +25,7 @@ public:
{
}
Rect(const GUI_Rect&);
Rect(const WSAPI_Rect&);
bool is_null() const
{
@ -170,7 +170,7 @@ public:
Point location() const { return m_location; }
Size size() const { return m_size; }
operator GUI_Rect() const;
operator WSAPI_Rect() const;
bool operator==(const Rect& other) const
{

6
SharedGraphics/Size.h
View file

@ -2,13 +2,13 @@
#include <AK/AKString.h>
struct GUI_Size;
struct WSAPI_Size;
class Size {
public:
Size() { }
Size(int w, int h) : m_width(w), m_height(h) { }
Size(const GUI_Size&);
Size(const WSAPI_Size&);
bool is_empty() const { return !m_width || !m_height; }
@ -38,7 +38,7 @@ public:
return *this;
}
operator GUI_Size() const;
operator WSAPI_Size() const;
String to_string() const { return String::format("[%d,%d]", m_width, m_height); }

54
WindowServer/WSAPITypes.h
View file

@ -5,57 +5,57 @@
// GUI system call API types.
struct GUI_WindowFlags { enum {
struct WSAPI_WindowFlags { enum {
Visible = 1 << 0,
}; };
typedef unsigned GUI_Color;
typedef unsigned WSAPI_Color;
struct GUI_Point {
struct WSAPI_Point {
int x;
int y;
};
struct GUI_Size {
struct WSAPI_Size {
int width;
int height;
};
struct GUI_Rect {
GUI_Point location;
GUI_Size size;
struct WSAPI_Rect {
WSAPI_Point location;
WSAPI_Size size;
};
struct GUI_WindowParameters {
GUI_Rect rect;
struct WSAPI_WindowParameters {
WSAPI_Rect rect;
Color background_color;
unsigned flags { 0 };
char title[128];
};
struct GUI_WindowBackingStoreInfo {
struct WSAPI_WindowBackingStoreInfo {
void* backing_store_id;
GUI_Size size;
WSAPI_Size size;
size_t bpp;
size_t pitch;
RGBA32* pixels;
};
enum class GUI_MouseButton : unsigned char {
enum class WSAPI_MouseButton : unsigned char {
NoButton = 0,
Left = 1,
Right = 2,
Middle = 4,
};
struct GUI_KeyModifiers { enum {
struct WSAPI_KeyModifiers { enum {
Shift = 1 << 0,
Alt = 1 << 1,
Ctrl = 1 << 2,
}; };
struct GUI_ServerMessage {
struct WSAPI_ServerMessage {
enum Type : unsigned {
Invalid,
Error,
@ -90,14 +90,14 @@ struct GUI_ServerMessage {
union {
struct {
GUI_Rect rect;
WSAPI_Rect rect;
} window;
struct {
GUI_Rect rect;
WSAPI_Rect rect;
} paint;
struct {
GUI_Point position;
GUI_MouseButton button;
WSAPI_Point position;
WSAPI_MouseButton button;
unsigned buttons;
} mouse;
struct {
@ -115,7 +115,7 @@ struct GUI_ServerMessage {
} menu;
struct {
void* backing_store_id;
GUI_Size size;
WSAPI_Size size;
size_t bpp;
size_t pitch;
RGBA32* pixels;
@ -123,7 +123,7 @@ struct GUI_ServerMessage {
};
};
struct GUI_ClientMessage {
struct WSAPI_ClientMessage {
enum Type : unsigned {
Invalid,
CreateMenubar,
@ -159,7 +159,7 @@ struct GUI_ClientMessage {
unsigned identifier;
} menu;
struct {
GUI_Rect rect;
WSAPI_Rect rect;
} window;
struct {
void* backing_store_id;
@ -167,9 +167,9 @@ struct GUI_ClientMessage {
};
};
inline Rect::Rect(const GUI_Rect& r) : Rect(r.location, r.size) { }
inline Point::Point(const GUI_Point& p) : Point(p.x, p.y) { }
inline Size::Size(const GUI_Size& s) : Size(s.width, s.height) { }
inline Rect::operator GUI_Rect() const { return { m_location, m_size }; }
inline Point::operator GUI_Point() const { return { m_x, m_y }; }
inline Size::operator GUI_Size() const { return { m_width, m_height }; }
inline Rect::Rect(const WSAPI_Rect& r) : Rect(r.location, r.size) { }
inline Point::Point(const WSAPI_Point& p) : Point(p.x, p.y) { }
inline Size::Size(const WSAPI_Size& s) : Size(s.width, s.height) { }
inline Rect::operator WSAPI_Rect() const { return { m_location, m_size }; }
inline Point::operator WSAPI_Point() const { return { m_x, m_y }; }
inline Size::operator WSAPI_Size() const { return { m_width, m_height }; }

58
WindowServer/WSClientConnection.cpp
View file

@ -69,15 +69,15 @@ WSClientConnection::~WSClientConnection()
void WSClientConnection::post_error(const String& error_message)
{
dbgprintf("WSClientConnection::post_error: client_id=%d: %s\n", m_client_id, error_message.characters());
GUI_ServerMessage message;
message.type = GUI_ServerMessage::Type::Error;
WSAPI_ServerMessage message;
message.type = WSAPI_ServerMessage::Type::Error;
ASSERT(error_message.length() < sizeof(message.text));
strcpy(message.text, error_message.characters());
message.text_length = error_message.length();
WSMessageLoop::the().post_message_to_client(m_client_id, message);
}
void WSClientConnection::post_message(const GUI_ServerMessage& message)
void WSClientConnection::post_message(const WSAPI_ServerMessage& message)
{
int nwritten = WSMessageLoop::the().server_process().sys$write(m_fd, &message, sizeof(message));
ASSERT(nwritten == sizeof(message));
@ -110,8 +110,8 @@ void WSClientConnection::handle_request(WSAPICreateMenubarRequest& request)
int menubar_id = m_next_menubar_id++;
auto menubar = make<WSMenuBar>(request.client_id(), menubar_id);
m_menubars.set(menubar_id, move(menubar));
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidCreateMenubar;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidCreateMenubar;
response.menu.menubar_id = menubar_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
}
@ -127,8 +127,8 @@ void WSClientConnection::handle_request(WSAPIDestroyMenubarRequest& request)
auto& menubar = *(*it).value;
WSWindowManager::the().close_menubar(menubar);
m_menubars.remove(it);
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidDestroyMenubar;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidDestroyMenubar;
response.menu.menubar_id = menubar_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
}
@ -138,8 +138,8 @@ void WSClientConnection::handle_request(WSAPICreateMenuRequest& request)
int menu_id = m_next_menu_id++;
auto menu = make<WSMenu>(request.client_id(), menu_id, request.text());
m_menus.set(menu_id, move(menu));
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidCreateMenu;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidCreateMenu;
response.menu.menu_id = menu_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
}
@ -155,8 +155,8 @@ void WSClientConnection::handle_request(WSAPIDestroyMenuRequest& request)
auto& menu = *(*it).value;
WSWindowManager::the().close_menu(menu);
m_menus.remove(it);
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidDestroyMenu;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidDestroyMenu;
response.menu.menu_id = menu_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
}
@ -172,8 +172,8 @@ void WSClientConnection::handle_request(WSAPISetApplicationMenubarRequest& reque
auto& menubar = *(*it).value;
m_app_menubar = menubar.make_weak_ptr();
WSWindowManager::the().notify_client_changed_app_menubar(*this);
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidSetApplicationMenubar;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidSetApplicationMenubar;
response.menu.menubar_id = menubar_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
}
@ -195,8 +195,8 @@ void WSClientConnection::handle_request(WSAPIAddMenuToMenubarRequest& request)
auto& menubar = *(*it).value;
auto& menu = *(*jt).value;
menubar.add_menu(&menu);
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidAddMenuToMenubar;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidAddMenuToMenubar;
response.menu.menubar_id = menubar_id;
response.menu.menu_id = menu_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
@ -214,8 +214,8 @@ void WSClientConnection::handle_request(WSAPIAddMenuItemRequest& request)
}
auto& menu = *(*it).value;
menu.add_item(make<WSMenuItem>(identifier, move(text)));
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidAddMenuItem;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidAddMenuItem;
response.menu.menu_id = menu_id;
response.menu.identifier = identifier;
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
@ -231,8 +231,8 @@ void WSClientConnection::handle_request(WSAPIAddMenuSeparatorRequest& request)
}
auto& menu = *(*it).value;
menu.add_item(make<WSMenuItem>(WSMenuItem::Separator));
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidAddMenuSeparator;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidAddMenuSeparator;
response.menu.menu_id = menu_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
}
@ -258,8 +258,8 @@ void WSClientConnection::handle_request(WSAPIGetWindowTitleRequest& request)
return;
}
auto& window = *(*it).value;
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidGetWindowTitle;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidGetWindowTitle;
response.window_id = window.window_id();
ASSERT(window.title().length() < sizeof(response.text));
strcpy(response.text, window.title().characters());
@ -288,8 +288,8 @@ void WSClientConnection::handle_request(WSAPIGetWindowRectRequest& request)
return;
}
auto& window = *(*it).value;
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidGetWindowRect;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidGetWindowRect;
response.window_id = window.window_id();
response.window.rect = window.rect();
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
@ -302,8 +302,8 @@ void WSClientConnection::handle_request(WSAPICreateWindowRequest& request)
window->set_title(request.title());
window->set_rect(request.rect());
m_windows.set(window_id, move(window));
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidCreateWindow;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidCreateWindow;
response.window_id = window_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
}
@ -329,8 +329,8 @@ void WSClientConnection::handle_request(WSAPIInvalidateRectRequest& request)
post_error("Bad window ID");
return;
}
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::Paint;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::Paint;
response.window_id = window_id;
response.paint.rect = request.rect();
WSMessageLoop::the().post_message_to_client(request.client_id(), response);
@ -362,8 +362,8 @@ void WSClientConnection::handle_request(WSAPIGetWindowBackingStoreRequest& reque
// FIXME: It shouldn't work this way!
backing_store->retain();
GUI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidGetWindowBackingStore;
WSAPI_ServerMessage response;
response.type = WSAPI_ServerMessage::Type::DidGetWindowBackingStore;
response.window_id = window_id;
response.backing.backing_store_id = backing_store;
response.backing.bpp = sizeof(RGBA32);

4
WindowServer/WSClientConnection.h
View file

@ -11,7 +11,7 @@
class WSWindow;
class WSMenu;
class WSMenuBar;
struct GUI_ServerMessage;
struct WSAPI_ServerMessage;
// FIXME: Remove.
class Process;
@ -25,7 +25,7 @@ public:
static WSClientConnection* ensure_for_client_id(int client_id);
static void for_each_client(Function<void(WSClientConnection&)>);
void post_message(const GUI_ServerMessage&);
void post_message(const WSAPI_ServerMessage&);
RetainPtr<GraphicsBitmap> create_bitmap(const Size&);
int client_id() const { return m_client_id; }

4
WindowServer/WSMenu.cpp
View file

@ -139,8 +139,8 @@ void WSMenu::did_activate(WSMenuItem& item)
close();
GUI_ServerMessage message;
message.type = GUI_ServerMessage::Type::MenuItemActivated;
WSAPI_ServerMessage message;
message.type = WSAPI_ServerMessage::Type::MenuItemActivated;
message.menu.menu_id = m_menu_id;
message.menu.identifier = item.identifier();

44
WindowServer/WSMessageLoop.cpp
View file

@ -87,7 +87,7 @@ Process* WSMessageLoop::process_from_client_id(int client_id)
return (Process*)client_id;
}
void WSMessageLoop::post_message_to_client(int client_id, const GUI_ServerMessage& message)
void WSMessageLoop::post_message_to_client(int client_id, const WSAPI_ServerMessage& message)
{
auto* client = WSClientConnection::from_client_id(client_id);
if (!client)
@ -245,7 +245,7 @@ void WSMessageLoop::wait_for_message()
WSClientConnection::for_each_client([&] (WSClientConnection& client) {
if (bitmap.get(client.fd())) {
byte buffer[4096];
ssize_t nread = m_server_process->sys$read(client.fd(), buffer, sizeof(GUI_ClientMessage));
ssize_t nread = m_server_process->sys$read(client.fd(), buffer, sizeof(WSAPI_ClientMessage));
on_receive_from_client(client.client_id(), buffer, nread);
}
});
@ -323,66 +323,66 @@ ssize_t WSMessageLoop::on_receive_from_client(int client_id, const byte* data, s
WSClientConnection* client = WSClientConnection::ensure_for_client_id(client_id);
ASSERT(size == sizeof(GUI_ClientMessage));
auto& message = *reinterpret_cast<const GUI_ClientMessage*>(data);
ASSERT(size == sizeof(WSAPI_ClientMessage));
auto& message = *reinterpret_cast<const WSAPI_ClientMessage*>(data);
switch (message.type) {
case GUI_ClientMessage::Type::CreateMenubar:
case WSAPI_ClientMessage::Type::CreateMenubar:
post_message(client, make<WSAPICreateMenubarRequest>(client_id));
break;
case GUI_ClientMessage::Type::DestroyMenubar:
case WSAPI_ClientMessage::Type::DestroyMenubar:
post_message(client, make<WSAPIDestroyMenubarRequest>(client_id, message.menu.menubar_id));
break;
case GUI_ClientMessage::Type::SetApplicationMenubar:
case WSAPI_ClientMessage::Type::SetApplicationMenubar:
post_message(client, make<WSAPISetApplicationMenubarRequest>(client_id, message.menu.menubar_id));
break;
case GUI_ClientMessage::Type::AddMenuToMenubar:
case WSAPI_ClientMessage::Type::AddMenuToMenubar:
post_message(client, make<WSAPIAddMenuToMenubarRequest>(client_id, message.menu.menubar_id, message.menu.menu_id));
break;
case GUI_ClientMessage::Type::CreateMenu:
case WSAPI_ClientMessage::Type::CreateMenu:
ASSERT(message.text_length < sizeof(message.text));
post_message(client, make<WSAPICreateMenuRequest>(client_id, String(message.text, message.text_length)));
break;
case GUI_ClientMessage::Type::DestroyMenu:
case WSAPI_ClientMessage::Type::DestroyMenu:
post_message(client, make<WSAPIDestroyMenuRequest>(client_id, message.menu.menu_id));
break;
case GUI_ClientMessage::Type::AddMenuItem:
case WSAPI_ClientMessage::Type::AddMenuItem:
ASSERT(message.text_length < sizeof(message.text));
post_message(client, make<WSAPIAddMenuItemRequest>(client_id, message.menu.menu_id, message.menu.identifier, String(message.text, message.text_length)));
break;
case GUI_ClientMessage::Type::CreateWindow:
case WSAPI_ClientMessage::Type::CreateWindow:
ASSERT(message.text_length < sizeof(message.text));
post_message(client, make<WSAPICreateWindowRequest>(client_id, message.window.rect, String(message.text, message.text_length)));
break;
case GUI_ClientMessage::Type::DestroyWindow:
case WSAPI_ClientMessage::Type::DestroyWindow:
post_message(client, make<WSAPIDestroyWindowRequest>(client_id, message.window_id));
break;
case GUI_ClientMessage::Type::SetWindowTitle:
case WSAPI_ClientMessage::Type::SetWindowTitle:
ASSERT(message.text_length < sizeof(message.text));
post_message(client, make<WSAPISetWindowTitleRequest>(client_id, message.window_id, String(message.text, message.text_length)));
break;
case GUI_ClientMessage::Type::GetWindowTitle:
case WSAPI_ClientMessage::Type::GetWindowTitle:
ASSERT(message.text_length < sizeof(message.text));
post_message(client, make<WSAPIGetWindowTitleRequest>(client_id, message.window_id));
break;
case GUI_ClientMessage::Type::SetWindowRect:
case WSAPI_ClientMessage::Type::SetWindowRect:
post_message(client, make<WSAPISetWindowRectRequest>(client_id, message.window_id, message.window.rect));
break;
case GUI_ClientMessage::Type::GetWindowRect:
case WSAPI_ClientMessage::Type::GetWindowRect:
post_message(client, make<WSAPIGetWindowRectRequest>(client_id, message.window_id));
break;
case GUI_ClientMessage::Type::InvalidateRect:
case WSAPI_ClientMessage::Type::InvalidateRect:
post_message(client, make<WSAPIInvalidateRectRequest>(client_id, message.window_id, message.window.rect));
break;
case GUI_ClientMessage::Type::DidFinishPainting:
case WSAPI_ClientMessage::Type::DidFinishPainting:
post_message(client, make<WSAPIDidFinishPaintingNotification>(client_id, message.window_id, message.window.rect));
break;
case GUI_ClientMessage::Type::GetWindowBackingStore:
case WSAPI_ClientMessage::Type::GetWindowBackingStore:
post_message(client, make<WSAPIGetWindowBackingStoreRequest>(client_id, message.window_id));
break;
case GUI_ClientMessage::Type::ReleaseWindowBackingStore:
case WSAPI_ClientMessage::Type::ReleaseWindowBackingStore:
post_message(client, make<WSAPIReleaseWindowBackingStoreRequest>(client_id, (int)message.backing.backing_store_id));
break;
case GUI_ClientMessage::Type::SetGlobalCursorTracking:
case WSAPI_ClientMessage::Type::SetGlobalCursorTracking:
post_message(client, make<WSAPISetGlobalCursorTrackingRequest>(client_id, message.window_id, message.value));
break;
}

4
WindowServer/WSMessageLoop.h
View file

@ -9,7 +9,7 @@
class WSMessageReceiver;
class Process;
struct GUI_ServerMessage;
struct WSAPI_ServerMessage;
class WSMessageLoop {
public:
@ -30,7 +30,7 @@ public:
int start_timer(int ms, Function<void()>&&);
int stop_timer(int timer_id);
void post_message_to_client(int client_id, const GUI_ServerMessage&);
void post_message_to_client(int client_id, const WSAPI_ServerMessage&);
ssize_t on_receive_from_client(int client_id, const byte*, size_t);
static Process* process_from_client_id(int client_id);

32
WindowServer/WSWindow.cpp
View file

@ -54,13 +54,13 @@ void WSWindow::set_rect(const Rect& rect)
}
// FIXME: Just use the same types.
static GUI_MouseButton to_api(MouseButton button)
static WSAPI_MouseButton to_api(MouseButton button)
{
switch (button) {
case MouseButton::None: return GUI_MouseButton::NoButton;
case MouseButton::Left: return GUI_MouseButton::Left;
case MouseButton::Right: return GUI_MouseButton::Right;
case MouseButton::Middle: return GUI_MouseButton::Middle;
case MouseButton::None: return WSAPI_MouseButton::NoButton;
case MouseButton::Left: return WSAPI_MouseButton::Left;
case MouseButton::Right: return WSAPI_MouseButton::Right;
case MouseButton::Middle: return WSAPI_MouseButton::Middle;
}
ASSERT_NOT_REACHED();
}
@ -72,30 +72,30 @@ void WSWindow::on_message(WSMessage& message)
return;
}
GUI_ServerMessage server_message;
WSAPI_ServerMessage server_message;
server_message.window_id = window_id();
switch (message.type()) {
case WSMessage::MouseMove:
server_message.type = GUI_ServerMessage::Type::MouseMove;
server_message.type = WSAPI_ServerMessage::Type::MouseMove;
server_message.mouse.position = static_cast<WSMouseEvent&>(message).position();
server_message.mouse.button = GUI_MouseButton::NoButton;
server_message.mouse.button = WSAPI_MouseButton::NoButton;
server_message.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break;
case WSMessage::MouseDown:
server_message.type = GUI_ServerMessage::Type::MouseDown;
server_message.type = WSAPI_ServerMessage::Type::MouseDown;
server_message.mouse.position = static_cast<WSMouseEvent&>(message).position();
server_message.mouse.button = to_api(static_cast<WSMouseEvent&>(message).button());
server_message.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break;
case WSMessage::MouseUp:
server_message.type = GUI_ServerMessage::Type::MouseUp;
server_message.type = WSAPI_ServerMessage::Type::MouseUp;
server_message.mouse.position = static_cast<WSMouseEvent&>(message).position();
server_message.mouse.button = to_api(static_cast<WSMouseEvent&>(message).button());
server_message.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break;
case WSMessage::KeyDown:
server_message.type = GUI_ServerMessage::Type::KeyDown;
server_message.type = WSAPI_ServerMessage::Type::KeyDown;
server_message.key.character = static_cast<WSKeyEvent&>(message).character();
server_message.key.key = static_cast<WSKeyEvent&>(message).key();
server_message.key.alt = static_cast<WSKeyEvent&>(message).alt();
@ -103,7 +103,7 @@ void WSWindow::on_message(WSMessage& message)
server_message.key.shift = static_cast<WSKeyEvent&>(message).shift();
break;
case WSMessage::KeyUp:
server_message.type = GUI_ServerMessage::Type::KeyUp;
server_message.type = WSAPI_ServerMessage::Type::KeyUp;
server_message.key.character = static_cast<WSKeyEvent&>(message).character();
server_message.key.key = static_cast<WSKeyEvent&>(message).key();
server_message.key.alt = static_cast<WSKeyEvent&>(message).alt();
@ -111,19 +111,19 @@ void WSWindow::on_message(WSMessage& message)
server_message.key.shift = static_cast<WSKeyEvent&>(message).shift();
break;
case WSMessage::WindowActivated:
server_message.type = GUI_ServerMessage::Type::WindowActivated;
server_message.type = WSAPI_ServerMessage::Type::WindowActivated;
break;
case WSMessage::WindowDeactivated:
server_message.type = GUI_ServerMessage::Type::WindowDeactivated;
server_message.type = WSAPI_ServerMessage::Type::WindowDeactivated;
break;
case WSMessage::WindowCloseRequest:
server_message.type = GUI_ServerMessage::Type::WindowCloseRequest;
server_message.type = WSAPI_ServerMessage::Type::WindowCloseRequest;
break;
default:
break;
}
if (server_message.type == GUI_ServerMessage::Type::Invalid)
if (server_message.type == WSAPI_ServerMessage::Type::Invalid)
return;
if (auto* client = WSClientConnection::from_client_id(m_client_id))