berkus
/
essence-os
mirror of https://gitlab.com/nakst/essence
1
0
Fork 0
Code Releases Activity

file based clipboard

This commit is contained in:
nakst 2021-08-19 11:21:01 +01:00
parent da515416bb
commit 9ad6930ac7
10 changed files with 282 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
desktop/api.cpp
View File

@ -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;

214
desktop/desktop.cpp
View File

@ -166,14 +166,23 @@ struct {
Array<ApplicationInstance *> allApplicationInstances;
Array<ContainerWindow *> allContainerWindows;
Array<EsMessageDevice> connectedDevices;
InstalledApplication *fileManager;
EsObjectID currentDocumentID;
HashStore<EsObjectID, OpenDocument> 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) {

2
desktop/gui.cpp
View File

@ -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);
}

20
desktop/os.header
View File

@ -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);

4
desktop/prefix.h
View File

@ -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

85
desktop/syscall.cpp
View File

@ -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);
}

21
desktop/text.cpp
View File

@ -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) {

66
kernel/syscall.cpp
View File

@ -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);
}
}

85
kernel/windows.cpp
View File

@ -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

4
util/api_table.ini
View File

@ -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