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

525 lines
18 KiB
C++
Raw Blame History

// This file is part of the Essence operating system.
// It is released under the terms of the MIT license -- see LICENSE.md.
// Written by: nakst.
void CommandRename(Instance *instance, EsElement *, EsCommand *) {
// TODO Undo.
intptr_t index = -1;
for (uintptr_t i = 0; i < instance->listContents.Length(); i++) {
ListEntry *entry = &instance->listContents[i];
if (entry->selected) {
index = i;
break;
}
}
EsAssert(index != -1);
instance->rename.textbox = EsListViewCreateInlineTextbox(instance->list, 0, index, ES_LIST_VIEW_INLINE_TEXTBOX_COPY_EXISTING_TEXT);
instance->rename.index = index;
FolderEntry *entry = instance->listContents[index].entry;
if (entry->extensionOffset != entry->nameBytes) {
// Don't include the file extension in the initial selection.
EsTextboxSetSelection(instance->rename.textbox, 0, 0, 0, entry->extensionOffset - 1);
}
instance->rename.textbox->messageUser = [] (EsElement *element, EsMessage *message) {
if (message->type == ES_MSG_TEXTBOX_EDIT_END) {
Instance *instance = element->instance;
String name = {};
name.text = EsTextboxGetContents((EsTextbox *) element, &name.bytes);
name.allocated = name.bytes;
if (!name.bytes || message->endEdit.rejected) {
StringDestroy(&name);
} else {
FolderEntry *entry = instance->listContents[instance->rename.index].entry;
String oldName = entry->GetName();
BlockingTaskQueue(instance, {
.string = name,
.string2 = StringDuplicate(oldName),
.cDescription = interfaceString_FileManagerRenameTask,
.callback = [] (Instance *instance, Task *task) {
if (StringEquals(task->string, task->string2)) {
task->result = ES_SUCCESS;
} else {
task->result = instance->folder->itemHandler->renameItem(instance->folder, task->string2, task->string);
}
},
.then = [] (Instance *instance, Task *task) {
if (instance->closed) {
// Ignore.
} else if (task->result != ES_SUCCESS) {
InstanceReportError(instance, ERROR_RENAME_ITEM, task->result);
} else {
Folder *folder = instance->folder;
size_t newPathBytes;
char *newPath = EsStringAllocateAndFormat(&newPathBytes, "%s%s", STRFMT(instance->folder->path), STRFMT(task->string));
size_t oldPathBytes;
char *oldPath = EsStringAllocateAndFormat(&oldPathBytes, "%s%s", STRFMT(instance->folder->path), STRFMT(task->string2));
FolderPathMoved({ .text = oldPath, .bytes = oldPathBytes }, { .text = newPath, .bytes = newPathBytes }, true);
EsDirectoryChild information = {};
EsPathQueryInformation(newPath, newPathBytes, &information);
EsMutexAcquire(&folder->modifyEntriesMutex);
EsAssert(folder->doneInitialEnumeration);
uint64_t id = FolderRemoveEntryAndUpdateInstances(folder, STRING(task->string2));
FolderAddEntryAndUpdateInstances(folder, STRING(task->string), &information, instance, id);
EsMutexRelease(&folder->modifyEntriesMutex);
EsHeapFree(oldPath);
EsHeapFree(newPath);
}
StringDestroy(&task->string);
StringDestroy(&task->string2);
},
});
}
EsElementDestroy(element);
}
return 0;
};
}
void CommandNewFolder(Instance *instance, EsElement *, EsCommand *) {
String name = StringAllocateAndFormat("%z", interfaceString_FileManagerNewFolderName);
BlockingTaskQueue(instance, {
.string = name,
.cDescription = interfaceString_FileManagerNewFolderTask,
.callback = [] (Instance *instance, Task *task) {
task->result = instance->folder->itemHandler->createChildFolder(instance->folder, &task->string, true);
},
.then = [] (Instance *instance, Task *task) {
if (instance->closed) {
// Ignore.
} else if (task->result != ES_SUCCESS) {
InstanceReportError(instance, ERROR_NEW_FOLDER, task->result);
} else {
Folder *folder = instance->folder;
EsDirectoryChild information = {};
information.type = ES_NODE_DIRECTORY;
EsMutexAcquire(&folder->modifyEntriesMutex);
EsAssert(folder->doneInitialEnumeration);
FolderAddEntryAndUpdateInstances(folder, STRING(task->string), &information, instance);
EsMutexRelease(&folder->modifyEntriesMutex);
CommandRename(instance, nullptr, nullptr);
}
StringDestroy(&task->string);
},
});
}
void CommandCopyOrCut(Instance *instance, uint32_t flags) {
// TODO If copying a single file, copy the data of the file (as well as its path),
// so that document can be pasted into other applications.
uint8_t _buffer[4096];
EsBuffer buffer = { .out = _buffer, .bytes = sizeof(_buffer) };
buffer.fileStore = EsClipboardOpen(ES_CLIPBOARD_PRIMARY);
for (uintptr_t i = 0; i < instance->listContents.Length() && !buffer.error; i++) {
if (instance->listContents[i].selected) {
FolderEntry *entry = instance->listContents[i].entry;
String path = instance->folder->itemHandler->getPathForChild(instance->folder, entry);
EsBufferWrite(&buffer, STRING(path));
StringDestroy(&path);
uint8_t separator = '\n';
EsBufferWrite(&buffer, &separator, 1);
}
}
EsBufferFlushToFileStore(&buffer);
EsPoint point = EsListViewGetAnnouncementPointForSelection(instance->list);
EsError error = EsClipboardCloseAndAdd(ES_CLIPBOARD_PRIMARY, ES_CLIPBOARD_FORMAT_PATH_LIST, buffer.fileStore, flags);
if (error == ES_SUCCESS) {
if (flags & ES_CLIPBOARD_ADD_LAZY_CUT) {
EsAnnouncementShow(instance->window, ES_FLAGS_DEFAULT, point.x, point.y, INTERFACE_STRING(CommonAnnouncementCut));
} else {
EsAnnouncementShow(instance->window, ES_FLAGS_DEFAULT, point.x, point.y, INTERFACE_STRING(CommonAnnouncementCopied));
}
} else if (error == ES_ERROR_INSUFFICIENT_RESOURCES || error == ES_ERROR_DRIVE_FULL) {
EsAnnouncementShow(instance->window, ES_FLAGS_DEFAULT, point.x, point.y, INTERFACE_STRING(CommonAnnouncementCopyErrorResources));
} else {
EsAnnouncementShow(instance->window, ES_FLAGS_DEFAULT, point.x, point.y, INTERFACE_STRING(CommonAnnouncementCopyErrorOther));
}
}
void CommandCut(Instance *instance, EsElement *, EsCommand *) {
CommandCopyOrCut(instance, ES_CLIPBOARD_ADD_LAZY_CUT);
}
void CommandCopy(Instance *instance, EsElement *, EsCommand *) {
CommandCopyOrCut(instance, ES_FLAGS_DEFAULT);
}
struct PasteOperation {
String source, destination;
};
struct PasteTask {
// Input:
String destinationBase;
bool move;
char *pathList;
size_t pathListBytes;
// State:
bool progressByData;
EsFileOffset totalDataToProcess, totalDataProcessed;
size_t sourceItemCount, sourceItemsProcessed;
EsUserTask *userTask;
EsFileOffset lastBytesCopied, cumulativeSecondBytesCopied;
EsFileOffsetDifference bytesPerSecond;
double cumulativeSecondTimeStampMs;
};
bool CommandPasteCopyCallback(EsFileOffset bytesCopied, EsFileOffset totalBytes, EsGeneric data) {
(void) totalBytes;
PasteTask *task = (PasteTask *) data.p;
EsFileOffset delta = bytesCopied - task->lastBytesCopied;
task->totalDataProcessed += delta;
task->lastBytesCopied = bytesCopied;
if (task->progressByData) {
double timeStampMs = EsTimeStampMs();
if (!task->cumulativeSecondTimeStampMs) {
task->cumulativeSecondTimeStampMs = timeStampMs;
task->bytesPerSecond = -1;
} else if (timeStampMs - task->cumulativeSecondTimeStampMs > 1000.0) {
// TODO Test that this calculation is correct.
task->bytesPerSecond = task->cumulativeSecondBytesCopied / (timeStampMs - task->cumulativeSecondTimeStampMs);
task->cumulativeSecondTimeStampMs = timeStampMs;
task->cumulativeSecondBytesCopied = 0;
}
task->cumulativeSecondBytesCopied += delta;
EsUserTaskSetProgress(task->userTask, (double) task->totalDataProcessed / task->totalDataToProcess, task->bytesPerSecond);
}
return EsUserTaskIsRunning(task->userTask);
}
EsError CommandPasteFile(String source, String destinationBase, void **copyBuffer, PasteTask *task, String *_destination) {
if (!EsUserTaskIsRunning(task->userTask)) {
return ES_ERROR_CANCELLED;
}
if (PathHasPrefix(destinationBase, source)) {
return ES_ERROR_TARGET_WITHIN_SOURCE;
}
String name = PathGetName(source);
String destination = StringAllocateAndFormat("%s%z%s", STRFMT(destinationBase), PathHasTrailingSlash(destinationBase) ? "" : "/", STRFMT(name));
EsError error;
if (StringEquals(PathGetParent(source), destinationBase)) {
if (task->move) {
// Move with the source and destination folders identical; meaningless.
error = ES_SUCCESS;
goto done;
}
destination.allocated += 32;
destination.text = (char *) EsHeapReallocate(destination.text, destination.allocated, false);
size_t bytes = EsPathFindUniqueName(destination.text, destination.bytes, destination.allocated);
if (bytes) {
destination.bytes = destination.allocated = bytes;
} else {
destination.allocated = destination.bytes;
StringDestroy(&destination);
return ES_ERROR_ALREADY_EXISTS;
}
}
EsPrint("%z %s -> %s...\n", task->move ? "Moving" : "Copying", STRFMT(source), STRFMT(destination));
if (task->move) {
error = EsPathMove(STRING(source), STRING(destination), ES_FLAGS_DEFAULT);
if (error == ES_ERROR_VOLUME_MISMATCH) {
// TODO Delete the files after all copies complete successfully.
goto copy;
}
} else {
copy:;
task->lastBytesCopied = 0;
error = EsFileCopy(STRING(source), STRING(destination), copyBuffer, CommandPasteCopyCallback, task);
}
if (error == ES_ERROR_INCORRECT_NODE_TYPE) {
uintptr_t childCount;
EsDirectoryChild *buffer = EsDirectoryEnumerateChildren(STRING(source), &childCount, &error);
if (error == ES_SUCCESS) {
error = EsPathCreate(STRING(destination), ES_NODE_DIRECTORY, false);
if (error == ES_SUCCESS) {
for (uintptr_t i = 0; i < childCount && error == ES_SUCCESS; i++) {
String childSourcePath = StringAllocateAndFormat("%s%z%s", STRFMT(source),
PathHasTrailingSlash(source) ? "" : "/", buffer[i].nameBytes, buffer[i].name);
error = CommandPasteFile(childSourcePath, destination, copyBuffer, task, nullptr);
StringDestroy(&childSourcePath);
}
}
EsHeapFree(buffer);
}
}
if (error == ES_SUCCESS) {
EsMessageMutexAcquire();
if (task->move) FolderFileUpdatedAtPath(source, nullptr);
FolderFileUpdatedAtPath(destination, nullptr);
EsMessageMutexRelease();
}
done:;
if (_destination && error == ES_SUCCESS) {
*_destination = destination;
} else {
StringDestroy(&destination);
}
return error;
}
void CommandPasteTask(EsUserTask *userTask, EsGeneric _task) {
// TODO Reporting errors properly. Ask to retry or skip.
// TODO If the destination file already exists, ask to rename or skip (as replace is destructive, it should be an advanced option).
// TODO Other namespace handlers.
// TODO Undo.
PasteTask *task = (PasteTask *) _task.p;
Array<PasteOperation> pasteOperations = {};
EsError error = ES_SUCCESS;
task->userTask = userTask;
void *copyBuffer = nullptr;
const char *position = task->pathList;
size_t remainingBytes = task->pathListBytes;
while (remainingBytes && EsUserTaskIsRunning(task->userTask)) {
const char *newline = (const char *) EsCRTmemchr(position, '\n', remainingBytes);
if (!newline) break;
String source = StringFromLiteralWithSize(position, newline - position);
if (!task->move || !StringEquals(PathGetDrive(source), PathGetDrive(task->destinationBase))) {
// Files are actually being copied, so report progress by the amount of data copied,
// rather than the amount of files processed.
task->progressByData = true;
}
EsDirectoryChild information;
if (EsPathQueryInformation(STRING(source), &information)) {
if (information.fileSize == -1) {
// TODO Support progress on volumes that don't report total directory sizes.
} else {
task->totalDataToProcess += information.fileSize;
}
task->sourceItemCount++;
} else {
// We will probably error on this file, so ignore it.
}
position += source.bytes + 1;
remainingBytes -= source.bytes + 1;
}
position = task->pathList;
remainingBytes = task->pathListBytes;
while (remainingBytes && EsUserTaskIsRunning(task->userTask)) {
const char *newline = (const char *) EsCRTmemchr(position, '\n', remainingBytes);
if (!newline) break;
String source = StringFromLiteralWithSize(position, newline - position);
String destination;
error = CommandPasteFile(source, task->destinationBase, &copyBuffer, task, &destination);
if (error != ES_SUCCESS) break;
PasteOperation operation = { .source = StringDuplicate(source), .destination = destination };
pasteOperations.Add(operation);
position += source.bytes + 1;
remainingBytes -= source.bytes + 1;
task->sourceItemsProcessed++;
if (!task->progressByData) {
EsUserTaskSetProgress(userTask, (double) task->sourceItemsProcessed / task->sourceItemCount, -1);
}
}
EsMessageMutexAcquire();
size_t pathSectionCount = PathCountSections(task->destinationBase);
FolderFileUpdatedAtPath(PathGetDrive(task->destinationBase), nullptr);
for (uintptr_t i = 0; i < pathSectionCount; i++) {
String parent = PathGetParent(task->destinationBase, i + 1);
FolderFileUpdatedAtPath(parent, nullptr);
}
if (task->move) {
if (pasteOperations.Length()) {
size_t pathSectionCount = PathCountSections(pasteOperations[0].source);
FolderFileUpdatedAtPath(PathGetDrive(pasteOperations[0].source), nullptr);
for (uintptr_t i = 0; i < pathSectionCount; i++) {
String parent = PathGetParent(pasteOperations[0].source, i + 1);
FolderFileUpdatedAtPath(parent, nullptr);
}
}
for (uintptr_t i = 0; i < pasteOperations.Length(); i++) {
FolderPathMoved(pasteOperations[i].source, pasteOperations[i].destination, i == pasteOperations.Length() - 1);
}
}
for (uintptr_t i = 0; i < instances.Length(); i++) {
Instance *instance = instances[i];
if (!instance->closed && instance->issuedPasteTask == task) {
instance->issuedPasteTask = nullptr;
if (error != ES_SUCCESS) {
EsPoint point = EsListViewGetAnnouncementPointForSelection(instance->list);
EsAnnouncementShow(instance->window, ES_FLAGS_DEFAULT, point.x, point.y, INTERFACE_STRING(CommonAnnouncementPasteErrorOther));
} else {
EsListViewSelectNone(instance->list);
for (uintptr_t i = 0; i < pasteOperations.Length(); i++) {
String name = PathRemoveTrailingSlash(PathGetName(pasteOperations[i].destination));
InstanceSelectByName(instance, name, true, i == pasteOperations.Length() - 1);
}
}
}
}
EsMessageMutexRelease();
for (uintptr_t i = 0; i < pasteOperations.Length(); i++) {
StringDestroy(&pasteOperations[i].source);
StringDestroy(&pasteOperations[i].destination);
}
pasteOperations.Free();
EsHeapFree(copyBuffer);
EsHeapFree(task->pathList);
StringDestroy(&task->destinationBase);
EsHeapFree(task);
}
void CommandPaste(Instance *instance, EsElement *, EsCommand *) {
if (EsClipboardHasFormat(ES_CLIPBOARD_PRIMARY, ES_CLIPBOARD_FORMAT_PATH_LIST)) {
PasteTask *task = (PasteTask *) EsHeapAllocate(sizeof(PasteTask), true);
uint32_t flags;
task->pathList = EsClipboardReadText(ES_CLIPBOARD_PRIMARY, &task->pathListBytes, &flags);
task->move = flags & ES_CLIPBOARD_ADD_LAZY_CUT;
task->destinationBase = StringDuplicate(instance->folder->path);
instance->issuedPasteTask = task;
EsError error;
if (task->move) {
error = EsUserTaskStart(CommandPasteTask, task, INTERFACE_STRING(FileManagerMoveTask), ES_ICON_FOLDER_MOVE);
} else {
error = EsUserTaskStart(CommandPasteTask, task, INTERFACE_STRING(FileManagerCopyTask), ES_ICON_FOLDER_COPY);
}
if (error != ES_SUCCESS) {
EsPoint point = EsListViewGetAnnouncementPointForSelection(instance->list);
EsAnnouncementShow(instance->window, ES_FLAGS_DEFAULT, point.x, point.y, INTERFACE_STRING(CommonAnnouncementPasteErrorOther));
EsHeapFree(task->pathList);
StringDestroy(&task->destinationBase);
EsHeapFree(task);
}
} else {
// TODO Paste the data into a new file.
}
}
void InstanceRegisterCommands(Instance *instance) {
uint32_t stableCommandID = 1;
EsCommandRegister(&instance->commandGoBackwards, instance, INTERFACE_STRING(FileManagerGoBack), [] (Instance *instance, EsElement *, EsCommand *) {
EsAssert(instance->pathBackwardHistory.Length());
HistoryEntry entry = instance->pathBackwardHistory.Pop();
StringDestroy(&instance->delayedFocusItem);
instance->delayedFocusItem = entry.focusedItem;
InstanceLoadFolder(instance, entry.path, LOAD_FOLDER_BACK);
}, stableCommandID++, "Backspace|Alt+Left");
EsCommandRegister(&instance->commandGoForwards, instance, INTERFACE_STRING(FileManagerGoForwards), [] (Instance *instance, EsElement *, EsCommand *) {
EsAssert(instance->pathForwardHistory.Length());
HistoryEntry entry = instance->pathForwardHistory.Pop();
StringDestroy(&instance->delayedFocusItem);
instance->delayedFocusItem = entry.focusedItem;
InstanceLoadFolder(instance, entry.path, LOAD_FOLDER_FORWARD);
}, stableCommandID++, "Alt+Right");
EsCommandRegister(&instance->commandGoParent, instance, INTERFACE_STRING(FileManagerGoUp), [] (Instance *instance, EsElement *, EsCommand *) {
String parent = PathGetParent(instance->folder->path);
InstanceLoadFolder(instance, StringDuplicate(parent));
}, stableCommandID++, "Alt+Up");
EsCommandRegister(&instance->commandRefresh, instance, INTERFACE_STRING(FileManagerRefresh), [] (Instance *instance, EsElement *, EsCommand *) {
FolderRefresh(instance->folder);
}, stableCommandID++, "F5");
EsCommandRegister(&instance->commandNewFolder, instance, INTERFACE_STRING(FileManagerNewFolderToolbarItem), CommandNewFolder, stableCommandID++, "Ctrl+Shift+N");
EsCommandRegister(&instance->commandRename, instance, INTERFACE_STRING(FileManagerRenameAction), CommandRename, stableCommandID++, "F2");
EsCommandRegister(&instance->commandViewDetails, instance, INTERFACE_STRING(CommonListViewTypeDetails), [] (Instance *instance, EsElement *, EsCommand *) {
instance->viewSettings.viewType = VIEW_DETAILS;
InstanceRefreshViewType(instance);
InstanceViewSettingsUpdated(instance);
}, stableCommandID++);
EsCommandRegister(&instance->commandViewTiles, instance, INTERFACE_STRING(CommonListViewTypeTiles), [] (Instance *instance, EsElement *, EsCommand *) {
instance->viewSettings.viewType = VIEW_TILES;
InstanceRefreshViewType(instance);
InstanceViewSettingsUpdated(instance);
}, stableCommandID++);
EsCommandRegister(&instance->commandViewThumbnails, instance, INTERFACE_STRING(CommonListViewTypeThumbnails), [] (Instance *instance, EsElement *, EsCommand *) {
instance->viewSettings.viewType = VIEW_THUMBNAILS;
InstanceRefreshViewType(instance);
InstanceViewSettingsUpdated(instance);
}, stableCommandID++);
EsCommandSetDisabled(&instance->commandViewDetails, false);
EsCommandSetDisabled(&instance->commandViewTiles, false);
EsCommandSetDisabled(&instance->commandViewThumbnails, false);
EsCommandSetCheck(&instance->commandViewDetails, ES_CHECK_CHECKED, false);
}
View Git Blame Copy Permalink