mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-12-27 21:21:50 +03:00
e800605ad3
This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
390 lines
16 KiB
C++
390 lines
16 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
* Copyright (c) 2021, Mohsan Ali <mohsan0073@gmail.com>
|
|
* Copyright (c) 2023, Caoimhe Byrne <caoimhebyrne06@gmail.com>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include "MainWidget.h"
|
|
#include "ViewWidget.h"
|
|
#include <LibConfig/Client.h>
|
|
#include <LibCore/ArgsParser.h>
|
|
#include <LibCore/System.h>
|
|
#include <LibDesktop/Launcher.h>
|
|
#include <LibFileSystemAccessClient/Client.h>
|
|
#include <LibGUI/Action.h>
|
|
#include <LibGUI/ActionGroup.h>
|
|
#include <LibGUI/Application.h>
|
|
#include <LibGUI/BoxLayout.h>
|
|
#include <LibGUI/Clipboard.h>
|
|
#include <LibGUI/Desktop.h>
|
|
#include <LibGUI/FilePicker.h>
|
|
#include <LibGUI/Label.h>
|
|
#include <LibGUI/Menu.h>
|
|
#include <LibGUI/Menubar.h>
|
|
#include <LibGUI/MessageBox.h>
|
|
#include <LibGUI/Toolbar.h>
|
|
#include <LibGUI/ToolbarContainer.h>
|
|
#include <LibGUI/Window.h>
|
|
#include <LibGfx/Bitmap.h>
|
|
#include <LibGfx/Palette.h>
|
|
#include <LibGfx/Rect.h>
|
|
#include <LibMain/Main.h>
|
|
#include <LibURL/URL.h>
|
|
#include <serenity.h>
|
|
#include <string.h>
|
|
|
|
using namespace ImageViewer;
|
|
|
|
ErrorOr<int> serenity_main(Main::Arguments arguments)
|
|
{
|
|
TRY(Core::System::pledge("stdio recvfd sendfd rpath wpath cpath unix thread"));
|
|
|
|
auto app = TRY(GUI::Application::create(arguments));
|
|
|
|
Config::pledge_domains({ "ImageViewer", "WindowManager" });
|
|
|
|
app->set_config_domain("ImageViewer"_string);
|
|
|
|
TRY(Desktop::Launcher::add_allowed_handler_with_any_url("/bin/ImageViewer"));
|
|
TRY(Desktop::Launcher::add_allowed_handler_with_only_specific_urls("/bin/Help", { URL::create_with_file_scheme("/usr/share/man/man1/Applications/ImageViewer.md") }));
|
|
TRY(Desktop::Launcher::seal_allowlist());
|
|
|
|
// FIXME: Use unveil when we solve the issue with ViewWidget::load_files_from_directory, an explanation is given in ViewWidget.cpp
|
|
// TRY(Core::System::unveil("/tmp/session/%sid/portal/filesystemaccess", "rw"));
|
|
// TRY(Core::System::unveil("/tmp/session/%sid/portal/image", "rw"));
|
|
// TRY(Core::System::unveil("/res", "r"));
|
|
// TRY(Core::System::unveil(nullptr, nullptr));
|
|
|
|
auto app_icon = GUI::Icon::default_icon("app-image-viewer"sv);
|
|
|
|
StringView path;
|
|
Core::ArgsParser args_parser;
|
|
args_parser.add_positional_argument(path, "The image file to be displayed.", "file", Core::ArgsParser::Required::No);
|
|
args_parser.parse(arguments);
|
|
|
|
auto window = GUI::Window::construct();
|
|
window->set_double_buffering_enabled(true);
|
|
window->resize(300, 200);
|
|
window->set_icon(app_icon.bitmap_for_size(16));
|
|
window->set_title("Image Viewer");
|
|
|
|
auto root_widget = window->set_main_widget<MainWidget>();
|
|
|
|
auto& toolbar_container = root_widget->add<GUI::ToolbarContainer>();
|
|
auto& main_toolbar = toolbar_container.add<GUI::Toolbar>();
|
|
|
|
auto& widget = root_widget->add<ViewWidget>();
|
|
widget.on_scale_change = [&](float scale) {
|
|
if (!widget.image()) {
|
|
window->set_title("Image Viewer");
|
|
return;
|
|
}
|
|
|
|
window->set_title(ByteString::formatted("{} {} {}% - Image Viewer", widget.path(), widget.image()->size().to_byte_string(), (int)(scale * 100)));
|
|
|
|
if (!widget.scaled_for_first_image()) {
|
|
widget.set_scaled_for_first_image(true);
|
|
widget.resize_window();
|
|
}
|
|
};
|
|
widget.on_drop = [&](auto& event) {
|
|
if (!event.mime_data().has_urls())
|
|
return;
|
|
|
|
auto urls = event.mime_data().urls();
|
|
|
|
if (urls.is_empty())
|
|
return;
|
|
|
|
window->move_to_front();
|
|
|
|
auto path = urls.first().serialize_path();
|
|
auto result = FileSystemAccessClient::Client::the().request_file_read_only_approved(window, path);
|
|
if (result.is_error())
|
|
return;
|
|
|
|
auto value = result.release_value();
|
|
widget.open_file(MUST(String::from_byte_string(value.filename())), value.stream());
|
|
|
|
for (size_t i = 1; i < urls.size(); ++i) {
|
|
Desktop::Launcher::open(URL::create_with_file_scheme(urls[i].serialize_path().characters()), "/bin/ImageViewer");
|
|
}
|
|
};
|
|
widget.on_doubleclick = [&] {
|
|
window->set_fullscreen(!window->is_fullscreen());
|
|
toolbar_container.set_visible(!window->is_fullscreen());
|
|
widget.set_frame_style(window->is_fullscreen() ? Gfx::FrameStyle::NoFrame : Gfx::FrameStyle::SunkenContainer);
|
|
};
|
|
|
|
// Actions
|
|
auto open_action = GUI::CommonActions::make_open_action(
|
|
[&](auto&) {
|
|
FileSystemAccessClient::OpenFileOptions options {
|
|
.window_title = "Open Image"sv,
|
|
.allowed_file_types = Vector { GUI::FileTypeFilter::image_files(), GUI::FileTypeFilter::all_files() },
|
|
};
|
|
auto result = FileSystemAccessClient::Client::the().open_file(window, options);
|
|
if (result.is_error())
|
|
return;
|
|
|
|
auto value = result.release_value();
|
|
widget.open_file(MUST(String::from_byte_string(value.filename())), value.stream());
|
|
});
|
|
|
|
auto delete_action = GUI::CommonActions::make_delete_action(
|
|
[&](auto&) {
|
|
auto path = widget.path();
|
|
if (path.is_empty())
|
|
return;
|
|
|
|
auto msgbox_result = GUI::MessageBox::show(window,
|
|
ByteString::formatted("Are you sure you want to delete {}?", path),
|
|
"Confirm Deletion"sv,
|
|
GUI::MessageBox::Type::Warning,
|
|
GUI::MessageBox::InputType::OKCancel);
|
|
|
|
if (msgbox_result == GUI::MessageBox::ExecResult::Cancel)
|
|
return;
|
|
|
|
auto unlinked_or_error = Core::System::unlink(widget.path());
|
|
if (unlinked_or_error.is_error()) {
|
|
GUI::MessageBox::show(window,
|
|
ByteString::formatted("unlink({}) failed: {}", path, unlinked_or_error.error()),
|
|
"Delete Failed"sv,
|
|
GUI::MessageBox::Type::Error);
|
|
|
|
return;
|
|
}
|
|
|
|
widget.clear();
|
|
});
|
|
|
|
auto quit_action = GUI::CommonActions::make_quit_action(
|
|
[&](auto&) {
|
|
app->quit();
|
|
});
|
|
|
|
auto rotate_counterclockwise_action = GUI::CommonActions::make_rotate_counterclockwise_action([&](auto&) {
|
|
widget.rotate(Gfx::RotationDirection::CounterClockwise);
|
|
});
|
|
|
|
auto rotate_clockwise_action = GUI::CommonActions::make_rotate_clockwise_action([&](auto&) {
|
|
widget.rotate(Gfx::RotationDirection::Clockwise);
|
|
});
|
|
|
|
auto vertical_flip_action = GUI::Action::create("Flip &Vertically", { Mod_None, Key_V }, TRY(Gfx::Bitmap::load_from_file("/res/icons/16x16/edit-flip-vertical.png"sv)),
|
|
[&](auto&) {
|
|
widget.flip(Gfx::Orientation::Vertical);
|
|
});
|
|
|
|
auto horizontal_flip_action = GUI::Action::create("Flip &Horizontally", { Mod_None, Key_H }, TRY(Gfx::Bitmap::load_from_file("/res/icons/16x16/edit-flip-horizontal.png"sv)),
|
|
[&](auto&) {
|
|
widget.flip(Gfx::Orientation::Horizontal);
|
|
});
|
|
|
|
auto desktop_wallpaper_action = GUI::Action::create("Set as Desktop &Wallpaper", TRY(Gfx::Bitmap::load_from_file("/res/icons/16x16/app-display-settings.png"sv)),
|
|
[&](auto&) {
|
|
if (!GUI::Desktop::the().set_wallpaper(widget.image()->bitmap(GUI::Desktop::the().rect().size()).release_value_but_fixme_should_propagate_errors(), widget.path())) {
|
|
GUI::MessageBox::show(window,
|
|
ByteString::formatted("set_wallpaper({}) failed", widget.path()),
|
|
"Could not set wallpaper"sv,
|
|
GUI::MessageBox::Type::Error);
|
|
}
|
|
});
|
|
|
|
auto go_first_action = GUI::Action::create("&Go to First", { Mod_None, Key_Home }, TRY(Gfx::Bitmap::load_from_file("/res/icons/16x16/go-first.png"sv)),
|
|
[&](auto&) {
|
|
widget.navigate(ViewWidget::Directions::First);
|
|
});
|
|
|
|
auto go_back_action = GUI::Action::create("Go to &Previous", { Mod_None, Key_Left }, TRY(Gfx::Bitmap::load_from_file("/res/icons/16x16/go-back.png"sv)),
|
|
[&](auto&) {
|
|
widget.navigate(ViewWidget::Directions::Back);
|
|
});
|
|
|
|
auto go_forward_action = GUI::Action::create("Go to &Next", { Mod_None, Key_Right }, TRY(Gfx::Bitmap::load_from_file("/res/icons/16x16/go-forward.png"sv)),
|
|
[&](auto&) {
|
|
widget.navigate(ViewWidget::Directions::Forward);
|
|
});
|
|
|
|
auto go_last_action = GUI::Action::create("Go to &Last", { Mod_None, Key_End }, TRY(Gfx::Bitmap::load_from_file("/res/icons/16x16/go-last.png"sv)),
|
|
[&](auto&) {
|
|
widget.navigate(ViewWidget::Directions::Last);
|
|
});
|
|
|
|
auto full_screen_action = GUI::CommonActions::make_fullscreen_action(
|
|
[&](auto&) {
|
|
widget.on_doubleclick();
|
|
});
|
|
|
|
auto zoom_in_action = GUI::CommonActions::make_zoom_in_action(
|
|
[&](auto&) {
|
|
widget.set_scale(widget.scale() * 1.44f);
|
|
},
|
|
window);
|
|
|
|
auto reset_zoom_action = GUI::CommonActions::make_reset_zoom_action(
|
|
[&](auto&) {
|
|
widget.set_scale(1.f);
|
|
},
|
|
window);
|
|
|
|
auto fit_image_to_view_action = GUI::Action::create(
|
|
"Fit Image To &View", TRY(Gfx::Bitmap::load_from_file("/res/icons/16x16/fit-image-to-view.png"sv)), [&](auto&) {
|
|
widget.fit_content_to_view();
|
|
});
|
|
|
|
auto zoom_out_action = GUI::CommonActions::make_zoom_out_action(
|
|
[&](auto&) {
|
|
widget.set_scale(widget.scale() / 1.44f);
|
|
},
|
|
window);
|
|
|
|
auto hide_show_toolbar_action = GUI::Action::create_checkable("&Toolbar", { Mod_Ctrl, Key_T },
|
|
[&](auto& action) {
|
|
toolbar_container.set_visible(action.is_checked());
|
|
});
|
|
hide_show_toolbar_action->set_checked(true);
|
|
|
|
auto copy_action = GUI::CommonActions::make_copy_action([&](auto&) {
|
|
if (widget.image())
|
|
GUI::Clipboard::the().set_bitmap(*widget.image()->bitmap({}).release_value_but_fixme_should_propagate_errors());
|
|
});
|
|
|
|
auto nearest_neighbor_action = GUI::Action::create_checkable("&Nearest Neighbor", [&](auto&) {
|
|
widget.set_scaling_mode(Gfx::Painter::ScalingMode::NearestNeighbor);
|
|
});
|
|
nearest_neighbor_action->set_checked(true);
|
|
|
|
auto smooth_pixels_action = GUI::Action::create_checkable("&Smooth Pixels", [&](auto&) {
|
|
widget.set_scaling_mode(Gfx::Painter::ScalingMode::SmoothPixels);
|
|
});
|
|
|
|
auto bilinear_action = GUI::Action::create_checkable("&Bilinear", [&](auto&) {
|
|
widget.set_scaling_mode(Gfx::Painter::ScalingMode::BilinearBlend);
|
|
});
|
|
|
|
auto box_sampling_action = GUI::Action::create_checkable("B&ox Sampling", [&](auto&) {
|
|
widget.set_scaling_mode(Gfx::Painter::ScalingMode::BoxSampling);
|
|
});
|
|
|
|
widget.on_image_change = [&](Image const* image) {
|
|
bool should_enable_image_actions = (image != nullptr);
|
|
bool should_enable_forward_actions = (widget.is_next_available() && should_enable_image_actions);
|
|
bool should_enable_backward_actions = (widget.is_previous_available() && should_enable_image_actions);
|
|
delete_action->set_enabled(should_enable_image_actions);
|
|
rotate_counterclockwise_action->set_enabled(should_enable_image_actions);
|
|
rotate_clockwise_action->set_enabled(should_enable_image_actions);
|
|
vertical_flip_action->set_enabled(should_enable_image_actions);
|
|
horizontal_flip_action->set_enabled(should_enable_image_actions);
|
|
desktop_wallpaper_action->set_enabled(should_enable_image_actions);
|
|
|
|
go_first_action->set_enabled(should_enable_backward_actions);
|
|
go_back_action->set_enabled(should_enable_backward_actions);
|
|
go_forward_action->set_enabled(should_enable_forward_actions);
|
|
go_last_action->set_enabled(should_enable_forward_actions);
|
|
|
|
zoom_in_action->set_enabled(should_enable_image_actions);
|
|
reset_zoom_action->set_enabled(should_enable_image_actions);
|
|
zoom_out_action->set_enabled(should_enable_image_actions);
|
|
if (!should_enable_image_actions) {
|
|
window->set_title("Image Viewer");
|
|
}
|
|
};
|
|
|
|
main_toolbar.add_action(open_action);
|
|
main_toolbar.add_action(delete_action);
|
|
main_toolbar.add_separator();
|
|
main_toolbar.add_action(go_first_action);
|
|
main_toolbar.add_action(go_back_action);
|
|
main_toolbar.add_action(go_forward_action);
|
|
main_toolbar.add_action(go_last_action);
|
|
main_toolbar.add_separator();
|
|
main_toolbar.add_action(zoom_in_action);
|
|
main_toolbar.add_action(reset_zoom_action);
|
|
main_toolbar.add_action(zoom_out_action);
|
|
|
|
auto file_menu = window->add_menu("&File"_string);
|
|
file_menu->add_action(open_action);
|
|
file_menu->add_action(delete_action);
|
|
file_menu->add_separator();
|
|
|
|
file_menu->add_recent_files_list([&](auto& action) {
|
|
auto path = action.text();
|
|
auto result = FileSystemAccessClient::Client::the().request_file_read_only_approved(window, path);
|
|
if (result.is_error())
|
|
return;
|
|
|
|
auto value = result.release_value();
|
|
widget.open_file(MUST(String::from_byte_string(value.filename())), value.stream());
|
|
});
|
|
|
|
file_menu->add_action(quit_action);
|
|
|
|
auto image_menu = window->add_menu("&Image"_string);
|
|
image_menu->add_action(rotate_counterclockwise_action);
|
|
image_menu->add_action(rotate_clockwise_action);
|
|
image_menu->add_action(vertical_flip_action);
|
|
image_menu->add_action(horizontal_flip_action);
|
|
image_menu->add_separator();
|
|
image_menu->add_action(desktop_wallpaper_action);
|
|
|
|
auto navigate_menu = window->add_menu("&Navigate"_string);
|
|
navigate_menu->add_action(go_first_action);
|
|
navigate_menu->add_action(go_back_action);
|
|
navigate_menu->add_action(go_forward_action);
|
|
navigate_menu->add_action(go_last_action);
|
|
|
|
auto view_menu = window->add_menu("&View"_string);
|
|
view_menu->add_action(full_screen_action);
|
|
view_menu->add_separator();
|
|
view_menu->add_action(zoom_in_action);
|
|
view_menu->add_action(reset_zoom_action);
|
|
view_menu->add_action(fit_image_to_view_action);
|
|
view_menu->add_action(zoom_out_action);
|
|
view_menu->add_separator();
|
|
|
|
auto scaling_mode_menu = view_menu->add_submenu("&Scaling Mode"_string);
|
|
scaling_mode_menu->set_icon(TRY(Gfx::Bitmap::load_from_file("/res/icons/16x16/scale.png"sv)));
|
|
|
|
auto scaling_mode_group = make<GUI::ActionGroup>();
|
|
scaling_mode_group->set_exclusive(true);
|
|
scaling_mode_group->add_action(*nearest_neighbor_action);
|
|
scaling_mode_group->add_action(*smooth_pixels_action);
|
|
scaling_mode_group->add_action(*bilinear_action);
|
|
scaling_mode_group->add_action(*box_sampling_action);
|
|
|
|
scaling_mode_menu->add_action(nearest_neighbor_action);
|
|
scaling_mode_menu->add_action(smooth_pixels_action);
|
|
scaling_mode_menu->add_action(bilinear_action);
|
|
scaling_mode_menu->add_action(box_sampling_action);
|
|
|
|
view_menu->add_separator();
|
|
view_menu->add_action(hide_show_toolbar_action);
|
|
|
|
auto help_menu = window->add_menu("&Help"_string);
|
|
help_menu->add_action(GUI::CommonActions::make_command_palette_action(window));
|
|
help_menu->add_action(GUI::CommonActions::make_help_action([](auto&) {
|
|
Desktop::Launcher::open(URL::create_with_file_scheme("/usr/share/man/man1/Applications/ImageViewer.md"), "/bin/Help");
|
|
}));
|
|
help_menu->add_action(GUI::CommonActions::make_about_action("Image Viewer"_string, app_icon, window));
|
|
|
|
window->show();
|
|
|
|
// We must do this here and not any earlier, as we need a visible window to call FileSystemAccessClient::Client::request_file_read_only_approved();
|
|
if (path != nullptr) {
|
|
auto result = FileSystemAccessClient::Client::the().request_file_read_only_approved(window, path);
|
|
if (result.is_error())
|
|
return 1;
|
|
|
|
auto value = result.release_value();
|
|
widget.open_file(MUST(String::from_byte_string(value.filename())), value.stream());
|
|
} else {
|
|
widget.clear();
|
|
}
|
|
|
|
return app->exec();
|
|
}
|