main.cpp 38 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * All rights reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. *
  8. * 1. Redistributions of source code must retain the above copyright notice, this
  9. * list of conditions and the following disclaimer.
  10. *
  11. * 2. Redistributions in binary form must reproduce the above copyright notice,
  12. * this list of conditions and the following disclaimer in the documentation
  13. * and/or other materials provided with the distribution.
  14. *
  15. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  16. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  19. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  21. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  22. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25. */
  26. #include "DesktopWidget.h"
  27. #include "DirectoryView.h"
  28. #include "FileUtils.h"
  29. #include "PropertiesDialog.h"
  30. #include <AK/LexicalPath.h>
  31. #include <AK/StringBuilder.h>
  32. #include <AK/URL.h>
  33. #include <Applications/FileManager/FileManagerWindowGML.h>
  34. #include <LibCore/ConfigFile.h>
  35. #include <LibCore/MimeData.h>
  36. #include <LibCore/StandardPaths.h>
  37. #include <LibDesktop/Launcher.h>
  38. #include <LibGUI/AboutDialog.h>
  39. #include <LibGUI/Action.h>
  40. #include <LibGUI/ActionGroup.h>
  41. #include <LibGUI/Application.h>
  42. #include <LibGUI/BoxLayout.h>
  43. #include <LibGUI/BreadcrumbBar.h>
  44. #include <LibGUI/Clipboard.h>
  45. #include <LibGUI/Desktop.h>
  46. #include <LibGUI/FileIconProvider.h>
  47. #include <LibGUI/FileSystemModel.h>
  48. #include <LibGUI/InputBox.h>
  49. #include <LibGUI/Label.h>
  50. #include <LibGUI/Menu.h>
  51. #include <LibGUI/MenuBar.h>
  52. #include <LibGUI/MessageBox.h>
  53. #include <LibGUI/Painter.h>
  54. #include <LibGUI/ProgressBar.h>
  55. #include <LibGUI/Splitter.h>
  56. #include <LibGUI/StatusBar.h>
  57. #include <LibGUI/TextEditor.h>
  58. #include <LibGUI/ToolBar.h>
  59. #include <LibGUI/ToolBarContainer.h>
  60. #include <LibGUI/TreeView.h>
  61. #include <LibGUI/Widget.h>
  62. #include <LibGUI/Window.h>
  63. #include <LibGfx/Palette.h>
  64. #include <pthread.h>
  65. #include <serenity.h>
  66. #include <signal.h>
  67. #include <spawn.h>
  68. #include <stdio.h>
  69. #include <string.h>
  70. #include <unistd.h>
  71. using namespace FileManager;
  72. static int run_in_desktop_mode(RefPtr<Core::ConfigFile>);
  73. static int run_in_windowed_mode(RefPtr<Core::ConfigFile>, String initial_location);
  74. static void do_copy(const Vector<String>& selected_file_paths);
  75. static void do_paste(const String& target_directory, GUI::Window* window);
  76. static void do_create_link(const Vector<String>& selected_file_paths, GUI::Window* window);
  77. static void show_properties(const String& container_dir_path, const String& path, const Vector<String>& selected, GUI::Window* window);
  78. int main(int argc, char** argv)
  79. {
  80. if (pledge("stdio thread shared_buffer accept unix cpath rpath wpath fattr proc exec sigaction", nullptr) < 0) {
  81. perror("pledge");
  82. return 1;
  83. }
  84. struct sigaction act;
  85. memset(&act, 0, sizeof(act));
  86. act.sa_flags = SA_NOCLDWAIT;
  87. act.sa_handler = SIG_IGN;
  88. int rc = sigaction(SIGCHLD, &act, nullptr);
  89. if (rc < 0) {
  90. perror("sigaction");
  91. return 1;
  92. }
  93. RefPtr<Core::ConfigFile> config = Core::ConfigFile::get_for_app("FileManager");
  94. auto app = GUI::Application::construct(argc, argv);
  95. if (pledge("stdio thread shared_buffer accept cpath rpath wpath fattr proc exec unix", nullptr) < 0) {
  96. perror("pledge");
  97. return 1;
  98. }
  99. if (app->args().contains_slow("--desktop") || app->args().contains_slow("-d"))
  100. return run_in_desktop_mode(move(config));
  101. // our initial location is defined as, in order of precedence:
  102. // 1. the first command-line argument (e.g. FileManager /bin)
  103. // 2. the user's home directory
  104. // 3. the root directory
  105. String initial_location;
  106. if (argc >= 2) {
  107. char* buffer = realpath(argv[1], nullptr);
  108. initial_location = buffer;
  109. free(buffer);
  110. }
  111. if (initial_location.is_empty())
  112. initial_location = Core::StandardPaths::home_directory();
  113. if (initial_location.is_empty())
  114. initial_location = "/";
  115. return run_in_windowed_mode(move(config), initial_location);
  116. }
  117. void do_copy(const Vector<String>& selected_file_paths)
  118. {
  119. if (selected_file_paths.is_empty())
  120. ASSERT_NOT_REACHED();
  121. StringBuilder copy_text;
  122. for (auto& path : selected_file_paths) {
  123. auto url = URL::create_with_file_protocol(path);
  124. copy_text.appendff("{}\n", url);
  125. }
  126. GUI::Clipboard::the().set_data(copy_text.build().bytes(), "text/uri-list");
  127. }
  128. void do_paste(const String& target_directory, GUI::Window* window)
  129. {
  130. auto data_and_type = GUI::Clipboard::the().data_and_type();
  131. if (data_and_type.mime_type != "text/uri-list") {
  132. dbgln("Cannot paste clipboard type {}", data_and_type.mime_type);
  133. return;
  134. }
  135. auto copied_lines = String::copy(data_and_type.data).split('\n');
  136. if (copied_lines.is_empty()) {
  137. dbgln("No files to paste");
  138. return;
  139. }
  140. for (auto& uri_as_string : copied_lines) {
  141. if (uri_as_string.is_empty())
  142. continue;
  143. URL url = uri_as_string;
  144. if (!url.is_valid() || url.protocol() != "file") {
  145. dbgln("Cannot paste URI {}", uri_as_string);
  146. continue;
  147. }
  148. auto new_path = String::formatted("{}/{}", target_directory, url.basename());
  149. if (!FileUtils::copy_file_or_directory(url.path(), new_path)) {
  150. auto error_message = String::formatted("Could not paste {}.", url.path());
  151. GUI::MessageBox::show(window, error_message, "File Manager", GUI::MessageBox::Type::Error);
  152. }
  153. }
  154. }
  155. void do_create_link(const Vector<String>& selected_file_paths, GUI::Window* window)
  156. {
  157. auto path = selected_file_paths.first();
  158. auto title = LexicalPath(path.view()).title();
  159. auto destination = String::formatted("{}/{}", Core::StandardPaths::desktop_directory(), title);
  160. if (!FileUtils::link_file(path, destination)) {
  161. GUI::MessageBox::show(window, "Could not create desktop shortcut", "File Manager",
  162. GUI::MessageBox::Type::Error);
  163. }
  164. }
  165. void show_properties(const String& container_dir_path, const String& path, const Vector<String>& selected, GUI::Window* window)
  166. {
  167. RefPtr<PropertiesDialog> properties;
  168. if (selected.is_empty()) {
  169. properties = window->add<PropertiesDialog>(path, true);
  170. } else {
  171. properties = window->add<PropertiesDialog>(selected.first(), access(container_dir_path.characters(), W_OK) != 0);
  172. }
  173. properties->exec();
  174. }
  175. int run_in_desktop_mode([[maybe_unused]] RefPtr<Core::ConfigFile> config)
  176. {
  177. static constexpr const char* process_name = "FileManager (Desktop)";
  178. set_process_name(process_name, strlen(process_name));
  179. pthread_setname_np(pthread_self(), process_name);
  180. auto window = GUI::Window::construct();
  181. window->set_title("Desktop Manager");
  182. window->set_window_type(GUI::WindowType::Desktop);
  183. window->set_has_alpha_channel(true);
  184. auto& desktop_widget = window->set_main_widget<FileManager::DesktopWidget>();
  185. desktop_widget.set_layout<GUI::VerticalBoxLayout>();
  186. [[maybe_unused]] auto& directory_view = desktop_widget.add<DirectoryView>(DirectoryView::Mode::Desktop);
  187. auto copy_action = GUI::CommonActions::make_copy_action(
  188. [&](auto&) {
  189. auto paths = directory_view.selected_file_paths();
  190. if (paths.is_empty())
  191. ASSERT_NOT_REACHED();
  192. do_copy(paths);
  193. },
  194. window);
  195. copy_action->set_enabled(false);
  196. directory_view.on_selection_change = [&](const GUI::AbstractView& view) {
  197. copy_action->set_enabled(!view.selection().is_empty());
  198. };
  199. auto properties_action
  200. = GUI::Action::create(
  201. "Properties...", { Mod_Alt, Key_Return }, Gfx::Bitmap::load_from_file("/res/icons/16x16/properties.png"), [&](const GUI::Action&) {
  202. String path = directory_view.path();
  203. Vector<String> selected = directory_view.selected_file_paths();
  204. show_properties(path, path, selected, directory_view.window());
  205. },
  206. window);
  207. auto paste_action = GUI::CommonActions::make_paste_action(
  208. [&](const GUI::Action&) {
  209. do_paste(directory_view.path(), directory_view.window());
  210. },
  211. window);
  212. paste_action->set_enabled(GUI::Clipboard::the().mime_type() == "text/uri-list" && access(directory_view.path().characters(), W_OK) == 0);
  213. GUI::Clipboard::the().on_change = [&](const String& data_type) {
  214. paste_action->set_enabled(data_type == "text/uri-list" && access(directory_view.path().characters(), W_OK) == 0);
  215. };
  216. auto desktop_view_context_menu = GUI::Menu::construct("Directory View");
  217. auto file_manager_action = GUI::Action::create("Show in FileManager...", {}, Gfx::Bitmap::load_from_file("/res/icons/16x16/filetype-folder.png"), [&](const GUI::Action&) {
  218. Desktop::Launcher::open(URL::create_with_file_protocol(directory_view.path()));
  219. });
  220. auto display_properties_action = GUI::Action::create("Display settings...", {}, Gfx::Bitmap::load_from_file("/res/icons/16x16/app-display-settings.png"), [&](const GUI::Action&) {
  221. Desktop::Launcher::open(URL::create_with_file_protocol("/bin/DisplaySettings"));
  222. });
  223. desktop_view_context_menu->add_action(directory_view.mkdir_action());
  224. desktop_view_context_menu->add_action(directory_view.touch_action());
  225. desktop_view_context_menu->add_action(paste_action);
  226. desktop_view_context_menu->add_separator();
  227. desktop_view_context_menu->add_action(file_manager_action);
  228. desktop_view_context_menu->add_action(directory_view.open_terminal_action());
  229. desktop_view_context_menu->add_separator();
  230. desktop_view_context_menu->add_action(display_properties_action);
  231. auto desktop_context_menu = GUI::Menu::construct("Directory View Directory");
  232. desktop_context_menu->add_action(copy_action);
  233. desktop_context_menu->add_action(paste_action);
  234. desktop_context_menu->add_action(directory_view.delete_action());
  235. desktop_context_menu->add_separator();
  236. desktop_context_menu->add_action(properties_action);
  237. directory_view.on_context_menu_request = [&](const GUI::ModelIndex& index, const GUI::ContextMenuEvent& event) {
  238. if (!index.is_valid())
  239. desktop_view_context_menu->popup(event.screen_position());
  240. else
  241. desktop_context_menu->popup(event.screen_position());
  242. };
  243. auto wm_config = Core::ConfigFile::get_for_app("WindowManager");
  244. auto selected_wallpaper = wm_config->read_entry("Background", "Wallpaper", "");
  245. if (!selected_wallpaper.is_empty()) {
  246. GUI::Desktop::the().set_wallpaper(selected_wallpaper, false);
  247. }
  248. window->show();
  249. return GUI::Application::the()->exec();
  250. }
  251. int run_in_windowed_mode(RefPtr<Core::ConfigFile> config, String initial_location)
  252. {
  253. auto window = GUI::Window::construct();
  254. window->set_title("File Manager");
  255. auto left = config->read_num_entry("Window", "Left", 150);
  256. auto top = config->read_num_entry("Window", "Top", 75);
  257. auto width = config->read_num_entry("Window", "Width", 640);
  258. auto height = config->read_num_entry("Window", "Height", 480);
  259. window->set_rect({ left, top, width, height });
  260. auto& widget = window->set_main_widget<GUI::Widget>();
  261. widget.load_from_gml(file_manager_window_gml);
  262. auto& main_toolbar = (GUI::ToolBar&)*widget.find_descendant_by_name("main_toolbar");
  263. auto& location_toolbar = (GUI::ToolBar&)*widget.find_descendant_by_name("location_toolbar");
  264. location_toolbar.layout()->set_margins({ 6, 3, 6, 3 });
  265. auto& location_textbox = (GUI::TextBox&)*widget.find_descendant_by_name("location_textbox");
  266. auto& breadcrumb_toolbar = (GUI::ToolBar&)*widget.find_descendant_by_name("breadcrumb_toolbar");
  267. breadcrumb_toolbar.layout()->set_margins({});
  268. auto& breadcrumb_bar = (GUI::BreadcrumbBar&)*widget.find_descendant_by_name("breadcrumb_bar");
  269. location_textbox.on_focusout = [&] {
  270. location_toolbar.set_visible(false);
  271. breadcrumb_toolbar.set_visible(true);
  272. };
  273. auto& splitter = (GUI::HorizontalSplitter&)*widget.find_descendant_by_name("splitter");
  274. auto& tree_view = (GUI::TreeView&)*widget.find_descendant_by_name("tree_view");
  275. auto directories_model = GUI::FileSystemModel::create({}, GUI::FileSystemModel::Mode::DirectoriesOnly);
  276. tree_view.set_model(directories_model);
  277. tree_view.set_column_hidden(GUI::FileSystemModel::Column::Icon, true);
  278. tree_view.set_column_hidden(GUI::FileSystemModel::Column::Size, true);
  279. tree_view.set_column_hidden(GUI::FileSystemModel::Column::Owner, true);
  280. tree_view.set_column_hidden(GUI::FileSystemModel::Column::Group, true);
  281. tree_view.set_column_hidden(GUI::FileSystemModel::Column::Permissions, true);
  282. tree_view.set_column_hidden(GUI::FileSystemModel::Column::ModificationTime, true);
  283. tree_view.set_column_hidden(GUI::FileSystemModel::Column::Inode, true);
  284. tree_view.set_column_hidden(GUI::FileSystemModel::Column::SymlinkTarget, true);
  285. bool is_reacting_to_tree_view_selection_change = false;
  286. auto& directory_view = splitter.add<DirectoryView>(DirectoryView::Mode::Normal);
  287. location_textbox.on_escape_pressed = [&] {
  288. directory_view.set_focus(true);
  289. };
  290. // Open the root directory. FIXME: This is awkward.
  291. tree_view.toggle_index(directories_model->index(0, 0, {}));
  292. auto& statusbar = (GUI::StatusBar&)*widget.find_descendant_by_name("statusbar");
  293. auto& progressbar = (GUI::ProgressBar&)*widget.find_descendant_by_name("progressbar");
  294. progressbar.set_format(GUI::ProgressBar::Format::ValueSlashMax);
  295. progressbar.set_frame_shape(Gfx::FrameShape::Panel);
  296. progressbar.set_frame_shadow(Gfx::FrameShadow::Sunken);
  297. progressbar.set_frame_thickness(1);
  298. location_textbox.on_return_pressed = [&] {
  299. directory_view.open(location_textbox.text());
  300. };
  301. auto refresh_tree_view = [&] {
  302. directories_model->update();
  303. auto current_path = directory_view.path();
  304. struct stat st;
  305. // If the directory no longer exists, we find a parent that does.
  306. while (stat(current_path.characters(), &st) != 0) {
  307. directory_view.open_parent_directory();
  308. current_path = directory_view.path();
  309. if (current_path == directories_model->root_path()) {
  310. break;
  311. }
  312. }
  313. // Reselect the existing folder in the tree.
  314. auto new_index = directories_model->index(current_path, GUI::FileSystemModel::Column::Name);
  315. if (new_index.is_valid()) {
  316. tree_view.expand_all_parents_of(new_index);
  317. tree_view.set_cursor(new_index, GUI::AbstractView::SelectionUpdate::Set, true);
  318. }
  319. directory_view.refresh();
  320. };
  321. auto directory_context_menu = GUI::Menu::construct("Directory View Directory");
  322. auto directory_view_context_menu = GUI::Menu::construct("Directory View");
  323. auto tree_view_directory_context_menu = GUI::Menu::construct("Tree View Directory");
  324. auto tree_view_context_menu = GUI::Menu::construct("Tree View");
  325. auto open_parent_directory_action = GUI::Action::create("Open parent directory", { Mod_Alt, Key_Up }, Gfx::Bitmap::load_from_file("/res/icons/16x16/open-parent-directory.png"), [&](const GUI::Action&) {
  326. directory_view.open_parent_directory();
  327. });
  328. RefPtr<GUI::Action> view_as_table_action;
  329. RefPtr<GUI::Action> view_as_icons_action;
  330. RefPtr<GUI::Action> view_as_columns_action;
  331. view_as_icons_action = GUI::Action::create_checkable(
  332. "Icon view", { Mod_Ctrl, KeyCode::Key_1 }, Gfx::Bitmap::load_from_file("/res/icons/16x16/icon-view.png"), [&](const GUI::Action&) {
  333. directory_view.set_view_mode(DirectoryView::ViewMode::Icon);
  334. config->write_entry("DirectoryView", "ViewMode", "Icon");
  335. config->sync();
  336. },
  337. window);
  338. view_as_table_action = GUI::Action::create_checkable(
  339. "Table view", { Mod_Ctrl, KeyCode::Key_2 }, Gfx::Bitmap::load_from_file("/res/icons/16x16/table-view.png"), [&](const GUI::Action&) {
  340. directory_view.set_view_mode(DirectoryView::ViewMode::Table);
  341. config->write_entry("DirectoryView", "ViewMode", "Table");
  342. config->sync();
  343. },
  344. window);
  345. view_as_columns_action = GUI::Action::create_checkable(
  346. "Columns view", { Mod_Ctrl, KeyCode::Key_3 }, Gfx::Bitmap::load_from_file("/res/icons/16x16/columns-view.png"), [&](const GUI::Action&) {
  347. directory_view.set_view_mode(DirectoryView::ViewMode::Columns);
  348. config->write_entry("DirectoryView", "ViewMode", "Columns");
  349. config->sync();
  350. },
  351. window);
  352. auto view_type_action_group = make<GUI::ActionGroup>();
  353. view_type_action_group->set_exclusive(true);
  354. view_type_action_group->add_action(*view_as_icons_action);
  355. view_type_action_group->add_action(*view_as_table_action);
  356. view_type_action_group->add_action(*view_as_columns_action);
  357. auto tree_view_selected_file_paths = [&] {
  358. Vector<String> paths;
  359. auto& view = tree_view;
  360. view.selection().for_each_index([&](const GUI::ModelIndex& index) {
  361. paths.append(directories_model->full_path(index));
  362. });
  363. return paths;
  364. };
  365. auto select_all_action = GUI::Action::create("Select all", { Mod_Ctrl, KeyCode::Key_A }, [&](const GUI::Action&) {
  366. directory_view.current_view().select_all();
  367. });
  368. auto copy_action = GUI::CommonActions::make_copy_action(
  369. [&](auto&) {
  370. auto paths = directory_view.selected_file_paths();
  371. if (paths.is_empty())
  372. paths = tree_view_selected_file_paths();
  373. if (paths.is_empty())
  374. ASSERT_NOT_REACHED();
  375. do_copy(paths);
  376. refresh_tree_view();
  377. },
  378. window);
  379. copy_action->set_enabled(false);
  380. auto shortcut_action
  381. = GUI::Action::create(
  382. "Create desktop shortcut",
  383. {},
  384. Gfx::Bitmap::load_from_file("/res/icons/16x16/filetype-symlink.png"),
  385. [&](const GUI::Action&) {
  386. auto paths = directory_view.selected_file_paths();
  387. if (paths.is_empty()) {
  388. return;
  389. }
  390. do_create_link(paths, directory_view.window());
  391. },
  392. window);
  393. auto properties_action
  394. = GUI::Action::create(
  395. "Properties...", { Mod_Alt, Key_Return }, Gfx::Bitmap::load_from_file("/res/icons/16x16/properties.png"), [&](const GUI::Action& action) {
  396. String container_dir_path;
  397. String path;
  398. Vector<String> selected;
  399. if (action.activator() == directory_context_menu || directory_view.active_widget()->is_focused()) {
  400. path = directory_view.path();
  401. container_dir_path = path;
  402. selected = directory_view.selected_file_paths();
  403. } else {
  404. path = directories_model->full_path(tree_view.selection().first());
  405. container_dir_path = LexicalPath(path).basename();
  406. selected = tree_view_selected_file_paths();
  407. }
  408. show_properties(container_dir_path, path, selected, directory_view.window());
  409. },
  410. window);
  411. auto paste_action = GUI::CommonActions::make_paste_action(
  412. [&](const GUI::Action& action) {
  413. String target_directory;
  414. if (action.activator() == directory_context_menu)
  415. target_directory = directory_view.selected_file_paths()[0];
  416. else
  417. target_directory = directory_view.path();
  418. do_paste(target_directory, directory_view.window());
  419. refresh_tree_view();
  420. },
  421. window);
  422. auto folder_specific_paste_action = GUI::CommonActions::make_paste_action(
  423. [&](const GUI::Action& action) {
  424. String target_directory;
  425. if (action.activator() == directory_context_menu)
  426. target_directory = directory_view.selected_file_paths()[0];
  427. else
  428. target_directory = directory_view.path();
  429. do_paste(target_directory, directory_view.window());
  430. refresh_tree_view();
  431. },
  432. window);
  433. auto go_back_action = GUI::CommonActions::make_go_back_action(
  434. [&](auto&) {
  435. directory_view.open_previous_directory();
  436. },
  437. window);
  438. auto go_forward_action = GUI::CommonActions::make_go_forward_action(
  439. [&](auto&) {
  440. directory_view.open_next_directory();
  441. },
  442. window);
  443. auto go_home_action = GUI::CommonActions::make_go_home_action(
  444. [&](auto&) {
  445. directory_view.open(Core::StandardPaths::home_directory());
  446. },
  447. window);
  448. GUI::Clipboard::the().on_change = [&](const String& data_type) {
  449. auto current_location = directory_view.path();
  450. paste_action->set_enabled(data_type == "text/uri-list" && access(current_location.characters(), W_OK) == 0);
  451. };
  452. auto tree_view_delete_action = GUI::CommonActions::make_delete_action(
  453. [&](auto&) {
  454. FileUtils::delete_paths(tree_view_selected_file_paths(), true, window);
  455. refresh_tree_view();
  456. },
  457. &tree_view);
  458. // This is a little awkward. The menu action does something different depending on which view has focus.
  459. // It would be nice to find a good abstraction for this instead of creating a branching action like this.
  460. auto focus_dependent_delete_action = GUI::CommonActions::make_delete_action([&](auto&) {
  461. if (tree_view.is_focused())
  462. tree_view_delete_action->activate();
  463. else
  464. directory_view.delete_action().activate();
  465. refresh_tree_view();
  466. });
  467. focus_dependent_delete_action->set_enabled(false);
  468. auto mkdir_action = GUI::Action::create("New directory...", { Mod_Ctrl | Mod_Shift, Key_N }, Gfx::Bitmap::load_from_file("/res/icons/16x16/mkdir.png"), [&](const GUI::Action&) {
  469. directory_view.mkdir_action().activate();
  470. refresh_tree_view();
  471. });
  472. auto touch_action = GUI::Action::create("New file...", { Mod_Ctrl | Mod_Shift, Key_F }, Gfx::Bitmap::load_from_file("/res/icons/16x16/new.png"), [&](const GUI::Action&) {
  473. directory_view.touch_action().activate();
  474. refresh_tree_view();
  475. });
  476. auto menubar = GUI::MenuBar::construct();
  477. auto& app_menu = menubar->add_menu("File Manager");
  478. app_menu.add_action(mkdir_action);
  479. app_menu.add_action(touch_action);
  480. app_menu.add_action(copy_action);
  481. app_menu.add_action(paste_action);
  482. app_menu.add_action(focus_dependent_delete_action);
  483. app_menu.add_action(directory_view.open_terminal_action());
  484. app_menu.add_separator();
  485. app_menu.add_action(properties_action);
  486. app_menu.add_separator();
  487. app_menu.add_action(GUI::CommonActions::make_quit_action([](auto&) {
  488. GUI::Application::the()->quit();
  489. }));
  490. auto action_show_dotfiles = GUI::Action::create_checkable("Show dotfiles", { Mod_Ctrl, Key_H }, [&](auto& action) {
  491. directory_view.set_should_show_dotfiles(action.is_checked());
  492. refresh_tree_view();
  493. });
  494. auto& view_menu = menubar->add_menu("View");
  495. view_menu.add_action(*view_as_icons_action);
  496. view_menu.add_action(*view_as_table_action);
  497. view_menu.add_action(*view_as_columns_action);
  498. view_menu.add_separator();
  499. view_menu.add_action(action_show_dotfiles);
  500. auto& go_menu = menubar->add_menu("Go");
  501. go_menu.add_action(go_back_action);
  502. go_menu.add_action(go_forward_action);
  503. go_menu.add_action(open_parent_directory_action);
  504. go_menu.add_action(go_home_action);
  505. go_menu.add_action(GUI::Action::create(
  506. "Go to location...", { Mod_Ctrl, Key_L }, [&](auto&) {
  507. location_toolbar.set_visible(true);
  508. breadcrumb_toolbar.set_visible(false);
  509. location_textbox.select_all();
  510. location_textbox.set_focus(true);
  511. }));
  512. auto& help_menu = menubar->add_menu("Help");
  513. help_menu.add_action(GUI::Action::create("About", [&](auto&) {
  514. GUI::AboutDialog::show("File Manager", Gfx::Bitmap::load_from_file("/res/icons/32x32/filetype-folder.png"), window);
  515. }));
  516. GUI::Application::the()->set_menubar(move(menubar));
  517. main_toolbar.add_action(go_back_action);
  518. main_toolbar.add_action(go_forward_action);
  519. main_toolbar.add_action(open_parent_directory_action);
  520. main_toolbar.add_action(go_home_action);
  521. main_toolbar.add_separator();
  522. main_toolbar.add_action(mkdir_action);
  523. main_toolbar.add_action(touch_action);
  524. main_toolbar.add_action(copy_action);
  525. main_toolbar.add_action(paste_action);
  526. main_toolbar.add_action(focus_dependent_delete_action);
  527. main_toolbar.add_action(directory_view.open_terminal_action());
  528. main_toolbar.add_separator();
  529. main_toolbar.add_action(*view_as_icons_action);
  530. main_toolbar.add_action(*view_as_table_action);
  531. main_toolbar.add_action(*view_as_columns_action);
  532. directory_view.on_path_change = [&](const String& new_path, bool can_write_in_path) {
  533. auto icon = GUI::FileIconProvider::icon_for_path(new_path);
  534. auto* bitmap = icon.bitmap_for_size(16);
  535. window->set_icon(bitmap);
  536. location_textbox.set_icon(bitmap);
  537. window->set_title(String::formatted("{} - File Manager", new_path));
  538. location_textbox.set_text(new_path);
  539. {
  540. LexicalPath lexical_path(new_path);
  541. auto segment_index_of_new_path_in_breadcrumb_bar = [&]() -> Optional<size_t> {
  542. for (size_t i = 0; i < breadcrumb_bar.segment_count(); ++i) {
  543. if (breadcrumb_bar.segment_data(i) == new_path)
  544. return i;
  545. }
  546. return {};
  547. }();
  548. if (segment_index_of_new_path_in_breadcrumb_bar.has_value()) {
  549. breadcrumb_bar.set_selected_segment(segment_index_of_new_path_in_breadcrumb_bar.value());
  550. } else {
  551. breadcrumb_bar.clear_segments();
  552. breadcrumb_bar.append_segment("/", GUI::FileIconProvider::icon_for_path("/").bitmap_for_size(16), "/");
  553. StringBuilder builder;
  554. for (auto& part : lexical_path.parts()) {
  555. // NOTE: We rebuild the path as we go, so we have something to pass to GUI::FileIconProvider.
  556. builder.append('/');
  557. builder.append(part);
  558. breadcrumb_bar.append_segment(part, GUI::FileIconProvider::icon_for_path(builder.string_view()).bitmap_for_size(16), builder.string_view());
  559. }
  560. breadcrumb_bar.set_selected_segment(breadcrumb_bar.segment_count() - 1);
  561. breadcrumb_bar.on_segment_click = [&](size_t segment_index) {
  562. directory_view.open(breadcrumb_bar.segment_data(segment_index));
  563. };
  564. }
  565. }
  566. if (!is_reacting_to_tree_view_selection_change) {
  567. auto new_index = directories_model->index(new_path, GUI::FileSystemModel::Column::Name);
  568. if (new_index.is_valid()) {
  569. tree_view.expand_all_parents_of(new_index);
  570. tree_view.set_cursor(new_index, GUI::AbstractView::SelectionUpdate::Set);
  571. }
  572. }
  573. struct stat st;
  574. if (lstat(new_path.characters(), &st)) {
  575. perror("stat");
  576. return;
  577. }
  578. paste_action->set_enabled(can_write_in_path && GUI::Clipboard::the().mime_type() == "text/uri-list");
  579. go_forward_action->set_enabled(directory_view.path_history_position() < directory_view.path_history_size() - 1);
  580. go_back_action->set_enabled(directory_view.path_history_position() > 0);
  581. open_parent_directory_action->set_enabled(new_path != "/");
  582. };
  583. directory_view.on_accepted_drop = [&]() {
  584. refresh_tree_view();
  585. };
  586. directory_view.on_status_message = [&](const StringView& message) {
  587. statusbar.set_text(message);
  588. };
  589. directory_view.on_thumbnail_progress = [&](int done, int total) {
  590. if (done == total) {
  591. progressbar.set_visible(false);
  592. return;
  593. }
  594. progressbar.set_range(0, total);
  595. progressbar.set_value(done);
  596. progressbar.set_visible(true);
  597. };
  598. directory_view.on_selection_change = [&](GUI::AbstractView& view) {
  599. auto& selection = view.selection();
  600. copy_action->set_enabled(!selection.is_empty());
  601. focus_dependent_delete_action->set_enabled((!tree_view.selection().is_empty() && tree_view.is_focused())
  602. || !directory_view.current_view().selection().is_empty());
  603. };
  604. directory_context_menu->add_action(copy_action);
  605. directory_context_menu->add_action(folder_specific_paste_action);
  606. directory_context_menu->add_action(directory_view.delete_action());
  607. directory_context_menu->add_action(shortcut_action);
  608. directory_context_menu->add_separator();
  609. directory_context_menu->add_action(properties_action);
  610. directory_view_context_menu->add_action(mkdir_action);
  611. directory_view_context_menu->add_action(touch_action);
  612. directory_view_context_menu->add_action(paste_action);
  613. directory_view_context_menu->add_action(directory_view.open_terminal_action());
  614. directory_view_context_menu->add_separator();
  615. directory_view_context_menu->add_action(action_show_dotfiles);
  616. directory_view_context_menu->add_separator();
  617. directory_view_context_menu->add_action(properties_action);
  618. tree_view_directory_context_menu->add_action(copy_action);
  619. tree_view_directory_context_menu->add_action(paste_action);
  620. tree_view_directory_context_menu->add_action(tree_view_delete_action);
  621. tree_view_directory_context_menu->add_separator();
  622. tree_view_directory_context_menu->add_action(properties_action);
  623. tree_view_directory_context_menu->add_separator();
  624. tree_view_directory_context_menu->add_action(mkdir_action);
  625. tree_view_directory_context_menu->add_action(touch_action);
  626. RefPtr<GUI::Menu> file_context_menu;
  627. NonnullRefPtrVector<LauncherHandler> current_file_handlers;
  628. RefPtr<GUI::Action> file_context_menu_action_default_action;
  629. directory_view.on_context_menu_request = [&](const GUI::ModelIndex& index, const GUI::ContextMenuEvent& event) {
  630. if (index.is_valid()) {
  631. auto& node = directory_view.node(index);
  632. if (node.is_directory()) {
  633. auto should_get_enabled = access(node.full_path().characters(), W_OK) == 0 && GUI::Clipboard::the().mime_type() == "text/uri-list";
  634. folder_specific_paste_action->set_enabled(should_get_enabled);
  635. directory_context_menu->popup(event.screen_position());
  636. } else {
  637. auto full_path = node.full_path();
  638. current_file_handlers = directory_view.get_launch_handlers(full_path);
  639. file_context_menu = GUI::Menu::construct("Directory View File");
  640. file_context_menu->add_action(copy_action);
  641. file_context_menu->add_action(paste_action);
  642. file_context_menu->add_action(directory_view.delete_action());
  643. file_context_menu->add_action(shortcut_action);
  644. file_context_menu->add_separator();
  645. bool added_open_menu_items = false;
  646. auto default_file_handler = directory_view.get_default_launch_handler(current_file_handlers);
  647. if (default_file_handler) {
  648. auto file_open_action = default_file_handler->create_launch_action([&, full_path = move(full_path)](auto& launcher_handler) {
  649. directory_view.launch(URL::create_with_file_protocol(full_path), launcher_handler);
  650. });
  651. if (default_file_handler->details().launcher_type == Desktop::Launcher::LauncherType::Application)
  652. file_open_action->set_text(String::formatted("Run {}", file_open_action->text()));
  653. else
  654. file_open_action->set_text(String::formatted("Open in {}", file_open_action->text()));
  655. file_context_menu_action_default_action = file_open_action;
  656. file_context_menu->add_action(move(file_open_action));
  657. added_open_menu_items = true;
  658. } else {
  659. file_context_menu_action_default_action.clear();
  660. }
  661. if (current_file_handlers.size() > 1) {
  662. added_open_menu_items = true;
  663. auto& file_open_with_menu = file_context_menu->add_submenu("Open with");
  664. for (auto& handler : current_file_handlers) {
  665. if (&handler == default_file_handler.ptr())
  666. continue;
  667. file_open_with_menu.add_action(handler.create_launch_action([&, full_path = move(full_path)](auto& launcher_handler) {
  668. directory_view.launch(URL::create_with_file_protocol(full_path), launcher_handler);
  669. }));
  670. }
  671. }
  672. if (added_open_menu_items)
  673. file_context_menu->add_separator();
  674. file_context_menu->add_action(properties_action);
  675. file_context_menu->popup(event.screen_position(), file_context_menu_action_default_action);
  676. }
  677. } else {
  678. directory_view_context_menu->popup(event.screen_position());
  679. }
  680. };
  681. tree_view.on_selection = [&](const GUI::ModelIndex& index) {
  682. if (directories_model->m_previously_selected_index.is_valid())
  683. directories_model->update_node_on_selection(directories_model->m_previously_selected_index, false);
  684. directories_model->update_node_on_selection(index, true);
  685. directories_model->m_previously_selected_index = index;
  686. };
  687. tree_view.on_selection_change = [&] {
  688. focus_dependent_delete_action->set_enabled((!tree_view.selection().is_empty() && tree_view.is_focused())
  689. || !directory_view.current_view().selection().is_empty());
  690. if (tree_view.selection().is_empty())
  691. return;
  692. auto path = directories_model->full_path(tree_view.selection().first());
  693. if (directory_view.path() == path)
  694. return;
  695. TemporaryChange change(is_reacting_to_tree_view_selection_change, true);
  696. directory_view.open(path);
  697. copy_action->set_enabled(!tree_view.selection().is_empty());
  698. directory_view.delete_action().set_enabled(!tree_view.selection().is_empty());
  699. };
  700. tree_view.on_focus_change = [&]([[maybe_unused]] const bool has_focus, [[maybe_unused]] const GUI::FocusSource source) {
  701. focus_dependent_delete_action->set_enabled((!tree_view.selection().is_empty() && has_focus)
  702. || !directory_view.current_view().selection().is_empty());
  703. };
  704. tree_view.on_context_menu_request = [&](const GUI::ModelIndex& index, const GUI::ContextMenuEvent& event) {
  705. if (index.is_valid()) {
  706. tree_view_directory_context_menu->popup(event.screen_position());
  707. }
  708. };
  709. tree_view.on_drop = [&](const GUI::ModelIndex& index, const GUI::DropEvent& event) {
  710. if (!event.mime_data().has_urls())
  711. return;
  712. auto urls = event.mime_data().urls();
  713. if (urls.is_empty()) {
  714. dbgln("No files to drop");
  715. return;
  716. }
  717. auto& target_node = directories_model->node(index);
  718. if (!target_node.is_directory())
  719. return;
  720. bool had_accepted_drop = false;
  721. for (auto& url_to_copy : urls) {
  722. if (!url_to_copy.is_valid() || url_to_copy.path() == target_node.full_path())
  723. continue;
  724. auto new_path = String::formatted("{}/{}", target_node.full_path(), LexicalPath(url_to_copy.path()).basename());
  725. if (url_to_copy.path() == new_path)
  726. continue;
  727. if (!FileUtils::copy_file_or_directory(url_to_copy.path(), new_path)) {
  728. auto error_message = String::formatted("Could not copy {} into {}.", url_to_copy.to_string(), new_path);
  729. GUI::MessageBox::show(window, error_message, "File Manager", GUI::MessageBox::Type::Error);
  730. } else {
  731. had_accepted_drop = true;
  732. }
  733. }
  734. if (had_accepted_drop)
  735. refresh_tree_view();
  736. };
  737. directory_view.open(initial_location);
  738. directory_view.set_focus(true);
  739. paste_action->set_enabled(GUI::Clipboard::the().mime_type() == "text/uri-list" && access(initial_location.characters(), W_OK) == 0);
  740. window->show();
  741. // Read directory read mode from config.
  742. auto dir_view_mode = config->read_entry("DirectoryView", "ViewMode", "Icon");
  743. if (dir_view_mode.contains("Table")) {
  744. directory_view.set_view_mode(DirectoryView::ViewMode::Table);
  745. view_as_table_action->set_checked(true);
  746. } else if (dir_view_mode.contains("Columns")) {
  747. directory_view.set_view_mode(DirectoryView::ViewMode::Columns);
  748. view_as_columns_action->set_checked(true);
  749. } else {
  750. directory_view.set_view_mode(DirectoryView::ViewMode::Icon);
  751. view_as_icons_action->set_checked(true);
  752. }
  753. // Write window position to config file on close request.
  754. window->on_close_request = [&] {
  755. config->write_num_entry("Window", "Left", window->x());
  756. config->write_num_entry("Window", "Top", window->y());
  757. config->write_num_entry("Window", "Width", window->width());
  758. config->write_num_entry("Window", "Height", window->height());
  759. config->sync();
  760. return GUI::Window::CloseRequestDecision::Close;
  761. };
  762. return GUI::Application::the()->exec();
  763. }