keyboard message forwarding

desktop/api.cpp

@@ -61,6 +61,7 @@ struct EnumString { const char *cName; int value; };
 #define DESKTOP_MSG_CLIPBOARD_GET             (12)
 #define DESKTOP_MSG_SYSTEM_CONFIGURATION_GET  (13)
 #define DESKTOP_MSG_FILE_TYPES_GET            (14)
+#define DESKTOP_MSG_UNHANDLED_KEY_EVENT       (15)
 
 extern "C" uintptr_t ProcessorTLSRead(uintptr_t offset);
 

desktop/desktop.cpp

@@ -1954,6 +1954,13 @@ void DesktopMessage2(EsMessage *message, uint8_t *buffer, EsBuffer *pipe) {
 			desktop.installedApplications.Add(application);
 			ApplicationInstanceCreate(application->id, nullptr, nullptr);
 		}
+	} else if (buffer[0] == DESKTOP_MSG_UNHANDLED_KEY_EVENT) {
+		_EsMessageWithObject message;
+		EsSyscall(ES_SYSCALL_WINDOW_GET_EMBED_KEYBOARD, instance->tab->window->handle, (uintptr_t) &message, 0, 0);
+
+		if (message.message.type != ES_MSG_INVALID) {
+			UIProcessWindowManagerMessage((EsWindow *) message.object, &message.message, nullptr);
+		}
 	}
 }
 

desktop/gui.cpp

@@ -6068,9 +6068,13 @@ void UIHandleKeyMessage(EsWindow *window, EsMessage *message) {
 
 		if (message->keyboard.scancode == ES_SCANCODE_LEFT_ALT && gui.unhandledAltPress) {
 			AccessKeyModeEnter(window);
+		} else if (window->focused) {
+			EsMessageSend(window->focused, message);
+		} else if (window->windowStyle == ES_WINDOW_NORMAL) {
+			uint8_t m = DESKTOP_MSG_UNHANDLED_KEY_EVENT;
+			MessageDesktop(&m, 1, window->handle);
 		}
 
-		if (window->focused) EsMessageSend(window->focused, message);
 		return;
 	}
 
@@ -6156,9 +6160,11 @@ void UIHandleKeyMessage(EsWindow *window, EsMessage *message) {
 	if (window->enterButton && message->keyboard.scancode == ES_SCANCODE_ENTER && !message->keyboard.modifiers
 			&& window->enterButton->onCommand && (~window->enterButton->flags & ES_ELEMENT_DISABLED)) {
 		window->enterButton->onCommand(window->instance, window->enterButton, window->enterButton->command);
+		return;
 	} else if (window->escapeButton && message->keyboard.scancode == ES_SCANCODE_ESCAPE && !message->keyboard.modifiers
 			&& window->escapeButton->onCommand && (~window->escapeButton->flags & ES_ELEMENT_DISABLED)) {
 		window->escapeButton->onCommand(window->instance, window->escapeButton, window->escapeButton->command);
+		return;
 	}
 
 	if (!window->hasDialog) {
@@ -6198,6 +6204,12 @@ void UIHandleKeyMessage(EsWindow *window, EsMessage *message) {
 			}
 		}
 	}
