Applications: Move to Userland/Applications/

Userland/Applications/QuickShow/CMakeLists.txt

@@ -0,0 +1,7 @@
+set(SOURCES
+    main.cpp
+    QSWidget.cpp
+)
+
+serenity_app(QuickShow ICON filetype-image)
+target_link_libraries(QuickShow LibGUI LibGfx)

Userland/Applications/QuickShow/QSWidget.cpp

@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "QSWidget.h"
+#include <AK/StringBuilder.h>
+#include <LibCore/DirIterator.h>
+#include <LibGUI/MessageBox.h>
+#include <LibGUI/Painter.h>
+#include <LibGUI/Window.h>
+#include <LibGfx/Bitmap.h>
+#include <LibGfx/Orientation.h>
+#include <LibGfx/Palette.h>
+
+QSWidget::QSWidget()
+{
+    set_fill_with_background_color(false);
+}
+
+QSWidget::~QSWidget()
+{
+}
+
+void QSWidget::clear()
+{
+    m_bitmap = nullptr;
+    m_path = {};
+
+    set_scale(100);
+    update();
+}
+
+void QSWidget::flip(Gfx::Orientation orientation)
+{
+    m_bitmap = m_bitmap->flipped(orientation);
+    set_scale(m_scale);
+
+    resize_window();
+}
+
+void QSWidget::rotate(Gfx::RotationDirection rotation_direction)
+{
+    m_bitmap = m_bitmap->rotated(rotation_direction);
+    set_scale(m_scale);
+
+    resize_window();
+}
+
+void QSWidget::navigate(Directions direction)
+{
+    if (m_path == nullptr)
+        return;
+
+    auto parts = m_path.split('/');
+    parts.remove(parts.size() - 1);
+    StringBuilder sb;
+    sb.append("/");
+    sb.join("/", parts);
+    AK::String current_dir = sb.to_string();
+
+    if (m_files_in_same_dir.is_empty()) {
+        Core::DirIterator iterator(current_dir, Core::DirIterator::Flags::SkipDots);
+        while (iterator.has_next()) {
+            String file = iterator.next_full_path();
+            if (!Gfx::Bitmap::is_path_a_supported_image_format(file))
+                continue;
+            m_files_in_same_dir.append(file);
+        }
+    }
+
+    auto current_index = m_files_in_same_dir.find_first_index(m_path);
+    if (!current_index.has_value()) {
+        return;
+    }
+
+    size_t index = current_index.value();
+    if (direction == Directions::Back) {
+        if (index == 0) {
+            GUI::MessageBox::show(window(), "This is the first file.", "Cannot open image", GUI::MessageBox::Type::Error);
+            return;
+        }
+
+        index--;
+    } else if (direction == Directions::Forward) {
+        if (index == m_files_in_same_dir.size() - 1) {
+            GUI::MessageBox::show(window(), "This is the last file.", "Cannot open image", GUI::MessageBox::Type::Error);
+            return;
+        }
+
+        index++;
+    } else if (direction == Directions::First) {
+        index = 0;
+    } else if (direction == Directions::Last) {
+        index = m_files_in_same_dir.size() - 1;
+    }
+
+    this->load_from_file(m_files_in_same_dir.at(index));
+}
+
+void QSWidget::set_scale(int scale)
+{
+    if (m_bitmap.is_null())
+        return;
+
+    if (m_scale == scale) {
+        update();
+        return;
+    }
+
+    if (scale < 10)
+        scale = 10;
+    if (scale > 1000)
+        scale = 1000;
+
+    if (scale == 100)
+        m_pan_origin = { 0, 0 };
+
+    m_scale = scale;
+    float scale_factor = (float)m_scale / 100.0f;
+
+    Gfx::IntSize new_size;
+    new_size.set_width(m_bitmap->width() * scale_factor);
+    new_size.set_height(m_bitmap->height() * scale_factor);
+    m_bitmap_rect.set_size(new_size);
+
+    if (on_scale_change)
+        on_scale_change(m_scale, m_bitmap_rect);
+
+    relayout();
+}
+
+void QSWidget::relayout()
+{
+    if (m_bitmap.is_null())
+        return;
+
+    float scale_factor = (float)m_scale / 100.0f;
+    Gfx::IntSize new_size = m_bitmap_rect.size();
+
+    Gfx::IntPoint new_location;
+    new_location.set_x((width() / 2) - (new_size.width() / 2) - (m_pan_origin.x() * scale_factor));
+    new_location.set_y((height() / 2) - (new_size.height() / 2) - (m_pan_origin.y() * scale_factor));
+    m_bitmap_rect.set_location(new_location);
+
+    update();
+}
+
+void QSWidget::resize_event(GUI::ResizeEvent& event)
+{
+    relayout();
+    GUI::Widget::resize_event(event);
+}
+
+void QSWidget::doubleclick_event(GUI::MouseEvent&)
+{
+    on_doubleclick();
+}
+
+void QSWidget::paint_event(GUI::PaintEvent& event)
+{
+    Frame::paint_event(event);
+
+    GUI::Painter painter(*this);
+    painter.add_clip_rect(event.rect());
+    painter.add_clip_rect(frame_inner_rect());
+
+    Gfx::StylePainter::paint_transparency_grid(painter, frame_inner_rect(), palette());
+
+    if (!m_bitmap.is_null())
+        painter.draw_scaled_bitmap(m_bitmap_rect, *m_bitmap, m_bitmap->rect());
+}
+
+void QSWidget::mousedown_event(GUI::MouseEvent& event)
+{
+    if (event.button() != GUI::MouseButton::Left)
+        return;
+    m_click_position = event.position();
+    m_saved_pan_origin = m_pan_origin;
+}
+
+void QSWidget::mouseup_event([[maybe_unused]] GUI::MouseEvent& event) { }
+
+void QSWidget::mousemove_event(GUI::MouseEvent& event)
+{
+    if (!(event.buttons() & GUI::MouseButton::Left))
+        return;
+
+    auto delta = event.position() - m_click_position;
+    float scale_factor = (float)m_scale / 100.0f;
+    m_pan_origin = m_saved_pan_origin.translated(
+        -delta.x() / scale_factor,
+        -delta.y() / scale_factor);
+
+    relayout();
+}
+
+void QSWidget::mousewheel_event(GUI::MouseEvent& event)
+{
+    int new_scale = m_scale - event.wheel_delta() * 10;
+    if (new_scale < 10)
+        new_scale = 10;
+    if (new_scale > 1000)
+        new_scale = 1000;
+
+    if (new_scale == m_scale) {
+        return;
+    }
+
+    auto old_scale_factor = (float)m_scale / 100.0f;
+    auto new_scale_factor = (float)new_scale / 100.0f;
+
+    auto focus_point = Gfx::FloatPoint(
+        m_pan_origin.x() - ((float)event.x() - (float)width() / 2.0) / old_scale_factor,
+        m_pan_origin.y() - ((float)event.y() - (float)height() / 2.0) / old_scale_factor);
+
+    m_pan_origin = Gfx::FloatPoint(
+        focus_point.x() - new_scale_factor / old_scale_factor * (focus_point.x() - m_pan_origin.x()),
+        focus_point.y() - new_scale_factor / old_scale_factor * (focus_point.y() - m_pan_origin.y()));
+
+    set_scale(new_scale);
+}
+
+void QSWidget::load_from_file(const String& path)
+{
+    auto bitmap = Gfx::Bitmap::load_from_file(path);
+    if (!bitmap) {
+        GUI::MessageBox::show(window(), String::formatted("Failed to open {}", path), "Cannot open image", GUI::MessageBox::Type::Error);
+        return;
+    }
+
+    m_path = path;
+    m_bitmap = bitmap;
+    m_scale = -1;
+    set_scale(100);
+}
+
+void QSWidget::drop_event(GUI::DropEvent& event)
+{
+    event.accept();
+    if (on_drop)
+        on_drop(event);
+}
+
+void QSWidget::resize_window()
+{
+    if (window()->is_fullscreen())
+        return;
+
+    if (!m_bitmap)
+        return;
+
+    auto new_size = m_bitmap->size();
+
+    if (new_size.width() < 300)
+        new_size.set_width(300);
+    if (new_size.height() < 200)
+        new_size.set_height(200);
+
+    new_size.set_height(new_size.height() + m_toolbar_height);
+    window()->resize(new_size);
+}

