RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 11:58:12 +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) }); 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 #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); 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)); 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 #ifdef GEVENTLOOP_DEBUG
dbgprintf("WID=%x WindowActivation\n", event.window_id); dbgprintf("WID=%x WindowActivation\n", event.window_id);
#endif #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)); 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 #ifdef GEVENTLOOP_DEBUG
dbgprintf("WID=%x KeyEvent character=0x%b\n", event.window_id, event.key.character); dbgprintf("WID=%x KeyEvent character=0x%b\n", event.window_id, event.key.character);
#endif #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_alt = event.key.alt;
key_event->m_ctrl = event.key.ctrl; key_event->m_ctrl = event.key.ctrl;
key_event->m_shift = event.key.shift; 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)); 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 #ifdef GEVENTLOOP_DEBUG
dbgprintf("WID=%x MouseEvent %d,%d\n", event.window_id, event.mouse.position.x, event.mouse.position.y); dbgprintf("WID=%x MouseEvent %d,%d\n", event.window_id, event.mouse.position.x, event.mouse.position.y);
#endif #endif
GMouseEvent::Type type; GMouseEvent::Type type;
switch (event.type) { switch (event.type) {
case GUI_ServerMessage::Type::MouseMove: type = GEvent::MouseMove; break; case WSAPI_ServerMessage::Type::MouseMove: type = GEvent::MouseMove; break;
case GUI_ServerMessage::Type::MouseUp: type = GEvent::MouseUp; break; case WSAPI_ServerMessage::Type::MouseUp: type = GEvent::MouseUp; break;
case GUI_ServerMessage::Type::MouseDown: type = GEvent::MouseDown; break; case WSAPI_ServerMessage::Type::MouseDown: type = GEvent::MouseDown; break;
default: ASSERT_NOT_REACHED(); break; default: ASSERT_NOT_REACHED(); break;
} }
GMouseButton button { GMouseButton::None }; GMouseButton button { GMouseButton::None };
switch (event.mouse.button) { switch (event.mouse.button) {
case GUI_MouseButton::NoButton: button = GMouseButton::None; break; case WSAPI_MouseButton::NoButton: button = GMouseButton::None; break;
case GUI_MouseButton::Left: button = GMouseButton::Left; break; case WSAPI_MouseButton::Left: button = GMouseButton::Left; break;
case GUI_MouseButton::Right: button = GMouseButton::Right; break; case WSAPI_MouseButton::Right: button = GMouseButton::Right; break;
case GUI_MouseButton::Middle: button = GMouseButton::Middle; break; case WSAPI_MouseButton::Middle: button = GMouseButton::Middle; break;
default: ASSERT_NOT_REACHED(); break; default: ASSERT_NOT_REACHED(); break;
} }
post_event(&window, make<GMouseEvent>(type, event.mouse.position, event.mouse.buttons, button)); 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); auto* menu = GMenu::from_menu_id(event.menu.menu_id);
if (!menu) { if (!menu) {
dbgprintf("GEventLoop received event for invalid window ID %d\n", event.window_id); 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); auto unprocessed_events = move(m_unprocessed_messages);
for (auto& event : unprocessed_events) { 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("GEventLoop got error message from server\n");
dbgprintf(" - error message: %s\n", String(event.text, event.text_length).characters()); dbgprintf(" - error message: %s\n", String(event.text, event.text_length).characters());
exit(1); exit(1);
@ -261,7 +261,7 @@ void GEventLoop::wait_for_event()
} }
switch (event.type) { switch (event.type) {
case GUI_ServerMessage::MenuItemActivated: case WSAPI_ServerMessage::MenuItemActivated:
handle_menu_event(event); handle_menu_event(event);
continue; continue;
default: default:
@ -274,23 +274,23 @@ void GEventLoop::wait_for_event()
continue; continue;
} }
switch (event.type) { switch (event.type) {
case GUI_ServerMessage::Type::Paint: case WSAPI_ServerMessage::Type::Paint:
handle_paint_event(event, *window); handle_paint_event(event, *window);
break; break;
case GUI_ServerMessage::Type::MouseDown: case WSAPI_ServerMessage::Type::MouseDown:
case GUI_ServerMessage::Type::MouseUp: case WSAPI_ServerMessage::Type::MouseUp:
case GUI_ServerMessage::Type::MouseMove: case WSAPI_ServerMessage::Type::MouseMove:
handle_mouse_event(event, *window); handle_mouse_event(event, *window);
break; break;
case GUI_ServerMessage::Type::WindowActivated: case WSAPI_ServerMessage::Type::WindowActivated:
case GUI_ServerMessage::Type::WindowDeactivated: case WSAPI_ServerMessage::Type::WindowDeactivated:
handle_window_activation_event(event, *window); handle_window_activation_event(event, *window);
break; break;
case GUI_ServerMessage::Type::WindowCloseRequest: case WSAPI_ServerMessage::Type::WindowCloseRequest:
handle_window_close_request_event(event, *window); handle_window_close_request_event(event, *window);
break; break;
case GUI_ServerMessage::Type::KeyDown: case WSAPI_ServerMessage::Type::KeyDown:
case GUI_ServerMessage::Type::KeyUp: case WSAPI_ServerMessage::Type::KeyUp:
handle_key_event(event, *window); handle_key_event(event, *window);
break; break;
default: default:
@ -302,8 +302,8 @@ void GEventLoop::wait_for_event()
bool GEventLoop::drain_messages_from_server() bool GEventLoop::drain_messages_from_server()
{ {
for (;;) { for (;;) {
GUI_ServerMessage message; WSAPI_ServerMessage message;
ssize_t nread = read(m_event_fd, &message, sizeof(GUI_ServerMessage)); ssize_t nread = read(m_event_fd, &message, sizeof(WSAPI_ServerMessage));
if (nread < 0) { if (nread < 0) {
perror("read"); perror("read");
exit(1); exit(1);
@ -376,13 +376,13 @@ void GEventLoop::unregister_notifier(Badge<GNotifier>, GNotifier& notifier)
m_notifiers.remove(&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)); int nwritten = write(m_event_fd, &message, sizeof(WSAPI_ClientMessage));
return nwritten == sizeof(GUI_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 (;;) { for (;;) {
fd_set rfds; 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); bool success = post_message_to_server(request);
ASSERT(success); ASSERT(success);
GUI_ServerMessage response; WSAPI_ServerMessage response;
success = GEventLoop::main().wait_for_specific_event(response_type, response); success = GEventLoop::main().wait_for_specific_event(response_type, response);
ASSERT(success); ASSERT(success);
return response; return response;

20
LibGUI/GEventLoop.h
View file

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

24
LibGUI/GMenu.cpp
View file

@ -41,34 +41,34 @@ void GMenu::add_separator()
int GMenu::realize_menu() int GMenu::realize_menu()
{ {
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::CreateMenu; request.type = WSAPI_ClientMessage::Type::CreateMenu;
ASSERT(m_name.length() < sizeof(request.text)); ASSERT(m_name.length() < sizeof(request.text));
strcpy(request.text, m_name.characters()); strcpy(request.text, m_name.characters());
request.text_length = m_name.length(); 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; m_menu_id = response.menu.menu_id;
ASSERT(m_menu_id > 0); ASSERT(m_menu_id > 0);
for (size_t i = 0; i < m_items.size(); ++i) { for (size_t i = 0; i < m_items.size(); ++i) {
auto& item = *m_items[i]; auto& item = *m_items[i];
if (item.type() == GMenuItem::Separator) { if (item.type() == GMenuItem::Separator) {
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::AddMenuSeparator; request.type = WSAPI_ClientMessage::Type::AddMenuSeparator;
request.menu.menu_id = m_menu_id; 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; continue;
} }
if (item.type() == GMenuItem::Action) { if (item.type() == GMenuItem::Action) {
auto& action = *item.action(); auto& action = *item.action();
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::AddMenuItem; request.type = WSAPI_ClientMessage::Type::AddMenuItem;
request.menu.menu_id = m_menu_id; request.menu.menu_id = m_menu_id;
request.menu.identifier = i; request.menu.identifier = i;
ASSERT(action.text().length() < sizeof(request.text)); ASSERT(action.text().length() < sizeof(request.text));
strcpy(request.text, action.text().characters()); strcpy(request.text, action.text().characters());
request.text_length = action.text().length(); 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); all_menus().set(m_menu_id, this);
@ -80,10 +80,10 @@ void GMenu::unrealize_menu()
if (!m_menu_id) if (!m_menu_id)
return; return;
all_menus().remove(m_menu_id); all_menus().remove(m_menu_id);
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::DestroyMenu; request.type = WSAPI_ClientMessage::Type::DestroyMenu;
request.menu.menu_id = m_menu_id; 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; 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() int GMenuBar::realize_menubar()
{ {
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::CreateMenubar; request.type = WSAPI_ClientMessage::Type::CreateMenubar;
GUI_ServerMessage response = GEventLoop::main().sync_request(request, GUI_ServerMessage::Type::DidCreateMenubar); WSAPI_ServerMessage response = GEventLoop::main().sync_request(request, WSAPI_ServerMessage::Type::DidCreateMenubar);
return response.menu.menubar_id; return response.menu.menubar_id;
} }
@ -27,10 +27,10 @@ void GMenuBar::unrealize_menubar()
{ {
if (!m_menubar_id) if (!m_menubar_id)
return; return;
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::DestroyMenubar; request.type = WSAPI_ClientMessage::Type::DestroyMenubar;
request.menu.menubar_id = m_menubar_id; 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; m_menubar_id = 0;
} }
@ -43,16 +43,16 @@ void GMenuBar::notify_added_to_application(Badge<GApplication>)
ASSERT(menu); ASSERT(menu);
int menu_id = menu->realize_menu(); int menu_id = menu->realize_menu();
ASSERT(menu_id > 0); ASSERT(menu_id > 0);
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::AddMenuToMenubar; request.type = WSAPI_ClientMessage::Type::AddMenuToMenubar;
request.menu.menubar_id = m_menubar_id; request.menu.menubar_id = m_menubar_id;
request.menu.menu_id = menu_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; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::SetApplicationMenubar; request.type = WSAPI_ClientMessage::Type::SetApplicationMenubar;
request.menu.menubar_id = m_menubar_id; 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>) 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) if (m_window_id)
return; return;
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::CreateWindow; request.type = WSAPI_ClientMessage::Type::CreateWindow;
request.window_id = m_window_id; request.window_id = m_window_id;
request.window.rect = m_rect_when_windowless; request.window.rect = m_rect_when_windowless;
ASSERT(m_title_when_windowless.length() < sizeof(request.text)); ASSERT(m_title_when_windowless.length() < sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters()); strcpy(request.text, m_title_when_windowless.characters());
request.text_length = m_title_when_windowless.length(); 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; m_window_id = response.window_id;
windows().set(m_window_id, this); windows().set(m_window_id, this);
@ -74,8 +74,8 @@ void GWindow::hide()
if (!m_window_id) if (!m_window_id)
return; return;
windows().remove(m_window_id); windows().remove(m_window_id);
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::DestroyWindow; request.type = WSAPI_ClientMessage::Type::DestroyWindow;
request.window_id = m_window_id; request.window_id = m_window_id;
ASSERT(m_title_when_windowless.length() < sizeof(request.text)); ASSERT(m_title_when_windowless.length() < sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters()); strcpy(request.text, m_title_when_windowless.characters());
@ -89,8 +89,8 @@ void GWindow::set_title(String&& title)
if (!m_window_id) if (!m_window_id)
return; return;
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::SetWindowTitle; request.type = WSAPI_ClientMessage::Type::SetWindowTitle;
request.window_id = m_window_id; request.window_id = m_window_id;
ASSERT(m_title_when_windowless.length() < sizeof(request.text)); ASSERT(m_title_when_windowless.length() < sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters()); strcpy(request.text, m_title_when_windowless.characters());
@ -103,13 +103,13 @@ String GWindow::title() const
if (!m_window_id) if (!m_window_id)
return m_title_when_windowless; return m_title_when_windowless;
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::GetWindowTitle; request.type = WSAPI_ClientMessage::Type::GetWindowTitle;
request.window_id = m_window_id; request.window_id = m_window_id;
ASSERT(m_title_when_windowless.length() < sizeof(request.text)); ASSERT(m_title_when_windowless.length() < sizeof(request.text));
strcpy(request.text, m_title_when_windowless.characters()); strcpy(request.text, m_title_when_windowless.characters());
request.text_length = m_title_when_windowless.length(); 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); return String(response.text, response.text_length);
} }
@ -118,10 +118,10 @@ Rect GWindow::rect() const
if (!m_window_id) if (!m_window_id)
return m_rect_when_windowless; return m_rect_when_windowless;
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::GetWindowRect; request.type = WSAPI_ClientMessage::Type::GetWindowRect;
request.window_id = m_window_id; 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); ASSERT(response.window_id == m_window_id);
return response.window.rect; return response.window.rect;
} }
@ -131,8 +131,8 @@ void GWindow::set_rect(const Rect& a_rect)
m_rect_when_windowless = a_rect; m_rect_when_windowless = a_rect;
if (!m_window_id) if (!m_window_id)
return; return;
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::SetWindowRect; request.type = WSAPI_ClientMessage::Type::SetWindowRect;
request.window_id = m_window_id; request.window_id = m_window_id;
request.window.rect = a_rect; request.window.rect = a_rect;
GEventLoop::main().post_message_to_server(request); GEventLoop::main().post_message_to_server(request);
@ -170,8 +170,8 @@ void GWindow::event(GEvent& event)
rect = m_main_widget->rect(); rect = m_main_widget->rect();
m_main_widget->event(*make<GPaintEvent>(rect)); m_main_widget->event(*make<GPaintEvent>(rect));
if (m_window_id) { if (m_window_id) {
GUI_ClientMessage message; WSAPI_ClientMessage message;
message.type = GUI_ClientMessage::Type::DidFinishPainting; message.type = WSAPI_ClientMessage::Type::DidFinishPainting;
message.window_id = m_window_id; message.window_id = m_window_id;
message.window.rect = rect; message.window.rect = rect;
GEventLoop::main().post_message_to_server(message); 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); m_pending_paint_event_rects.append(a_rect);
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::InvalidateRect; request.type = WSAPI_ClientMessage::Type::InvalidateRect;
request.window_id = m_window_id; request.window_id = m_window_id;
request.window.rect = a_rect; request.window.rect = a_rect;
GEventLoop::main().post_message_to_server(request); GEventLoop::main().post_message_to_server(request);
@ -272,8 +272,8 @@ void GWindow::set_global_cursor_tracking_widget(GWidget* widget)
return; return;
m_global_cursor_tracking_widget = widget ? widget->make_weak_ptr() : nullptr; m_global_cursor_tracking_widget = widget ? widget->make_weak_ptr() : nullptr;
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::SetGlobalCursorTracking; request.type = WSAPI_ClientMessage::Type::SetGlobalCursorTracking;
request.window_id = m_window_id; request.window_id = m_window_id;
request.value = widget != nullptr; request.value = widget != nullptr;
// FIXME: What if the cursor moves out of our interest range before the server can handle this? // 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) Painter::Painter(GWidget& widget)
: m_font(&widget.font()) : m_font(&widget.font())
{ {
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::GetWindowBackingStore; request.type = WSAPI_ClientMessage::Type::GetWindowBackingStore;
request.window_id = widget.window()->window_id(); 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_backing_store_id = response.backing.backing_store_id;
m_target = GraphicsBitmap::create_wrapper(response.backing.size, response.backing.pixels); m_target = GraphicsBitmap::create_wrapper(response.backing.size, response.backing.pixels);
@ -53,8 +53,8 @@ Painter::~Painter()
#ifdef USERLAND #ifdef USERLAND
m_target = nullptr; m_target = nullptr;
if (m_backing_store_id) { if (m_backing_store_id) {
GUI_ClientMessage request; WSAPI_ClientMessage request;
request.type = GUI_ClientMessage::Type::ReleaseWindowBackingStore; request.type = WSAPI_ClientMessage::Type::ReleaseWindowBackingStore;
request.backing.backing_store_id = m_backing_store_id; request.backing.backing_store_id = m_backing_store_id;
GEventLoop::main().post_message_to_server(request); GEventLoop::main().post_message_to_server(request);
} }

6
SharedGraphics/Point.h
View file

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

6
SharedGraphics/Rect.h
View file

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

6
SharedGraphics/Size.h
View file

@ -2,13 +2,13 @@
#include <AK/AKString.h> #include <AK/AKString.h>
struct GUI_Size; struct WSAPI_Size;
class Size { class Size {
public: public:
Size() { } Size() { }
Size(int w, int h) : m_width(w), m_height(h) { } 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; } bool is_empty() const { return !m_width || !m_height; }
@ -38,7 +38,7 @@ public:
return *this; return *this;
} }
operator GUI_Size() const; operator WSAPI_Size() const;
String to_string() const { return String::format("[%d,%d]", m_width, m_height); } 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. // GUI system call API types.
struct GUI_WindowFlags { enum { struct WSAPI_WindowFlags { enum {
Visible = 1 << 0, Visible = 1 << 0,
}; }; }; };
typedef unsigned GUI_Color; typedef unsigned WSAPI_Color;
struct GUI_Point { struct WSAPI_Point {
int x; int x;
int y; int y;
}; };
struct GUI_Size { struct WSAPI_Size {
int width; int width;
int height; int height;
}; };
struct GUI_Rect { struct WSAPI_Rect {
GUI_Point location; WSAPI_Point location;
GUI_Size size; WSAPI_Size size;
}; };
struct GUI_WindowParameters { struct WSAPI_WindowParameters {
GUI_Rect rect; WSAPI_Rect rect;
Color background_color; Color background_color;
unsigned flags { 0 }; unsigned flags { 0 };
char title[128]; char title[128];
}; };
struct GUI_WindowBackingStoreInfo { struct WSAPI_WindowBackingStoreInfo {
void* backing_store_id; void* backing_store_id;
GUI_Size size; WSAPI_Size size;
size_t bpp; size_t bpp;
size_t pitch; size_t pitch;
RGBA32* pixels; RGBA32* pixels;
}; };
enum class GUI_MouseButton : unsigned char { enum class WSAPI_MouseButton : unsigned char {
NoButton = 0, NoButton = 0,
Left = 1, Left = 1,
Right = 2, Right = 2,
Middle = 4, Middle = 4,
}; };
struct GUI_KeyModifiers { enum { struct WSAPI_KeyModifiers { enum {
Shift = 1 << 0, Shift = 1 << 0,
Alt = 1 << 1, Alt = 1 << 1,
Ctrl = 1 << 2, Ctrl = 1 << 2,
}; }; }; };
struct GUI_ServerMessage { struct WSAPI_ServerMessage {
enum Type : unsigned { enum Type : unsigned {
Invalid, Invalid,
Error, Error,
@ -90,14 +90,14 @@ struct GUI_ServerMessage {
union { union {
struct { struct {
GUI_Rect rect; WSAPI_Rect rect;
} window; } window;
struct { struct {
GUI_Rect rect; WSAPI_Rect rect;
} paint; } paint;
struct { struct {
GUI_Point position; WSAPI_Point position;
GUI_MouseButton button; WSAPI_MouseButton button;
unsigned buttons; unsigned buttons;
} mouse; } mouse;
struct { struct {
@ -115,7 +115,7 @@ struct GUI_ServerMessage {
} menu; } menu;
struct { struct {
void* backing_store_id; void* backing_store_id;
GUI_Size size; WSAPI_Size size;
size_t bpp; size_t bpp;
size_t pitch; size_t pitch;
RGBA32* pixels; RGBA32* pixels;
@ -123,7 +123,7 @@ struct GUI_ServerMessage {
}; };
}; };
struct GUI_ClientMessage { struct WSAPI_ClientMessage {
enum Type : unsigned { enum Type : unsigned {
Invalid, Invalid,
CreateMenubar, CreateMenubar,
@ -159,7 +159,7 @@ struct GUI_ClientMessage {
unsigned identifier; unsigned identifier;
} menu; } menu;
struct { struct {
GUI_Rect rect; WSAPI_Rect rect;
} window; } window;
struct { struct {
void* backing_store_id; void* backing_store_id;
@ -167,9 +167,9 @@ struct GUI_ClientMessage {
}; };
}; };
inline Rect::Rect(const GUI_Rect& r) : Rect(r.location, r.size) { } inline Rect::Rect(const WSAPI_Rect& r) : Rect(r.location, r.size) { }
inline Point::Point(const GUI_Point& p) : Point(p.x, p.y) { } inline Point::Point(const WSAPI_Point& p) : Point(p.x, p.y) { }
inline Size::Size(const GUI_Size& s) : Size(s.width, s.height) { } inline Size::Size(const WSAPI_Size& s) : Size(s.width, s.height) { }
inline Rect::operator GUI_Rect() const { return { m_location, m_size }; } inline Rect::operator WSAPI_Rect() const { return { m_location, m_size }; }
inline Point::operator GUI_Point() const { return { m_x, m_y }; } inline Point::operator WSAPI_Point() const { return { m_x, m_y }; }
inline Size::operator GUI_Size() const { return { m_width, m_height }; } 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) void WSClientConnection::post_error(const String& error_message)
{ {
dbgprintf("WSClientConnection::post_error: client_id=%d: %s\n", m_client_id, error_message.characters()); dbgprintf("WSClientConnection::post_error: client_id=%d: %s\n", m_client_id, error_message.characters());
GUI_ServerMessage message; WSAPI_ServerMessage message;
message.type = GUI_ServerMessage::Type::Error; message.type = WSAPI_ServerMessage::Type::Error;
ASSERT(error_message.length() < sizeof(message.text)); ASSERT(error_message.length() < sizeof(message.text));
strcpy(message.text, error_message.characters()); strcpy(message.text, error_message.characters());
message.text_length = error_message.length(); message.text_length = error_message.length();
WSMessageLoop::the().post_message_to_client(m_client_id, message); 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)); int nwritten = WSMessageLoop::the().server_process().sys$write(m_fd, &message, sizeof(message));
ASSERT(nwritten == sizeof(message)); ASSERT(nwritten == sizeof(message));
@ -110,8 +110,8 @@ void WSClientConnection::handle_request(WSAPICreateMenubarRequest& request)
int menubar_id = m_next_menubar_id++; int menubar_id = m_next_menubar_id++;
auto menubar = make<WSMenuBar>(request.client_id(), menubar_id); auto menubar = make<WSMenuBar>(request.client_id(), menubar_id);
m_menubars.set(menubar_id, move(menubar)); m_menubars.set(menubar_id, move(menubar));
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidCreateMenubar; response.type = WSAPI_ServerMessage::Type::DidCreateMenubar;
response.menu.menubar_id = menubar_id; response.menu.menubar_id = menubar_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response); WSMessageLoop::the().post_message_to_client(request.client_id(), response);
} }
@ -127,8 +127,8 @@ void WSClientConnection::handle_request(WSAPIDestroyMenubarRequest& request)
auto& menubar = *(*it).value; auto& menubar = *(*it).value;
WSWindowManager::the().close_menubar(menubar); WSWindowManager::the().close_menubar(menubar);
m_menubars.remove(it); m_menubars.remove(it);
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidDestroyMenubar; response.type = WSAPI_ServerMessage::Type::DidDestroyMenubar;
response.menu.menubar_id = menubar_id; response.menu.menubar_id = menubar_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response); 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++; int menu_id = m_next_menu_id++;
auto menu = make<WSMenu>(request.client_id(), menu_id, request.text()); auto menu = make<WSMenu>(request.client_id(), menu_id, request.text());
m_menus.set(menu_id, move(menu)); m_menus.set(menu_id, move(menu));
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidCreateMenu; response.type = WSAPI_ServerMessage::Type::DidCreateMenu;
response.menu.menu_id = menu_id; response.menu.menu_id = menu_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response); WSMessageLoop::the().post_message_to_client(request.client_id(), response);
} }
@ -155,8 +155,8 @@ void WSClientConnection::handle_request(WSAPIDestroyMenuRequest& request)
auto& menu = *(*it).value; auto& menu = *(*it).value;
WSWindowManager::the().close_menu(menu); WSWindowManager::the().close_menu(menu);
m_menus.remove(it); m_menus.remove(it);
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidDestroyMenu; response.type = WSAPI_ServerMessage::Type::DidDestroyMenu;
response.menu.menu_id = menu_id; response.menu.menu_id = menu_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response); WSMessageLoop::the().post_message_to_client(request.client_id(), response);
} }
@ -172,8 +172,8 @@ void WSClientConnection::handle_request(WSAPISetApplicationMenubarRequest& reque
auto& menubar = *(*it).value; auto& menubar = *(*it).value;
m_app_menubar = menubar.make_weak_ptr(); m_app_menubar = menubar.make_weak_ptr();
WSWindowManager::the().notify_client_changed_app_menubar(*this); WSWindowManager::the().notify_client_changed_app_menubar(*this);
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidSetApplicationMenubar; response.type = WSAPI_ServerMessage::Type::DidSetApplicationMenubar;
response.menu.menubar_id = menubar_id; response.menu.menubar_id = menubar_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response); 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& menubar = *(*it).value;
auto& menu = *(*jt).value; auto& menu = *(*jt).value;
menubar.add_menu(&menu); menubar.add_menu(&menu);
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidAddMenuToMenubar; response.type = WSAPI_ServerMessage::Type::DidAddMenuToMenubar;
response.menu.menubar_id = menubar_id; response.menu.menubar_id = menubar_id;
response.menu.menu_id = menu_id; response.menu.menu_id = menu_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response); WSMessageLoop::the().post_message_to_client(request.client_id(), response);
@ -214,8 +214,8 @@ void WSClientConnection::handle_request(WSAPIAddMenuItemRequest& request)
} }
auto& menu = *(*it).value; auto& menu = *(*it).value;
menu.add_item(make<WSMenuItem>(identifier, move(text))); menu.add_item(make<WSMenuItem>(identifier, move(text)));
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidAddMenuItem; response.type = WSAPI_ServerMessage::Type::DidAddMenuItem;
response.menu.menu_id = menu_id; response.menu.menu_id = menu_id;
response.menu.identifier = identifier; response.menu.identifier = identifier;
WSMessageLoop::the().post_message_to_client(request.client_id(), response); WSMessageLoop::the().post_message_to_client(request.client_id(), response);
@ -231,8 +231,8 @@ void WSClientConnection::handle_request(WSAPIAddMenuSeparatorRequest& request)
} }
auto& menu = *(*it).value; auto& menu = *(*it).value;
menu.add_item(make<WSMenuItem>(WSMenuItem::Separator)); menu.add_item(make<WSMenuItem>(WSMenuItem::Separator));
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidAddMenuSeparator; response.type = WSAPI_ServerMessage::Type::DidAddMenuSeparator;
response.menu.menu_id = menu_id; response.menu.menu_id = menu_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response); WSMessageLoop::the().post_message_to_client(request.client_id(), response);
} }
@ -258,8 +258,8 @@ void WSClientConnection::handle_request(WSAPIGetWindowTitleRequest& request)
return; return;
} }
auto& window = *(*it).value; auto& window = *(*it).value;
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidGetWindowTitle; response.type = WSAPI_ServerMessage::Type::DidGetWindowTitle;
response.window_id = window.window_id(); response.window_id = window.window_id();
ASSERT(window.title().length() < sizeof(response.text)); ASSERT(window.title().length() < sizeof(response.text));
strcpy(response.text, window.title().characters()); strcpy(response.text, window.title().characters());
@ -288,8 +288,8 @@ void WSClientConnection::handle_request(WSAPIGetWindowRectRequest& request)
return; return;
} }
auto& window = *(*it).value; auto& window = *(*it).value;
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidGetWindowRect; response.type = WSAPI_ServerMessage::Type::DidGetWindowRect;
response.window_id = window.window_id(); response.window_id = window.window_id();
response.window.rect = window.rect(); response.window.rect = window.rect();
WSMessageLoop::the().post_message_to_client(request.client_id(), response); 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_title(request.title());
window->set_rect(request.rect()); window->set_rect(request.rect());
m_windows.set(window_id, move(window)); m_windows.set(window_id, move(window));
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidCreateWindow; response.type = WSAPI_ServerMessage::Type::DidCreateWindow;
response.window_id = window_id; response.window_id = window_id;
WSMessageLoop::the().post_message_to_client(request.client_id(), response); 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"); post_error("Bad window ID");
return; return;
} }
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::Paint; response.type = WSAPI_ServerMessage::Type::Paint;
response.window_id = window_id; response.window_id = window_id;
response.paint.rect = request.rect(); response.paint.rect = request.rect();
WSMessageLoop::the().post_message_to_client(request.client_id(), response); 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! // FIXME: It shouldn't work this way!
backing_store->retain(); backing_store->retain();
GUI_ServerMessage response; WSAPI_ServerMessage response;
response.type = GUI_ServerMessage::Type::DidGetWindowBackingStore; response.type = WSAPI_ServerMessage::Type::DidGetWindowBackingStore;
response.window_id = window_id; response.window_id = window_id;
response.backing.backing_store_id = backing_store; response.backing.backing_store_id = backing_store;
response.backing.bpp = sizeof(RGBA32); response.backing.bpp = sizeof(RGBA32);