+
+	if (window->windowStyle == ES_WINDOW_NORMAL) {
+		uint8_t m = DESKTOP_MSG_UNHANDLED_KEY_EVENT;
+		MessageDesktop(&m, 1, window->handle);
+		return;
+	}
 }
 
 void UIWindowPaintNow(EsWindow *window, ProcessMessageTiming *timing, bool afterResize) {

desktop/os.header

@@ -803,6 +803,7 @@ enum EsSyscallType {
 	ES_SYSCALL_WINDOW_MOVE
 	ES_SYSCALL_WINDOW_GET_ID
 	ES_SYSCALL_WINDOW_GET_BOUNDS
+	ES_SYSCALL_WINDOW_GET_EMBED_KEYBOARD
 	ES_SYSCALL_WINDOW_SET_BITS
 	ES_SYSCALL_WINDOW_SET_CURSOR
 	ES_SYSCALL_WINDOW_SET_PROPERTY
@@ -860,6 +861,8 @@ enum EsSyscallType {
 }
 
 enum EsMessageType {
+	ES_MSG_INVALID				= 0x0000
+		
 	// Window manager messages (don't rearrange; see SendMessageToWindow in kernel/window_manager.cpp):
 	ES_MSG_WM_START				= 0x1000
 	ES_MSG_MOUSE_MOVED 			= 0x1001

kernel/syscall.cpp

@@ -1190,6 +1190,21 @@ SYSCALL_IMPLEMENT(ES_SYSCALL_WINDOW_GET_BOUNDS) {
 	SYSCALL_RETURN(ES_SUCCESS, false);
 }
 
+SYSCALL_IMPLEMENT(ES_SYSCALL_WINDOW_GET_EMBED_KEYBOARD) {
+	KObject _window(currentProcess, argument0, KERNEL_OBJECT_WINDOW);
+	CHECK_OBJECT(_window);
+	_EsMessageWithObject m;
+	EsMemoryZero(&m, sizeof(_EsMessageWithObject));
+	KMutexAcquire(&windowManager.mutex);
+	Window *window = (Window *) _window.object;
+	m.object = window->apiWindow;
+	EsMemoryCopy(&m.message, &window->lastEmbedKeyboardMessage, sizeof(EsMessage));
+	window->lastEmbedKeyboardMessage.type = ES_MSG_INVALID;
+	KMutexRelease(&windowManager.mutex);
+	SYSCALL_WRITE(argument1, &m, sizeof(_EsMessageWithObject));
+	SYSCALL_RETURN(ES_SUCCESS, false);
+}
+
 SYSCALL_IMPLEMENT(ES_SYSCALL_PROCESS_PAUSE) {
 	KObject _process(currentProcess, argument0, KERNEL_OBJECT_PROCESS);
 	CHECK_OBJECT(_process);

kernel/windows.cpp

@@ -36,6 +36,7 @@ struct Window {
 	EsRectangle solidInsets;
 	bool solid, noClickActivate, hidden, isMaximised, alwaysOnTop, hoveringOverEmbed, queuedScrollUpdate, activationClick, noBringToFront;
 	volatile bool closed;
+	EsMessage lastEmbedKeyboardMessage; // The most recent keyboard message sent to the embedded window.
 
 	// Appearance:
 	Surface surface;
@@ -180,6 +181,8 @@ void SendMessageToWindow(Window *window, EsMessage *message) {
 		return;
 	}
 
+	window->lastEmbedKeyboardMessage.type = ES_MSG_INVALID;
+
 	if (message->type == ES_MSG_WINDOW_RESIZED) {
 		message->windowResized.content = ES_RECT_4(0, window->width, 0, window->height);
 		window->owner->messageQueue.SendMessage(window->apiWindow, message);
@@ -229,12 +232,12 @@ void SendMessageToWindow(Window *window, EsMessage *message) {
 			window->owner->messageQueue.SendMessage(window->apiWindow, message);
 		}
 	} else if (message->type == ES_MSG_KEY_DOWN || message->type == ES_MSG_KEY_UP) {
-		window->embed->owner->messageQueue.SendMessage(window->embed->apiWindow, message);
+		// If the embedded window doesn't handle the key event,
+		// then the container window can get it from here.
+		// See DESKTOP_MSG_UNHANDLED_KEY_EVENT and ES_SYSCALL_WINDOW_GET_EMBED_KEYBOARD.
+		EsMemoryCopy(&window->lastEmbedKeyboardMessage, message, sizeof(EsMessage));
 
-		// TODO Better method of handling keyboard shortcuts that Desktop needs to process?
-		// 	By sending the message to both processes, two threads will wake up,
-		// 	which could increase latency of handling the message.
-		window->owner->messageQueue.SendMessage(window->apiWindow, message);
+		window->embed->owner->messageQueue.SendMessage(window->embed->apiWindow, message);
 	} else if (message->type == ES_MSG_MOUSE_EXIT) {
 		window->embed->owner->messageQueue.SendMessage(window->embed->apiWindow, message);
 		window->owner->messageQueue.SendMessage(window->apiWindow, message);