mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-04-22 12:35:14 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

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
Notes: sideshowbarker 2024-07-19 15:56:33 +09:00
9 changed files with 78 additions and 78 deletions
Show stats 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;
if (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();
return 0;
}
@ -169,7 +169,7 @@ int Process::gui$notify_paint_finished(int window_id, const GUI_Rect* a_rect)
Rect rect;
if (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();
return 0;
}
@ -207,7 +207,7 @@ int Process::gui$set_window_title(int window_id, const char* title, size_t size)
return -EBADWINDOW;
auto& window = *(*it).value;
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();
return 0;
}
@ -240,7 +240,7 @@ int Process::gui$set_window_rect(int window_id, const GUI_Rect* rect)
return -EBADWINDOW;
auto& window = *(*it).value;
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();
return 0;
}

52
WindowServer/WSMessageLoop.cpp
View file

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

10
WindowServer/WSMessageLoop.h
View file

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

2
WindowServer/WSMessageReceiver.h
View file

@ -9,5 +9,5 @@ public:
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)
buttons |= (unsigned)MouseButton::Right;
if (m_cursor_location != prev_location) {
auto event = make<WSMouseEvent>(WSMessage::MouseMove, m_cursor_location, buttons);
WSMessageLoop::the().post_event(&WSWindowManager::the(), move(event));
auto message = make<WSMouseEvent>(WSMessage::MouseMove, m_cursor_location, buttons);
WSMessageLoop::the().post_message(&WSWindowManager::the(), move(message));
}
bool prev_left_button = m_left_mouse_button_pressed;
bool prev_right_button = m_right_mouse_button_pressed;
m_left_mouse_button_pressed = left_button;
m_right_mouse_button_pressed = right_button;
if (prev_left_button != left_button) {
auto event = make<WSMouseEvent>(left_button ? WSMessage::MouseDown : WSMessage::MouseUp, m_cursor_location, buttons, MouseButton::Left);
WSMessageLoop::the().post_event(&WSWindowManager::the(), move(event));
auto message = make<WSMouseEvent>(left_button ? WSMessage::MouseDown : WSMessage::MouseUp, m_cursor_location, buttons, MouseButton::Left);
WSMessageLoop::the().post_message(&WSWindowManager::the(), move(message));
}
if (prev_right_button != right_button) {
auto event = make<WSMouseEvent>(right_button ? WSMessage::MouseDown : WSMessage::MouseUp, m_cursor_location, buttons, MouseButton::Right);
WSMessageLoop::the().post_event(&WSWindowManager::the(), move(event));
auto message = make<WSMouseEvent>(right_button ? WSMessage::MouseDown : WSMessage::MouseUp, m_cursor_location, buttons, MouseButton::Right);
WSMessageLoop::the().post_message(&WSWindowManager::the(), move(message));
}
if (m_cursor_location != prev_location || prev_left_button != left_button)
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)
{
auto event = make<WSKeyEvent>(kernel_event.is_press() ? WSMessage::KeyDown : WSMessage::KeyUp, kernel_event.key, kernel_event.character);
event->m_shift = kernel_event.shift();
event->m_ctrl = kernel_event.ctrl();
event->m_alt = kernel_event.alt();
WSMessageLoop::the().post_event(&WSWindowManager::the(), move(event));
auto message = make<WSKeyEvent>(kernel_event.is_press() ? WSMessage::KeyDown : WSMessage::KeyUp, kernel_event.key, kernel_event.character);
message->m_shift = kernel_event.shift();
message->m_ctrl = kernel_event.ctrl();
message->m_alt = kernel_event.alt();
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.window_id = window_id();
switch (event.type()) {
switch (message.type()) {
case WSMessage::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;
case WSMessage::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.buttons = static_cast<WSMouseEvent&>(event).buttons();
gui_event.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break;
case WSMessage::MouseDown:
gui_event.type = GUI_Event::Type::MouseDown;
gui_event.mouse.position = static_cast<WSMouseEvent&>(event).position();
gui_event.mouse.button = to_api(static_cast<WSMouseEvent&>(event).button());
gui_event.mouse.buttons = static_cast<WSMouseEvent&>(event).buttons();
gui_event.mouse.position = static_cast<WSMouseEvent&>(message).position();
gui_event.mouse.button = to_api(static_cast<WSMouseEvent&>(message).button());
gui_event.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break;
case WSMessage::MouseUp:
gui_event.type = GUI_Event::Type::MouseUp;
gui_event.mouse.position = static_cast<WSMouseEvent&>(event).position();
gui_event.mouse.button = to_api(static_cast<WSMouseEvent&>(event).button());
gui_event.mouse.buttons = static_cast<WSMouseEvent&>(event).buttons();
gui_event.mouse.position = static_cast<WSMouseEvent&>(message).position();
gui_event.mouse.button = to_api(static_cast<WSMouseEvent&>(message).button());
gui_event.mouse.buttons = static_cast<WSMouseEvent&>(message).buttons();
break;
case WSMessage::KeyDown:
gui_event.type = GUI_Event::Type::KeyDown;
gui_event.key.character = static_cast<WSKeyEvent&>(event).character();
gui_event.key.key = static_cast<WSKeyEvent&>(event).key();
gui_event.key.alt = static_cast<WSKeyEvent&>(event).alt();
gui_event.key.ctrl = static_cast<WSKeyEvent&>(event).ctrl();
gui_event.key.shift = static_cast<WSKeyEvent&>(event).shift();
gui_event.key.character = static_cast<WSKeyEvent&>(message).character();
gui_event.key.key = static_cast<WSKeyEvent&>(message).key();
gui_event.key.alt = static_cast<WSKeyEvent&>(message).alt();
gui_event.key.ctrl = static_cast<WSKeyEvent&>(message).ctrl();
gui_event.key.shift = static_cast<WSKeyEvent&>(message).shift();
break;
case WSMessage::WM_Invalidate:
WSWindowManager::the().invalidate(*this, static_cast<WSWindowInvalidationEvent&>(event).rect());
WSWindowManager::the().invalidate(*this, static_cast<WSWindowInvalidationEvent&>(message).rect());
return;
case WSMessage::WM_SetWindowRect:
set_rect(static_cast<WSSetWindowRect&>(event).rect());
set_rect(static_cast<WSSetWindowRect&>(message).rect());
return;
case WSMessage::WM_SetWindowTitle:
set_title(static_cast<WSSetWindowTitle&>(event).title());
set_title(static_cast<WSSetWindowTitle&>(message).title());
return;
case WSMessage::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_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; }
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?
Point position { event.x() - window->rect().x(), event.y() - window->rect().y() };
auto local_event = make<WSMouseEvent>(event.type(), position, event.buttons(), event.button());
window->event(*local_event);
window->on_message(*local_event);
return;
}
}
@ -387,21 +387,21 @@ void WSWindowManager::draw_cursor()
m_last_cursor_rect = cursor_rect;
}
void WSWindowManager::event(WSMessage& event)
void WSWindowManager::on_message(WSMessage& message)
{
ASSERT_INTERRUPTS_ENABLED();
LOCKER(m_lock);
if (event.is_mouse_event())
return process_mouse_event(static_cast<WSMouseEvent&>(event));
if (message.is_mouse_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. :)
if (m_active_window)
return m_active_window->event(event);
return m_active_window->on_message(message);
return;
}
if (event.type() == WSMessage::WM_Compose) {
if (message.type() == WSMessage::WM_Compose) {
m_pending_compose_event = false;
compose();
return;
@ -415,12 +415,12 @@ void WSWindowManager::set_active_window(WSWindow* window)
return;
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);
}
m_active_window = window->makeWeakPtr();
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);
}
}
@ -454,7 +454,7 @@ void WSWindowManager::invalidate(const Rect& a_rect)
if (!m_pending_compose_event) {
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;
}
}

2
WindowServer/WSWindowManager.h
View file

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