4
WindowServer/WSClientConnection.h
View file

@ -11,7 +11,7 @@
class WSWindow; class WSWindow;
class WSMenu; class WSMenu;
class WSMenuBar; class WSMenuBar;
struct GUI_ServerMessage; struct WSAPI_ServerMessage;
// FIXME: Remove. // FIXME: Remove.
class Process; class Process;
@ -25,7 +25,7 @@ public:
static WSClientConnection* ensure_for_client_id(int client_id); static WSClientConnection* ensure_for_client_id(int client_id);
static void for_each_client(Function<void(WSClientConnection&)>); 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&); RetainPtr<GraphicsBitmap> create_bitmap(const Size&);
int client_id() const { return m_client_id; } 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(); close();
GUI_ServerMessage message; WSAPI_ServerMessage message;
message.type = GUI_ServerMessage::Type::MenuItemActivated; message.type = WSAPI_ServerMessage::Type::MenuItemActivated;
message.menu.menu_id = m_menu_id; message.menu.menu_id = m_menu_id;
message.menu.identifier = item.identifier(); 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; 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); auto* client = WSClientConnection::from_client_id(client_id);
if (!client) if (!client)
@ -245,7 +245,7 @@ void WSMessageLoop::wait_for_message()
WSClientConnection::for_each_client([&] (WSClientConnection& client) { WSClientConnection::for_each_client([&] (WSClientConnection& client) {
if (bitmap.get(client.fd())) { if (bitmap.get(client.fd())) {
byte buffer[4096]; 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); 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); WSClientConnection* client = WSClientConnection::ensure_for_client_id(client_id);
ASSERT(size == sizeof(GUI_ClientMessage)); ASSERT(size == sizeof(WSAPI_ClientMessage));
auto& message = *reinterpret_cast<const GUI_ClientMessage*>(data); auto& message = *reinterpret_cast<const WSAPI_ClientMessage*>(data);
switch (message.type) { switch (message.type) {
case GUI_ClientMessage::Type::CreateMenubar: case WSAPI_ClientMessage::Type::CreateMenubar:
post_message(client, make<WSAPICreateMenubarRequest>(client_id)); post_message(client, make<WSAPICreateMenubarRequest>(client_id));
break; break;
case GUI_ClientMessage::Type::DestroyMenubar: case WSAPI_ClientMessage::Type::DestroyMenubar:
post_message(client, make<WSAPIDestroyMenubarRequest>(client_id, message.menu.menubar_id)); post_message(client, make<WSAPIDestroyMenubarRequest>(client_id, message.menu.menubar_id));
break; break;
case GUI_ClientMessage::Type::SetApplicationMenubar: case WSAPI_ClientMessage::Type::SetApplicationMenubar:
post_message(client, make<WSAPISetApplicationMenubarRequest>(client_id, message.menu.menubar_id)); post_message(client, make<WSAPISetApplicationMenubarRequest>(client_id, message.menu.menubar_id));
break; 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)); post_message(client, make<WSAPIAddMenuToMenubarRequest>(client_id, message.menu.menubar_id, message.menu.menu_id));
break; break;
case GUI_ClientMessage::Type::CreateMenu: case WSAPI_ClientMessage::Type::CreateMenu:
ASSERT(message.text_length < sizeof(message.text)); ASSERT(message.text_length < sizeof(message.text));
post_message(client, make<WSAPICreateMenuRequest>(client_id, String(message.text, message.text_length))); post_message(client, make<WSAPICreateMenuRequest>(client_id, String(message.text, message.text_length)));
break; break;
case GUI_ClientMessage::Type::DestroyMenu: case WSAPI_ClientMessage::Type::DestroyMenu:
post_message(client, make<WSAPIDestroyMenuRequest>(client_id, message.menu.menu_id)); post_message(client, make<WSAPIDestroyMenuRequest>(client_id, message.menu.menu_id));
break; break;
case GUI_ClientMessage::Type::AddMenuItem: case WSAPI_ClientMessage::Type::AddMenuItem:
ASSERT(message.text_length < sizeof(message.text)); 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))); post_message(client, make<WSAPIAddMenuItemRequest>(client_id, message.menu.menu_id, message.menu.identifier, String(message.text, message.text_length)));
break; break;
case GUI_ClientMessage::Type::CreateWindow: case WSAPI_ClientMessage::Type::CreateWindow:
ASSERT(message.text_length < sizeof(message.text)); ASSERT(message.text_length < sizeof(message.text));
post_message(client, make<WSAPICreateWindowRequest>(client_id, message.window.rect, String(message.text, message.text_length))); post_message(client, make<WSAPICreateWindowRequest>(client_id, message.window.rect, String(message.text, message.text_length)));
break; break;
case GUI_ClientMessage::Type::DestroyWindow: case WSAPI_ClientMessage::Type::DestroyWindow:
post_message(client, make<WSAPIDestroyWindowRequest>(client_id, message.window_id)); post_message(client, make<WSAPIDestroyWindowRequest>(client_id, message.window_id));
break; break;
case GUI_ClientMessage::Type::SetWindowTitle: case WSAPI_ClientMessage::Type::SetWindowTitle:
ASSERT(message.text_length < sizeof(message.text)); ASSERT(message.text_length < sizeof(message.text));
post_message(client, make<WSAPISetWindowTitleRequest>(client_id, message.window_id, String(message.text, message.text_length))); post_message(client, make<WSAPISetWindowTitleRequest>(client_id, message.window_id, String(message.text, message.text_length)));
break; break;
case GUI_ClientMessage::Type::GetWindowTitle: case WSAPI_ClientMessage::Type::GetWindowTitle:
ASSERT(message.text_length < sizeof(message.text)); ASSERT(message.text_length < sizeof(message.text));
post_message(client, make<WSAPIGetWindowTitleRequest>(client_id, message.window_id)); post_message(client, make<WSAPIGetWindowTitleRequest>(client_id, message.window_id));
break; break;
case GUI_ClientMessage::Type::SetWindowRect: case WSAPI_ClientMessage::Type::SetWindowRect:
post_message(client, make<WSAPISetWindowRectRequest>(client_id, message.window_id, message.window.rect)); post_message(client, make<WSAPISetWindowRectRequest>(client_id, message.window_id, message.window.rect));
break; break;
case GUI_ClientMessage::Type::GetWindowRect: case WSAPI_ClientMessage::Type::GetWindowRect:
post_message(client, make<WSAPIGetWindowRectRequest>(client_id, message.window_id)); post_message(client, make<WSAPIGetWindowRectRequest>(client_id, message.window_id));
break; break;
case GUI_ClientMessage::Type::InvalidateRect: case WSAPI_ClientMessage::Type::InvalidateRect:
post_message(client, make<WSAPIInvalidateRectRequest>(client_id, message.window_id, message.window.rect)); post_message(client, make<WSAPIInvalidateRectRequest>(client_id, message.window_id, message.window.rect));
break; break;
case GUI_ClientMessage::Type::DidFinishPainting: case WSAPI_ClientMessage::Type::DidFinishPainting:
post_message(client, make<WSAPIDidFinishPaintingNotification>(client_id, message.window_id, message.window.rect)); post_message(client, make<WSAPIDidFinishPaintingNotification>(client_id, message.window_id, message.window.rect));
break; break;
case GUI_ClientMessage::Type::GetWindowBackingStore: case WSAPI_ClientMessage::Type::GetWindowBackingStore:
post_message(client, make<WSAPIGetWindowBackingStoreRequest>(client_id, message.window_id)); post_message(client, make<WSAPIGetWindowBackingStoreRequest>(client_id, message.window_id));
break; break;
case GUI_ClientMessage::Type::ReleaseWindowBackingStore: case WSAPI_ClientMessage::Type::ReleaseWindowBackingStore:
post_message(client, make<WSAPIReleaseWindowBackingStoreRequest>(client_id, (int)message.backing.backing_store_id)); post_message(client, make<WSAPIReleaseWindowBackingStoreRequest>(client_id, (int)message.backing.backing_store_id));
break; break;
case GUI_ClientMessage::Type::SetGlobalCursorTracking: case WSAPI_ClientMessage::Type::SetGlobalCursorTracking:
post_message(client, make<WSAPISetGlobalCursorTrackingRequest>(client_id, message.window_id, message.value)); post_message(client, make<WSAPISetGlobalCursorTrackingRequest>(client_id, message.window_id, message.value));
break; break;
} }

