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

started Settings application

This commit is contained in:
nakst 2021-08-22 15:15:25 +01:00
parent 43df38e5a8
commit f245ef819d
18 changed files with 562 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
apps/image_editor.cpp
View File

@ -255,8 +255,8 @@ int BrushSizeMessage(EsElement *element, EsMessage *message) {
if (newValue < 1) {
newValue = 1;
} else if (newValue > 1000) {
newValue = 1000;
} else if (newValue > 200) {
newValue = 200;
}
char result[64];

14
desktop/api.cpp
View File

@ -361,7 +361,7 @@ uint8_t *ApplicationStartupInformationToBuffer(const EsApplicationStartupInforma
void EsApplicationStart(const EsApplicationStartupInformation *information) {
size_t bufferBytes;
uint8_t *buffer = ApplicationStartupInformationToBuffer(information, &bufferBytes);
EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) buffer, bufferBytes, 0, 0);
MessageDesktop(buffer, bufferBytes);
}
EsApplicationStartupInformation *ApplicationStartupInformationParse(const void *data, size_t dataBytes) {
@ -490,7 +490,7 @@ void _EsPathAnnouncePathMoved(EsInstance *instance, const char *oldPath, ptrdiff
EsMemoryCopy(buffer + 1 + sizeof(uintptr_t), &newPathBytes, sizeof(uintptr_t));
EsMemoryCopy(buffer + 1 + sizeof(uintptr_t) * 2, oldPath, oldPathBytes);
EsMemoryCopy(buffer + 1 + sizeof(uintptr_t) * 2 + oldPathBytes, newPath, newPathBytes);
EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) buffer, bufferBytes, instance->window->handle, 0);
MessageDesktop(buffer, bufferBytes, instance->window->handle);
EsHeapFree(buffer);
}
@ -499,13 +499,13 @@ void EsApplicationRunTemporary(EsInstance *instance, const char *path, ptrdiff_t
char *buffer = (char *) EsHeapAllocate(pathBytes + 1, false);
buffer[0] = DESKTOP_MSG_RUN_TEMPORARY_APPLICATION;
EsMemoryCopy(buffer + 1, path, pathBytes);
EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) buffer, pathBytes + 1, instance->window->handle, 0);
MessageDesktop(buffer, pathBytes + 1, instance->window->handle);
EsHeapFree(buffer);
}
void EsSystemShowShutdownDialog(EsInstance *instance) {
uint8_t message = DESKTOP_MSG_REQUEST_SHUTDOWN;
EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) &message, 1, instance->window->handle, 0);
MessageDesktop(&message, 1, instance->window->handle);
}
void InstanceSave(EsInstance *_instance) {
@ -515,7 +515,7 @@ void InstanceSave(EsInstance *_instance) {
char *buffer = (char *) EsHeapAllocate(bufferBytes, false);
buffer[0] = DESKTOP_MSG_REQUEST_SAVE;
EsMemoryCopy(buffer + 1, instance->editorSettings.newDocumentFileName, instance->editorSettings.newDocumentFileNameBytes);
EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) buffer, bufferBytes, _instance->window->handle, 0);
MessageDesktop(buffer, bufferBytes, _instance->window->handle);
EsHeapFree(buffer);
}
@ -604,7 +604,7 @@ APIInstance *InstanceSetup(EsInstance *instance) {
EsCommandSetCallback(&apiInstance->commandShowInFileManager, [] (EsInstance *instance, EsElement *, EsCommand *) {
char buffer[1];
buffer[0] = DESKTOP_MSG_SHOW_IN_FILE_MANAGER;
EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) buffer, 1, instance->window->handle, 0);
MessageDesktop(buffer, 1, instance->window->handle);
});
return apiInstance;
@ -973,7 +973,7 @@ void EsInstanceSaveComplete(EsMessage *message, bool success) {
if (instance) {
char buffer[1];
buffer[0] = DESKTOP_MSG_COMPLETE_SAVE;
EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) buffer, 1, instance->window->handle, 0);
MessageDesktop(buffer, 1, instance->window->handle);
if (success) {
EsCommandSetDisabled(EsCommandByID(instance, ES_COMMAND_SAVE), true);

114
desktop/desktop.cpp
View File

@ -113,6 +113,8 @@ struct InstalledApplication {
int64_t id;
uint32_t iconID;
bool hidden, useSingleProcess, temporary;
bool useSingleInstance;
struct ApplicationInstance *singleInstance;
uint64_t permissions;
size_t openInstanceCount; // Only used if useSingleProcess is true.
EsHandle singleProcessHandle;
@ -125,9 +127,6 @@ struct CrashedTabInstance : EsInstance {
struct BlankTabInstance : EsInstance {
};
struct SettingsInstance : EsInstance {
};
struct ApplicationInstance {
// User interface.
WindowTab *tab; // nullptr for notRespondingInstance.
@ -149,7 +148,7 @@ const EsStyle styleNewTabContent = {
.metrics = {
.mask = ES_THEME_METRICS_INSETS | ES_THEME_METRICS_GAP_MAJOR,
.insets = ES_RECT_4(50, 50, 50, 50),
.gapMajor = 30,
.gapMajor = 25,
},
};
@ -188,11 +187,13 @@ struct {
int TaskBarButtonMessage(EsElement *element, EsMessage *message);
ApplicationInstance *ApplicationInstanceCreate(int64_t id, EsApplicationStartupInformation *startupInformation, ContainerWindow *container, bool hidden = false);
void ApplicationInstanceStart(int64_t applicationID, EsApplicationStartupInformation *startupInformation, ApplicationInstance *instance);
bool ApplicationInstanceStart(int64_t applicationID, EsApplicationStartupInformation *startupInformation, ApplicationInstance *instance);
void ApplicationInstanceClose(ApplicationInstance *instance);
ApplicationInstance *ApplicationInstanceFindByWindowID(EsObjectID windowID, bool remove = false);
void EmbeddedWindowDestroyed(EsObjectID id);
#include "settings.cpp"
//////////////////////////////////////////////////////
// Reorder lists:
//////////////////////////////////////////////////////
@ -825,38 +826,22 @@ void InstanceBlankTabCreate(EsMessage *message) {
InstalledApplication *application = desktop.installedApplications[i];
if (application->hidden) continue;
EsButton *button = EsButtonCreate(buttonGroup, ES_CELL_H_FILL | ES_BUTTON_NOT_FOCUSABLE, ES_STYLE_BUTTON_GROUP_ITEM, application->cName);
EsButton *button = EsButtonCreate(buttonGroup, ES_CELL_H_FILL | ES_ELEMENT_NO_FOCUS_ON_CLICK, ES_STYLE_BUTTON_GROUP_ITEM, application->cName);
EsButtonSetIcon(button, (EsStandardIcon) application->iconID ?: ES_ICON_APPLICATION_DEFAULT_ICON);
button->userData = application;
EsButtonOnCommand(button, [] (EsInstance *, EsElement *element, EsCommand *) {
EsObjectID tabID = EsSyscall(ES_SYSCALL_WINDOW_GET_ID, element->window->handle, 0, 0, 0);
ApplicationInstance *instance = ApplicationInstanceFindByWindowID(tabID);
ApplicationInstanceStart(((InstalledApplication *) element->userData.p)->id, nullptr, instance);
WindowTabActivate(instance->tab, true);
EsInstanceDestroy(element->instance);
if (ApplicationInstanceStart(((InstalledApplication *) element->userData.p)->id, nullptr, instance)) {
WindowTabActivate(instance->tab, true);
EsInstanceDestroy(element->instance);
}
});
}
}
void InstanceSettingsCreate(EsMessage *message) {
// TODO.
EsInstance *instance = _EsInstanceCreate(sizeof(SettingsInstance), message, nullptr);
EsWindowSetTitle(instance->window, INTERFACE_STRING(DesktopSettingsTitle));
EsWindowSetIcon(instance->window, ES_ICON_PREFERENCES_DESKTOP);
EsPanel *windowBackground = EsPanelCreate(instance->window, ES_CELL_FILL, ES_STYLE_PANEL_WINDOW_BACKGROUND);
EsPanel *content = EsPanelCreate(windowBackground, ES_CELL_FILL | ES_PANEL_V_SCROLL_AUTO, &styleNewTabContent);
EsPanel *buttonGroup;
buttonGroup = EsPanelCreate(content, ES_PANEL_VERTICAL | ES_CELL_H_SHRINK, &styleButtonGroupContainer);
buttonGroup->separatorStylePart = ES_STYLE_BUTTON_GROUP_SEPARATOR;
buttonGroup->separatorFlags = ES_CELL_H_FILL;
EsButton *button = EsButtonCreate(buttonGroup, ES_CELL_H_FILL | ES_BUTTON_NOT_FOCUSABLE, ES_STYLE_BUTTON_GROUP_ITEM, "Keyboard");
EsButtonSetIcon(button, ES_ICON_PREFERENCES_DESKTOP_KEYBOARD);
}
//////////////////////////////////////////////////////
// Application management:
//////////////////////////////////////////////////////
@ -884,7 +869,27 @@ void ApplicationInstanceClose(ApplicationInstance *instance) {
EsMessagePostRemote(instance->processHandle, &m);
}
void ApplicationInstanceStart(int64_t applicationID, EsApplicationStartupInformation *startupInformation, ApplicationInstance *instance) {
bool ApplicationInstanceStart(int64_t applicationID, EsApplicationStartupInformation *startupInformation, ApplicationInstance *instance) {
InstalledApplication *application = nullptr;
for (uintptr_t i = 0; i < desktop.installedApplications.Length(); i++) {
if (desktop.installedApplications[i]->id == applicationID) {
application = desktop.installedApplications[i];
}
}
if (application && application->useSingleInstance && application->singleInstance) {
WindowTabActivate(application->singleInstance->tab);
EsSyscall(ES_SYSCALL_WINDOW_SET_PROPERTY, application->singleInstance->tab->window->handle, 0, 0, ES_WINDOW_PROPERTY_FOCUSED);
return false;
}
if (!application) {
EsApplicationStartupInformation s = {};
s.data = CRASHED_TAB_PROGRAM_NOT_FOUND;
return ApplicationInstanceStart(APPLICATION_ID_DESKTOP_CRASHED, &s, instance);
}
EsApplicationStartupInformation _startupInformation = {};
if (!startupInformation) {
@ -902,21 +907,6 @@ void ApplicationInstanceStart(int64_t applicationID, EsApplicationStartupInforma
instance->processHandle = ES_INVALID_HANDLE;
}
InstalledApplication *application = nullptr;
for (uintptr_t i = 0; i < desktop.installedApplications.Length(); i++) {
if (desktop.installedApplications[i]->id == applicationID) {
application = desktop.installedApplications[i];
}
}
if (!application) {
EsApplicationStartupInformation s = {};
s.data = CRASHED_TAB_PROGRAM_NOT_FOUND;
ApplicationInstanceStart(APPLICATION_ID_DESKTOP_CRASHED, &s, instance);
return;
}
instance->application = application;
if (application->useSingleProcess && application->singleProcessHandle) {
@ -944,8 +934,7 @@ void ApplicationInstanceStart(int64_t applicationID, EsApplicationStartupInforma
if (ES_CHECK_ERROR(error)) {
EsApplicationStartupInformation s = {};
s.data = CRASHED_TAB_INVALID_EXECUTABLE;
ApplicationInstanceStart(APPLICATION_ID_DESKTOP_CRASHED, &s, instance);
return;
return ApplicationInstanceStart(APPLICATION_ID_DESKTOP_CRASHED, &s, instance);
}
arguments.executable = executableNode.handle;
@ -1016,8 +1005,7 @@ void ApplicationInstanceStart(int64_t applicationID, EsApplicationStartupInforma
} else {
EsApplicationStartupInformation s = {};
s.data = CRASHED_TAB_INVALID_EXECUTABLE;
ApplicationInstanceStart(APPLICATION_ID_DESKTOP_CRASHED, &s, instance);
return;
return ApplicationInstanceStart(APPLICATION_ID_DESKTOP_CRASHED, &s, instance);
}
}
@ -1073,6 +1061,12 @@ void ApplicationInstanceStart(int64_t applicationID, EsApplicationStartupInforma
application->openInstanceCount++;
}
}
if (application->useSingleInstance) {
application->singleInstance = instance;
}
return true;
}
ApplicationInstance *ApplicationInstanceCreate(int64_t id, EsApplicationStartupInformation *startupInformation, ContainerWindow *container, bool hidden) {
@ -1131,6 +1125,7 @@ void ApplicationInstanceCrashed(EsMessage *message) {
&& EsProcessGetID(desktop.installedApplications[i]->singleProcessHandle) == message->crash.pid) {
EsHandleClose(desktop.installedApplications[i]->singleProcessHandle);
desktop.installedApplications[i]->singleProcessHandle = ES_INVALID_HANDLE;
desktop.installedApplications[i]->singleInstance = nullptr;
desktop.installedApplications[i]->openInstanceCount = 0;
ApplicationTemporaryDestroy(desktop.installedApplications[i]);
break;
@ -1157,6 +1152,7 @@ void ApplicationProcessTerminated(EsObjectID pid) {
&& EsProcessGetID(desktop.installedApplications[i]->singleProcessHandle) == pid) {
EsHandleClose(desktop.installedApplications[i]->singleProcessHandle);
desktop.installedApplications[i]->singleProcessHandle = ES_INVALID_HANDLE;
desktop.installedApplications[i]->singleInstance = nullptr;
desktop.installedApplications[i]->openInstanceCount = 0;
ApplicationTemporaryDestroy(desktop.installedApplications[i]);
break;
@ -1453,6 +1449,7 @@ void ConfigurationLoad() {
application->id = APPLICATION_ID_DESKTOP_SETTINGS;
application->iconID = ES_ICON_PREFERENCES_DESKTOP;
application->createInstance = InstanceSettingsCreate;
application->useSingleInstance = true;
desktop.installedApplications.Add(application);
}
@ -1801,13 +1798,13 @@ void DesktopSetup() {
desktop.setupDesktopUIComplete = true;
}
void DesktopMessage2(EsMessage *message, uint8_t *buffer) {
void DesktopMessage2(EsMessage *message, uint8_t *buffer, EsBuffer *pipe) {
ApplicationInstance *instance = ApplicationInstanceFindByWindowID(message->desktop.windowID);
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) {
} else if (buffer[0] == DESKTOP_MSG_CREATE_CLIPBOARD_FILE && pipe) {
EsHandle processHandle = EsProcessOpen(message->desktop.processID);
if (processHandle) {
@ -1831,8 +1828,8 @@ void DesktopMessage2(EsMessage *message, uint8_t *buffer) {
handle = ES_INVALID_HANDLE;
}
EsPipeWrite(message->desktop.pipe, &handle, sizeof(handle));
EsPipeWrite(message->desktop.pipe, &error, sizeof(error));
EsBufferWrite(pipe, &handle, sizeof(handle));
EsBufferWrite(pipe, &error, sizeof(error));
EsHandleClose(processHandle);
}
@ -1862,14 +1859,14 @@ void DesktopMessage2(EsMessage *message, uint8_t *buffer) {
desktop.nextClipboardFile = ES_INVALID_HANDLE;
desktop.nextClipboardProcessID = 0;
} else if (buffer[0] == DESKTOP_MSG_CLIPBOARD_GET && message->desktop.pipe) {
} else if (buffer[0] == DESKTOP_MSG_CLIPBOARD_GET && 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));
EsBufferWrite(pipe, &desktop.clipboardInformation, sizeof(desktop.clipboardInformation));
EsBufferWrite(pipe, &fileHandle, sizeof(fileHandle));
EsHandleClose(processHandle);
}
} else if (!instance) {
@ -1946,6 +1943,10 @@ void EmbeddedWindowDestroyed(EsObjectID id) {
InstalledApplication *application = instance->application;
if (application && application->singleInstance) {
application->singleInstance = nullptr;
}
if (application && application->singleProcessHandle) {
EsAssert(application->openInstanceCount);
application->openInstanceCount--;
@ -1995,7 +1996,10 @@ void DesktopMessage(EsMessage *message) {
if (buffer) {
EsConstantBufferRead(message->desktop.buffer, buffer);
DesktopMessage2(message, buffer);
EsBuffer pipe = { .canGrow = true };
DesktopMessage2(message, buffer, &pipe);
if (message->desktop.pipe) EsPipeWrite(message->desktop.pipe, pipe.out, pipe.position);
EsHeapFree(pipe.out);
EsHeapFree(buffer);
}

122
desktop/gui.cpp
View File

@ -27,7 +27,7 @@ struct AccessKeyEntry {
char character;
int number;
EsElement *element;
int x, y;
EsRectangle bounds;
};
struct {
@ -1310,8 +1310,8 @@ void UIDrawTransitionEffect(EsPainter *painter, EsPaintTarget *sourceSurface, Es
EsDrawPaintTarget(painter, sourceSurface, destinationRegion, sourceRegion, alpha);
}
void EsElementStartTransition(EsElement *element, EsTransitionType transitionType, uint32_t flags, uint32_t durationMs) {
durationMs *= ANIMATION_TIME_SCALE;
void EsElementStartTransition(EsElement *element, EsTransitionType transitionType, uint32_t flags, float timeMultiplier) {
uint32_t durationMs = timeMultiplier * GetConstantNumber("transitionTime");
if (!durationMs) {
return;
@ -3400,10 +3400,11 @@ void EsPanelTableSetChildCells(EsPanel *panel) {
}
}
void EsPanelSwitchTo(EsPanel *panel, EsElement *targetChild, EsTransitionType transitionType, uint32_t flags, uint32_t timeMs) {
void EsPanelSwitchTo(EsPanel *panel, EsElement *targetChild, EsTransitionType transitionType, uint32_t flags, float timeMultiplier) {
EsMessageMutexCheck();
EsAssert(targetChild->parent == panel);
EsAssert(panel->flags & ES_PANEL_SWITCHER); // Cannot switch element for a non-switcher panel.
timeMs *= ANIMATION_TIME_SCALE;
uint32_t timeMs = timeMultiplier * GetConstantNumber("transitionTime");
if (targetChild == panel->switchedTo) {
return;
@ -3441,10 +3442,10 @@ void EsPanelSwitchTo(EsPanel *panel, EsElement *targetChild, EsTransitionType tr
EsElementRelayout(panel);
}
void EsPanelStartMovementAnimation(EsPanel *panel, uint32_t timeMs) {
void EsPanelStartMovementAnimation(EsPanel *panel, float timeMultiplier) {
// TODO Custom smoothing functions.
timeMs *= ANIMATION_TIME_SCALE;
uint32_t timeMs = timeMultiplier * GetConstantNumber("transitionTime");
if (!timeMs) return;
EsMessageMutexCheck();
EsAssert(~panel->flags & ES_PANEL_SWITCHER); // Use EsPanelSwitchTo!
@ -5126,7 +5127,7 @@ void EsWindowSetIcon(EsWindow *window, uint32_t iconID) {
char buffer[5];
buffer[0] = DESKTOP_MSG_SET_ICON;
EsMemoryCopy(buffer + 1, &iconID, sizeof(uint32_t));
EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) buffer, sizeof(buffer), window->handle, 0);
MessageDesktop(buffer, sizeof(buffer), window->handle);
}
void EsWindowSetTitle(EsWindow *window, const char *title, ptrdiff_t titleBytes) {
@ -5150,7 +5151,7 @@ void EsWindowSetTitle(EsWindow *window, const char *title, ptrdiff_t titleBytes)
char buffer[4096];
size_t bytes = EsStringFormat(buffer, 4096, "%c%s%s", DESKTOP_MSG_SET_TITLE, titleBytes, title, applicationNameBytes, applicationName);
EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) buffer, bytes, window->handle, 0);
MessageDesktop(buffer, bytes, window->handle);
}
void EsMouseSetPosition(EsWindow *relativeWindow, int x, int y) {
@ -5882,15 +5883,44 @@ void AccessKeysGather(EsElement *element) {
entry.number = gui.accessKeys.numbers[entry.character - 'A'];
entry.element = element;
if (entry.number >= 10) return;
UIStyle *style = gui.accessKeys.hintStyle;
int x, y;
if (element->flags & ES_ELEMENT_CENTER_ACCESS_KEY_HINT) {
entry.x = (bounds.l + bounds.r) / 2;
entry.y = (bounds.t + bounds.b) / 2;
x = (bounds.l + bounds.r) / 2;
y = (bounds.t + bounds.b) / 2 - style->preferredHeight / 4;
} else {
entry.x = (bounds.l + bounds.r) / 2;
entry.y = bounds.b;
x = (bounds.l + bounds.r) / 2;
y = bounds.b;
}
if (entry.number >= 10) return;
EsRectangle hintBounds = ES_RECT_4(x - style->preferredWidth / 2, x + style->preferredWidth / 2,
y - style->preferredHeight / 4, y + 3 * style->preferredHeight / 4);
if (hintBounds.r > (int32_t) gui.accessKeys.window->windowWidth) {
hintBounds.l = gui.accessKeys.window->windowWidth - style->preferredWidth;
hintBounds.r = hintBounds.l + style->preferredWidth;
}
if (hintBounds.l < 0) {
hintBounds.l = 0;
hintBounds.r = hintBounds.l + style->preferredWidth;
}
if (hintBounds.b > (int32_t) gui.accessKeys.window->windowHeight) {
hintBounds.t = gui.accessKeys.window->windowHeight - style->preferredHeight;
hintBounds.b = hintBounds.t + style->preferredHeight;
}
if (hintBounds.t < 0) {
hintBounds.t = 0;
hintBounds.b = hintBounds.t + style->preferredHeight;
}
entry.bounds = hintBounds;
gui.accessKeys.entries.Add(entry);
gui.accessKeys.numbers[entry.character - 'A']++;
@ -5905,41 +5935,9 @@ void AccessKeyHintsShow(EsPainter *painter) {
continue;
}
EsRectangle bounds = ES_RECT_4(
entry->x - style->preferredWidth / 2,
entry->x + style->preferredWidth / 2,
entry->y - style->preferredHeight / 4,
entry->y + 3 * style->preferredHeight / 4);
if (entry->element->flags & ES_ELEMENT_CENTER_ACCESS_KEY_HINT) {
bounds.t -= style->preferredHeight / 4;
bounds.b -= style->preferredHeight / 4;
}
if (bounds.r > (int32_t) gui.accessKeys.window->windowWidth) {
bounds.l = gui.accessKeys.window->windowWidth - style->preferredWidth;
bounds.r = bounds.l + style->preferredWidth;
}
if (bounds.l < 0) {
bounds.l = 0;
bounds.r = bounds.l + style->preferredWidth;
}
if (bounds.b > (int32_t) gui.accessKeys.window->windowHeight) {
bounds.t = gui.accessKeys.window->windowHeight - style->preferredHeight;
bounds.b = bounds.t + style->preferredHeight;
}
if (bounds.t < 0) {
bounds.t = 0;
bounds.b = bounds.t + style->preferredHeight;
}
style->PaintLayers(painter, bounds, 0, THEME_LAYER_MODE_BACKGROUND);
style->PaintLayers(painter, entry->bounds, 0, THEME_LAYER_MODE_BACKGROUND);
char c = gui.accessKeys.typedCharacter ? entry->number + '0' : entry->character;
style->PaintText(painter, nullptr, bounds, &c, 1, 0, ES_FLAGS_DEFAULT);
style->PaintText(painter, nullptr, entry->bounds, &c, 1, 0, ES_FLAGS_DEFAULT);
}
}
@ -5956,20 +5954,20 @@ void AccessKeyModeEnter(EsWindow *window) {
return;
}
gui.accessKeyMode = true;
AccessKeysGather(window);
if (!gui.accessKeys.hintStyle) {
gui.accessKeys.hintStyle = GetStyle(MakeStyleKey(ES_STYLE_ACCESS_KEY_HINT, 0), false);
}
gui.accessKeyMode = true;
gui.accessKeys.window = window;
AccessKeysGather(window);
for (uintptr_t i = 0; i < gui.accessKeys.entries.Length(); i++) {
if (gui.accessKeys.numbers[gui.accessKeys.entries[i].character - 'A'] == 1) {
gui.accessKeys.entries[i].number = -1;
}
}
gui.accessKeys.window = window;
window->Repaint(true);
}
@ -5987,6 +5985,10 @@ void AccessKeyModeExit() {
}
void AccessKeyModeHandleKeyPress(EsMessage *message) {
if (message->type == ES_MSG_KEY_UP) {
return;
}
int ic, isc;
ConvertScancodeToCharacter(message->keyboard.scancode, &ic, &isc, false, false);
ic = EsCRTtoupper(ic);
@ -6090,13 +6092,9 @@ void UIHandleKeyMessage(EsWindow *window, EsMessage *message) {
// TODO Up/down to traverse menu.
// TODO Enter to open submenu/invoke item.
return;
} else if (gui.accessKeyMode) {
if (gui.accessKeys.window != window) {
AccessKeyModeExit();
} else {
AccessKeyModeHandleKeyPress(message);
return;
}
} else if (gui.accessKeyMode && gui.accessKeys.window == window) {
AccessKeyModeHandleKeyPress(message);
return;
}
if (window->pressed) {
@ -6425,7 +6423,7 @@ void UIProcessWindowManagerMessage(EsWindow *window, EsMessage *message, Process
message->mouseDown.positionY -= bounds.t;
if (ES_REJECTED != UIMessageSendPropagateToAncestors(element, message, &window->dragged)) {
if (window->dragged) {
if (window->dragged && (~window->dragged->flags & ES_ELEMENT_NO_FOCUS_ON_CLICK)) {
EsElementFocus(window->dragged, false);
}
}
@ -6500,6 +6498,10 @@ void UIProcessWindowManagerMessage(EsWindow *window, EsMessage *message, Process
window->receivedFirstResize = true;
if (!window->width || !window->height) {
UIRefreshPrimaryClipboard(window); // Embedded window activated.
}
window->width = window->windowWidth = message->windowResized.content.r;
window->height = window->windowHeight = message->windowResized.content.b;

46
desktop/os.header
View File

@ -327,14 +327,12 @@ define ES_ERROR_NODE_NOT_LOADED (-71)
define ES_ERROR_DIRECTORY_ENTRY_BEING_REMOVED (-72)
define ES_SYSTEM_CONSTANT_TIME_STAMP_UNITS_PER_MICROSECOND (0)
define ES_SYSTEM_CONSTANT_NO_FANCY_GRAPHICS (1)
define ES_SYSTEM_CONSTANT_RIGHT_TO_LEFT (2)
define ES_SYSTEM_CONSTANT_WINDOW_INSET (3)
define ES_SYSTEM_CONSTANT_CONTAINER_TAB_BAND_HEIGHT (4)
define ES_SYSTEM_CONSTANT_UI_SCALE (5)
define ES_SYSTEM_CONSTANT_BORDER_THICKNESS (6)
define ES_SYSTEM_CONSTANT_OPTIMAL_WORK_QUEUE_THREAD_COUNT (7)
define ES_SYSTEM_CONSTANT_COUNT (8)
define ES_SYSTEM_CONSTANT_OPTIMAL_WORK_QUEUE_THREAD_COUNT (1)
define ES_SYSTEM_CONSTANT_WINDOW_INSET (2)
define ES_SYSTEM_CONSTANT_CONTAINER_TAB_BAND_HEIGHT (3)
define ES_SYSTEM_CONSTANT_UI_SCALE (4)
define ES_SYSTEM_CONSTANT_BORDER_THICKNESS (5)
define ES_SYSTEM_CONSTANT_COUNT (6)
define ES_INVALID_HANDLE ((EsHandle) (0))
define ES_CURRENT_THREAD ((EsHandle) (0x10))
@ -437,11 +435,12 @@ define ES_ELEMENT_NO_HOVER ((_EsLongConstant) (1) << 37) // For z-stacked elem
define ES_ELEMENT_NO_HOVER_DESCENDENTS ((_EsLongConstant) (1) << 38) // Prevent hovering over any descendents.
define ES_ELEMENT_BLOCK_FOCUS ((_EsLongConstant) (1) << 39) // This element and descendents cannot take focus.
define ES_ELEMENT_NOT_TAB_TRAVERSABLE ((_EsLongConstant) (1) << 40) // Use with ES_ELEMENT_FOCUSABLE to indicate the element cannot be focused from tab traversal.
define ES_ELEMENT_CENTER_ACCESS_KEY_HINT ((_EsLongConstant) (1) << 41) // TODO Make this more customizable with a message perhaps?
define ES_ELEMENT_LAYOUT_HINT_HORIZONTAL ((_EsLongConstant) (1) << 42) // Hint for autoCorners and autoBorders.
define ES_ELEMENT_LAYOUT_HINT_REVERSE ((_EsLongConstant) (1) << 43) // Hint for autoCorners and autoBorders; and tab traversal.
define ES_ELEMENT_STICKY_ACCESS_KEY ((_EsLongConstant) (1) << 44) // Don't exit access key mode after using the access key.
define ES_ELEMENT_NON_CLIENT ((_EsLongConstant) (1) << 45)
define ES_ELEMENT_NO_FOCUS_ON_CLICK ((_EsLongConstant) (1) << 41) // Use with ES_ELEMENT_FOCUSABLE to indicate the element cannot be focused by clicking it.
define ES_ELEMENT_CENTER_ACCESS_KEY_HINT ((_EsLongConstant) (1) << 42)
define ES_ELEMENT_LAYOUT_HINT_HORIZONTAL ((_EsLongConstant) (1) << 43) // Hint for autoCorners and autoBorders.
define ES_ELEMENT_LAYOUT_HINT_REVERSE ((_EsLongConstant) (1) << 44) // Hint for autoCorners and autoBorders; and tab traversal.
define ES_ELEMENT_STICKY_ACCESS_KEY ((_EsLongConstant) (1) << 45) // Don't exit access key mode after using the access key.
define ES_ELEMENT_NON_CLIENT ((_EsLongConstant) (1) << 46)
// For children of splitters:
define ES_CELL_COLLAPSABLE ((_EsLongConstant) (1) << 51)
@ -924,6 +923,7 @@ enum EsMessageType {
// This will NOT be sent if the element did not handle LEFT_DOWN.
ES_MSG_MOUSE_RIGHT_DRAG = 0x2027 // Similar to LEFT_DRAG above, but for the right button.
ES_MSG_MOUSE_MIDDLE_DRAG = 0x2028 // Similar to LEFT_DRAG above, but for the middle button.
ES_MSG_GET_ACCESS_KEY_HINT_BOUNDS = 0x2029 // Get the bounds to display an access key hint.
// State change messages: (causes a style refresh)
ES_MSG_STATE_CHANGE_MESSAGE_START = 0x2080
@ -1110,7 +1110,9 @@ enum EsDeviceType {
ES_DEVICE_GRAPHICS_TARGET
ES_DEVICE_BLOCK
ES_DEVICE_AUDIO
ES_DEVICE_HID
ES_DEVICE_KEYBOARD
ES_DEVICE_MOUSE
ES_DEVICE_GAME_CONTROLLER
ES_DEVICE_NETWORK_CARD
ES_DEVICE_USB
ES_DEVICE_PCI_FUNCTION
@ -1752,14 +1754,15 @@ struct EsMessage {
EsMessageLayout layout;
EsMessageMeasure measure;
EsMessageHitTest hitTest;
EsPainter *painter;
EsElement *child;
EsCursorStyle cursorStyle;
EsMessageZOrder zOrder;
EsMessageBeforeZOrder beforeZOrder;
EsMessageItemToString itemToString;
EsMessageFocus focus;
const EsStyle *childStyleVariant;
EsRectangle *accessKeyHintBounds;
EsPainter *painter;
EsElement *child;
EsCursorStyle cursorStyle;
// List view messages:
EsMessageIterateIndex iterateIndex;
@ -1952,6 +1955,7 @@ function void EsArenaFree(EsArena *arena, void *pointer); // Not thread-safe.
function void EsArenaInitialise(EsArena *arena, size_t blockSize, size_t itemSize);
function const void *EsBufferRead(struct EsBuffer *buffer, size_t readBytes);
function bool EsBufferReadInto(struct EsBuffer *buffer, void *destination, size_t readBytes);
function const void *EsBufferReadMany(struct EsBuffer *buffer, size_t a, size_t b);
function void *EsBufferWrite(EsBuffer *buffer, const void *source, size_t writeBytes);
function void EsBufferFormat(EsBuffer *buffer, EsCString format, ...); // Appends.
@ -2092,7 +2096,7 @@ function bool EsMouseIsMiddleHeld();
// Pipes.
function EsHandle EsPipeCreate();
function void EsPipeCreate(EsHandle *readEnd, EsHandle *writeEnd);
function size_t EsPipeRead(EsHandle pipe, void *buffer, size_t bytes);
function size_t EsPipeWrite(EsHandle pipe, const void *buffer, size_t bytes);
@ -2262,7 +2266,7 @@ function EsElement *EsElementGetLayoutParent(EsElement *element);
function void EsElementDestroy(EsElement *element);
function void EsElementDestroyContents(EsElement *element);
function bool EsElementStartAnimating(EsElement *element); // Returns false if the element was already animating.
function void EsElementStartTransition(EsElement *element, EsTransitionType transitionType, uint32_t flags = ES_FLAGS_DEFAULT, uint32_t timeMs = 150); // TODO More customization.
function void EsElementStartTransition(EsElement *element, EsTransitionType transitionType, uint32_t flags = ES_FLAGS_DEFAULT, float timeMultiplier = 1); // TODO More customization.
function void EsElementInsertAfter(EsElement *element); // The next element created will be inserted after this element. They must have the same parent. Or, if this is the parent of the next element created, then it will be inserted at the start of the parent.
function void EsElementUpdateContentSize(EsElement *element, uint32_t flags = ES_FLAGS_DEFAULT);
function void EsElementGetTextStyle(EsElement *element, EsTextStyle *style);
@ -2343,8 +2347,8 @@ function void EsPanelSetBands(EsPanel *panel, size_t columnCount, size_t rowCoun
function void EsPanelSetBandsAll(EsPanel *panel, EsPanelBand *column = ES_NULL, EsPanelBand *row = ES_NULL); // Set all the columns/rows to have the same properties. This must be called after the final number of bands has been determined/set!
function void EsPanelTableSetChildCells(EsPanel *panel); // Automatically set the child cells for items in a table. This is only necessary if the number of columns/rows is changed after adding items to a table.
function void EsPanelSwitchTo(EsPanel *panel, EsElement *targetChild, EsTransitionType transitionType, uint32_t flags = ES_FLAGS_DEFAULT, uint32_t timeMs = 150); // TODO More customization of transitions?
function void EsPanelStartMovementAnimation(EsPanel *panel, uint32_t timeMs = 150); // TODO More customization.
function void EsPanelSwitchTo(EsPanel *panel, EsElement *targetChild, EsTransitionType transitionType, uint32_t flags = ES_FLAGS_DEFAULT, float timeMultiplier = 1); // TODO More customization of transitions?
function void EsPanelStartMovementAnimation(EsPanel *panel, float timeMultiplier = 1); // TODO More customization.
// Static displays.

263
desktop/settings.cpp Normal file
View File

@ -0,0 +1,263 @@
struct SettingsInstance : EsInstance {
EsPanel *switcher;
EsPanel *mainPage;
};
const EsStyle styleSettingsGroupContainer = {
.inherit = ES_STYLE_BUTTON_GROUP_CONTAINER,
.metrics = {
.mask = ES_THEME_METRICS_PREFERRED_WIDTH | ES_THEME_METRICS_INSETS,
.insets = ES_RECT_1(5),
.preferredWidth = 400,
},
};
const EsStyle styleSettingsGroupContainer2 = {
.inherit = ES_STYLE_BUTTON_GROUP_CONTAINER,
.metrics = {
.mask = ES_THEME_METRICS_PREFERRED_WIDTH | ES_THEME_METRICS_INSETS | ES_THEME_METRICS_GAP_MAJOR,
.insets = ES_RECT_1(15),
.preferredWidth = 400,
.gapMajor = 15,
},
};
const EsStyle styleSettingsNumberTextbox = {
.inherit = ES_STYLE_TEXTBOX_BORDERED_SINGLE,
.metrics = {
.mask = ES_THEME_METRICS_PREFERRED_WIDTH,
.preferredWidth = 80,
},
};
const EsStyle styleSettingsTable = {
.metrics = {
.mask = ES_THEME_METRICS_GAP_MAJOR | ES_THEME_METRICS_GAP_MINOR,
.gapMajor = 5,
.gapMinor = 5,
},
};
const EsStyle styleSettingsCheckboxGroup = {
.metrics = {
.mask = ES_THEME_METRICS_GAP_MAJOR | ES_THEME_METRICS_GAP_MINOR,
.gapMajor = 0,
.gapMinor = 0,
},
};
const EsStyle styleSettingsOverlayPanel = {
.metrics = {
.mask = ES_THEME_METRICS_INSETS,
.insets = ES_RECT_1(10),
},
};
const EsStyle styleSettingsButton = {
.inherit = ES_STYLE_PUSH_BUTTON_TOOLBAR,
.metrics = {
.mask = ES_THEME_METRICS_PREFERRED_WIDTH | ES_THEME_METRICS_PREFERRED_HEIGHT | ES_THEME_METRICS_LAYOUT_VERTICAL
| ES_THEME_METRICS_GAP_ALL | ES_THEME_METRICS_TEXT_ALIGN | ES_THEME_METRICS_INSETS | ES_THEME_METRICS_ICON_SIZE,
.insets = ES_RECT_2(0, 10),
.preferredWidth = 0,
.preferredHeight = 75,
.gapMajor = 3,
.gapMinor = 3,
.gapWrap = 3,
.textAlign = ES_TEXT_H_CENTER,
.iconSize = 32,
.layoutVertical = true,
},
};
struct SettingsPage {
const char *string;
ptrdiff_t stringBytes;
uint32_t iconID;
void (*create)(EsElement *parent, SettingsPage *page);
char accessKey;
};
void SettingsBackButton(EsInstance *_instance, EsElement *, EsCommand *) {
SettingsInstance *instance = (SettingsInstance *) _instance;
EsPanelSwitchTo(instance->switcher, instance->mainPage, ES_TRANSITION_ZOOM_OUT, ES_PANEL_SWITCHER_DESTROY_PREVIOUS_AFTER_TRANSITION, 1.0f);
}
void SettingsPageAddTitle(EsElement *container, SettingsPage *page) {
EsPanel *row = EsPanelCreate(container, ES_CELL_H_FILL | ES_PANEL_HORIZONTAL);
EsIconDisplayCreate(row, ES_FLAGS_DEFAULT, ES_STYLE_ICON_DISPLAY, page->iconID);
EsSpacerCreate(row, ES_FLAGS_DEFAULT, 0, 10, 0);
EsTextDisplayCreate(row, ES_CELL_H_FILL, ES_STYLE_TEXT_HEADING2, page->string, page->stringBytes);
}
void SettingsPageAddUndoButton(EsElement *stack) {
EsPanel *overlay = EsPanelCreate(stack, ES_CELL_H_RIGHT | ES_CELL_V_TOP, &styleSettingsOverlayPanel);
EsButton *undoButton = EsButtonCreate(overlay, ES_BUTTON_TOOLBAR, 0, INTERFACE_STRING(DesktopSettingsUndoButton));
undoButton->accessKey = 'U';
EsButtonSetIcon(undoButton, ES_ICON_EDIT_UNDO_SYMBOLIC);
EsElementSetDisabled(undoButton, true);
}
void SettingsPageUnimplemented(EsElement *element, SettingsPage *page) {
EsPanel *content = EsPanelCreate(element, ES_CELL_FILL | ES_PANEL_V_SCROLL_AUTO, &styleNewTabContent);
EsPanel *container = EsPanelCreate(content, ES_PANEL_VERTICAL | ES_CELL_H_SHRINK, &styleSettingsGroupContainer2);
SettingsPageAddTitle(container, page);
EsTextDisplayCreate(container, ES_CELL_H_CENTER, 0, "Work in progress" ELLIPSIS);
}
void SettingsPageMouse(EsElement *element, SettingsPage *page) {
// TODO Make this interactive.
SettingsPageAddUndoButton(element);
EsPanel *content = EsPanelCreate(element, ES_CELL_FILL | ES_PANEL_V_SCROLL_AUTO, &styleNewTabContent);
EsPanel *container = EsPanelCreate(content, ES_PANEL_VERTICAL | ES_CELL_H_SHRINK, &styleSettingsGroupContainer2);
SettingsPageAddTitle(container, page);
EsPanel *table = EsPanelCreate(container, ES_CELL_H_FILL | ES_PANEL_TABLE | ES_PANEL_HORIZONTAL, &styleSettingsTable);
EsPanelSetBands(table, 2);
EsTextbox *textbox;
EsTextDisplayCreate(table, ES_CELL_H_RIGHT | ES_CELL_H_PUSH, 0, INTERFACE_STRING(DesktopSettingsMouseDoubleClickSpeed));
textbox = EsTextboxCreate(table, ES_CELL_H_LEFT | ES_CELL_H_PUSH | ES_TEXTBOX_EDIT_BASED, &styleSettingsNumberTextbox);
textbox->accessKey = 'D';
EsTextboxUseNumberOverlay(textbox, false);
EsTextboxInsert(textbox, "500 ms");
EsTextDisplayCreate(table, ES_CELL_H_RIGHT | ES_CELL_H_PUSH, 0, INTERFACE_STRING(DesktopSettingsMouseSpeed));
textbox = EsTextboxCreate(table, ES_CELL_H_LEFT | ES_CELL_H_PUSH | ES_TEXTBOX_EDIT_BASED, &styleSettingsNumberTextbox);
textbox->accessKey = 'M';
EsTextboxUseNumberOverlay(textbox, false);
EsTextboxInsert(textbox, "50%");
EsTextDisplayCreate(table, ES_CELL_H_RIGHT | ES_CELL_H_PUSH, 0, INTERFACE_STRING(DesktopSettingsMouseCursorTrails));
textbox = EsTextboxCreate(table, ES_CELL_H_LEFT | ES_CELL_H_PUSH | ES_TEXTBOX_EDIT_BASED, &styleSettingsNumberTextbox);
textbox->accessKey = 'T';
EsTextboxUseNumberOverlay(textbox, false);
EsTextboxInsert(textbox, "0");
EsTextDisplayCreate(table, ES_CELL_H_RIGHT | ES_CELL_H_PUSH, 0, INTERFACE_STRING(DesktopSettingsMouseLinesPerScrollNotch));
textbox = EsTextboxCreate(table, ES_CELL_H_LEFT | ES_CELL_H_PUSH | ES_TEXTBOX_EDIT_BASED, &styleSettingsNumberTextbox);
textbox->accessKey = 'S';
EsTextboxUseNumberOverlay(textbox, false);
EsTextboxInsert(textbox, "3");
table = EsPanelCreate(container, ES_CELL_H_FILL | ES_PANEL_TABLE | ES_PANEL_HORIZONTAL, &styleSettingsCheckboxGroup);
EsPanelSetBands(table, 1);
EsButtonCreate(table, ES_CELL_H_FILL | ES_BUTTON_CHECKBOX, 0, INTERFACE_STRING(DesktopSettingsMouseSwapLeftAndRightButtons))->accessKey = 'B';
EsButtonCreate(table, ES_CELL_H_FILL | ES_BUTTON_CHECKBOX, 0, INTERFACE_STRING(DesktopSettingsMouseShowShadow))->accessKey = 'W';
EsButtonCreate(table, ES_CELL_H_FILL | ES_BUTTON_CHECKBOX, 0, INTERFACE_STRING(DesktopSettingsMouseLocateCursorOnCtrl))->accessKey = 'L';
}
void SettingsPageKeyboard(EsElement *element, SettingsPage *page) {
// TODO Make this interactive.
SettingsPageAddUndoButton(element);
EsPanel *content = EsPanelCreate(element, ES_CELL_FILL | ES_PANEL_V_SCROLL_AUTO, &styleNewTabContent);
EsPanel *container = EsPanelCreate(content, ES_PANEL_VERTICAL | ES_CELL_H_SHRINK, &styleSettingsGroupContainer2);
SettingsPageAddTitle(container, page);
EsPanel *table = EsPanelCreate(container, ES_CELL_H_FILL | ES_PANEL_TABLE | ES_PANEL_HORIZONTAL, &styleSettingsTable);
EsPanelSetBands(table, 2);
EsTextbox *textbox;
EsTextDisplayCreate(table, ES_CELL_H_RIGHT | ES_CELL_H_PUSH, 0, INTERFACE_STRING(DesktopSettingsKeyboardKeyRepeatDelay));
textbox = EsTextboxCreate(table, ES_CELL_H_LEFT | ES_CELL_H_PUSH | ES_TEXTBOX_EDIT_BASED, &styleSettingsNumberTextbox);
textbox->accessKey = 'D';
EsTextboxUseNumberOverlay(textbox, false);
EsTextboxInsert(textbox, "400 ms");
EsTextDisplayCreate(table, ES_CELL_H_RIGHT | ES_CELL_H_PUSH, 0, INTERFACE_STRING(DesktopSettingsKeyboardKeyRepeatRate));
textbox = EsTextboxCreate(table, ES_CELL_H_LEFT | ES_CELL_H_PUSH | ES_TEXTBOX_EDIT_BASED, &styleSettingsNumberTextbox);
textbox->accessKey = 'R';
EsTextboxUseNumberOverlay(textbox, false);
EsTextboxInsert(textbox, "40 ms");
EsTextDisplayCreate(table, ES_CELL_H_RIGHT | ES_CELL_H_PUSH, 0, INTERFACE_STRING(DesktopSettingsKeyboardCaretBlinkRate));
textbox = EsTextboxCreate(table, ES_CELL_H_LEFT | ES_CELL_H_PUSH | ES_TEXTBOX_EDIT_BASED, &styleSettingsNumberTextbox);
textbox->accessKey = 'B';
EsTextboxUseNumberOverlay(textbox, false);
EsTextboxInsert(textbox, "500 ms");
EsPanel *testBox = EsPanelCreate(container, ES_CELL_H_FILL);
EsTextDisplayCreate(testBox, ES_CELL_H_FILL, ES_STYLE_TEXT_PARAGRAPH, INTERFACE_STRING(DesktopSettingsKeyboardTestTextboxIntroduction));
EsSpacerCreate(testBox, ES_FLAGS_DEFAULT, 0, 0, 5);
EsTextboxCreate(testBox, ES_CELL_H_LEFT)->accessKey = 'T';
}
SettingsPage settingsPages[] = {
{ INTERFACE_STRING(DesktopSettingsAccessibility), ES_ICON_PREFERENCES_DESKTOP_ACCESSIBILITY, SettingsPageUnimplemented, 'A' },
{ INTERFACE_STRING(DesktopSettingsApplications), ES_ICON_APPLICATIONS_OTHER, SettingsPageUnimplemented, 'A' },
{ INTERFACE_STRING(DesktopSettingsDateAndTime), ES_ICON_PREFERENCES_SYSTEM_TIME, SettingsPageUnimplemented, 'D' },
{ INTERFACE_STRING(DesktopSettingsDevices), ES_ICON_COMPUTER_LAPTOP, SettingsPageUnimplemented, 'D' },
{ INTERFACE_STRING(DesktopSettingsDisplay), ES_ICON_PREFERENCES_DESKTOP_DISPLAY, SettingsPageUnimplemented, 'D' },
{ INTERFACE_STRING(DesktopSettingsKeyboard), ES_ICON_INPUT_KEYBOARD, SettingsPageKeyboard, 'K' },
{ INTERFACE_STRING(DesktopSettingsLocalisation), ES_ICON_PREFERENCES_DESKTOP_LOCALE, SettingsPageUnimplemented, 'L' },
{ INTERFACE_STRING(DesktopSettingsMouse), ES_ICON_INPUT_MOUSE, SettingsPageMouse, 'M' },
{ INTERFACE_STRING(DesktopSettingsNetwork), ES_ICON_PREFERENCES_SYSTEM_NETWORK, SettingsPageUnimplemented, 'N' },
{ INTERFACE_STRING(DesktopSettingsPower), ES_ICON_PREFERENCES_SYSTEM_POWER, SettingsPageUnimplemented, 'P' },
{ INTERFACE_STRING(DesktopSettingsSound), ES_ICON_PREFERENCES_DESKTOP_SOUND, SettingsPageUnimplemented, 'S' },
{ INTERFACE_STRING(DesktopSettingsTheme), ES_ICON_APPLICATIONS_INTERFACEDESIGN, SettingsPageUnimplemented, 'T' },
};
void SettingsButtonPressed(EsInstance *_instance, EsElement *element, EsCommand *) {
SettingsInstance *instance = (SettingsInstance *) _instance;
SettingsPage *page = (SettingsPage *) element->userData.p;
EsPanel *stack = EsPanelCreate(instance->switcher, ES_CELL_FILL | ES_PANEL_Z_STACK);
page->create(stack, page);
{
EsPanel *overlay = EsPanelCreate(stack, ES_CELL_H_LEFT | ES_CELL_V_TOP, &styleSettingsOverlayPanel);
EsButton *backButton = EsButtonCreate(overlay, ES_CELL_H_LEFT | ES_BUTTON_TOOLBAR, 0, INTERFACE_STRING(DesktopSettingsBackButton));
backButton->accessKey = 'A';
EsButtonSetIcon(backButton, ES_ICON_GO_HOME_SYMBOLIC);
EsButtonOnCommand(backButton, SettingsBackButton);
}
EsPanelSwitchTo(instance->switcher, stack, ES_TRANSITION_ZOOM_IN, ES_FLAGS_DEFAULT, 1.0f);
}
void InstanceSettingsCreate(EsMessage *message) {
SettingsInstance *instance = (SettingsInstance *) _EsInstanceCreate(sizeof(SettingsInstance), message, nullptr);
EsWindowSetTitle(instance->window, INTERFACE_STRING(DesktopSettingsTitle));
EsWindowSetIcon(instance->window, ES_ICON_PREFERENCES_DESKTOP);
EsPanel *windowBackground = EsPanelCreate(instance->window, ES_CELL_FILL, ES_STYLE_PANEL_WINDOW_BACKGROUND);
instance->switcher = EsPanelCreate(windowBackground, ES_CELL_FILL | ES_PANEL_SWITCHER);
EsPanel *content = EsPanelCreate(instance->switcher, ES_CELL_FILL | ES_PANEL_V_SCROLL_AUTO, &styleNewTabContent);
instance->mainPage = content;
EsPanelSwitchTo(instance->switcher, content, ES_TRANSITION_NONE);
{
EsPanel *row = EsPanelCreate(content, ES_CELL_H_CENTER | ES_PANEL_HORIZONTAL);
EsIconDisplayCreate(row, ES_FLAGS_DEFAULT, ES_STYLE_ICON_DISPLAY, ES_ICON_PREFERENCES_DESKTOP);
EsSpacerCreate(row, ES_FLAGS_DEFAULT, 0, 10, 0);
EsTextDisplayCreate(row, ES_FLAGS_DEFAULT, ES_STYLE_TEXT_HEADING1, INTERFACE_STRING(DesktopSettingsTitle));
}
{
EsPanel *container = EsPanelCreate(content, ES_CELL_H_SHRINK | ES_PANEL_TABLE | ES_PANEL_HORIZONTAL, &styleSettingsGroupContainer);
EsPanelSetBands(container, 4);
EsSort(settingsPages, sizeof(settingsPages) / sizeof(settingsPages[0]), sizeof(settingsPages[0]), [] (const void *_a, const void *_b, EsGeneric) {
SettingsPage *a = (SettingsPage *) _a, *b = (SettingsPage *) _b;
return EsStringCompare(a->string, a->stringBytes, b->string, b->stringBytes);
}, nullptr);
for (uintptr_t i = 0; i < sizeof(settingsPages) / sizeof(settingsPages[0]); i++) {
EsButton *button = EsButtonCreate(container, ES_ELEMENT_NO_FOCUS_ON_CLICK | ES_CELL_H_FILL,
&styleSettingsButton, settingsPages[i].string, settingsPages[i].stringBytes);
button->userData = &settingsPages[i];
button->accessKey = settingsPages[i].accessKey;
EsButtonSetIcon(button, settingsPages[i].iconID);
EsButtonOnCommand(button, SettingsButtonPressed);
}
}
}

1
desktop/styles.header
View File

@ -92,6 +92,7 @@ define_private ES_STYLE_TASK_BAR_BUTTON (ES_STYLE_CAST(1381))
define_private ES_STYLE_TASK_BAR_EXTRA (ES_STYLE_CAST(1507))
define_private ES_STYLE_TASK_BAR_NEW_WINDOW (ES_STYLE_CAST(1383))
define ES_STYLE_TEXT_HEADING0 (ES_STYLE_CAST(1387))
define ES_STYLE_TEXT_HEADING1 (ES_STYLE_CAST(1581))
define ES_STYLE_TEXT_HEADING2 (ES_STYLE_CAST(1389))
define_private ES_STYLE_TEXT_HEADING3 (ES_STYLE_CAST(1423))
define ES_STYLE_TEXT_LABEL (ES_STYLE_CAST(1391))

87
desktop/syscall.cpp
View File

@ -634,6 +634,46 @@ size_t EsGameControllerStatePoll(EsGameControllerState *buffer) {
return EsSyscall(ES_SYSCALL_GAME_CONTROLLER_STATE_POLL, (uintptr_t) buffer, 0, 0, 0);
}
void DesktopMessage2(EsMessage *message, uint8_t *buffer, EsBuffer *pipe);
void MessageDesktop(void *message, size_t messageBytes, EsHandle embeddedWindow = ES_INVALID_HANDLE, EsBuffer *responseBuffer = nullptr) {
if (api.startupInformation->isDesktop) {
// HACK This assumes the response from DesktopMessage2 will not exceed the size of the pipe's buffer.
EsMessage m = {};
m.type = ES_MSG_DESKTOP;
m.desktop.windowID = embeddedWindow ? EsSyscall(ES_SYSCALL_WINDOW_GET_ID, embeddedWindow, 0, 0, 0) : 0;
m.desktop.processID = EsProcessGetID(ES_CURRENT_PROCESS);
m.desktop.bytes = messageBytes;
DesktopMessage2(&m, (uint8_t *) message, responseBuffer);
} else {
EsHandle pipeRead = ES_INVALID_HANDLE, pipeWrite = ES_INVALID_HANDLE;
if (responseBuffer) {
EsPipeCreate(&pipeRead, &pipeWrite);
}
EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) message, messageBytes, embeddedWindow, pipeWrite);
if (responseBuffer) {
char buffer[4096];
EsHandleClose(pipeWrite);
while (true) {
size_t bytesRead = EsPipeRead(pipeRead, buffer, sizeof(buffer));
if (!bytesRead) break;
EsBufferWrite(responseBuffer, buffer, bytesRead);
}
EsHandleClose(pipeRead);
}
}
if (responseBuffer) {
responseBuffer->bytes = responseBuffer->position;
responseBuffer->position = 0;
}
}
struct ClipboardInformation {
uint8_t desktopMessageTag;
intptr_t error;
@ -643,12 +683,13 @@ struct ClipboardInformation {
EsError EsClipboardAddText(EsClipboard clipboard, const char *text, ptrdiff_t textBytes) {
(void) clipboard;
uint8_t m = DESKTOP_MSG_CREATE_CLIPBOARD_FILE;
EsHandle pipe = EsPipeCreate(), file;
EsBuffer buffer = { .canGrow = true };
EsHandle 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);
MessageDesktop(&m, 1, ES_INVALID_HANDLE, &buffer);
EsBufferReadInto(&buffer, &file, sizeof(file));
EsBufferReadInto(&buffer, &error, sizeof(error));
EsHeapFree(buffer.out);
if (error != ES_SUCCESS) return error;
error = EsFileWriteAllFromHandle(file, text, textBytes);
EsHandleClose(file);
@ -656,19 +697,24 @@ EsError EsClipboardAddText(EsClipboard clipboard, const char *text, ptrdiff_t te
information.desktopMessageTag = DESKTOP_MSG_CLIPBOARD_PUT;
information.error = error;
information.isText = true;
EsSyscall(ES_SYSCALL_MESSAGE_DESKTOP, (uintptr_t) &information, sizeof(information), 0, 0);
MessageDesktop(&information, sizeof(information));
return error;
}
void ClipboardGetInformation(EsHandle *file, ClipboardInformation *information) {
uint8_t m = DESKTOP_MSG_CLIPBOARD_GET;
EsBuffer buffer = { .canGrow = true };
MessageDesktop(&m, 1, ES_INVALID_HANDLE, &buffer);
EsBufferReadInto(&buffer, information, sizeof(*information));
EsBufferReadInto(&buffer, file, sizeof(file));
EsHeapFree(buffer.out);
}
bool EsClipboardHasText(EsClipboard clipboard) {
(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);
EsHandle file;
ClipboardInformation information;
ClipboardGetInformation(&file, &information);
if (file) EsHandleClose(file);
return information.error == ES_SUCCESS && information.isText;
}
@ -679,13 +725,9 @@ char *EsClipboardReadText(EsClipboard clipboard, size_t *bytes) {
char *result = nullptr;
*bytes = 0;
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);
EsHandle file;
ClipboardInformation information;
ClipboardGetInformation(&file, &information);
if (file) {
if (information.isText) {
@ -698,8 +740,9 @@ char *EsClipboardReadText(EsClipboard clipboard, size_t *bytes) {
return result;
}
EsHandle EsPipeCreate() {
return EsSyscall(ES_SYSCALL_PIPE_CREATE, 0, 0, 0, 0);
void EsPipeCreate(EsHandle *readEnd, EsHandle *writeEnd) {
*readEnd = *writeEnd = ES_INVALID_HANDLE;
EsSyscall(ES_SYSCALL_PIPE_CREATE, (uintptr_t) readEnd, (uintptr_t) writeEnd, 0, 0);
}
size_t EsPipeRead(EsHandle pipe, void *buffer, size_t bytes) {

12
desktop/text.cpp
View File

@ -1062,7 +1062,8 @@ IconPackImage *IconPackReadImage(uint32_t id, uint32_t size, int *type) {
*type = (EsBufferReadInt(&iconManagement.pack) == 1) ? CHARACTER_RECOLOR : CHARACTER_IMAGE;
iconManagement.pack.position = start;
bool rtl = api.systemConstants[ES_SYSTEM_CONSTANT_RIGHT_TO_LEFT];
// bool rtl = api.systemConstants[ES_SYSTEM_CONSTANT_RIGHT_TO_LEFT];
bool rtl = false;
bool found = false;
uint32_t variant = 0;
@ -1289,7 +1290,7 @@ bool EsDrawStandardIcon(EsPainter *painter, uint32_t id, int size, EsRectangle r
cacheEntry->data = (uint8_t *) EsHeapAllocate(cacheEntry->dataBytes, true);
RegisterGlyphCacheEntry(key, cacheEntry);
IconPackImage *image = IconPackReadImage(id, size, &cacheEntry->type);
DrawIcon(size, size, cacheEntry->data, image, size * 4, 0, 0, (float) size / image->width, (float) size / image->height);
if (image) DrawIcon(size, size, cacheEntry->data, image, size * 4, 0, 0, (float) size / image->width, (float) size / image->height);
EsHeapFree(iconManagement.buffer);
}
@ -2252,6 +2253,9 @@ void DrawTextPiece(EsPainter *painter, EsTextPlan *plan, TextPiece *piece, TextL
positionY = ((glyphPositions[i].y_offset + FREETYPE_UNIT_SCALE / 2) / FREETYPE_UNIT_SCALE + cursorY);
uint32_t color = plan->currentTextStyle->color;
// bool mono = api.systemConstants[ES_SYSTEM_CONSTANT_NO_FANCY_GRAPHICS];
bool mono = false;
GlyphCacheKey key = {};
key.glyphIndex = codepoint;
key.size = plan->currentTextStyle->size;
@ -2273,7 +2277,7 @@ void DrawTextPiece(EsPainter *painter, EsTextPlan *plan, TextPiece *piece, TextL
entry = LookupGlyphCacheEntry(key);
if (!entry->data) {
if (!FontRenderGlyph(api.systemConstants[ES_SYSTEM_CONSTANT_NO_FANCY_GRAPHICS], key, entry)) {
if (!FontRenderGlyph(mono, key, entry)) {
EsHeapFree(entry);
goto nextCharacter;
} else {
@ -2293,7 +2297,7 @@ void DrawTextPiece(EsPainter *painter, EsTextPlan *plan, TextPiece *piece, TextL
ES_POINT(positionX, positionY + line->ascent / FREETYPE_UNIT_SCALE),
painter->clip, painter->target,
plan->currentTextStyle->blur,
api.systemConstants[ES_SYSTEM_CONSTANT_NO_FANCY_GRAPHICS] ? CHARACTER_MONO : CHARACTER_SUBPIXEL,
mono ? CHARACTER_MONO : CHARACTER_SUBPIXEL,
false, entry->data,
color, 0, -1, painter->target->fullAlpha);

2
drivers/ps2.cpp
View File

@ -551,7 +551,7 @@ void PS2::Initialise(KDevice *parentDevice) {
}
KDevice *controller = KDeviceCreate("PS/2 controller", parentDevice, sizeof(KDevice));
KDeviceCreate("PS/2 keyboard", controller, sizeof(KDevice));
KDeviceSendConnectedMessage(KDeviceCreate("PS/2 keyboard", controller, sizeof(KDevice)), ES_DEVICE_KEYBOARD);
if (channels == 2) KDeviceCreate("PS/2 mouse", controller, sizeof(KDevice));
KernelLog(LOG_INFO, "PS/2", "controller initialised", "Setup PS/2 controller%z.\n", channels == 2 ? ", with a mouse" : "");

14
drivers/usb_hid.cpp
View File

@ -681,6 +681,20 @@ void HIDDevice::Initialise() {
return;
}
// Work out if this is a keyboard or mouse.
for (uintptr_t i = 0; i < reportItems.Length(); i++) {
ReportItem *item = &reportItems[i];
if (item->application == HID_APPLICATION_KEYBOARD && item->usage == HID_USAGE_KEYCODES) {
KDeviceSendConnectedMessage(this, ES_DEVICE_KEYBOARD);
break;
} else if (item->application == HID_APPLICATION_MOUSE) {
KDeviceSendConnectedMessage(this, ES_DEVICE_MOUSE);
break;
}
}
// If this is a game controller, tell the window manager it's been connected.
{

16
kernel/scheduler.cpp
View File

@ -655,18 +655,20 @@ void NewProcess() {
bool Process::Start(char *imagePath, size_t imagePathLength) {
uint64_t flags = ES_FILE_READ | ES_NODE_FAIL_IF_NOT_FOUND;
KNodeInformation node = FSNodeOpen(imagePath, imagePathLength, flags);
bool result = false;
if (ES_CHECK_ERROR(node.error)) {
return false;
}
if (!ES_CHECK_ERROR(node.error)) {
if (node.node->directoryEntry->type == ES_NODE_FILE) {
result = StartWithNode(node.node);
}
if (node.node->directoryEntry->type != ES_NODE_FILE) {
CloseHandleToObject(node.node, KERNEL_OBJECT_NODE, flags);
return false;
}
bool result = StartWithNode(node.node);
CloseHandleToObject(node.node, KERNEL_OBJECT_NODE, flags);
if (!result && type == PROCESS_DESKTOP) {
KernelPanic("Process::Start - Could not load the desktop executable.\n");
}
return result;
}

7
kernel/syscall.cpp
View File

@ -1375,7 +1375,6 @@ SYSCALL_IMPLEMENT(ES_SYSCALL_SYSTEM_GET_CONSTANTS) {
systemConstants[ES_SYSTEM_CONSTANT_TIME_STAMP_UNITS_PER_MICROSECOND] = timeStampTicksPerMs / 1000;
systemConstants[ES_SYSTEM_CONSTANT_WINDOW_INSET] = WINDOW_INSET;
systemConstants[ES_SYSTEM_CONSTANT_CONTAINER_TAB_BAND_HEIGHT] = CONTAINER_TAB_BAND_HEIGHT;
systemConstants[ES_SYSTEM_CONSTANT_NO_FANCY_GRAPHICS] = graphics.target ? graphics.target->reducedColors : false;
systemConstants[ES_SYSTEM_CONSTANT_UI_SCALE] = UI_SCALE;
systemConstants[ES_SYSTEM_CONSTANT_BORDER_THICKNESS] = BORDER_THICKNESS;
systemConstants[ES_SYSTEM_CONSTANT_OPTIMAL_WORK_QUEUE_THREAD_COUNT] = scheduler.currentProcessorID; // TODO Update this as processors are added/removed.
@ -1579,7 +1578,11 @@ SYSCALL_IMPLEMENT(ES_SYSCALL_PIPE_CREATE) {
if (!pipe) SYSCALL_RETURN(ES_ERROR_INSUFFICIENT_RESOURCES, false);
pipe->writers = pipe->readers = 1;
KEventSet(&pipe->canWrite);
SYSCALL_RETURN(currentProcess->handleTable.OpenHandle(pipe, PIPE_READER | PIPE_WRITER, KERNEL_OBJECT_PIPE), false);
EsHandle readEnd = currentProcess->handleTable.OpenHandle(pipe, PIPE_READER, KERNEL_OBJECT_PIPE);
EsHandle writeEnd = currentProcess->handleTable.OpenHandle(pipe, PIPE_WRITER, KERNEL_OBJECT_PIPE);
SYSCALL_WRITE(argument0, &readEnd, sizeof(EsHandle));
SYSCALL_WRITE(argument1, &writeEnd, sizeof(EsHandle));
SYSCALL_RETURN(ES_SUCCESS, false);
}
SYSCALL_IMPLEMENT(ES_SYSCALL_PIPE_READ) {

BIN
res/Theme Source.dat
View File

Binary file not shown.

BIN
res/Themes/Theme.dat
View File

Binary file not shown.

12
shared/common.cpp
View File

@ -2539,6 +2539,18 @@ const void *EsBufferRead(EsBuffer *buffer, size_t readBytes) {
}
}
bool EsBufferReadInto(EsBuffer *buffer, void *destination, size_t readBytes) {
const void *source = EsBufferRead(buffer, readBytes);
if (source) {
EsMemoryCopy(destination, source, readBytes);
return true;
} else {
EsMemoryZero(destination, readBytes);
return false;
}
}
const void *EsBufferReadMany(EsBuffer *buffer, size_t a, size_t b) {
size_t c;

28
shared/strings.cpp
View File

@ -78,8 +78,36 @@ DEFINE_INTERFACE_STRING(DesktopNoSuchApplication, "The requested application cou
DEFINE_INTERFACE_STRING(DesktopApplicationStartupError, "The requested application could not be started. Your system may be low on resources, or the application files may have been corrupted.");
DEFINE_INTERFACE_STRING(DesktopNotResponding, "The application is not responding.\nIf you choose to force quit, any unsaved data may be lost.");
DEFINE_INTERFACE_STRING(DesktopConfirmShutdown, "Are you sure you want to turn off your computer? All applications will be closed.");
DEFINE_INTERFACE_STRING(DesktopSettingsApplication, "Settings");
DEFINE_INTERFACE_STRING(DesktopSettingsTitle, "Settings");
DEFINE_INTERFACE_STRING(DesktopSettingsBackButton, "All settings");
DEFINE_INTERFACE_STRING(DesktopSettingsUndoButton, "Undo changes");
DEFINE_INTERFACE_STRING(DesktopSettingsAccessibility, "Accessibility");
DEFINE_INTERFACE_STRING(DesktopSettingsApplications, "Applications");
DEFINE_INTERFACE_STRING(DesktopSettingsDateAndTime, "Date and time");
DEFINE_INTERFACE_STRING(DesktopSettingsDevices, "Devices");
DEFINE_INTERFACE_STRING(DesktopSettingsDisplay, "Display");
DEFINE_INTERFACE_STRING(DesktopSettingsKeyboard, "Keyboard");
DEFINE_INTERFACE_STRING(DesktopSettingsLocalisation, "Localisation");
DEFINE_INTERFACE_STRING(DesktopSettingsMouse, "Mouse");
DEFINE_INTERFACE_STRING(DesktopSettingsNetwork, "Network");
DEFINE_INTERFACE_STRING(DesktopSettingsPower, "Power");
DEFINE_INTERFACE_STRING(DesktopSettingsSound, "Sound");
DEFINE_INTERFACE_STRING(DesktopSettingsTheme, "Theme");
DEFINE_INTERFACE_STRING(DesktopSettingsKeyboardKeyRepeatDelay, "Key repeat delay:");
DEFINE_INTERFACE_STRING(DesktopSettingsKeyboardKeyRepeatRate, "Key repeat rate:");
DEFINE_INTERFACE_STRING(DesktopSettingsKeyboardCaretBlinkRate, "Caret blink rate:");
DEFINE_INTERFACE_STRING(DesktopSettingsKeyboardTestTextboxIntroduction, "Try out the settings in the textbox below:");
DEFINE_INTERFACE_STRING(DesktopSettingsMouseDoubleClickSpeed, "Double-click speed:");
DEFINE_INTERFACE_STRING(DesktopSettingsMouseSpeed, "Cursor movement speed:");
DEFINE_INTERFACE_STRING(DesktopSettingsMouseCursorTrails, "Cursor trail count:");
DEFINE_INTERFACE_STRING(DesktopSettingsMouseLinesPerScrollNotch, "Lines to scroll per wheel notch:");
DEFINE_INTERFACE_STRING(DesktopSettingsMouseSwapLeftAndRightButtons, "Swap left and right buttons");
DEFINE_INTERFACE_STRING(DesktopSettingsMouseShowShadow, "Show shadow below cursor");
DEFINE_INTERFACE_STRING(DesktopSettingsMouseLocateCursorOnCtrl, "Show cursor location when Ctrl is pressed");
// File operations.

1
util/api_table.ini
View File

@ -310,6 +310,7 @@ EsUndoPop=308
EsTextboxSetUndoManager=309
EsListViewInsertGroup=310
EsFileDelete=311
EsBufferReadInto=312
EsListViewRemoveAll=313
EsSystemShowShutdownDialog=314
EsListViewSetColumns=315