Move EventDispatcher code out of .hpp.

firmware/application/event_m0.cpp

@@ -21,11 +21,23 @@
 
 #include "event_m0.hpp"
 
+#include "portapack.hpp"
+#include "portapack_shared_memory.hpp"
+
+#include "sd_card.hpp"
+
+#include "message.hpp"
+#include "message_queue.hpp"
+
+#include "irq_controls.hpp"
+
 #include "ch.h"
 
 #include "lpc43xx_cpp.hpp"
 using namespace lpc43xx;
 
+#include <array>
+
 extern "C" {
 
 CH_IRQ_HANDLER(M4Core_IRQHandler) {
@@ -43,3 +55,165 @@ CH_IRQ_HANDLER(M4Core_IRQHandler) {
 }
 
 Thread* EventDispatcher::thread_event_loop = nullptr;
+
+EventDispatcher::EventDispatcher(
+	ui::Widget* const top_widget,
+	ui::Painter& painter,
+	ui::Context& context
+) : top_widget { top_widget },
+	painter(painter),
+	context(context)
+{
+	thread_event_loop = chThdSelf();
+	touch_manager.on_event = [this](const ui::TouchEvent event) {
+		this->on_touch_event(event);
+	};
+}
+
+void EventDispatcher::run() {
+	creg::m4txevent::enable();
+
+	while(is_running) {
+		const auto events = wait();
+		dispatch(events);
+	}
+
+	creg::m4txevent::disable();
+}
+
+void EventDispatcher::request_stop() {
+	is_running = false;
+}
+
+eventmask_t EventDispatcher::wait() {
+	return chEvtWaitAny(ALL_EVENTS);
+}
+
+void EventDispatcher::dispatch(const eventmask_t events) {
+	if( events & EVT_MASK_APPLICATION ) {
+		handle_application_queue();
+	}
+
+	if( events & EVT_MASK_RTC_TICK ) {
+		handle_rtc_tick();
+	}
+
+	if( events & EVT_MASK_LCD_FRAME_SYNC ) {
+		handle_lcd_frame_sync();
+	}
+
+	if( events & EVT_MASK_SWITCHES ) {
+		handle_switches();
+	}
+
+	if( events & EVT_MASK_ENCODER ) {
+		handle_encoder();
+	}
+
+	if( events & EVT_MASK_TOUCH ) {
+		handle_touch();
+	}
+}
+
+void EventDispatcher::handle_application_queue() {
+	std::array<uint8_t, Message::MAX_SIZE> message_buffer;
+	while(Message* const message = shared_memory.application_queue.pop(message_buffer)) {
+		context.message_map().send(message);
+	}
+}
+
+void EventDispatcher::handle_rtc_tick() {
+	sd_card::poll_inserted();
+
+	portapack::temperature_logger.second_tick();
+}
+
+ui::Widget* EventDispatcher::touch_widget(ui::Widget* const w, ui::TouchEvent event) {
+	if( !w->hidden() ) {
+		// To achieve reverse depth ordering (last object drawn is
+		// considered "top"), descend first.
+		for(const auto child : w->children()) {
+			const auto touched_widget = touch_widget(child, event);
+			if( touched_widget ) {
+				return touched_widget;
+			}
+		}
+
+		const auto r = w->screen_rect();
+		if( r.contains(event.point) ) {
+			if( w->on_touch(event) ) {
+				// This widget responded. Return it up the call stack.
+				return w;
+			}
+		}
+	}
+	return nullptr;
+}
+
+void EventDispatcher::on_touch_event(ui::TouchEvent event) {
+	/* TODO: Capture widget receiving the Start event, send Move and
+	 * End events to the same widget.
+	 */
+	/* Capture Start widget.
+	 * If touch is over Start widget at Move event, then the widget
+	 * should be highlighted. If the touch is not over the Start
+	 * widget at Move event, widget should un-highlight.
+	 * If touch is over Start widget at End event, then the widget
+	 * action should occur.
+	 */
+	if( event.type == ui::TouchEvent::Type::Start ) {
+		captured_widget = touch_widget(this->top_widget, event);
+	}
+
+	if( captured_widget ) {
+		captured_widget->on_touch(event);
+	}
+}
+
+void EventDispatcher::handle_lcd_frame_sync() {
+	DisplayFrameSyncMessage message;
+	context.message_map().send(&message);
+	painter.paint_widget_tree(top_widget);
+}
+
+void EventDispatcher::handle_switches() {
+	const auto switches_state = get_switches_state();
+	for(size_t i=0; i<switches_state.size(); i++) {
+		// TODO: Ignore multiple keys at the same time?
+		if( switches_state[i] ) {
+			const auto event = static_cast<ui::KeyEvent>(i);
+			if( !event_bubble_key(event) ) {
+				context.focus_manager().update(top_widget, event);
+			}
+		}
+	}
+}
+
+void EventDispatcher::handle_encoder() {
+	const uint32_t encoder_now = get_encoder_position();
+	const int32_t delta = static_cast<int32_t>(encoder_now - encoder_last);
+	encoder_last = encoder_now;
+	const auto event = static_cast<ui::EncoderEvent>(delta);
+	event_bubble_encoder(event);
+}
+
+void EventDispatcher::handle_touch() {
+	touch_manager.feed(get_touch_frame());
+}
+
+bool EventDispatcher::event_bubble_key(const ui::KeyEvent event) {
+	auto target = context.focus_manager().focus_widget();
+	while( (target != nullptr) && !target->on_key(event) ) {
+		target = target->parent();
+	}
+
+	/* Return true if event was consumed. */
+	return (target != nullptr);
+}
+
+void EventDispatcher::event_bubble_encoder(const ui::EncoderEvent event) {
+	auto target = context.focus_manager().focus_widget();
+	while( (target != nullptr) && !target->on_encoder(event) ) {
+		target = target->parent();
+	}
+}

firmware/application/event_m0.hpp

@@ -24,30 +24,14 @@
 
 #include "event.hpp"
 
-#include "portapack.hpp"
-#include "portapack_shared_memory.hpp"
-
 #include "ui_widget.hpp"
 #include "ui_painter.hpp"
 
 #include "touch.hpp"
 
-#include "irq_lcd_frame.hpp"
-#include "irq_controls.hpp"
-#include "irq_rtc.hpp"
-
-#include "message.hpp"
-#include "message_queue.hpp"
-
-#include "sd_card.hpp"
-
 #include "ch.h"
 
-#include "lpc43xx_cpp.hpp"
-using namespace lpc43xx;
-
 #include <cstdint>
-#include <array>
 
 constexpr auto EVT_MASK_RTC_TICK		= EVENT_MASK(0);
 constexpr auto EVT_MASK_LCD_FRAME_SYNC	= EVENT_MASK(1);
@@ -62,30 +46,10 @@ public:
 		ui::Widget* const top_widget,
 		ui::Painter& painter,
 		ui::Context& context
-	) : top_widget { top_widget },
+	);
-		painter(painter),
-		context(context)
-	{
-		thread_event_loop = chThdSelf();
-		touch_manager.on_event = [this](const ui::TouchEvent event) {
-			this->on_touch_event(event);
-		};
-	}
 
