From 9ad6930ac7bec99776aee4350a9d5794f866d593 Mon Sep 17 00:00:00 2001 From: nakst <> Date: Thu, 19 Aug 2021 11:21:01 +0100 Subject: [PATCH] file based clipboard --- desktop/api.cpp | 6 ++ desktop/desktop.cpp | 214 +++++++++++++++++++++++++++++++------------- desktop/gui.cpp | 2 - desktop/os.header | 20 +++-- desktop/prefix.h | 4 +- desktop/syscall.cpp | 85 ++++++++++++++---- desktop/text.cpp | 21 ++--- kernel/syscall.cpp | 66 ++++++-------- kernel/windows.cpp | 85 +----------------- util/api_table.ini | 4 + 10 files changed, 282 insertions(+), 225 deletions(-) diff --git a/desktop/api.cpp b/desktop/api.cpp index abe0178..fe0b1d2 100644 --- a/desktop/api.cpp +++ b/desktop/api.cpp @@ -56,6 +56,9 @@ struct EnumString { const char *cName; int value; }; #define DESKTOP_MSG_RUN_TEMPORARY_APPLICATION (7) #define DESKTOP_MSG_REQUEST_SHUTDOWN (8) #define DESKTOP_MSG_START_APPLICATION (9) +#define DESKTOP_MSG_CREATE_CLIPBOARD_FILE (10) +#define DESKTOP_MSG_CLIPBOARD_PUT (11) +#define DESKTOP_MSG_CLIPBOARD_GET (12) extern "C" uintptr_t ProcessorTLSRead(uintptr_t offset); @@ -860,6 +863,9 @@ EsMessage *EsMessageReceive() { } else { EsHandleClose(message.message.tabOperation.handle); } + } else if (type == ES_MSG_PRIMARY_CLIPBOARD_UPDATED) { + EsInstance *instance = InstanceFromWindowID(message.message.tabOperation.id); + if (instance) UIRefreshPrimaryClipboard(instance->window); } else if (type == ES_MSG_REGISTER_FILE_SYSTEM) { EsMessageRegisterFileSystem *m = &message.message.registerFileSystem; diff --git a/desktop/desktop.cpp b/desktop/desktop.cpp index 61b75b3..c332b2e 100644 --- a/desktop/desktop.cpp +++ b/desktop/desktop.cpp @@ -166,14 +166,23 @@ struct { Array allApplicationInstances; Array allContainerWindows; Array connectedDevices; + InstalledApplication *fileManager; + EsObjectID currentDocumentID; HashStore openDocuments; + TaskBar taskBar; EsWindow *wallpaperWindow; + bool shutdownWindowOpen; bool setupDesktopUIComplete; int installationState; + + EsHandle nextClipboardFile; + EsObjectID nextClipboardProcessID; + EsHandle clipboardFile; + ClipboardInformation clipboardInformation; } desktop; int TaskBarButtonMessage(EsElement *element, EsMessage *message); @@ -1202,6 +1211,35 @@ void OpenDocumentWithApplication(EsApplicationStartupInformation *startupInforma } } +EsError TemporaryFileCreate(EsHandle *handle, char **path, size_t *pathBytes) { + char temporaryFileName[32]; + + for (uintptr_t i = 0; i < sizeof(temporaryFileName); i++) { + temporaryFileName[i] = (EsRandomU8() % 26) + 'a'; + } + + size_t temporaryFolderBytes; + char *temporaryFolder = EsSystemConfigurationReadString(EsLiteral("general"), EsLiteral("temporary_path"), &temporaryFolderBytes); + char *temporaryFilePath = (char *) EsHeapAllocate(temporaryFolderBytes + 1 + sizeof(temporaryFileName), false); + size_t temporaryFilePathBytes = EsStringFormat(temporaryFilePath, ES_STRING_FORMAT_ENOUGH_SPACE, "%s/%s", + temporaryFolderBytes, temporaryFolder, sizeof(temporaryFileName), temporaryFileName); + + EsFileInformation file = EsFileOpen(temporaryFilePath, temporaryFilePathBytes, + ES_FILE_WRITE_EXCLUSIVE | ES_NODE_FAIL_IF_FOUND | ES_NODE_CREATE_DIRECTORIES); + + EsHeapFree(temporaryFolder); + + if (file.error != ES_SUCCESS) { + EsHeapFree(temporaryFilePath); + } else { + *path = temporaryFilePath; + *pathBytes = temporaryFilePathBytes; + *handle = file.handle; + } + + return file.error; +} + void ApplicationInstanceRequestSave(ApplicationInstance *instance, const char *newName, size_t newNameBytes) { if (!instance->processHandle) return; @@ -1271,33 +1309,13 @@ void ApplicationInstanceRequestSave(ApplicationInstance *instance, const char *n if (document->currentWriter) { m.tabOperation.error = ES_ERROR_FILE_CANNOT_GET_EXCLUSIVE_USE; } else { - char temporaryFileName[32]; + EsHandle fileHandle; + m.tabOperation.error = TemporaryFileCreate(&fileHandle, &document->temporarySavePath, &document->temporarySavePathBytes); - for (uintptr_t i = 0; i < sizeof(temporaryFileName); i++) { - temporaryFileName[i] = (EsRandomU8() % 26) + 'a'; - } - - size_t temporaryFolderBytes; - char *temporaryFolder = EsSystemConfigurationReadString(EsLiteral("general"), EsLiteral("temporary_path"), &temporaryFolderBytes); - char *temporaryFilePath = (char *) EsHeapAllocate(temporaryFolderBytes + 1 + sizeof(temporaryFileName), false); - size_t temporaryFilePathBytes = EsStringFormat(temporaryFilePath, ES_STRING_FORMAT_ENOUGH_SPACE, "%s/%s", - temporaryFolderBytes, temporaryFolder, sizeof(temporaryFileName), temporaryFileName); - - EsFileInformation file = EsFileOpen(temporaryFilePath, temporaryFilePathBytes, - ES_FILE_WRITE_EXCLUSIVE | ES_NODE_FAIL_IF_FOUND | ES_NODE_CREATE_DIRECTORIES); - - EsHeapFree(temporaryFolder); - - if (file.error != ES_SUCCESS) { - m.tabOperation.error = file.error; - EsHeapFree(temporaryFilePath); - } else { - m.tabOperation.handle = EsSyscall(ES_SYSCALL_NODE_SHARE, file.handle, instance->processHandle, 0, 0); - m.tabOperation.error = ES_SUCCESS; + if (m.tabOperation.error == ES_SUCCESS) { document->currentWriter = instance->embeddedWindowID; - document->temporarySavePath = temporaryFilePath; - document->temporarySavePathBytes = temporaryFilePathBytes; - EsHandleClose(file.handle); + m.tabOperation.handle = EsSyscall(ES_SYSCALL_NODE_SHARE, fileHandle, instance->processHandle, 0, 0); + EsHandleClose(fileHandle); } } @@ -1593,47 +1611,53 @@ void WallpaperLoad(EsGeneric) { // General Desktop: ////////////////////////////////////////////////////// -void CheckForegroundWindowResponding(EsGeneric) { +ApplicationInstance *ApplicationInstanceFindForeground() { for (uintptr_t i = 0; i < desktop.allApplicationInstances.Length(); i++) { ApplicationInstance *instance = desktop.allApplicationInstances[i]; WindowTab *tab = instance->tab; - if (!tab || (~tab->container->taskBarButton->customStyleState & THEME_STATE_SELECTED) || tab->container->active != instance->tab) { - continue; + if (tab && (tab->container->taskBarButton->customStyleState & THEME_STATE_SELECTED) && tab->container->active == instance->tab) { + return instance; } - - EsProcessState state; - EsProcessGetState(instance->processHandle, &state); - - if (state.flags & ES_PROCESS_STATE_PINGED) { - if (tab->notRespondingInstance) { - // The tab is already not responding. - } else { - // The tab has just stopped not responding. - EsApplicationStartupInformation startupInformation = { .data = CRASHED_TAB_NOT_RESPONDING }; - tab->notRespondingInstance = ApplicationInstanceCreate(APPLICATION_ID_DESKTOP_CRASHED, - &startupInformation, tab->container, true /* hidden */); - WindowTabActivate(tab, true); - } - } else { - if (tab->notRespondingInstance) { - // The tab has started responding. - ApplicationInstanceClose(tab->notRespondingInstance); - tab->notRespondingInstance = nullptr; - WindowTabActivate(tab, true); - } else { - // Check if the tab is responding. - EsMessage m; - EsMemoryZero(&m, sizeof(EsMessage)); - m.type = ES_MSG_PING; - EsMessagePostRemote(instance->processHandle, &m); - } - } - - break; } + return nullptr; +} + +void CheckForegroundWindowResponding(EsGeneric) { + ApplicationInstance *instance = ApplicationInstanceFindForeground(); EsTimerSet(2500, CheckForegroundWindowResponding, 0); + if (!instance) return; + + WindowTab *tab = instance->tab; + + EsProcessState state; + EsProcessGetState(instance->processHandle, &state); + + if (state.flags & ES_PROCESS_STATE_PINGED) { + if (tab->notRespondingInstance) { + // The tab is already not responding. + } else { + // The tab has just stopped not responding. + EsApplicationStartupInformation startupInformation = { .data = CRASHED_TAB_NOT_RESPONDING }; + tab->notRespondingInstance = ApplicationInstanceCreate(APPLICATION_ID_DESKTOP_CRASHED, + &startupInformation, tab->container, true /* hidden */); + WindowTabActivate(tab, true); + } + } else { + if (tab->notRespondingInstance) { + // The tab has started responding. + ApplicationInstanceClose(tab->notRespondingInstance); + tab->notRespondingInstance = nullptr; + WindowTabActivate(tab, true); + } else { + // Check if the tab is responding. + EsMessage m; + EsMemoryZero(&m, sizeof(EsMessage)); + m.type = ES_MSG_PING; + EsMessagePostRemote(instance->processHandle, &m); + } + } } void DesktopSetup() { @@ -1726,7 +1750,7 @@ void DesktopSetup() { if (firstApplication && firstApplication[0]) { for (uintptr_t i = 0; i < desktop.installedApplications.Length(); i++) { - if (0 == EsCRTstrcmp(desktop.installedApplications[i]->cName, firstApplication)) { + if (desktop.installedApplications[i]->cName && 0 == EsCRTstrcmp(desktop.installedApplications[i]->cName, firstApplication)) { ApplicationInstanceCreate(desktop.installedApplications[i]->id, nullptr, nullptr); } } @@ -1782,6 +1806,71 @@ void DesktopMessage2(EsMessage *message, uint8_t *buffer) { if (buffer[0] == DESKTOP_MSG_START_APPLICATION) { EsApplicationStartupInformation *information = ApplicationStartupInformationParse(buffer + 1, message->desktop.bytes - 1); if (information) OpenDocumentWithApplication(information); + } else if (buffer[0] == DESKTOP_MSG_CREATE_CLIPBOARD_FILE && message->desktop.pipe) { + EsHandle processHandle = EsProcessOpen(message->desktop.processID); + + if (processHandle) { + EsHandle handle; + char *path; + size_t pathBytes; + EsError error = TemporaryFileCreate(&handle, &path, &pathBytes); + + if (error == ES_SUCCESS) { + if (desktop.nextClipboardFile) { + EsHandleClose(desktop.nextClipboardFile); + } + + desktop.nextClipboardFile = handle; + desktop.nextClipboardProcessID = message->desktop.processID; + + handle = EsSyscall(ES_SYSCALL_NODE_SHARE, handle, processHandle, 0, 0); + + EsHeapFree(path); + } else { + handle = ES_INVALID_HANDLE; + } + + EsPipeWrite(message->desktop.pipe, &handle, sizeof(handle)); + EsPipeWrite(message->desktop.pipe, &error, sizeof(error)); + + EsHandleClose(processHandle); + } + } else if (buffer[0] == DESKTOP_MSG_CLIPBOARD_PUT && message->desktop.bytes == sizeof(ClipboardInformation) + && desktop.nextClipboardFile && desktop.nextClipboardProcessID == message->desktop.processID) { + ClipboardInformation *information = (ClipboardInformation *) buffer; + + if (information->error == ES_SUCCESS) { + if (desktop.clipboardFile) { + EsFileDelete(desktop.clipboardFile); + EsHandleClose(desktop.clipboardFile); + } + + desktop.clipboardFile = desktop.nextClipboardFile; + desktop.clipboardInformation = *information; + + ApplicationInstance *foreground = ApplicationInstanceFindForeground(); + + if (foreground && foreground->processHandle) { + EsMessage m = { ES_MSG_PRIMARY_CLIPBOARD_UPDATED }; + m.tabOperation.id = foreground->embeddedWindowID; + EsMessagePostRemote(foreground->processHandle, &m); + } + } else { + EsHandleClose(desktop.nextClipboardFile); + } + + desktop.nextClipboardFile = ES_INVALID_HANDLE; + desktop.nextClipboardProcessID = 0; + } else if (buffer[0] == DESKTOP_MSG_CLIPBOARD_GET && message->desktop.pipe) { + EsHandle processHandle = EsProcessOpen(message->desktop.processID); + + if (processHandle) { + EsHandle fileHandle = desktop.clipboardFile + ? EsSyscall(ES_SYSCALL_NODE_SHARE, desktop.clipboardFile, processHandle, 0, 1 /* ES_FILE_READ_SHARED */) : ES_INVALID_HANDLE; + EsPipeWrite(message->desktop.pipe, &desktop.clipboardInformation, sizeof(desktop.clipboardInformation)); + EsPipeWrite(message->desktop.pipe, &fileHandle, sizeof(fileHandle)); + EsHandleClose(processHandle); + } } else if (!instance) { // ------------------------------------------------- // | Messages below here require a valid instance. | @@ -1901,15 +1990,16 @@ void DesktopMessage(EsMessage *message) { } else if (message->type == ES_MSG_EMBEDDED_WINDOW_DESTROYED) { EmbeddedWindowDestroyed(message->desktop.windowID); } else if (message->type == ES_MSG_DESKTOP) { - if (message->desktop.bytes <= 0x4000) { - uint8_t *buffer = (uint8_t *) EsHeapAllocate(message->desktop.bytes, false); - if (!buffer) return; + uint8_t *buffer = (uint8_t *) EsHeapAllocate(message->desktop.bytes, false); + + if (buffer) { EsConstantBufferRead(message->desktop.buffer, buffer); DesktopMessage2(message, buffer); EsHeapFree(buffer); } EsHandleClose(message->desktop.buffer); + if (message->desktop.pipe) EsHandleClose(message->desktop.pipe); } else if (message->type == ES_MSG_APPLICATION_CRASH) { ApplicationInstanceCrashed(message); } else if (message->type == ES_MSG_PROCESS_TERMINATED) { diff --git a/desktop/gui.cpp b/desktop/gui.cpp index 57400e1..d6fc3a7 100644 --- a/desktop/gui.cpp +++ b/desktop/gui.cpp @@ -6568,8 +6568,6 @@ void UIProcessWindowManagerMessage(EsWindow *window, EsMessage *message, Process window->inactiveFocus = nullptr; } - UIRefreshPrimaryClipboard(window); - } else if (message->type == ES_MSG_PRIMARY_CLIPBOARD_UPDATED) { UIRefreshPrimaryClipboard(window); } diff --git a/desktop/os.header b/desktop/os.header index 87445e4..86cc6c4 100644 --- a/desktop/os.header +++ b/desktop/os.header @@ -323,7 +323,6 @@ define ES_ERROR_LOST_IP_ADDRESS (-66) define ES_ERROR_CONNECTION_RESET (-67) define ES_ERROR_CONNECTION_REFUSED (-68) define ES_ERROR_ILLEGAL_PATH (-69) -define ES_ERROR_INVALID_CLIPBOARD (-70) define ES_ERROR_NODE_NOT_LOADED (-71) define ES_ERROR_DIRECTORY_ENTRY_BEING_REMOVED (-72) @@ -812,10 +811,6 @@ enum EsSyscallType { ES_SYSCALL_MESSAGE_DESKTOP - ES_SYSCALL_CLIPBOARD_ADD - ES_SYSCALL_CLIPBOARD_HAS - ES_SYSCALL_CLIPBOARD_READ - // IO. ES_SYSCALL_NODE_OPEN @@ -886,7 +881,6 @@ enum EsMessageType { ES_MSG_KEY_DOWN = 0x100E // Propagates to ancestors if unhandled. ES_MSG_KEY_UP = 0x100F ES_MSG_UPDATE_WINDOW = 0x1010 - ES_MSG_PRIMARY_CLIPBOARD_UPDATED = 0x1011 ES_MSG_WM_END = 0x13FF // Internal GUI messages: // None of these should be sent directly. @@ -967,6 +961,7 @@ enum EsMessageType { ES_MSG_INSTANCE_SAVE_RESPONSE = 0x4A03 // Sent by Desktop after an application requested to save its document. ES_MSG_INSTANCE_DOCUMENT_RENAMED = 0x4A04 ES_MSG_INSTANCE_DOCUMENT_UPDATED = 0x4A05 + ES_MSG_PRIMARY_CLIPBOARD_UPDATED = 0x4A06 // Debugger messages: ES_MSG_APPLICATION_CRASH = 0x4C00 @@ -1689,8 +1684,8 @@ struct EsMessageProcessCrash { }; struct EsMessageDesktop { - EsObjectID windowID; - EsHandle buffer; + EsObjectID windowID, processID; + EsHandle buffer, pipe; size_t bytes; }; @@ -1917,6 +1912,7 @@ function EsFileOffset EsFileGetSize(EsHandle handle); function size_t EsFileReadSync(EsHandle file, EsFileOffset offset, size_t size, void *buffer); function EsError EsFileResize(EsHandle file, EsFileOffset newSize); function size_t EsFileWriteSync(EsHandle file, EsFileOffset offset, size_t size, const void *buffer); +function EsError EsFileDelete(EsHandle file); function EsError EsPathDelete(STRING path); function size_t EsPathFindUniqueName(char *buffer, size_t originalBytes, size_t bufferBytes); @@ -2094,6 +2090,12 @@ function bool EsMouseIsLeftHeld(); function bool EsMouseIsRightHeld(); function bool EsMouseIsMiddleHeld(); +// Pipes. + +function EsHandle EsPipeCreate(); +function size_t EsPipeRead(EsHandle pipe, void *buffer, size_t bytes); +function size_t EsPipeWrite(EsHandle pipe, const void *buffer, size_t bytes); + // Synchronisation and timing. function EsHandle EsEventCreate(bool autoReset); @@ -2198,7 +2200,7 @@ function int EsCRTvsnprintf(char *buffer, size_t bufferSize, const char *format, function EsError EsClipboardAddText(EsClipboard clipboard, STRING text = BLANK_STRING); function bool EsClipboardHasText(EsClipboard clipboard); -function char *EsClipboardReadText(EsClipboard clipboard, size_t *bytes); +function char *EsClipboardReadText(EsClipboard clipboard, size_t *bytes); // Free with EsHeapFree. function void EsUndoClear(EsUndoManager *manager); function void EsUndoContinueGroup(EsUndoManager *manager); diff --git a/desktop/prefix.h b/desktop/prefix.h index 8ca89a4..c0d0707 100644 --- a/desktop/prefix.h +++ b/desktop/prefix.h @@ -304,7 +304,9 @@ extern "C" void *EsBufferWrite(EsBuffer *buffer, const void *source, size_t writ inline void *Write(const void *source, size_t writeBytes) { return EsBufferWrite(this, source, writeBytes); } #endif -#define ES_POSIX_SYSCALL_GET_POSIX_FD_PATH (0x10000) +#define ES_POSIX_SYSCALL_GET_POSIX_FD_PATH (0x10000) + +#define DESKTOP_MESSAGE_SIZE_LIMIT (0x4000) #endif diff --git a/desktop/syscall.cpp b/desktop/syscall.cpp index f5f4eb1..7545a76 100644 --- a/desktop/syscall.cpp +++ b/desktop/syscall.cpp @@ -410,6 +410,10 @@ EsError EsPathDelete(const char *path, ptrdiff_t pathBytes) { return error; } +EsError EsFileDelete(EsHandle handle) { + return EsSyscall(ES_SYSCALL_NODE_DELETE, handle, 0, 0, 0); +} + void *EsFileMap(const char *path, ptrdiff_t pathBytes, size_t *fileSize, uint32_t flags) { EsFileInformation information = EsFileOpen(path, pathBytes, ES_NODE_FAIL_IF_NOT_FOUND | ((flags & ES_MAP_OBJECT_READ_WRITE) ? ES_FILE_WRITE_EXCLUSIVE : ES_FILE_READ)); @@ -630,29 +634,78 @@ size_t EsGameControllerStatePoll(EsGameControllerState *buffer) { return EsSyscall(ES_SYSCALL_GAME_CONTROLLER_STATE_POLL, (uintptr_t) buffer, 0, 0, 0); } -#define CLIPBOARD_FORMAT_TEXT (1) +struct ClipboardInformation { + uint8_t desktopMessageTag; + intptr_t error; + bool isText; +}; EsError EsClipboardAddText(EsClipboard clipboard, const char *text, ptrdiff_t textBytes) { - EsMessageMutexCheck(); - - if (textBytes == -1) { - textBytes = EsCStringLength(text); - } - - return EsSyscall(ES_SYSCALL_CLIPBOARD_ADD, clipboard, CLIPBOARD_FORMAT_TEXT, (uintptr_t) text, textBytes); + (void) clipboard; + uint8_t m = DESKTOP_MSG_CREATE_CLIPBOARD_FILE; + EsHandle pipe = EsPipeCreate(), file; + EsError error; + EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) &m, 1, 0, pipe); + EsPipeRead(pipe, &file, sizeof(file)); + EsPipeRead(pipe, &error, sizeof(error)); + EsHandleClose(pipe); + if (error != ES_SUCCESS) return error; + error = EsFileWriteAllFromHandle(file, text, textBytes); + EsHandleClose(file); + ClipboardInformation information = {}; + information.desktopMessageTag = DESKTOP_MSG_CLIPBOARD_PUT; + information.error = error; + information.isText = true; + EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) &information, sizeof(information), 0, 0); + return error; } bool EsClipboardHasText(EsClipboard clipboard) { - return EsSyscall(ES_SYSCALL_CLIPBOARD_HAS, clipboard, CLIPBOARD_FORMAT_TEXT, 0, 0); + (void) clipboard; + uint8_t m = DESKTOP_MSG_CLIPBOARD_GET; + EsHandle pipe = EsPipeCreate(), file; + EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) &m, 1, 0, pipe); + ClipboardInformation information = {}; + EsPipeRead(pipe, &information, sizeof(information)); + EsPipeRead(pipe, &file, sizeof(file)); + EsHandleClose(pipe); + if (file) EsHandleClose(file); + return information.error == ES_SUCCESS && information.isText; } char *EsClipboardReadText(EsClipboard clipboard, size_t *bytes) { + (void) clipboard; + + char *result = nullptr; *bytes = 0; - EsHandle handle = EsSyscall(ES_SYSCALL_CLIPBOARD_READ, clipboard, CLIPBOARD_FORMAT_TEXT, 0, (uintptr_t) bytes); - if (handle == ES_INVALID_HANDLE) return nullptr; - char *buffer = (char *) EsHeapAllocate(*bytes, false); - if (!buffer) return nullptr; - EsConstantBufferRead(handle, buffer); - EsHandleClose(handle); - return buffer; + + uint8_t m = DESKTOP_MSG_CLIPBOARD_GET; + EsHandle pipe = EsPipeCreate(), file; + EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) &m, 1, 0, pipe); + ClipboardInformation information = {}; + EsPipeRead(pipe, &information, sizeof(information)); + EsPipeRead(pipe, &file, sizeof(file)); + EsHandleClose(pipe); + + if (file) { + if (information.isText) { + result = (char *) EsFileReadAllFromHandle(file, bytes); + } + + EsHandleClose(file); + } + + return result; +} + +EsHandle EsPipeCreate() { + return EsSyscall(ES_SYSCALL_PIPE_CREATE, 0, 0, 0, 0); +} + +size_t EsPipeRead(EsHandle pipe, void *buffer, size_t bytes) { + return EsSyscall(ES_SYSCALL_PIPE_READ, pipe, (uintptr_t) buffer, bytes, 0); +} + +size_t EsPipeWrite(EsHandle pipe, const void *buffer, size_t bytes) { + return EsSyscall(ES_SYSCALL_PIPE_WRITE, pipe, (uintptr_t) buffer, bytes, 0); } diff --git a/desktop/text.cpp b/desktop/text.cpp index 51345ab..9207d2b 100644 --- a/desktop/text.cpp +++ b/desktop/text.cpp @@ -3050,7 +3050,7 @@ void TextboxEndEdit(EsTextbox *textbox, bool reject) { } } -void TextboxUpdateCommands(EsTextbox *textbox, bool caretsMovedOnly) { +void TextboxUpdateCommands(EsTextbox *textbox, bool noClipboard) { if (~textbox->state & UI_STATE_FOCUSED) { return; } @@ -3106,17 +3106,17 @@ void TextboxUpdateCommands(EsTextbox *textbox, bool caretsMovedOnly) { EsTextboxInsert(textbox, "", 0, true); }); - if (!caretsMovedOnly) { - EsInstanceSetActiveUndoManager(textbox->instance, textbox->undo); + EsInstanceSetActiveUndoManager(textbox->instance, textbox->undo); - command = EsCommandByID(textbox->instance, ES_COMMAND_SELECT_ALL); - command->data = textbox; - EsCommandSetDisabled(command, !(textbox->lines.Length() > 1 || textbox->lines[0].lengthBytes)); + command = EsCommandByID(textbox->instance, ES_COMMAND_SELECT_ALL); + command->data = textbox; + EsCommandSetDisabled(command, !(textbox->lines.Length() > 1 || textbox->lines[0].lengthBytes)); - EsCommandSetCallback(command, [] (EsInstance *, EsElement *, EsCommand *command) { - EsTextboxSelectAll((EsTextbox *) command->data.p); - }); + EsCommandSetCallback(command, [] (EsInstance *, EsElement *, EsCommand *command) { + EsTextboxSelectAll((EsTextbox *) command->data.p); + }); + if (!noClipboard) { command = EsCommandByID(textbox->instance, ES_COMMAND_PASTE); command->data = textbox; EsCommandSetDisabled(command, !EsClipboardHasText(ES_CLIPBOARD_PRIMARY)); @@ -3128,6 +3128,7 @@ void TextboxUpdateCommands(EsTextbox *textbox, bool caretsMovedOnly) { char *text = EsClipboardReadText(ES_CLIPBOARD_PRIMARY, &textBytes); EsTextboxInsert(textbox, text, textBytes, true); EsTextboxEnsureCaretVisible(textbox); + EsHeapFree(text); }); } } @@ -3811,7 +3812,7 @@ void EsTextboxInsert(EsTextbox *textbox, const char *string, ptrdiff_t stringByt // EsPrint("EsTextboxInsert in %Fms (%Fms measuring new lines).\n", time * 1000, measureLineTime * 1000); textbox->scroll.Refresh(); - TextboxUpdateCommands(textbox, false); + TextboxUpdateCommands(textbox, true); } char *EsTextboxGetContents(EsTextbox *textbox, size_t *_bytes, uint32_t flags) { diff --git a/kernel/syscall.cpp b/kernel/syscall.cpp index 2dd82fc..80d8142 100644 --- a/kernel/syscall.cpp +++ b/kernel/syscall.cpp @@ -598,39 +598,6 @@ SYSCALL_IMPLEMENT(ES_SYSCALL_WINDOW_SET_BITS) { SYSCALL_RETURN(ES_SUCCESS, false); } -SYSCALL_IMPLEMENT(ES_SYSCALL_CLIPBOARD_ADD) { - SYSCALL_PERMISSION(ES_PERMISSION_WINDOW_MANAGER); - - if (argument0 != ES_CLIPBOARD_PRIMARY) { - SYSCALL_RETURN(ES_ERROR_INVALID_CLIPBOARD, false); - } - - EsError error = primaryClipboard.Add((uintptr_t) argument1, (const void *) argument2, argument3); - SYSCALL_RETURN(error, false); -} - -SYSCALL_IMPLEMENT(ES_SYSCALL_CLIPBOARD_HAS) { - SYSCALL_PERMISSION(ES_PERMISSION_WINDOW_MANAGER); - - if (argument0 != ES_CLIPBOARD_PRIMARY) { - SYSCALL_RETURN(ES_ERROR_INVALID_CLIPBOARD, false); - } - - bool result = primaryClipboard.Has((uintptr_t) argument1); - SYSCALL_RETURN(result, false); -} - -SYSCALL_IMPLEMENT(ES_SYSCALL_CLIPBOARD_READ) { - SYSCALL_PERMISSION(ES_PERMISSION_WINDOW_MANAGER); - - if (argument0 != ES_CLIPBOARD_PRIMARY) { - SYSCALL_RETURN(ES_ERROR_INVALID_CLIPBOARD, false); - } - - EsHandle handle = primaryClipboard.Read((uintptr_t) argument1, (size_t *) argument3, currentProcess); - SYSCALL_RETURN(handle, false); -} - SYSCALL_IMPLEMENT(ES_SYSCALL_EVENT_CREATE) { KEvent *event = (KEvent *) EsHeapAllocate(sizeof(KEvent), true, K_FIXED); if (!event) SYSCALL_RETURN(ES_ERROR_INSUFFICIENT_RESOURCES, false); @@ -793,19 +760,21 @@ SYSCALL_IMPLEMENT(ES_SYSCALL_MEMORY_SHARE) { SYSCALL_RETURN(process->handleTable.OpenHandle(region, argument2, KERNEL_OBJECT_SHMEM), false); } -#define SYSCALL_SHARE_OBJECT(syscallName, objectType) \ +#define SYSCALL_SHARE_OBJECT(syscallName, objectType, _sharedFlags) \ SYSCALL_IMPLEMENT(syscallName) { \ KObject share(currentProcess, argument0, objectType); \ CHECK_OBJECT(share); \ KObject _process(currentProcess, argument1, KERNEL_OBJECT_PROCESS); \ CHECK_OBJECT(_process); \ Process *process = (Process *) _process.object; \ - OpenHandleToObject(share.object, objectType, share.flags); \ - SYSCALL_RETURN(process->handleTable.OpenHandle(share.object, share.flags, objectType), false); \ + uint32_t sharedFlags = _sharedFlags; \ + if (!OpenHandleToObject(share.object, objectType, sharedFlags)) return ES_ERROR_FILE_PERMISSION_NOT_GRANTED; \ + SYSCALL_RETURN(process->handleTable.OpenHandle(share.object, sharedFlags, objectType), false); \ } -SYSCALL_SHARE_OBJECT(ES_SYSCALL_PROCESS_SHARE, KERNEL_OBJECT_PROCESS); -SYSCALL_SHARE_OBJECT(ES_SYSCALL_NODE_SHARE, KERNEL_OBJECT_NODE); +SYSCALL_SHARE_OBJECT(ES_SYSCALL_PROCESS_SHARE, KERNEL_OBJECT_PROCESS, share.flags); +SYSCALL_SHARE_OBJECT(ES_SYSCALL_NODE_SHARE, KERNEL_OBJECT_NODE, + (argument3 & 1) && (share.flags & (ES_FILE_WRITE | ES_FILE_WRITE_EXCLUSIVE)) ? ES_FILE_READ_SHARED : share.flags); SYSCALL_IMPLEMENT(ES_SYSCALL_VOLUME_GET_INFORMATION) { if (~currentProcess->permissions & ES_PERMISSION_GET_VOLUME_INFORMATION) { @@ -1530,23 +1499,38 @@ SYSCALL_IMPLEMENT(ES_SYSCALL_SCREEN_WORK_AREA_GET) { SYSCALL_IMPLEMENT(ES_SYSCALL_MESSAGE_DESKTOP) { char *buffer; - if (argument1 > SYSCALL_BUFFER_LIMIT) SYSCALL_RETURN(ES_FATAL_ERROR_INVALID_BUFFER, true); + if (argument1 > DESKTOP_MESSAGE_SIZE_LIMIT) SYSCALL_RETURN(ES_ERROR_INSUFFICIENT_RESOURCES, false); SYSCALL_READ_HEAP(buffer, argument0, argument1); KObject _window(currentProcess, argument2, KERNEL_OBJECT_EMBEDDED_WINDOW | KERNEL_OBJECT_NONE); CHECK_OBJECT(_window); + KObject _pipe(currentProcess, argument3, KERNEL_OBJECT_PIPE | KERNEL_OBJECT_NONE); + CHECK_OBJECT(_pipe); + EmbeddedWindow *window = (EmbeddedWindow *) _window.object; + Pipe *pipe = (Pipe *) _pipe.object; + + if (pipe && (~_pipe.flags & PIPE_WRITER)) { + SYSCALL_RETURN(ES_FATAL_ERROR_INCORRECT_FILE_ACCESS, true); + } if (!scheduler.shutdown) { + if (pipe) { + OpenHandleToObject(pipe, KERNEL_OBJECT_PIPE, PIPE_WRITER); + } + _EsMessageWithObject m = {}; m.message.type = ES_MSG_DESKTOP; m.message.desktop.buffer = MakeConstantBufferForDesktop(buffer, argument1); m.message.desktop.bytes = argument1; m.message.desktop.windowID = window ? window->id : 0; + m.message.desktop.processID = currentProcess->id; + m.message.desktop.pipe = pipe ? desktopProcess->handleTable.OpenHandle(pipe, PIPE_WRITER, KERNEL_OBJECT_PIPE) : ES_INVALID_HANDLE; - if (!desktopProcess->messageQueue.SendMessage(&m)) { - desktopProcess->handleTable.CloseHandle(m.message.desktop.buffer); // This will check that the handle is still valid. + if (!m.message.desktop.buffer || !desktopProcess->messageQueue.SendMessage(&m)) { + desktopProcess->handleTable.CloseHandle(m.message.desktop.buffer); + desktopProcess->handleTable.CloseHandle(m.message.desktop.pipe); } } diff --git a/kernel/windows.cpp b/kernel/windows.cpp index 250d6fd..91db296 100644 --- a/kernel/windows.cpp +++ b/kernel/windows.cpp @@ -139,24 +139,7 @@ struct WindowManager { // when set, the old surface bits are copied on resize, so that if the resize times out the result will be reasonable. }; -struct ClipboardItem { - uint64_t format; - ConstantBuffer *buffer; -}; - -struct Clipboard { - KMutex mutex; -#define CLIPBOARD_ITEM_COUNT (1) - ClipboardItem items[CLIPBOARD_ITEM_COUNT]; - -#define CLIPBOARD_ITEM_SIZE_LIMIT (64 * 1024 * 1024) - EsError Add(uint64_t format, K_USER_BUFFER const void *data, size_t dataBytes); - bool Has(uint64_t format); - EsHandle Read(uint64_t format, K_USER_BUFFER size_t *bytes, Process *process); -}; - WindowManager windowManager; -Clipboard primaryClipboard; void SendMessageToWindow(Window *window, EsMessage *message); @@ -247,7 +230,7 @@ void SendMessageToWindow(Window *window, EsMessage *message) { // 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); - } else if (message->type == ES_MSG_MOUSE_EXIT || message->type == ES_MSG_PRIMARY_CLIPBOARD_UPDATED) { + } else if (message->type == ES_MSG_MOUSE_EXIT) { window->embed->owner->messageQueue.SendMessage(window->embed->apiWindow, message); window->owner->messageQueue.SendMessage(window->apiWindow, message); } else { @@ -1339,70 +1322,4 @@ void KGameControllerUpdateState(EsGameControllerState *state) { KMutexRelease(&windowManager.gameControllersMutex); } -EsError Clipboard::Add(uint64_t format, const void *data, size_t dataBytes) { - if (dataBytes > CLIPBOARD_ITEM_SIZE_LIMIT) { - return ES_ERROR_INSUFFICIENT_RESOURCES; - } - - ClipboardItem item = {}; - item.buffer = MakeConstantBuffer(data, dataBytes); - item.format = format; - - if (!item.buffer) { - return ES_ERROR_INSUFFICIENT_RESOURCES; - } - - KMutexAcquire(&mutex); - - if (items[CLIPBOARD_ITEM_COUNT - 1].buffer) { - CloseHandleToObject(items[CLIPBOARD_ITEM_COUNT - 1].buffer, KERNEL_OBJECT_CONSTANT_BUFFER); - } - - EsMemoryMove(items, items + CLIPBOARD_ITEM_COUNT - 1, sizeof(ClipboardItem), false); - items[0] = item; - - KMutexRelease(&mutex); - - if (this == &primaryClipboard) { - KMutexAcquire(&windowManager.mutex); - - if (windowManager.activeWindow) { - EsMessage m; - EsMemoryZero(&m, sizeof(EsMessage)); - m.type = ES_MSG_PRIMARY_CLIPBOARD_UPDATED; - SendMessageToWindow(windowManager.activeWindow, &m); - } - - KMutexRelease(&windowManager.mutex); - } - - return ES_SUCCESS; -} - -bool Clipboard::Has(uint64_t format) { - KMutexAcquire(&mutex); - bool result = items[0].format == format; - KMutexRelease(&mutex); - return result; -} - -EsHandle Clipboard::Read(uint64_t format, K_USER_BUFFER size_t *_bytes, Process *process) { - ConstantBuffer *buffer = nullptr; - KMutexAcquire(&mutex); - - if (items[0].format == format) { - buffer = items[0].buffer; - OpenHandleToObject(buffer, KERNEL_OBJECT_CONSTANT_BUFFER); - } - - KMutexRelease(&mutex); - - if (buffer) { - *_bytes = buffer->bytes; - return process->handleTable.OpenHandle(buffer, 0, KERNEL_OBJECT_CONSTANT_BUFFER); - } else { - return ES_INVALID_HANDLE; - } -} - #endif diff --git a/util/api_table.ini b/util/api_table.ini index e1fec8d..6ca5965 100644 --- a/util/api_table.ini +++ b/util/api_table.ini @@ -126,6 +126,8 @@ EsApplicationStart=124 EsINIFormat=125 EsINIZeroTerminate=126 EsIconIDFromString=127 +EsPipeCreate=128 +EsPipeRead=129 EsListViewInsert=130 EsListViewRemove=131 EsEventCreate=132 @@ -145,6 +147,7 @@ EsSchedulerYield=145 EsSleep=146 EsSpinlockAcquire=147 EsSpinlockRelease=148 +EsPipeWrite=149 EsTimerSet=150 EsWait=151 EsCStringLength=152 @@ -306,6 +309,7 @@ EsUndoInUndo=307 EsUndoPop=308 EsTextboxSetUndoManager=309 EsListViewInsertGroup=310 +EsFileDelete=311 EsListViewRemoveAll=313 EsSystemShowShutdownDialog=314 EsListViewSetColumns=315