Userland/Applications/QuickShow/QSWidget.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <LibGUI/Frame.h>
+#include <LibGfx/Bitmap.h>
+#include <LibGfx/Point.h>
+
+class QSLabel;
+
+class QSWidget final : public GUI::Frame {
+    C_OBJECT(QSWidget)
+public:
+    enum Directions {
+        First,
+        Back,
+        Forward,
+        Last
+    };
+
+    virtual ~QSWidget() override;
+
+    const Gfx::Bitmap* bitmap() const { return m_bitmap.ptr(); }
+    const String& path() const { return m_path; }
+    void set_scale(int);
+    int scale() { return m_scale; }
+    void set_toolbar_height(int height) { m_toolbar_height = height; }
+    int toolbar_height() { return m_toolbar_height; }
+
+    void clear();
+    void flip(Gfx::Orientation);
+    void rotate(Gfx::RotationDirection);
+    void navigate(Directions);
+    void load_from_file(const String&);
+
+    Function<void(int, Gfx::IntRect)> on_scale_change;
+    Function<void()> on_doubleclick;
+    Function<void(const GUI::DropEvent&)> on_drop;
+
+private:
+    QSWidget();
+    virtual void doubleclick_event(GUI::MouseEvent&) override;
+    virtual void paint_event(GUI::PaintEvent&) override;
+    virtual void resize_event(GUI::ResizeEvent&) override;
+    virtual void mousedown_event(GUI::MouseEvent&) override;
+    virtual void mouseup_event(GUI::MouseEvent&) override;
+    virtual void mousemove_event(GUI::MouseEvent&) override;
+    virtual void mousewheel_event(GUI::MouseEvent&) override;
+    virtual void drop_event(GUI::DropEvent&) override;
+
+    void relayout();
+    void resize_window();
+
+    String m_path;
+    RefPtr<Gfx::Bitmap> m_bitmap;
+    int m_toolbar_height { 28 };
+
+    Gfx::IntRect m_bitmap_rect;
+    int m_scale { -1 };
+    Gfx::FloatPoint m_pan_origin;
+
+    Gfx::IntPoint m_click_position;
+    Gfx::FloatPoint m_saved_pan_origin;
+    Vector<String> m_files_in_same_dir;
+};