-	void run() {
+	void run();
-		creg::m4txevent::enable();
+	void request_stop();
-
-		while(is_running) {
-			const auto events = wait();
-			dispatch(events);
-		}
-
-		creg::m4txevent::disable();
-	}
-
-	void request_stop() {
-		is_running = false;
-	}
 
 	static inline void events_flag(const eventmask_t events) {
 		if( thread_event_loop ) {
@@ -110,140 +74,25 @@ private:
 	bool is_running = true;
 	bool sd_card_present = false;
 
-	eventmask_t wait() {
+	eventmask_t wait();
-		return chEvtWaitAny(ALL_EVENTS);
+	void dispatch(const eventmask_t events);
-	}
 
-	void dispatch(const eventmask_t events) {
+	void handle_application_queue();
-		if( events & EVT_MASK_APPLICATION ) {
+	void handle_rtc_tick();
-			handle_application_queue();
-		}
 
-		if( events & EVT_MASK_RTC_TICK ) {
+	static ui::Widget* touch_widget(ui::Widget* const w, ui::TouchEvent event);
-			handle_rtc_tick();
-		}
-
-		if( events & EVT_MASK_LCD_FRAME_SYNC ) {
-			handle_lcd_frame_sync();
-		}
-
-		if( events & EVT_MASK_SWITCHES ) {
-			handle_switches();
-		}
-
-		if( events & EVT_MASK_ENCODER ) {
-			handle_encoder();
-		}
-
-		if( events & EVT_MASK_TOUCH ) {
-			handle_touch();
-		}
-	}
-
-	void handle_application_queue() {
-		std::array<uint8_t, Message::MAX_SIZE> message_buffer;
-		while(Message* const message = shared_memory.application_queue.pop(message_buffer)) {
-			context.message_map().send(message);
-		}
-	}
-
-	void handle_rtc_tick() {
-		sd_card::poll_inserted();
-
-		portapack::temperature_logger.second_tick();
-	}
-
-	static ui::Widget* touch_widget(ui::Widget* const w, ui::TouchEvent event) {
-		if( !w->hidden() ) {
-			// To achieve reverse depth ordering (last object drawn is
-			// considered "top"), descend first.
-			for(const auto child : w->children()) {
-				const auto touched_widget = touch_widget(child, event);
-				if( touched_widget ) {
-					return touched_widget;
-				}
-			}
-
-			const auto r = w->screen_rect();
-			if( r.contains(event.point) ) {
-				if( w->on_touch(event) ) {
-					// This widget responded. Return it up the call stack.
-					return w;
-				}
-			}
-		}
-		return nullptr;
-	}
 
 	ui::Widget* captured_widget { nullptr };
 
-	void on_touch_event(ui::TouchEvent event) {
+	void on_touch_event(ui::TouchEvent event);
-		/* TODO: Capture widget receiving the Start event, send Move and
-		 * End events to the same widget.
-		 */
-		/* Capture Start widget.
-		 * If touch is over Start widget at Move event, then the widget
-		 * should be highlighted. If the touch is not over the Start
-		 * widget at Move event, widget should un-highlight.
-		 * If touch is over Start widget at End event, then the widget
-		 * action should occur.
-		 */
-		if( event.type == ui::TouchEvent::Type::Start ) {
-			captured_widget = touch_widget(this->top_widget, event);
-		}
 
-		if( captured_widget ) {
+	void handle_lcd_frame_sync();
-			captured_widget->on_touch(event);
+	void handle_switches();
-		}
+	void handle_encoder();
-	}
+	void handle_touch();
 
-	void handle_lcd_frame_sync() {
+	bool event_bubble_key(const ui::KeyEvent event);
-		DisplayFrameSyncMessage message;
+	void event_bubble_encoder(const ui::EncoderEvent event);
-		context.message_map().send(&message);
-		painter.paint_widget_tree(top_widget);
-	}
-
-	void handle_switches() {
-		const auto switches_state = get_switches_state();
-		for(size_t i=0; i<switches_state.size(); i++) {
-			// TODO: Ignore multiple keys at the same time?
-			if( switches_state[i] ) {
-				const auto event = static_cast<ui::KeyEvent>(i);
-				if( !event_bubble_key(event) ) {
-					context.focus_manager().update(top_widget, event);
-				}
-			}
-		}
-	}
-
-	void handle_encoder() {
-		const uint32_t encoder_now = get_encoder_position();
-		const int32_t delta = static_cast<int32_t>(encoder_now - encoder_last);
-		encoder_last = encoder_now;
-		const auto event = static_cast<ui::EncoderEvent>(delta);
-		event_bubble_encoder(event);
-	}
-
-	void handle_touch() {
-		touch_manager.feed(get_touch_frame());
-	}
-
-	bool event_bubble_key(const ui::KeyEvent event) {
-		auto target = context.focus_manager().focus_widget();
-		while( (target != nullptr) && !target->on_key(event) ) {
-			target = target->parent();
-		}
-
-		/* Return true if event was consumed. */
-		return (target != nullptr);
-	}
-
-	void event_bubble_encoder(const ui::EncoderEvent event) {
-		auto target = context.focus_manager().focus_widget();
-		while( (target != nullptr) && !target->on_encoder(event) ) {
-			target = target->parent();
-		}
-	}
 };
 
 #endif/*__EVENT_M0_H__*/

firmware/baseband/event_m4.cpp

@@ -21,11 +21,18 @@
 
 #include "event_m4.hpp"
 
+#include "portapack_shared_memory.hpp"
+
+#include "message_queue.hpp"
+
 #include "ch.h"
 
 #include "lpc43xx_cpp.hpp"
 using namespace lpc43xx;
 
+#include <cstdint>
+#include <array>
+
 extern "C" {
 
 CH_IRQ_HANDLER(MAPP_IRQHandler) {
@@ -43,3 +50,70 @@ CH_IRQ_HANDLER(MAPP_IRQHandler) {
 }
 
 Thread* EventDispatcher::thread_event_loop = nullptr;
+
+void EventDispatcher::run() {
+	thread_event_loop = chThdSelf();
+	lpc43xx::creg::m0apptxevent::enable();
+
+	baseband_thread.thread_main = chThdSelf();
+	baseband_thread.thread_rssi = rssi_thread.start(NORMALPRIO + 10);
+	baseband_thread.start(NORMALPRIO + 20);
+
+	while(is_running) {
+		const auto events = wait();
+		dispatch(events);
+	}
+
+	lpc43xx::creg::m0apptxevent::disable();
+}
+
+void EventDispatcher::request_stop() {
+	is_running = false;
+}
+
+eventmask_t EventDispatcher::wait() {
+	return chEvtWaitAny(ALL_EVENTS);
+}
+
+void EventDispatcher::dispatch(const eventmask_t events) {
+	if( events & EVT_MASK_BASEBAND ) {
+		handle_baseband_queue();
+	}
+
+	if( events & EVT_MASK_SPECTRUM ) {
+		handle_spectrum();
+	}
+}
+
+void EventDispatcher::handle_baseband_queue() {
+	std::array<uint8_t, Message::MAX_SIZE> message_buffer;
+	while(Message* const message = shared_memory.baseband_queue.peek(message_buffer)) {
+		on_message(message);
+		shared_memory.baseband_queue.skip();
+	}
+}
+
+void EventDispatcher::on_message(const Message* const message) {
+	switch(message->id) {
+	case Message::ID::Shutdown:
+		on_message_shutdown(*reinterpret_cast<const ShutdownMessage*>(message));
+		break;
+
+	default:
+		on_message_default(message);
+		break;
+	}
+}
+
+void EventDispatcher::on_message_shutdown(const ShutdownMessage&) {
+	request_stop();
+}
+
+void EventDispatcher::on_message_default(const Message* const message) {
+	baseband_thread.on_message(message);
+}
+
+void EventDispatcher::handle_spectrum() {
+	const UpdateSpectrumMessage message;
+	baseband_thread.on_message(&message);
+}

firmware/baseband/event_m4.hpp

@@ -24,44 +24,20 @@
 
 #include "event.hpp"
 
-#include "portapack_shared_memory.hpp"
-
 #include "baseband_thread.hpp"
 #include "rssi_thread.hpp"
 
 #include "message.hpp"
-#include "message_queue.hpp"
 
 #include "ch.h"
 
-#include "lpc43xx_cpp.hpp"
-
-#include <array>
-
 constexpr auto EVT_MASK_BASEBAND = EVENT_MASK(0);
 constexpr auto EVT_MASK_SPECTRUM = EVENT_MASK(1);
 
 class EventDispatcher {
 public:
-	void run() {
+	void run();
-		thread_event_loop = chThdSelf();
+	void request_stop();
-		lpc43xx::creg::m0apptxevent::enable();
-
-		baseband_thread.thread_main = chThdSelf();
-		baseband_thread.thread_rssi = rssi_thread.start(NORMALPRIO + 10);
-		baseband_thread.start(NORMALPRIO + 20);
-
-		while(is_running) {
-			const auto events = wait();
-			dispatch(events);
-		}
-
-		lpc43xx::creg::m0apptxevent::disable();
-	}
-
-	void request_stop() {
-		is_running = false;
-	}
 
 	static inline void events_flag(const eventmask_t events) {
 		if( thread_event_loop ) {
@@ -83,52 +59,17 @@ private:
 
 	bool is_running = true;
 
-	eventmask_t wait() {
+	eventmask_t wait();
-		return chEvtWaitAny(ALL_EVENTS);
-	}
 
-	void dispatch(const eventmask_t events) {
+	void dispatch(const eventmask_t events);
-		if( events & EVT_MASK_BASEBAND ) {
-			handle_baseband_queue();
-		}
 
-		if( events & EVT_MASK_SPECTRUM ) {
+	void handle_baseband_queue();
-			handle_spectrum();
-		}
-	}
 
-	void handle_baseband_queue() {
+	void on_message(const Message* const message);
-		std::array<uint8_t, Message::MAX_SIZE> message_buffer;
+	void on_message_shutdown(const ShutdownMessage&);
-		while(Message* const message = shared_memory.baseband_queue.peek(message_buffer)) {
+	void on_message_default(const Message* const message);
-			on_message(message);
-			shared_memory.baseband_queue.skip();
-		}
-	}
 
-	void on_message(const Message* const message) {
+	void handle_spectrum();
-		switch(message->id) {
-		case Message::ID::Shutdown:
-			on_message_shutdown(*reinterpret_cast<const ShutdownMessage*>(message));
-			break;
-
-		default:
-			on_message_default(message);
-			break;
-		}
-	}
-
-	void on_message_shutdown(const ShutdownMessage&) {
-		request_stop();
-	}
-
-	void on_message_default(const Message* const message) {
-		baseband_thread.on_message(message);
-	}
-
-	void handle_spectrum() {
-		const UpdateSpectrumMessage message;
-		baseband_thread.on_message(&message);
-	}
 };
 
 #endif/*__EVENT_M4_H__*/