RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 16:47:36 +00:00
Code Issues Activity Actions

HexEditor: Port to Core::Stream

Browse source
This commit is contained in:
Lucas CHOLLET 2023-01-14 21:47:50 -05:00 • committed by Andrew Kaster
parent b1d8404c92
commit 3d914247cc
7 changed files with 58 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

57
Userland/Applications/HexEditor/HexDocument.cpp
View file

@ -5,6 +5,7 @@
*/ */
#include "HexDocument.h" #include "HexDocument.h"
#include <LibCore/Stream.h>
void HexDocument::set(size_t position, u8 value) void HexDocument::set(size_t position, u8 value)
{ {
@ -57,20 +58,20 @@ void HexDocumentMemory::clear_changes()
m_changes.clear(); m_changes.clear();
} }
bool HexDocumentMemory::write_to_file(NonnullRefPtr<Core::File> file) bool HexDocumentMemory::write_to_file(Core::Stream::File& file)
{ {
if (!file->seek(0)) if (file.seek(0, SeekMode::SetPosition).is_error())
return false; return false;
if (!file->write(m_buffer.data(), m_buffer.size())) if (file.write(m_buffer).is_error())
return false; return false;
for (auto& change : m_changes) { for (auto& change : m_changes) {
file->seek(change.key, SeekMode::SetPosition); file.seek(change.key, SeekMode::SetPosition).release_value_but_fixme_should_propagate_errors();
file->write(&change.value, 1); file.write({ &change.value, 1 }).release_value_but_fixme_should_propagate_errors();
} }
return true; return true;
} }
ErrorOr<NonnullOwnPtr<HexDocumentFile>> HexDocumentFile::create(NonnullRefPtr<Core::File> file) ErrorOr<NonnullOwnPtr<HexDocumentFile>> HexDocumentFile::create(NonnullOwnPtr<Core::Stream::File> file)
{ {
auto document = TRY(adopt_nonnull_own_or_enomem(new HexDocumentFile(move(file)))); auto document = TRY(adopt_nonnull_own_or_enomem(new HexDocumentFile(move(file))));
// FIXME: Remove this hackery // FIXME: Remove this hackery
@ -79,42 +80,43 @@ ErrorOr<NonnullOwnPtr<HexDocumentFile>> HexDocumentFile::create(NonnullRefPtr<Co
return document; return document;
} }
HexDocumentFile::HexDocumentFile(NonnullRefPtr<Core::File> file) HexDocumentFile::HexDocumentFile(NonnullOwnPtr<Core::Stream::File> file)
: m_file(file) : m_file(move(file))
{ {
} }
void HexDocumentFile::write_to_file() void HexDocumentFile::write_to_file()
{ {
for (auto& change : m_changes) { for (auto& change : m_changes) {
m_file->seek(change.key, SeekMode::SetPosition); m_file->seek(change.key, SeekMode::SetPosition).release_value_but_fixme_should_propagate_errors();
m_file->write(&change.value, 1); m_file->write({ &change.value, 1 }).release_value_but_fixme_should_propagate_errors();
} }
clear_changes(); clear_changes();
// make sure the next get operation triggers a read // make sure the next get operation triggers a read
m_buffer_file_pos = m_file_size + 1; m_buffer_file_pos = m_file_size + 1;
} }
bool HexDocumentFile::write_to_file(NonnullRefPtr<Core::File> file) bool HexDocumentFile::write_to_file(Core::Stream::File& file)
{ {
if (!file->truncate(size())) { if (file.truncate(size()).is_error()) {
return false; return false;
} }
if (!file->seek(0) || !m_file->seek(0)) { if (file.seek(0, SeekMode::SetPosition).is_error() || m_file->seek(0, SeekMode::SetPosition).is_error()) {
return false; return false;
} }
while (true) { while (true) {
auto copy_buffer = m_file->read(64 * KiB); Array<u8, 64 * KiB> buffer;
auto copy_buffer = m_file->read(buffer).release_value_but_fixme_should_propagate_errors();
if (copy_buffer.size() == 0) if (copy_buffer.size() == 0)
break; break;
file->write(copy_buffer.data(), copy_buffer.size()); file.write(copy_buffer).release_value_but_fixme_should_propagate_errors();
} }
for (auto& change : m_changes) { for (auto& change : m_changes) {
file->seek(change.key, SeekMode::SetPosition); file.seek(change.key, SeekMode::SetPosition).release_value_but_fixme_should_propagate_errors();
file->write(&change.value, 1); file.write({ &change.value, 1 }).release_value_but_fixme_should_propagate_errors();
} }
return true; return true;
@ -152,24 +154,23 @@ void HexDocumentFile::clear_changes()
m_changes.clear(); m_changes.clear();
} }
void HexDocumentFile::set_file(NonnullRefPtr<Core::File> file) void HexDocumentFile::set_file(NonnullOwnPtr<Core::Stream::File> file)
{ {
m_file = file; m_file = move(file);
off_t size = 0; if (auto result = m_file->seek(0, SeekMode::FromEndPosition); result.is_error())
if (!file->seek(0, SeekMode::FromEndPosition, &size)) {
m_file_size = 0; m_file_size = 0;
} else { else
m_file_size = size; m_file_size = result.value();
}
file->seek(0, SeekMode::SetPosition); m_file->seek(0, SeekMode::SetPosition).release_value_but_fixme_should_propagate_errors();
clear_changes(); clear_changes();
// make sure the next get operation triggers a read // make sure the next get operation triggers a read
m_buffer_file_pos = m_file_size + 1; m_buffer_file_pos = m_file_size + 1;
} }
NonnullRefPtr<Core::File> HexDocumentFile::file() const NonnullOwnPtr<Core::Stream::File> const& HexDocumentFile::file() const
{ {
return m_file; return m_file;
} }
@ -177,8 +178,8 @@ NonnullRefPtr<Core::File> HexDocumentFile::file() const
void HexDocumentFile::ensure_position_in_buffer(size_t position) void HexDocumentFile::ensure_position_in_buffer(size_t position)
{ {
if (position < m_buffer_file_pos || position >= m_buffer_file_pos + m_buffer.size()) { if (position < m_buffer_file_pos || position >= m_buffer_file_pos + m_buffer.size()) {
m_file->seek(position, SeekMode::SetPosition); m_file->seek(position, SeekMode::SetPosition).release_value_but_fixme_should_propagate_errors();
m_file->read(m_buffer.data(), m_buffer.size()); m_file->read(m_buffer).release_value_but_fixme_should_propagate_errors();
m_buffer_file_pos = position; m_buffer_file_pos = position;
} }
} }

14
Userland/Applications/HexEditor/HexDocument.h
View file

@ -50,7 +50,7 @@ public:
size_t size() const override; size_t size() const override;
Type type() const override; Type type() const override;
void clear_changes() override; void clear_changes() override;
bool write_to_file(NonnullRefPtr<Core::File> file); bool write_to_file(Core::Stream::File& file);
private: private:
ByteBuffer m_buffer; ByteBuffer m_buffer;
@ -58,16 +58,16 @@ private:
class HexDocumentFile final : public HexDocument { class HexDocumentFile final : public HexDocument {
public: public:
static ErrorOr<NonnullOwnPtr<HexDocumentFile>> create(NonnullRefPtr<Core::File> file); static ErrorOr<NonnullOwnPtr<HexDocumentFile>> create(NonnullOwnPtr<Core::Stream::File> file);
virtual ~HexDocumentFile() = default; virtual ~HexDocumentFile() = default;
HexDocumentFile(HexDocumentFile&&) = default; HexDocumentFile(HexDocumentFile&&) = default;
HexDocumentFile(HexDocumentFile const&) = delete; HexDocumentFile(HexDocumentFile const&) = delete;
void set_file(NonnullRefPtr<Core::File> file); void set_file(NonnullOwnPtr<Core::Stream::File> file);
NonnullRefPtr<Core::File> file() const; NonnullOwnPtr<Core::Stream::File> const& file() const;
void write_to_file(); void write_to_file();
bool write_to_file(NonnullRefPtr<Core::File> file); bool write_to_file(Core::Stream::File& file);
Cell get(size_t position) override; Cell get(size_t position) override;
u8 get_unchanged(size_t position) override; u8 get_unchanged(size_t position) override;
size_t size() const override; size_t size() const override;
@ -75,10 +75,10 @@ public:
void clear_changes() override; void clear_changes() override;
private: private:
explicit HexDocumentFile(NonnullRefPtr<Core::File> file); explicit HexDocumentFile(NonnullOwnPtr<Core::Stream::File> file);
void ensure_position_in_buffer(size_t position); void ensure_position_in_buffer(size_t position);
NonnullRefPtr<Core::File> m_file; NonnullOwnPtr<Core::Stream::File> m_file;
size_t m_file_size; size_t m_file_size;
Array<u8, 2048> m_buffer; Array<u8, 2048> m_buffer;

10
Userland/Applications/HexEditor/HexEditor.cpp
View file

@ -63,7 +63,7 @@ ErrorOr<void> HexEditor::open_new_file(size_t size)
return {}; return {};
} }
void HexEditor::open_file(NonnullRefPtr<Core::File> file) void HexEditor::open_file(NonnullOwnPtr<Core::Stream::File> file)
{ {
m_document = HexDocumentFile::create(move(file)).release_value_but_fixme_should_propagate_errors(); m_document = HexDocumentFile::create(move(file)).release_value_but_fixme_should_propagate_errors();
set_content_length(m_document->size()); set_content_length(m_document->size());
@ -135,16 +135,16 @@ void HexEditor::set_selection(size_t position, size_t length)
scroll_position_into_view(position); scroll_position_into_view(position);
update_status(); update_status();
} }
bool HexEditor::save_as(NonnullRefPtr<Core::File> new_file) bool HexEditor::save_as(NonnullOwnPtr<Core::Stream::File> new_file)
{ {
if (m_document->type() == HexDocument::Type::File) { if (m_document->type() == HexDocument::Type::File) {
auto& file_document = static_cast<HexDocumentFile&>(*m_document); auto& file_document = static_cast<HexDocumentFile&>(*m_document);
if (!file_document.write_to_file(new_file)) if (!file_document.write_to_file(*new_file))
return false; return false;
file_document.set_file(new_file); file_document.set_file(move(new_file));
} else { } else {
auto& memory_document = static_cast<HexDocumentMemory&>(*m_document); auto& memory_document = static_cast<HexDocumentMemory&>(*m_document);
if (!memory_document.write_to_file(new_file)) if (!memory_document.write_to_file(*new_file))
return false; return false;
m_document = HexDocumentFile::create(move(new_file)).release_value_but_fixme_should_propagate_errors(); m_document = HexDocumentFile::create(move(new_file)).release_value_but_fixme_should_propagate_errors();
} }

4
Userland/Applications/HexEditor/HexEditor.h
View file

@ -35,10 +35,10 @@ public:
size_t buffer_size() const { return m_document->size(); } size_t buffer_size() const { return m_document->size(); }
ErrorOr<void> open_new_file(size_t size); ErrorOr<void> open_new_file(size_t size);
void open_file(NonnullRefPtr<Core::File> file); void open_file(NonnullOwnPtr<Core::Stream::File> file);
ErrorOr<void> fill_selection(u8 fill_byte); ErrorOr<void> fill_selection(u8 fill_byte);
Optional<u8> get_byte(size_t position); Optional<u8> get_byte(size_t position);
bool save_as(NonnullRefPtr<Core::File>); bool save_as(NonnullOwnPtr<Core::Stream::File>);
bool save(); bool save();
bool undo(); bool undo();

24
Userland/Applications/HexEditor/HexEditorWidget.cpp
View file

@ -17,7 +17,7 @@
#include <AK/StringBuilder.h> #include <AK/StringBuilder.h>
#include <Applications/HexEditor/HexEditorWindowGML.h> #include <Applications/HexEditor/HexEditorWindowGML.h>
#include <LibConfig/Client.h> #include <LibConfig/Client.h>
#include <LibCore/File.h> #include <LibCore/Stream.h>
#include <LibDesktop/Launcher.h> #include <LibDesktop/Launcher.h>
#include <LibFileSystemAccessClient/Client.h> #include <LibFileSystemAccessClient/Client.h>
#include <LibGUI/Action.h> #include <LibGUI/Action.h>
@ -121,11 +121,11 @@ HexEditorWidget::HexEditorWidget()
if (!request_close()) if (!request_close())
return; return;
auto response = FileSystemAccessClient::Client::the().try_open_file_deprecated(window(), {}, Core::StandardPaths::home_directory(), Core::OpenMode::ReadWrite); auto response = FileSystemAccessClient::Client::the().open_file(window(), {}, Core::StandardPaths::home_directory(), Core::Stream::OpenMode::ReadWrite);
if (response.is_error()) if (response.is_error())
return; return;
open_file(response.value()); open_file(response.value().filename(), response.value().release_stream());
}); });
m_save_action = GUI::CommonActions::make_save_action([&](auto&) { m_save_action = GUI::CommonActions::make_save_action([&](auto&) {
@ -142,18 +142,18 @@ HexEditorWidget::HexEditorWidget()
}); });
m_save_as_action = GUI::CommonActions::make_save_as_action([&](auto&) { m_save_as_action = GUI::CommonActions::make_save_as_action([&](auto&) {
auto response = FileSystemAccessClient::Client::the().try_save_file_deprecated(window(), m_name, m_extension, Core::OpenMode::ReadWrite | Core::OpenMode::Truncate); auto response = FileSystemAccessClient::Client::the().save_file(window(), m_name, m_extension, Core::Stream::OpenMode::ReadWrite | Core::Stream::OpenMode::Truncate);
if (response.is_error()) if (response.is_error())
return; return;
auto file = response.release_value(); auto file = response.release_value();
if (!m_editor->save_as(file)) { if (!m_editor->save_as(file.release_stream())) {
GUI::MessageBox::show(window(), "Unable to save file.\n"sv, "Error"sv, GUI::MessageBox::Type::Error); GUI::MessageBox::show(window(), "Unable to save file.\n"sv, "Error"sv, GUI::MessageBox::Type::Error);
return; return;
} }
window()->set_modified(false); window()->set_modified(false);
set_path(file->filename()); set_path(file.filename());
dbgln("Wrote document to {}", file->filename()); dbgln("Wrote document to {}", file.filename());
}); });
m_undo_action = GUI::CommonActions::make_undo_action([&](auto&) { m_undo_action = GUI::CommonActions::make_undo_action([&](auto&) {
@ -525,11 +525,11 @@ void HexEditorWidget::update_title()
window()->set_title(builder.to_deprecated_string()); window()->set_title(builder.to_deprecated_string());
} }
void HexEditorWidget::open_file(NonnullRefPtr<Core::File> file) void HexEditorWidget::open_file(String const& filename, NonnullOwnPtr<Core::Stream::File> file)
{ {
window()->set_modified(false); window()->set_modified(false);
m_editor->open_file(file); m_editor->open_file(move(file));
set_path(file->filename()); set_path(filename.to_deprecated_string());
} }
bool HexEditorWidget::request_close() bool HexEditorWidget::request_close()
@ -586,9 +586,9 @@ void HexEditorWidget::drop_event(GUI::DropEvent& event)
return; return;
// TODO: A drop event should be considered user consent for opening a file // TODO: A drop event should be considered user consent for opening a file
auto response = FileSystemAccessClient::Client::the().try_request_file_deprecated(window(), urls.first().path(), Core::OpenMode::ReadOnly); auto response = FileSystemAccessClient::Client::the().request_file(window(), urls.first().path(), Core::Stream::OpenMode::Read);
if (response.is_error()) if (response.is_error())
return; return;
open_file(response.value()); open_file(response.value().filename(), response.value().release_stream());
} }
} }