Userland/Applications/QuickShow/main.cpp

@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "QSWidget.h"
+#include <AK/URL.h>
+#include <LibCore/ArgsParser.h>
+#include <LibCore/MimeData.h>
+#include <LibGUI/Action.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 <serenity.h>
+#include <spawn.h>
+#include <stdio.h>
+#include <string.h>
+
+int main(int argc, char** argv)
+{
+    if (pledge("stdio shared_buffer accept cpath rpath wpath unix cpath fattr proc exec thread", nullptr) < 0) {
+        perror("pledge");
+        return 1;
+    }
+
+    auto app = GUI::Application::construct(argc, argv);
+
+    if (pledge("stdio shared_buffer accept cpath rpath wpath proc exec thread", nullptr) < 0) {
+        perror("pledge");
+        return 1;
+    }
+
+    auto app_icon = GUI::Icon::default_icon("filetype-image");
+
+    const char* path = nullptr;
+    Core::ArgsParser args_parser;
+    args_parser.add_positional_argument(path, "The image file to be displayed.", "file", Core::ArgsParser::Required::No);
+    args_parser.parse(argc, argv);
+
+    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("QuickShow");
+
+    auto& root_widget = window->set_main_widget<GUI::Widget>();
+    root_widget.set_fill_with_background_color(true);
+    root_widget.set_layout<GUI::VerticalBoxLayout>();
+    root_widget.layout()->set_spacing(2);
+
+    auto& toolbar_container = root_widget.add<GUI::ToolBarContainer>();
+    auto& main_toolbar = toolbar_container.add<GUI::ToolBar>();
+
+    auto& widget = root_widget.add<QSWidget>();
+    widget.on_scale_change = [&](int scale, Gfx::IntRect rect) {
+        if (!widget.bitmap()) {
+            window->set_title("QuickShow");
+            return;
+        }
+
+        window->set_title(String::formatted("{} {} {}% - QuickShow", widget.path(), widget.bitmap()->size().to_string(), scale));
+
+        if (window->is_fullscreen())
+            return;
+
+        if (window->is_maximized())
+            return;
+
+        auto w = max(window->width(), rect.width() + 4);
+        auto h = max(window->height(), rect.height() + widget.toolbar_height() + 6);
+        window->resize(w, h);
+    };
+    widget.on_drop = [&](auto& event) {
+        window->move_to_front();
+
+        if (event.mime_data().has_urls()) {
+            auto urls = event.mime_data().urls();
+
+            if (!urls.is_empty()) {
+                auto url = urls.first();
+                widget.load_from_file(url.path());
+            }
+
+            pid_t child;
+            for (size_t i = 1; i < urls.size(); ++i) {
+                const char* argv[] = { "/bin/QuickShow", urls[i].path().characters(), nullptr };
+                if ((errno = posix_spawn(&child, "/bin/QuickShow", nullptr, nullptr, const_cast<char**>(argv), environ))) {
+                    perror("posix_spawn");
+                } else {
+                    if (disown(child) < 0)
+                        perror("disown");
+                }
+            }
+        }
+    };
+    widget.on_doubleclick = [&] {
+        window->set_fullscreen(!window->is_fullscreen());
+        toolbar_container.set_visible(!window->is_fullscreen());
+    };
+
+    // Actions
+    auto open_action = GUI::CommonActions::make_open_action(
+        [&](auto&) {
+            Optional<String> path = GUI::FilePicker::get_open_filepath(window, "Open image...");
+            if (path.has_value()) {
+                widget.load_from_file(path.value());
+            }
+        });
+
+    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,
+                String::formatted("Really delete {}?", path),
+                "Confirm deletion",
+                GUI::MessageBox::Type::Warning,
+                GUI::MessageBox::InputType::OKCancel);
+
+            if (msgbox_result == GUI::MessageBox::ExecCancel)
+                return;
+
+            auto unlink_result = unlink(widget.path().characters());
+            dbgln("unlink_result::{}", unlink_result);
+
+            if (unlink_result < 0) {
+                int saved_errno = errno;
+                GUI::MessageBox::show(window,
+                    String::formatted("unlink({}) failed: {}", path, strerror(saved_errno)),
+                    "Delete failed",
+                    GUI::MessageBox::Type::Error);
+
+                return;
+            }
+
+            widget.clear();
+        });
+
+    auto quit_action = GUI::CommonActions::make_quit_action(
+        [&](auto&) {
+            app->quit();
+        });
+
+    auto rotate_left_action = GUI::Action::create("Rotate Left", { Mod_None, Key_L },
+        [&](auto&) {
+            widget.rotate(Gfx::RotationDirection::Left);
+        });
+
+    auto rotate_right_action = GUI::Action::create("Rotate Right", { Mod_None, Key_R },
+        [&](auto&) {
+            widget.rotate(Gfx::RotationDirection::Right);
+        });
+
+    auto vertical_flip_action = GUI::Action::create("Vertical Flip", { Mod_None, Key_V },
+        [&](auto&) {
+            widget.flip(Gfx::Orientation::Vertical);
+        });
+
+    auto horizontal_flip_action = GUI::Action::create("Horizontal Flip", { Mod_None, Key_H },
+        [&](auto&) {
+            widget.flip(Gfx::Orientation::Horizontal);
+        });
+
+    auto desktop_wallpaper_action = GUI::Action::create("Set as desktop wallpaper",
+        [&](auto&) {
+            GUI::Desktop::the().set_wallpaper(widget.path());
+        });
+
+    auto go_first_action = GUI::Action::create("First", { Mod_None, Key_Home }, Gfx::Bitmap::load_from_file("/res/icons/16x16/go-first.png"),
+        [&](auto&) {
+            widget.navigate(QSWidget::Directions::First);
+        });
+
+    auto go_back_action = GUI::Action::create("Back", { Mod_None, Key_Left }, Gfx::Bitmap::load_from_file("/res/icons/16x16/go-back.png"),
+        [&](auto&) {
+            widget.navigate(QSWidget::Directions::Back);
+        });
+
+    auto go_forward_action = GUI::Action::create("Forward", { Mod_None, Key_Right }, Gfx::Bitmap::load_from_file("/res/icons/16x16/go-forward.png"),
+        [&](auto&) {
+            widget.navigate(QSWidget::Directions::Forward);
+        });
+
+    auto go_last_action = GUI::Action::create("Last", { Mod_None, Key_End }, Gfx::Bitmap::load_from_file("/res/icons/16x16/go-last.png"),
+        [&](auto&) {
+            widget.navigate(QSWidget::Directions::Last);
+        });
+
+    auto full_sceen_action = GUI::CommonActions::make_fullscreen_action(
+        [&](auto&) {
+            widget.on_doubleclick();
+        });
+
+    auto zoom_in_action = GUI::Action::create("Zoom In", { Mod_None, Key_Plus }, Gfx::Bitmap::load_from_file("/res/icons/16x16/zoom-in.png"),
+        [&](auto&) {
+            widget.set_scale(widget.scale() + 10);
+        });
+
+    auto zoom_reset_action = GUI::Action::create("Zoom 100%", { Mod_None, Key_0 }, Gfx::Bitmap::load_from_file("/res/icons/16x16/zoom-reset.png"),
+        [&](auto&) {
+            widget.set_scale(100);
+        });
+
+    auto zoom_out_action = GUI::Action::create("Zoom Out", { Mod_None, Key_Minus }, Gfx::Bitmap::load_from_file("/res/icons/16x16/zoom-out.png"),
+        [&](auto&) {
+            widget.set_scale(widget.scale() - 10);
+        });
+
+    auto hide_show_toolbar_action = GUI::Action::create("Hide/Show Toolbar", { Mod_Ctrl, Key_T },
+        [&](auto&) {
+            toolbar_container.set_visible(!toolbar_container.is_visible());
+        });
+
+    auto copy_action = GUI::CommonActions::make_copy_action([&](auto&) {
+        if (widget.bitmap())
+            GUI::Clipboard::the().set_bitmap(*widget.bitmap());
+    });
+
+    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(zoom_reset_action);
+    main_toolbar.add_action(zoom_out_action);
+
+    auto menubar = GUI::MenuBar::construct();
+
+    auto& app_menu = menubar->add_menu("QuickShow");
+    app_menu.add_action(open_action);
+    app_menu.add_action(delete_action);
+    app_menu.add_separator();
+    app_menu.add_action(quit_action);
+
+    auto& image_menu = menubar->add_menu("Image");
+    image_menu.add_action(rotate_left_action);
+    image_menu.add_action(rotate_right_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 = menubar->add_menu("Navigate");
+    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 = menubar->add_menu("View");
+    view_menu.add_action(full_sceen_action);
+    view_menu.add_separator();
+    view_menu.add_action(zoom_in_action);
+    view_menu.add_action(zoom_reset_action);
+    view_menu.add_action(zoom_out_action);
+    view_menu.add_separator();
+    view_menu.add_action(hide_show_toolbar_action);
+
+    auto& help_menu = menubar->add_menu("Help");
+    help_menu.add_action(GUI::CommonActions::make_about_action("QuickShow", app_icon, window));
+
+    app->set_menubar(move(menubar));
+
+    if (path != nullptr) {
+        widget.load_from_file(path);
+    }
+
+    window->show();
+
+    return app->exec();
+}