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

WindowServer: More event -> message renaming.

Browse source
This commit is contained in:
Andreas Kling 2019-01-26 05:35:45 +01:00
parent bba21adae3
commit 244d5bcce1
9 changed files with 78 additions and 78 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Kernel/ProcessGUI.cpp
View file

@ -145,7 +145,7 @@ int Process::gui$invalidate_window(int window_id, const GUI_Rect* a_rect)
Rect rect; Rect rect;
if (a_rect) if (a_rect)
rect = *a_rect; rect = *a_rect;
WSMessageLoop::the().post_event(&window, make<WSPaintEvent>(rect)); WSMessageLoop::the().post_message(&window, make<WSPaintEvent>(rect));
WSMessageLoop::the().server_process().request_wakeup(); WSMessageLoop::the().server_process().request_wakeup();
return 0; return 0;
} }
@ -169,7 +169,7 @@ int Process::gui$notify_paint_finished(int window_id, const GUI_Rect* a_rect)
Rect rect; Rect rect;
if (a_rect) if (a_rect)
rect = *a_rect; rect = *a_rect;
WSMessageLoop::the().post_event(&window, make<WSWindowInvalidationEvent>(rect)); WSMessageLoop::the().post_message(&window, make<WSWindowInvalidationEvent>(rect));
WSMessageLoop::the().server_process().request_wakeup(); WSMessageLoop::the().server_process().request_wakeup();
return 0; return 0;
} }
@ -207,7 +207,7 @@ int Process::gui$set_window_title(int window_id, const char* title, size_t size)
return -EBADWINDOW; return -EBADWINDOW;
auto& window = *(*it).value; auto& window = *(*it).value;
String new_title(title, size); String new_title(title, size);
WSMessageLoop::the().post_event(&window, make<WSSetWindowTitle>(move(new_title))); WSMessageLoop::the().post_message(&window, make<WSSetWindowTitle>(move(new_title)));
WSMessageLoop::the().server_process().request_wakeup(); WSMessageLoop::the().server_process().request_wakeup();
return 0; return 0;
} }
@ -240,7 +240,7 @@ int Process::gui$set_window_rect(int window_id, const GUI_Rect* rect)
return -EBADWINDOW; return -EBADWINDOW;
auto& window = *(*it).value; auto& window = *(*it).value;
Rect new_rect = *rect; Rect new_rect = *rect;
WSMessageLoop::the().post_event(&window, make<WSSetWindowRect>(new_rect)); WSMessageLoop::the().post_message(&window, make<WSSetWindowRect>(new_rect));
WSMessageLoop::the().server_process().request_wakeup(); WSMessageLoop::the().server_process().request_wakeup();
return 0; return 0;
} }

52
WindowServer/WSMessageLoop.cpp
View file

