RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 00:37:45 +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

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))