2
Userland/Applications/HexEditor/HexEditorWidget.h
View file

@ -25,7 +25,7 @@ class HexEditorWidget final : public GUI::Widget {
C_OBJECT(HexEditorWidget) C_OBJECT(HexEditorWidget)
public: public:
virtual ~HexEditorWidget() override = default; virtual ~HexEditorWidget() override = default;
void open_file(NonnullRefPtr<Core::File>); void open_file(String const& filename, NonnullOwnPtr<Core::Stream::File>);
void initialize_menubar(GUI::Window&); void initialize_menubar(GUI::Window&);
bool request_close(); bool request_close();

4
Userland/Applications/HexEditor/main.cpp
View file

@ -53,10 +53,10 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
if (arguments.argc > 1) { if (arguments.argc > 1) {
// FIXME: Using `try_request_file_read_only_approved` doesn't work here since the file stored in the editor is only readable. // FIXME: Using `try_request_file_read_only_approved` doesn't work here since the file stored in the editor is only readable.
auto response = FileSystemAccessClient::Client::the().try_request_file_deprecated(window, arguments.strings[1], Core::OpenMode::ReadWrite); auto response = FileSystemAccessClient::Client::the().request_file(window, arguments.strings[1], Core::Stream::OpenMode::ReadWrite);
if (response.is_error()) if (response.is_error())
return 1; return 1;
hex_editor_widget->open_file(response.value()); hex_editor_widget->open_file(response.value().filename(), response.value().release_stream());
} }
return app->exec(); return app->exec();