4
WindowServer/WSMessageLoop.h
View file

@ -9,7 +9,7 @@
class WSMessageReceiver; class WSMessageReceiver;
class Process; class Process;
struct GUI_ServerMessage; struct WSAPI_ServerMessage;
class WSMessageLoop { class WSMessageLoop {
public: public:
@ -30,7 +30,7 @@ public:
int start_timer(int ms, Function<void()>&&); int start_timer(int ms, Function<void()>&&);
int stop_timer(int timer_id); 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); ssize_t on_receive_from_client(int client_id, const byte*, size_t);
static Process* process_from_client_id(int client_id); 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. // FIXME: Just use the same types.
static GUI_MouseButton to_api(MouseButton button) static WSAPI_MouseButton to_api(MouseButton button)
{ {
switch (button) { switch (button) {
case MouseButton::None: return GUI_MouseButton::NoButton; case MouseButton::None: return WSAPI_MouseButton::NoButton;
case MouseButton::Left: return GUI_MouseButton::Left; case MouseButton::Left: return WSAPI_MouseButton::Left;
case MouseButton::Right: return GUI_MouseButton::Right; case MouseButton::Right: return WSAPI_MouseButton::Right;
case MouseButton::Middle: return GUI_MouseButton::Middle; case MouseButton::Middle: return WSAPI_MouseButton::Middle;
} }
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }
@ -72,30 +72,30 @@ void WSWindow::on_message(WSMessage& message)
return; return;
} }
GUI_ServerMessage server_message; WSAPI_ServerMessage server_message;
server_message.window_id = window_id(); server_message.window_id = window_id();
switch (message.type()) { switch (message.type()) {
case WSMessage::MouseMove: 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.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(); server_message.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break; break;
case WSMessage::MouseDown: 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.position = static_cast<WSMouseEvent&>(message).position();
server_message.mouse.button = to_api(static_cast<WSMouseEvent&>(message).button()); server_message.mouse.button = to_api(static_cast<WSMouseEvent&>(message).button());
server_message.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons(); server_message.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break; break;
case WSMessage::MouseUp: 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.position = static_cast<WSMouseEvent&>(message).position();
server_message.mouse.button = to_api(static_cast<WSMouseEvent&>(message).button()); server_message.mouse.button = to_api(static_cast<WSMouseEvent&>(message).button());
server_message.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons(); server_message.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break; break;
case WSMessage::KeyDown: 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.character = static_cast<WSKeyEvent&>(message).character();
server_message.key.key = static_cast<WSKeyEvent&>(message).key(); server_message.key.key = static_cast<WSKeyEvent&>(message).key();
server_message.key.alt = static_cast<WSKeyEvent&>(message).alt(); 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(); server_message.key.shift = static_cast<WSKeyEvent&>(message).shift();
break; break;
case WSMessage::KeyUp: 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.character = static_cast<WSKeyEvent&>(message).character();
server_message.key.key = static_cast<WSKeyEvent&>(message).key(); server_message.key.key = static_cast<WSKeyEvent&>(message).key();
server_message.key.alt = static_cast<WSKeyEvent&>(message).alt(); 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(); server_message.key.shift = static_cast<WSKeyEvent&>(message).shift();
break; break;
case WSMessage::WindowActivated: case WSMessage::WindowActivated:
server_message.type = GUI_ServerMessage::Type::WindowActivated; server_message.type = WSAPI_ServerMessage::Type::WindowActivated;
break; break;
case WSMessage::WindowDeactivated: case WSMessage::WindowDeactivated:
server_message.type = GUI_ServerMessage::Type::WindowDeactivated; server_message.type = WSAPI_ServerMessage::Type::WindowDeactivated;
break; break;
case WSMessage::WindowCloseRequest: case WSMessage::WindowCloseRequest:
server_message.type = GUI_ServerMessage::Type::WindowCloseRequest; server_message.type = WSAPI_ServerMessage::Type::WindowCloseRequest;
break; break;
default: default:
break; break;
} }
if (server_message.type == GUI_ServerMessage::Type::Invalid) if (server_message.type == WSAPI_ServerMessage::Type::Invalid)
return; return;
if (auto* client = WSClientConnection::from_client_id(m_client_id)) if (auto* client = WSClientConnection::from_client_id(m_client_id))