HexEditorWidget.cpp 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, Mustafa Quraish <mustafa@serenityos.org>
  4. * Copyright (c) 2022, the SerenityOS developers.
  5. * Copyright (c) 2022, Timothy Slater <tslater2006@gmail.com>
  6. *
  7. * SPDX-License-Identifier: BSD-2-Clause
  8. */
  9. #include "HexEditorWidget.h"
  10. #include "FindDialog.h"
  11. #include "GoToOffsetDialog.h"
  12. #include "SearchResultsModel.h"
  13. #include "ValueInspectorModel.h"
  14. #include <AK/Forward.h>
  15. #include <AK/Optional.h>
  16. #include <AK/StringBuilder.h>
  17. #include <Applications/HexEditor/HexEditorWindowGML.h>
  18. #include <LibConfig/Client.h>
  19. #include <LibCore/File.h>
  20. #include <LibDesktop/Launcher.h>
  21. #include <LibFileSystemAccessClient/Client.h>
  22. #include <LibGUI/Action.h>
  23. #include <LibGUI/BoxLayout.h>
  24. #include <LibGUI/Button.h>
  25. #include <LibGUI/FilePicker.h>
  26. #include <LibGUI/InputBox.h>
  27. #include <LibGUI/Menu.h>
  28. #include <LibGUI/Menubar.h>
  29. #include <LibGUI/MessageBox.h>
  30. #include <LibGUI/Model.h>
  31. #include <LibGUI/Statusbar.h>
  32. #include <LibGUI/TableView.h>
  33. #include <LibGUI/TextBox.h>
  34. #include <LibGUI/Toolbar.h>
  35. #include <LibGUI/ToolbarContainer.h>
  36. #include <string.h>
  37. REGISTER_WIDGET(HexEditor, HexEditor);
  38. HexEditorWidget::HexEditorWidget()
  39. {
  40. load_from_gml(hex_editor_window_gml);
  41. m_toolbar = *find_descendant_of_type_named<GUI::Toolbar>("toolbar");
  42. m_toolbar_container = *find_descendant_of_type_named<GUI::ToolbarContainer>("toolbar_container");
  43. m_editor = *find_descendant_of_type_named<HexEditor>("editor");
  44. m_statusbar = *find_descendant_of_type_named<GUI::Statusbar>("statusbar");
  45. m_search_results = *find_descendant_of_type_named<GUI::TableView>("search_results");
  46. m_search_results_container = *find_descendant_of_type_named<GUI::Widget>("search_results_container");
  47. m_side_panel_container = *find_descendant_of_type_named<GUI::Widget>("side_panel_container");
  48. m_value_inspector_container = *find_descendant_of_type_named<GUI::Widget>("value_inspector_container");
  49. m_value_inspector = *find_descendant_of_type_named<GUI::TableView>("value_inspector");
  50. m_value_inspector->on_activation = [this](GUI::ModelIndex const& index) {
  51. if (!index.is_valid())
  52. return;
  53. m_selecting_from_inspector = true;
  54. m_editor->set_selection(m_editor->selection_start_offset(), index.data(GUI::ModelRole::Custom).to_integer<size_t>());
  55. m_editor->update();
  56. };
  57. m_editor->on_status_change = [this](int position, HexEditor::EditMode edit_mode, int selection_start, int selection_end) {
  58. m_statusbar->set_text(0, String::formatted("Offset: {:#08X}", position));
  59. m_statusbar->set_text(1, String::formatted("Edit Mode: {}", edit_mode == HexEditor::EditMode::Hex ? "Hex" : "Text"));
  60. m_statusbar->set_text(2, String::formatted("Selection Start: {}", selection_start));
  61. m_statusbar->set_text(3, String::formatted("Selection End: {}", selection_end));
  62. m_statusbar->set_text(4, String::formatted("Selected Bytes: {}", m_editor->selection_size()));
  63. bool has_selection = m_editor->has_selection();
  64. m_copy_hex_action->set_enabled(has_selection);
  65. m_copy_text_action->set_enabled(has_selection);
  66. m_copy_as_c_code_action->set_enabled(has_selection);
  67. m_fill_selection_action->set_enabled(has_selection);
  68. if (m_value_inspector_container->is_visible() && !m_selecting_from_inspector) {
  69. update_inspector_values(selection_start);
  70. }
  71. m_selecting_from_inspector = false;
  72. };
  73. m_editor->on_change = [this] {
  74. window()->set_modified(true);
  75. };
  76. m_search_results->set_activates_on_selection(true);
  77. m_search_results->on_activation = [this](const GUI::ModelIndex& index) {
  78. if (!index.is_valid())
  79. return;
  80. auto offset = index.data(GUI::ModelRole::Custom).to_i32();
  81. m_last_found_index = offset;
  82. m_editor->set_position(offset);
  83. m_editor->update();
  84. };
  85. m_new_action = GUI::Action::create("New", { Mod_Ctrl, Key_N }, Gfx::Bitmap::try_load_from_file("/res/icons/16x16/new.png"sv).release_value_but_fixme_should_propagate_errors(), [this](const GUI::Action&) {
  86. String value;
  87. if (request_close() && GUI::InputBox::show(window(), value, "Enter new file size:"sv, "New file size"sv) == GUI::InputBox::ExecResult::OK && !value.is_empty()) {
  88. auto file_size = value.to_uint();
  89. if (!file_size.has_value()) {
  90. GUI::MessageBox::show(window(), "Invalid file size entered."sv, "Error"sv, GUI::MessageBox::Type::Error);
  91. return;
  92. }
  93. if (auto error = m_editor->open_new_file(file_size.value()); error.is_error()) {
  94. GUI::MessageBox::show(window(), String::formatted("Unable to open new file: {}"sv, error.error()), "Error"sv, GUI::MessageBox::Type::Error);
  95. return;
  96. }
  97. set_path({});
  98. window()->set_modified(false);
  99. }
  100. });
  101. m_open_action = GUI::CommonActions::make_open_action([this](auto&) {
  102. if (!request_close())
  103. return;
  104. auto response = FileSystemAccessClient::Client::the().try_open_file(window(), {}, Core::StandardPaths::home_directory(), Core::OpenMode::ReadWrite);
  105. if (response.is_error())
  106. return;
  107. open_file(response.value());
  108. });
  109. m_save_action = GUI::CommonActions::make_save_action([&](auto&) {
  110. if (m_path.is_empty())
  111. return m_save_as_action->activate();
  112. if (!m_editor->save()) {
  113. GUI::MessageBox::show(window(), "Unable to save file.\n"sv, "Error"sv, GUI::MessageBox::Type::Error);
  114. } else {
  115. window()->set_modified(false);
  116. m_editor->update();
  117. }
  118. return;
  119. });
  120. m_save_as_action = GUI::CommonActions::make_save_as_action([&](auto&) {
  121. auto response = FileSystemAccessClient::Client::the().try_save_file(window(), m_name, m_extension, Core::OpenMode::ReadWrite | Core::OpenMode::Truncate);
  122. if (response.is_error())
  123. return;
  124. auto file = response.release_value();
  125. if (!m_editor->save_as(file)) {
  126. GUI::MessageBox::show(window(), "Unable to save file.\n"sv, "Error"sv, GUI::MessageBox::Type::Error);
  127. return;
  128. }
  129. window()->set_modified(false);
  130. set_path(file->filename());
  131. dbgln("Wrote document to {}", file->filename());
  132. });
  133. m_find_action = GUI::Action::create("&Find", { Mod_Ctrl, Key_F }, Gfx::Bitmap::try_load_from_file("/res/icons/16x16/find.png"sv).release_value_but_fixme_should_propagate_errors(), [&](const GUI::Action&) {
  134. auto old_buffer = m_search_buffer;
  135. bool find_all = false;
  136. if (FindDialog::show(window(), m_search_text, m_search_buffer, find_all) == GUI::InputBox::ExecResult::OK) {
  137. if (find_all) {
  138. auto matches = m_editor->find_all(m_search_buffer, 0);
  139. m_search_results->set_model(*new SearchResultsModel(move(matches)));
  140. m_search_results->update();
  141. if (matches.is_empty()) {
  142. GUI::MessageBox::show(window(), String::formatted("Pattern \"{}\" not found in this file", m_search_text), "Not found"sv, GUI::MessageBox::Type::Warning);
  143. return;
  144. }
  145. GUI::MessageBox::show(window(), String::formatted("Found {} matches for \"{}\" in this file", matches.size(), m_search_text), String::formatted("{} matches", matches.size()), GUI::MessageBox::Type::Warning);
  146. set_search_results_visible(true);
  147. } else {
  148. bool same_buffers = false;
  149. if (old_buffer.size() == m_search_buffer.size()) {
  150. if (memcmp(old_buffer.data(), m_search_buffer.data(), old_buffer.size()) == 0)
  151. same_buffers = true;
  152. }
  153. auto result = m_editor->find_and_highlight(m_search_buffer, same_buffers ? last_found_index() : 0);
  154. if (!result.has_value()) {
  155. GUI::MessageBox::show(window(), String::formatted("Pattern \"{}\" not found in this file", m_search_text), "Not found"sv, GUI::MessageBox::Type::Warning);
  156. return;
  157. }
  158. m_last_found_index = result.value();
  159. }
  160. m_editor->update();
  161. }
  162. });
  163. m_goto_offset_action = GUI::Action::create("&Go to Offset ...", { Mod_Ctrl, Key_G }, Gfx::Bitmap::try_load_from_file("/res/icons/16x16/go-to.png"sv).release_value_but_fixme_should_propagate_errors(), [this](const GUI::Action&) {
  164. int new_offset;
  165. auto result = GoToOffsetDialog::show(
  166. window(),
  167. m_goto_history,
  168. new_offset,
  169. m_editor->selection_start_offset(),
  170. m_editor->buffer_size());
  171. if (result == GUI::InputBox::ExecResult::OK) {
  172. m_editor->highlight(new_offset, new_offset);
  173. m_editor->update();
  174. }
  175. });
  176. m_layout_toolbar_action = GUI::Action::create_checkable("&Toolbar", [&](auto& action) {
  177. m_toolbar_container->set_visible(action.is_checked());
  178. Config::write_bool("HexEditor"sv, "Layout"sv, "ShowToolbar"sv, action.is_checked());
  179. });
  180. m_layout_search_results_action = GUI::Action::create_checkable("&Search Results", [&](auto& action) {
  181. set_search_results_visible(action.is_checked());
  182. });
  183. m_copy_hex_action = GUI::Action::create("Copy &Hex", { Mod_Ctrl, Key_C }, Gfx::Bitmap::try_load_from_file("/res/icons/16x16/hex.png"sv).release_value_but_fixme_should_propagate_errors(), [&](const GUI::Action&) {
  184. m_editor->copy_selected_hex_to_clipboard();
  185. });
  186. m_copy_hex_action->set_enabled(false);
  187. m_copy_text_action = GUI::Action::create("Copy &Text", { Mod_Ctrl | Mod_Shift, Key_C }, Gfx::Bitmap::try_load_from_file("/res/icons/16x16/edit-copy.png"sv).release_value_but_fixme_should_propagate_errors(), [&](const GUI::Action&) {
  188. m_editor->copy_selected_text_to_clipboard();
  189. });
  190. m_copy_text_action->set_enabled(false);
  191. m_copy_as_c_code_action = GUI::Action::create("Copy as &C Code", { Mod_Alt | Mod_Shift, Key_C }, Gfx::Bitmap::try_load_from_file("/res/icons/16x16/c.png"sv).release_value_but_fixme_should_propagate_errors(), [&](const GUI::Action&) {
  192. m_editor->copy_selected_hex_to_clipboard_as_c_code();
  193. });
  194. m_copy_as_c_code_action->set_enabled(false);
  195. m_fill_selection_action = GUI::Action::create("Fill &Selection...", { Mod_Ctrl, Key_B }, [&](const GUI::Action&) {
  196. String value;
  197. if (GUI::InputBox::show(window(), value, "Fill byte (hex):"sv, "Fill Selection"sv) == GUI::InputBox::ExecResult::OK && !value.is_empty()) {
  198. auto fill_byte = strtol(value.characters(), nullptr, 16);
  199. m_editor->fill_selection(fill_byte);
  200. }
  201. });
  202. m_fill_selection_action->set_enabled(false);
  203. m_layout_value_inspector_action = GUI::Action::create_checkable("&Value Inspector", [&](auto& action) {
  204. set_value_inspector_visible(action.is_checked());
  205. });
  206. m_toolbar->add_action(*m_new_action);
  207. m_toolbar->add_action(*m_open_action);
  208. m_toolbar->add_action(*m_save_action);
  209. m_toolbar->add_separator();
  210. m_toolbar->add_action(*m_find_action);
  211. m_toolbar->add_action(*m_goto_offset_action);
  212. m_statusbar->segment(0).set_clickable(true);
  213. m_statusbar->segment(0).set_action(*m_goto_offset_action);
  214. m_editor->set_focus(true);
  215. }
  216. void HexEditorWidget::update_inspector_values(size_t position)
  217. {
  218. // build out primitive types like u8, i8, u16, etc
  219. size_t byte_read_count = 0;
  220. u64 unsigned_64_bit_int = 0;
  221. for (int i = 0; i < 8; ++i) {
  222. Optional<u8> read_result = m_editor->get_byte(position + i);
  223. u8 current_byte = 0;
  224. if (!read_result.has_value())
  225. break;
  226. current_byte = read_result.release_value();
  227. if (m_value_inspector_little_endian)
  228. unsigned_64_bit_int = ((u64)current_byte << (8 * byte_read_count)) + unsigned_64_bit_int;
  229. else
  230. unsigned_64_bit_int = (unsigned_64_bit_int << 8) + current_byte;
  231. ++byte_read_count;
  232. }
  233. if (!m_value_inspector_little_endian) {
  234. // if we didn't read far enough, lets finish shifting the bytes so the code below works
  235. size_t bytes_left_to_read = 8 - byte_read_count;
  236. unsigned_64_bit_int = (unsigned_64_bit_int << (8 * bytes_left_to_read));
  237. }
  238. // Populate the model
  239. NonnullRefPtr<ValueInspectorModel> value_inspector_model = make_ref_counted<ValueInspectorModel>(m_value_inspector_little_endian);
  240. if (byte_read_count >= 1) {
  241. u8 unsigned_byte_value = 0;
  242. if (m_value_inspector_little_endian)
  243. unsigned_byte_value = (unsigned_64_bit_int & 0xFF);
  244. else
  245. unsigned_byte_value = (unsigned_64_bit_int >> (64 - 8)) & 0xFF;
  246. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::SignedByte, String::number(static_cast<i8>(unsigned_byte_value)));
  247. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UnsignedByte, String::number(unsigned_byte_value));
  248. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::ASCII, String::formatted("{:c}", static_cast<char>(unsigned_byte_value)));
  249. } else {
  250. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::SignedByte, "");
  251. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UnsignedByte, "");
  252. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::ASCII, "");
  253. }
  254. if (byte_read_count >= 2) {
  255. u16 unsigned_short_value = 0;
  256. if (m_value_inspector_little_endian)
  257. unsigned_short_value = (unsigned_64_bit_int & 0xFFFF);
  258. else
  259. unsigned_short_value = (unsigned_64_bit_int >> (64 - 16)) & 0xFFFF;
  260. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::SignedShort, String::number(static_cast<i16>(unsigned_short_value)));
  261. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UnsignedShort, String::number(unsigned_short_value));
  262. } else {
  263. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::SignedShort, "");
  264. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UnsignedShort, "");
  265. }
  266. if (byte_read_count >= 4) {
  267. u32 unsigned_int_value = 0;
  268. if (m_value_inspector_little_endian)
  269. unsigned_int_value = (unsigned_64_bit_int & 0xFFFFFFFF);
  270. else
  271. unsigned_int_value = (unsigned_64_bit_int >> 32) & 0xFFFFFFFF;
  272. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::SignedInt, String::number(static_cast<i32>(unsigned_int_value)));
  273. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UnsignedInt, String::number(unsigned_int_value));
  274. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::Float, String::number(bit_cast<float>(unsigned_int_value)));
  275. } else {
  276. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::SignedInt, "");
  277. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UnsignedInt, "");
  278. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::Float, "");
  279. }
  280. if (byte_read_count >= 8) {
  281. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::SignedLong, String::number(static_cast<i64>(unsigned_64_bit_int)));
  282. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UnsignedLong, String::number(unsigned_64_bit_int));
  283. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::Double, String::number(bit_cast<double>(unsigned_64_bit_int)));
  284. } else {
  285. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::SignedLong, "");
  286. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UnsignedLong, "");
  287. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::Double, "");
  288. }
  289. // FIXME: This probably doesn't honour endianness correctly.
  290. Utf8View utf8_view { ReadonlyBytes { reinterpret_cast<u8 const*>(&unsigned_64_bit_int), 4 } };
  291. size_t valid_bytes;
  292. utf8_view.validate(valid_bytes);
  293. if (valid_bytes == 0)
  294. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UTF8, "");
  295. else
  296. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UTF8, utf8_view.unicode_substring_view(0, 1).as_string());
  297. if (byte_read_count % 2 == 0) {
  298. Utf16View utf16_view { Span<u16 const> { reinterpret_cast<u16 const*>(&unsigned_64_bit_int), 4 } };
  299. size_t valid_code_units;
  300. utf16_view.validate(valid_code_units);
  301. if (valid_code_units == 0)
  302. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UTF16, "");
  303. else
  304. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UTF16, utf16_view.unicode_substring_view(0, 1).to_utf8());
  305. } else {
  306. value_inspector_model->set_parsed_value(ValueInspectorModel::ValueType::UTF16, "");
  307. }
  308. // FIXME: Parse as other values like Timestamp etc
  309. m_value_inspector->set_model(value_inspector_model);
  310. m_value_inspector->update();
  311. }
  312. void HexEditorWidget::initialize_menubar(GUI::Window& window)
  313. {
  314. auto& file_menu = window.add_menu("&File");
  315. file_menu.add_action(*m_new_action);
  316. file_menu.add_action(*m_open_action);
  317. file_menu.add_action(*m_save_action);
  318. file_menu.add_action(*m_save_as_action);
  319. file_menu.add_separator();
  320. file_menu.add_action(GUI::CommonActions::make_quit_action([this](auto&) {
  321. if (!request_close())
  322. return;
  323. GUI::Application::the()->quit();
  324. }));
  325. auto& edit_menu = window.add_menu("&Edit");
  326. edit_menu.add_action(GUI::CommonActions::make_select_all_action([this](auto&) {
  327. m_editor->select_all();
  328. m_editor->update();
  329. }));
  330. edit_menu.add_action(*m_fill_selection_action);
  331. edit_menu.add_separator();
  332. edit_menu.add_action(*m_copy_hex_action);
  333. edit_menu.add_action(*m_copy_text_action);
  334. edit_menu.add_action(*m_copy_as_c_code_action);
  335. edit_menu.add_separator();
  336. edit_menu.add_action(*m_find_action);
  337. edit_menu.add_action(GUI::Action::create("Find &Next", { Mod_None, Key_F3 }, Gfx::Bitmap::try_load_from_file("/res/icons/16x16/find-next.png"sv).release_value_but_fixme_should_propagate_errors(), [&](const GUI::Action&) {
  338. if (m_search_text.is_empty() || m_search_buffer.is_empty()) {
  339. GUI::MessageBox::show(&window, "Nothing to search for"sv, "Not found"sv, GUI::MessageBox::Type::Warning);
  340. return;
  341. }
  342. auto result = m_editor->find_and_highlight(m_search_buffer, last_found_index());
  343. if (!result.has_value()) {
  344. GUI::MessageBox::show(&window, String::formatted("No more matches for \"{}\" found in this file", m_search_text), "Not found"sv, GUI::MessageBox::Type::Warning);
  345. return;
  346. }
  347. m_editor->update();
  348. m_last_found_index = result.value();
  349. }));
  350. edit_menu.add_action(GUI::Action::create("Find All &Strings", { Mod_Ctrl | Mod_Shift, Key_F }, Gfx::Bitmap::try_load_from_file("/res/icons/16x16/find.png"sv).release_value_but_fixme_should_propagate_errors(), [&](const GUI::Action&) {
  351. int min_length = 4;
  352. auto matches = m_editor->find_all_strings(min_length);
  353. m_search_results->set_model(*new SearchResultsModel(move(matches)));
  354. m_search_results->update();
  355. if (matches.is_empty()) {
  356. GUI::MessageBox::show(&window, "No strings found in this file"sv, "Not found"sv, GUI::MessageBox::Type::Warning);
  357. return;
  358. }
  359. set_search_results_visible(true);
  360. m_editor->update();
  361. }));
  362. edit_menu.add_separator();
  363. edit_menu.add_action(*m_goto_offset_action);
  364. auto& view_menu = window.add_menu("&View");
  365. auto show_toolbar = Config::read_bool("HexEditor"sv, "Layout"sv, "ShowToolbar"sv, true);
  366. m_layout_toolbar_action->set_checked(show_toolbar);
  367. m_toolbar_container->set_visible(show_toolbar);
  368. view_menu.add_action(*m_layout_toolbar_action);
  369. view_menu.add_action(*m_layout_search_results_action);
  370. view_menu.add_action(*m_layout_value_inspector_action);
  371. view_menu.add_separator();
  372. auto bytes_per_row = Config::read_i32("HexEditor"sv, "Layout"sv, "BytesPerRow"sv, 16);
  373. m_editor->set_bytes_per_row(bytes_per_row);
  374. m_editor->update();
  375. m_bytes_per_row_actions.set_exclusive(true);
  376. auto& bytes_per_row_menu = view_menu.add_submenu("Bytes per &Row");
  377. for (int i = 8; i <= 32; i += 8) {
  378. auto action = GUI::Action::create_checkable(String::number(i), [this, i](auto&) {
  379. m_editor->set_bytes_per_row(i);
  380. m_editor->update();
  381. Config::write_i32("HexEditor"sv, "Layout"sv, "BytesPerRow"sv, i);
  382. });
  383. m_bytes_per_row_actions.add_action(action);
  384. bytes_per_row_menu.add_action(action);
  385. if (i == bytes_per_row)
  386. action->set_checked(true);
  387. }
  388. m_value_inspector_mode_actions.set_exclusive(true);
  389. auto& inspector_mode_menu = view_menu.add_submenu("Value Inspector &Mode");
  390. auto little_endian_mode = GUI::Action::create_checkable("&Little Endian", [&](auto& action) {
  391. m_value_inspector_little_endian = action.is_checked();
  392. update_inspector_values(m_editor->selection_start_offset());
  393. });
  394. m_value_inspector_mode_actions.add_action(little_endian_mode);
  395. inspector_mode_menu.add_action(little_endian_mode);
  396. auto big_endian_mode = GUI::Action::create_checkable("&Big Endian", [this](auto& action) {
  397. m_value_inspector_little_endian = !action.is_checked();
  398. update_inspector_values(m_editor->selection_start_offset());
  399. });
  400. m_value_inspector_mode_actions.add_action(big_endian_mode);
  401. inspector_mode_menu.add_action(big_endian_mode);
  402. // Default to little endian mode
  403. little_endian_mode->set_checked(true);
  404. auto& help_menu = window.add_menu("&Help");
  405. help_menu.add_action(GUI::CommonActions::make_help_action([](auto&) {
  406. Desktop::Launcher::open(URL::create_with_file_protocol("/usr/share/man/man1/HexEditor.md"), "/bin/Help");
  407. }));
  408. help_menu.add_action(GUI::CommonActions::make_about_action("Hex Editor", GUI::Icon::default_icon("app-hex-editor"sv), &window));
  409. }
  410. void HexEditorWidget::set_path(StringView path)
  411. {
  412. if (path.is_empty()) {
  413. m_path = {};
  414. m_name = {};
  415. m_extension = {};
  416. } else {
  417. auto lexical_path = LexicalPath(path);
  418. m_path = lexical_path.string();
  419. m_name = lexical_path.title();
  420. m_extension = lexical_path.extension();
  421. }
  422. update_title();
  423. }
  424. void HexEditorWidget::update_title()
  425. {
  426. StringBuilder builder;
  427. if (m_path.is_empty())
  428. builder.append("Untitled"sv);
  429. else
  430. builder.append(m_path);
  431. builder.append("[*] - Hex Editor"sv);
  432. window()->set_title(builder.to_string());
  433. }
  434. void HexEditorWidget::open_file(NonnullRefPtr<Core::File> file)
  435. {
  436. window()->set_modified(false);
  437. m_editor->open_file(file);
  438. set_path(file->filename());
  439. }
  440. bool HexEditorWidget::request_close()
  441. {
  442. if (!window()->is_modified())
  443. return true;
  444. auto result = GUI::MessageBox::ask_about_unsaved_changes(window(), m_path);
  445. if (result == GUI::MessageBox::ExecResult::Yes) {
  446. m_save_action->activate();
  447. return !window()->is_modified();
  448. }
  449. return result == GUI::MessageBox::ExecResult::No;
  450. }
  451. void HexEditorWidget::set_search_results_visible(bool visible)
  452. {
  453. m_layout_search_results_action->set_checked(visible);
  454. m_search_results_container->set_visible(visible);
  455. // Ensure side panel container is visible if either search result or value inspector are turned on
  456. m_side_panel_container->set_visible(visible || m_value_inspector_container->is_visible());
  457. }
  458. void HexEditorWidget::set_value_inspector_visible(bool visible)
  459. {
  460. if (visible)
  461. update_inspector_values(m_editor->selection_start_offset());
  462. m_layout_value_inspector_action->set_checked(visible);
  463. m_value_inspector_container->set_visible(visible);
  464. // Ensure side panel container is visible if either search result or value inspector are turned on
  465. m_side_panel_container->set_visible(visible || m_search_results_container->is_visible());
  466. }
  467. void HexEditorWidget::drop_event(GUI::DropEvent& event)
  468. {
  469. event.accept();
  470. if (event.mime_data().has_urls()) {
  471. auto urls = event.mime_data().urls();
  472. if (urls.is_empty())
  473. return;
  474. window()->move_to_front();
  475. // TODO: A drop event should be considered user consent for opening a file
  476. auto response = FileSystemAccessClient::Client::the().try_request_file(window(), urls.first().path(), Core::OpenMode::ReadOnly);
  477. if (response.is_error())
  478. return;
  479. open_file(response.value());
  480. }
  481. }