@ -45,46 +45,46 @@ int WSMessageLoop::exec()
m_running = true; m_running = true;
for (;;) { for (;;) {
wait_for_event(); wait_for_message();
Vector<QueuedEvent> events; Vector<QueuedMessage> messages;
{ {
ASSERT_INTERRUPTS_ENABLED(); ASSERT_INTERRUPTS_ENABLED();
LOCKER(m_lock); LOCKER(m_lock);
events = move(m_queued_events); messages = move(m_queued_messages);
} }
for (auto& queued_event : events) { for (auto& queued_message : messages) {
auto* receiver = queued_event.receiver; auto* receiver = queued_message.receiver;
auto& event = *queued_event.event; auto& message = *queued_message.message;
#ifdef WSEVENTLOOP_DEBUG #ifdef WSEVENTLOOP_DEBUG
dbgprintf("WSMessageLoop: receiver{%p} event %u (%s)\n", receiver, (unsigned)event.type(), event.name()); dbgprintf("WSMessageLoop: receiver{%p} message %u (%s)\n", receiver, (unsigned)event.type(), event.name());
#endif #endif
if (!receiver) { if (!receiver) {
dbgprintf("WSMessage type %u with no receiver :(\n", event.type()); dbgprintf("WSMessage type %u with no receiver :(\n", message.type());
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
return 1; return 1;
} else { } else {
receiver->event(event); receiver->on_message(message);
} }
} }
} }
} }
void WSMessageLoop::post_event(WSMessageReceiver* receiver, OwnPtr<WSMessage>&& event) void WSMessageLoop::post_message(WSMessageReceiver* receiver, OwnPtr<WSMessage>&& message)
{ {
ASSERT_INTERRUPTS_ENABLED(); ASSERT_INTERRUPTS_ENABLED();
LOCKER(m_lock); LOCKER(m_lock);
#ifdef WSEVENTLOOP_DEBUG #ifdef WSEVENTLOOP_DEBUG
dbgprintf("WSMessageLoop::post_event: {%u} << receiver=%p, event=%p\n", m_queued_events.size(), receiver, event.ptr()); dbgprintf("WSMessageLoop::post_message: {%u} << receiver=%p, message=%p\n", m_queued_messages.size(), receiver, message.ptr());
#endif #endif
if (event->type() == WSMessage::WM_Invalidate) { if (message->type() == WSMessage::WM_Invalidate) {
auto& invalidation_event = static_cast<WSWindowInvalidationEvent&>(*event); auto& invalidation_message = static_cast<WSWindowInvalidationEvent&>(*message);
for (auto& queued_event : m_queued_events) { for (auto& queued_message : m_queued_messages) {
if (receiver == queued_event.receiver && queued_event.event->type() == WSMessage::WM_Invalidate) { if (receiver == queued_message.receiver && queued_message.message->type() == WSMessage::WM_Invalidate) {
auto& queued_invalidation_event = static_cast<WSWindowInvalidationEvent&>(*queued_event.event); auto& queued_invalidation_message = static_cast<WSWindowInvalidationEvent&>(*queued_message.message);
if (queued_invalidation_event.rect().is_empty() || queued_invalidation_event.rect().contains(invalidation_event.rect())) { if (queued_invalidation_message.rect().is_empty() || queued_invalidation_message.rect().contains(invalidation_message.rect())) {
#ifdef WSEVENTLOOP_DEBUG #ifdef WSEVENTLOOP_DEBUG
dbgprintf("Swallow WM_Invalidate\n"); dbgprintf("Swallow WM_Invalidate\n");
#endif #endif
@ -94,12 +94,12 @@ void WSMessageLoop::post_event(WSMessageReceiver* receiver, OwnPtr<WSMessage>&&
} }
} }
if (event->type() == WSMessage::Paint) { if (message->type() == WSMessage::Paint) {
auto& invalidation_event = static_cast<WSPaintEvent&>(*event); auto& invalidation_message = static_cast<WSPaintEvent&>(*message);
for (auto& queued_event : m_queued_events) { for (auto& queued_message : m_queued_messages) {
if (receiver == queued_event.receiver && queued_event.event->type() == WSMessage::Paint) { if (receiver == queued_message.receiver && queued_message.message->type() == WSMessage::Paint) {
auto& queued_invalidation_event = static_cast<WSPaintEvent&>(*queued_event.event); auto& queued_invalidation_message = static_cast<WSPaintEvent&>(*queued_message.message);
if (queued_invalidation_event.rect().is_empty() || queued_invalidation_event.rect().contains(invalidation_event.rect())) { if (queued_invalidation_message.rect().is_empty() || queued_invalidation_message.rect().contains(invalidation_message.rect())) {
#ifdef WSEVENTLOOP_DEBUG #ifdef WSEVENTLOOP_DEBUG
dbgprintf("Swallow WM_Paint\n"); dbgprintf("Swallow WM_Paint\n");
#endif #endif
@ -109,13 +109,13 @@ void WSMessageLoop::post_event(WSMessageReceiver* receiver, OwnPtr<WSMessage>&&
} }
} }
m_queued_events.append({ receiver, move(event) }); m_queued_messages.append({ receiver, move(message) });
if (current != m_server_process) if (current != m_server_process)
m_server_process->request_wakeup(); m_server_process->request_wakeup();
} }
void WSMessageLoop::wait_for_event() void WSMessageLoop::wait_for_message()
{ {
fd_set rfds; fd_set rfds;
memset(&rfds, 0, sizeof(rfds)); memset(&rfds, 0, sizeof(rfds));
@ -128,7 +128,7 @@ void WSMessageLoop::wait_for_event()
params.writefds = nullptr; params.writefds = nullptr;
params.exceptfds = nullptr; params.exceptfds = nullptr;
struct timeval timeout = { 0, 0 }; struct timeval timeout = { 0, 0 };
if (m_queued_events.is_empty()) if (m_queued_messages.is_empty())
params.timeout = nullptr; params.timeout = nullptr;
else else
params.timeout = &timeout; params.timeout = &timeout;

10
WindowServer/WSMessageLoop.h
View file

@ -15,7 +15,7 @@ public:
int exec(); int exec();
void post_event(WSMessageReceiver* receiver, OwnPtr<WSMessage>&&); void post_message(WSMessageReceiver* receiver, OwnPtr<WSMessage>&&);
static WSMessageLoop& the(); static WSMessageLoop& the();
@ -25,17 +25,17 @@ public:
Process& server_process() { return *m_server_process; } Process& server_process() { return *m_server_process; }
private: private:
void wait_for_event(); void wait_for_message();
void drain_mouse(); void drain_mouse();
void drain_keyboard(); void drain_keyboard();
Lock m_lock; Lock m_lock;
struct QueuedEvent { struct QueuedMessage {
WSMessageReceiver* receiver { nullptr }; WSMessageReceiver* receiver { nullptr };
OwnPtr<WSMessage> event; OwnPtr<WSMessage> message;
}; };
Vector<QueuedEvent> m_queued_events; Vector<QueuedMessage> m_queued_messages;
Process* m_server_process { nullptr }; Process* m_server_process { nullptr };
bool m_running { false }; bool m_running { false };

2
WindowServer/WSMessageReceiver.h
View file

@ -9,5 +9,5 @@ public:
WSMessageReceiver(); WSMessageReceiver();
virtual ~WSMessageReceiver(); virtual ~WSMessageReceiver();
virtual void event(WSMessage&) = 0; virtual void on_message(WSMessage&) = 0;
}; };

22
WindowServer/WSScreen.cpp
View file

@ -47,20 +47,20 @@ void WSScreen::on_receive_mouse_data(int dx, int dy, bool left_button, bool righ
if (right_button) if (right_button)
buttons |= (unsigned)MouseButton::Right; buttons |= (unsigned)MouseButton::Right;
if (m_cursor_location != prev_location) { if (m_cursor_location != prev_location) {
auto event = make<WSMouseEvent>(WSMessage::MouseMove, m_cursor_location, buttons); auto message = make<WSMouseEvent>(WSMessage::MouseMove, m_cursor_location, buttons);
WSMessageLoop::the().post_event(&WSWindowManager::the(), move(event)); WSMessageLoop::the().post_message(&WSWindowManager::the(), move(message));
} }
bool prev_left_button = m_left_mouse_button_pressed; bool prev_left_button = m_left_mouse_button_pressed;
bool prev_right_button = m_right_mouse_button_pressed; bool prev_right_button = m_right_mouse_button_pressed;
m_left_mouse_button_pressed = left_button; m_left_mouse_button_pressed = left_button;
m_right_mouse_button_pressed = right_button; m_right_mouse_button_pressed = right_button;
if (prev_left_button != left_button) { if (prev_left_button != left_button) {
auto event = make<WSMouseEvent>(left_button ? WSMessage::MouseDown : WSMessage::MouseUp, m_cursor_location, buttons, MouseButton::Left); auto message = make<WSMouseEvent>(left_button ? WSMessage::MouseDown : WSMessage::MouseUp, m_cursor_location, buttons, MouseButton::Left);
WSMessageLoop::the().post_event(&WSWindowManager::the(), move(event)); WSMessageLoop::the().post_message(&WSWindowManager::the(), move(message));
} }
if (prev_right_button != right_button) { if (prev_right_button != right_button) {
auto event = make<WSMouseEvent>(right_button ? WSMessage::MouseDown : WSMessage::MouseUp, m_cursor_location, buttons, MouseButton::Right); auto message = make<WSMouseEvent>(right_button ? WSMessage::MouseDown : WSMessage::MouseUp, m_cursor_location, buttons, MouseButton::Right);
WSMessageLoop::the().post_event(&WSWindowManager::the(), move(event)); WSMessageLoop::the().post_message(&WSWindowManager::the(), move(message));
} }
if (m_cursor_location != prev_location || prev_left_button != left_button) if (m_cursor_location != prev_location || prev_left_button != left_button)
WSWindowManager::the().draw_cursor(); WSWindowManager::the().draw_cursor();
@ -68,9 +68,9 @@ void WSScreen::on_receive_mouse_data(int dx, int dy, bool left_button, bool righ
void WSScreen::on_receive_keyboard_data(Keyboard::Event kernel_event) void WSScreen::on_receive_keyboard_data(Keyboard::Event kernel_event)
{ {
auto event = make<WSKeyEvent>(kernel_event.is_press() ? WSMessage::KeyDown : WSMessage::KeyUp, kernel_event.key, kernel_event.character); auto message = make<WSKeyEvent>(kernel_event.is_press() ? WSMessage::KeyDown : WSMessage::KeyUp, kernel_event.key, kernel_event.character);
event->m_shift = kernel_event.shift(); message->m_shift = kernel_event.shift();
event->m_ctrl = kernel_event.ctrl(); message->m_ctrl = kernel_event.ctrl();
event->m_alt = kernel_event.alt(); message->m_alt = kernel_event.alt();
WSMessageLoop::the().post_event(&WSWindowManager::the(), move(event)); WSMessageLoop::the().post_message(&WSWindowManager::the(), move(message));
} }

38
WindowServer/WSWindow.cpp
View file

@ -54,50 +54,50 @@ static GUI_MouseButton to_api(MouseButton button)
} }
} }
void WSWindow::event(WSMessage& event) void WSWindow::on_message(WSMessage& message)
{ {
GUI_Event gui_event; GUI_Event gui_event;
gui_event.window_id = window_id(); gui_event.window_id = window_id();
switch (event.type()) { switch (message.type()) {
case WSMessage::Paint: case WSMessage::Paint:
gui_event.type = GUI_Event::Type::Paint; gui_event.type = GUI_Event::Type::Paint;
gui_event.paint.rect = static_cast<WSPaintEvent&>(event).rect(); gui_event.paint.rect = static_cast<WSPaintEvent&>(message).rect();
break; break;
case WSMessage::MouseMove: case WSMessage::MouseMove:
gui_event.type = GUI_Event::Type::MouseMove; gui_event.type = GUI_Event::Type::MouseMove;
gui_event.mouse.position = static_cast<WSMouseEvent&>(event).position(); gui_event.mouse.position = static_cast<WSMouseEvent&>(message).position();
gui_event.mouse.button = GUI_MouseButton::NoButton; gui_event.mouse.button = GUI_MouseButton::NoButton;
gui_event.mouse.buttons = static_cast<WSMouseEvent&>(event).buttons(); gui_event.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break; break;
case WSMessage::MouseDown: case WSMessage::MouseDown:
gui_event.type = GUI_Event::Type::MouseDown; gui_event.type = GUI_Event::Type::MouseDown;
gui_event.mouse.position = static_cast<WSMouseEvent&>(event).position(); gui_event.mouse.position = static_cast<WSMouseEvent&>(message).position();
gui_event.mouse.button = to_api(static_cast<WSMouseEvent&>(event).button()); gui_event.mouse.button = to_api(static_cast<WSMouseEvent&>(message).button());
gui_event.mouse.buttons = static_cast<WSMouseEvent&>(event).buttons(); gui_event.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break; break;
case WSMessage::MouseUp: case WSMessage::MouseUp:
gui_event.type = GUI_Event::Type::MouseUp; gui_event.type = GUI_Event::Type::MouseUp;
gui_event.mouse.position = static_cast<WSMouseEvent&>(event).position(); gui_event.mouse.position = static_cast<WSMouseEvent&>(message).position();
gui_event.mouse.button = to_api(static_cast<WSMouseEvent&>(event).button()); gui_event.mouse.button = to_api(static_cast<WSMouseEvent&>(message).button());
gui_event.mouse.buttons = static_cast<WSMouseEvent&>(event).buttons(); gui_event.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break; break;
case WSMessage::KeyDown: case WSMessage::KeyDown:
gui_event.type = GUI_Event::Type::KeyDown; gui_event.type = GUI_Event::Type::KeyDown;
gui_event.key.character = static_cast<WSKeyEvent&>(event).character(); gui_event.key.character = static_cast<WSKeyEvent&>(message).character();
gui_event.key.key = static_cast<WSKeyEvent&>(event).key(); gui_event.key.key = static_cast<WSKeyEvent&>(message).key();
gui_event.key.alt = static_cast<WSKeyEvent&>(event).alt(); gui_event.key.alt = static_cast<WSKeyEvent&>(message).alt();
gui_event.key.ctrl = static_cast<WSKeyEvent&>(event).ctrl(); gui_event.key.ctrl = static_cast<WSKeyEvent&>(message).ctrl();
gui_event.key.shift = static_cast<WSKeyEvent&>(event).shift(); gui_event.key.shift = static_cast<WSKeyEvent&>(message).shift();
break; break;
case WSMessage::WM_Invalidate: case WSMessage::WM_Invalidate:
WSWindowManager::the().invalidate(*this, static_cast<WSWindowInvalidationEvent&>(event).rect()); WSWindowManager::the().invalidate(*this, static_cast<WSWindowInvalidationEvent&>(message).rect());
return; return;
case WSMessage::WM_SetWindowRect: case WSMessage::WM_SetWindowRect:
set_rect(static_cast<WSSetWindowRect&>(event).rect()); set_rect(static_cast<WSSetWindowRect&>(message).rect());
return; return;
case WSMessage::WM_SetWindowTitle: case WSMessage::WM_SetWindowTitle:
set_title(static_cast<WSSetWindowTitle&>(event).title()); set_title(static_cast<WSSetWindowTitle&>(message).title());
return; return;
case WSMessage::WindowActivated: case WSMessage::WindowActivated:
gui_event.type = GUI_Event::Type::WindowActivated; gui_event.type = GUI_Event::Type::WindowActivated;

2
WindowServer/WSWindow.h
View file

@ -33,7 +33,7 @@ public:
void set_position(const Point& position) { set_rect({ position.x(), position.y(), width(), height() }); } void set_position(const Point& position) { set_rect({ position.x(), position.y(), width(), height() }); }
void set_position_without_repaint(const Point& position) { set_rect_without_repaint({ position.x(), position.y(), width(), height() }); } void set_position_without_repaint(const Point& position) { set_rect_without_repaint({ position.x(), position.y(), width(), height() }); }
virtual void event(WSMessage&) override; virtual void on_message(WSMessage&) override;
bool is_being_dragged() const { return m_is_being_dragged; } bool is_being_dragged() const { return m_is_being_dragged; }
void set_is_being_dragged(bool b) { m_is_being_dragged = b; } void set_is_being_dragged(bool b) { m_is_being_dragged = b; }

20
WindowServer/WSWindowManager.cpp
View file

@ -305,7 +305,7 @@ void WSWindowManager::process_mouse_event(WSMouseEvent& event)
// FIXME: Should we just alter the coordinates of the existing MouseEvent and pass it through? // FIXME: Should we just alter the coordinates of the existing MouseEvent and pass it through?
Point position { event.x() - window->rect().x(), event.y() - window->rect().y() }; Point position { event.x() - window->rect().x(), event.y() - window->rect().y() };
auto local_event = make<WSMouseEvent>(event.type(), position, event.buttons(), event.button()); auto local_event = make<WSMouseEvent>(event.type(), position, event.buttons(), event.button());
window->event(*local_event); window->on_message(*local_event);
return; return;
} }
} }
@ -387,21 +387,21 @@ void WSWindowManager::draw_cursor()
m_last_cursor_rect = cursor_rect; m_last_cursor_rect = cursor_rect;
} }
void WSWindowManager::event(WSMessage& event) void WSWindowManager::on_message(WSMessage& message)
{ {
ASSERT_INTERRUPTS_ENABLED(); ASSERT_INTERRUPTS_ENABLED();
LOCKER(m_lock); LOCKER(m_lock);
if (event.is_mouse_event()) if (message.is_mouse_event())
return process_mouse_event(static_cast<WSMouseEvent&>(event)); return process_mouse_event(static_cast<WSMouseEvent&>(message));
if (event.is_key_event()) { if (message.is_key_event()) {
// FIXME: This is a good place to hook key events globally. :) // FIXME: This is a good place to hook key events globally. :)
if (m_active_window) if (m_active_window)
return m_active_window->event(event); return m_active_window->on_message(message);
return; return;
} }
if (event.type() == WSMessage::WM_Compose) { if (message.type() == WSMessage::WM_Compose) {
m_pending_compose_event = false; m_pending_compose_event = false;
compose(); compose();
return; return;
@ -415,12 +415,12 @@ void WSWindowManager::set_active_window(WSWindow* window)
return; return;
if (auto* previously_active_window = m_active_window.ptr()) { if (auto* previously_active_window = m_active_window.ptr()) {
WSMessageLoop::the().post_event(previously_active_window, make<WSMessage>(WSMessage::WindowDeactivated)); WSMessageLoop::the().post_message(previously_active_window, make<WSMessage>(WSMessage::WindowDeactivated));
invalidate(*previously_active_window); invalidate(*previously_active_window);
} }
m_active_window = window->makeWeakPtr(); m_active_window = window->makeWeakPtr();
if (m_active_window) { if (m_active_window) {
WSMessageLoop::the().post_event(m_active_window.ptr(), make<WSMessage>(WSMessage::WindowActivated)); WSMessageLoop::the().post_message(m_active_window.ptr(), make<WSMessage>(WSMessage::WindowActivated));
invalidate(*m_active_window); invalidate(*m_active_window);
} }
} }
@ -454,7 +454,7 @@ void WSWindowManager::invalidate(const Rect& a_rect)
if (!m_pending_compose_event) { if (!m_pending_compose_event) {
ASSERT_INTERRUPTS_ENABLED(); ASSERT_INTERRUPTS_ENABLED();
WSMessageLoop::the().post_event(this, make<WSMessage>(WSMessage::WM_Compose)); WSMessageLoop::the().post_message(this, make<WSMessage>(WSMessage::WM_Compose));
m_pending_compose_event = true; m_pending_compose_event = true;
} }
} }

2
WindowServer/WSWindowManager.h
View file

@ -48,7 +48,7 @@ private:
void set_active_window(WSWindow*); void set_active_window(WSWindow*);
virtual void event(WSMessage&) override; virtual void on_message(WSMessage&) override;
void compose(); void compose();
void paint_window_frame(WSWindow&); void paint_window_frame(WSWindow&);