LibrePCB

import {
    Badge,
    IconButton,
    LineEdit,
    MenuItem,
    MenuOverlay,
    MenuSeparator,
} from "widgets.slint";
import {
    Action,
    Backend,
    BoardAction,
    Constants,
    Data,
    EditorCommandSet as Cmd,
    FeatureState,
    Helpers,
    LibraryAction,
    LibraryData,
    LibraryElementAction,
    PanelPage,
    ProjectAction,
    SchematicAction,
    Shortcuts,
    TabAction,
    TabType,
    WindowSectionAction,
} from "api.slint";
import { Themes } from "api/themes.slint";

component MainMenuItem inherits Rectangle {
    in property <string> text;
    in property <bool> active;

    callback clicked <=> ta.clicked;
    callback hovered;

    width: self.visible ? (txt.preferred-width + 10px) : 0;
    background: (active || ta.has-hover) ? Data.theme.control : transparent;
    border-color: Data.theme.control-border;
    border-width: active ? 1px : 0;

    // Accessibility
    accessible-role: button;
    accessible-label: text;
    accessible-action-default => {
        ta.clicked();
    }

    txt := Text {
        x: 5px;
        font-size: 13px;
        color: (active || ta.has-hover) ? Data.theme.control-text : Data.theme.base-text;
        text: text;
    }

    ta := TouchArea {
        changed has-hover => {
            if self.has-hover {
                hovered();
            }
        }
    }
}

component MenuBarButton inherits IconButton {
    style: hyperlink;
}

component MenuBarSeparator inherits Rectangle {
    width: 5px;

    Rectangle {
        width: 1px;
        height: 15px;
        background: Data.theme.control-text-disabled;
    }
}

export component MainMenuBar {
    in property <length> window-height;
    in property <length> sections-start-x;
    out property <bool> menu-expanded: !current-menu-text.is-empty;
    property <string> undo-text: {
        if Data.current-tab.undo-text.is-empty {
            @tr("Undo")
        } else {
            @tr("Undo: {}", Data.current-tab.undo-text)
        }
    };
    property <string> redo-text: {
        if Data.current-tab.redo-text.is-empty {
            @tr("Redo")
        } else {
            @tr("Redo: {}", Data.current-tab.redo-text)
        }
    };
    property <string> current-menu-text;

    callback focus-root;
    callback focus-grid-interval;

    public function focus-search() {
        if search-edt.enabled {
            search-edt.accept-focus = true;
            search-edt.select-all();
            search-edt.focus();
        }
    }

    public function close-menu() {
        current-menu-text = "";
    }

    function menu-clicked(text: string) {
        if current-menu-text == text {
            close-menu();
        } else {
            current-menu-text = text;
        }
    }

    function menu-hovered(text: string) {
        if !current-menu-text.is-empty {
            current-menu-text = text;
        }
    }

    // Touch area to intercept clicks outside the menu.
    if menu-expanded: TouchArea {
        x: 0;
        y: 0;
        width: 100%;
        height: window-height;

        clicked => {
            close-menu();
        }
    }

    HorizontalLayout {
        padding-right: 4px;

        file-menu-item := MainMenuItem {
            text: @tr("File");
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: file-menu-popup := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                new-project-item := MenuItem {
                    cmd: Cmd.project-new;

                    clicked => {
                        Backend.trigger(Action.project-new);
                        close-menu();
                    }
                }

                open-project-item := MenuItem {
                    cmd: Cmd.project-open;

                    clicked => {
                        Backend.trigger(Action.project-open);
                        close-menu();
                    }
                }

                import-eagle-project-item := MenuItem {
                    cmd: Cmd.import-eagle-project;

                    clicked => {
                        Backend.trigger(Action.project-import-eagle);
                        close-menu();
                    }
                }

                add-example-projects-item := MenuItem {
                    cmd: Cmd.add-example-projects;

                    clicked => {
                        Backend.trigger(Action.project-import-examples);
                        close-menu();
                    }
                }

                MenuSeparator { }

                create-library-item := MenuItem {
                    text: @tr("New Library") + "...";
                    icon: @image-url("../../bootstrap-icons/icons/database-add.svg");
                    status-tip: @tr("Create a new local workspace library");

                    clicked => {
                        Backend.trigger(Action.library-create);
                        close-menu();
                    }
                }

                download-library-item := MenuItem {
                    text: @tr("Download Library") + "...";
                    icon: @image-url("../../bootstrap-icons/icons/cloud-arrow-down-fill.svg");
                    status-tip: @tr("Manually download an existing library from the Internet");

                    clicked => {
                        Backend.trigger(Action.library-download);
                        close-menu();
                    }
                }

                rescan-libraries-item := MenuItem {
                    cmd: Cmd.workspace-libraries-rescan;

                    clicked => {
                        Backend.trigger(Action.workspace-libraries-rescan);
                        close-menu();
                    }
                }

                MenuSeparator { }

                print-item := MenuItem {
                    cmd: Cmd.print;
                    enabled: Data.current-tab.features.export-graphics == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.print);
                        close-menu();
                    }
                }

                export-pdf-item := MenuItem {
                    cmd: Cmd.export-pdf;
                    enabled: Data.current-tab.features.export-graphics == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.export-pdf);
                        close-menu();
                    }
                }

                export-image-item := MenuItem {
                    cmd: Cmd.export-image;
                    enabled: Data.current-tab.features.export-graphics == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.export-image);
                        close-menu();
                    }
                }

                export-step-item := MenuItem {
                    cmd: Cmd.export-step;
                    enabled: (Data.current-tab.type == TabType.board-2d) || (Data.current-tab.type == TabType.board-3d);

                    clicked => {
                        if Data.current-tab.type == TabType.board-2d {
                            Backend.trigger-board(Data.current-board-2d-tab.project-index, Data.current-board-2d-tab.board-index, BoardAction.export-step);
                        } else {
                            Backend.trigger-board(Data.current-board-3d-tab.project-index, Data.current-board-3d-tab.board-index, BoardAction.export-step);
                        }
                        close-menu();
                    }
                }

                export-fabrication-data-item := MenuItem {
                    cmd: Cmd.generate-fabrication-data;
                    enabled: Data.current-tab.type == TabType.board-2d;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.export-fabrication-data);
                        close-menu();
                    }
                }

                export-pick-place-item := MenuItem {
                    cmd: Cmd.generate-pick-place;
                    enabled: Data.current-tab.type == TabType.board-2d;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.export-pick-place);
                        close-menu();
                    }
                }

                export-d356-netlist-item := MenuItem {
                    cmd: Cmd.generate-d356-netlist;
                    enabled: Data.current-tab.type == TabType.board-2d;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.export-d356-netlist);
                        close-menu();
                    }
                }

                MenuSeparator { }

                export-specctra-item := MenuItem {
                    cmd: Cmd.export-specctra-dsn;
                    enabled: Data.current-tab.type == TabType.board-2d;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.export-specctra);
                        close-menu();
                    }
                }

                import-specctra-item := MenuItem {
                    cmd: Cmd.import-specctra-ses;
                    enabled: Data.current-tab.type == TabType.board-2d;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.import-specctra);
                        close-menu();
                    }
                }

                import-dxf := MenuItem {
                    cmd: Cmd.import-dxf;
                    enabled: Data.current-tab.features.import-graphics == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.import-dxf);
                        close-menu();
                    }
                }

                MenuSeparator { }

                switch-workspace-item := MenuItem {
                    cmd: Cmd.workspace-switch;

                    clicked => {
                        Backend.trigger(Action.workspace-switch);
                        close-menu();
                    }
                }

                open-workspace-folder-item := MenuItem {
                    cmd: Cmd.file-manager;
                    text: @tr("Open Workspace Folder");  // More specific.
                    status-tip: "Open the workspace directory in the file manager";  // More specific.

                    clicked => {
                        Backend.trigger(Action.workspace-open-folder);
                        close-menu();
                    }
                }

                workspace-settings-item := MenuItem {
                    cmd: Cmd.workspace-settings;

                    clicked => {
                        Backend.trigger(Action.workspace-settings);
                        close-menu();
                    }
                }

                MenuSeparator { }

                quit-application-item := MenuItem {
                    cmd: Cmd.application-quit;

                    clicked => {
                        Backend.trigger(Action.quit);
                        close-menu();
                    }
                }
            }
        }

        edit-menu-item := MainMenuItem {
            text: @tr("Edit");
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: menu-edit := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                undo-item := MenuItem {
                    cmd: Cmd.undo;
                    text: undo-text;
                    enabled: Data.current-tab.features.undo == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.undo);
                        close-menu();
                    }
                }

                redo-item := MenuItem {
                    cmd: Cmd.redo;
                    text: redo-text;
                    enabled: Data.current-tab.features.redo == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.redo);
                        close-menu();
                    }
                }

                MenuSeparator { }

                select-all-item := MenuItem {
                    cmd: Cmd.select-all;
                    enabled: Data.current-tab.features.select == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.select-all);
                        close-menu();
                    }
                }

                cut-item := MenuItem {
                    text: @tr("Cut");
                    icon: @image-url("../../font-awesome/svgs/solid/scissors.svg");
                    status-tip: @tr("Cut the selected object(s) to clipboard");
                    shortcuts: "Ctrl+X";
                    enabled: Data.current-tab.features.cut == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.cut);
                        close-menu();
                    }
                }

                copy-item := MenuItem {
                    text: @tr("Copy");
                    icon: @image-url("../../font-awesome/svgs/regular/copy.svg");
                    status-tip: @tr("Copy the selected object(s) to clipboard");
                    shortcuts: "Ctrl+C";
                    enabled: Data.current-tab.features.copy == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.copy);
                        close-menu();
                    }
                }

                paste-item := MenuItem {
                    text: @tr("Paste");
                    icon: @image-url("../../font-awesome/svgs/solid/paste.svg");
                    status-tip: @tr("Paste object(s) from the clipboard");
                    shortcuts: "Ctrl+V";
                    enabled: Data.current-tab.features.paste == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.paste);
                        close-menu();
                    }
                }

                remove-item := MenuItem {
                    cmd: Cmd.remove;
                    icon: @image-url("../../font-awesome/svgs/solid/trash-can.svg");
                    enabled: Data.current-tab.features.remove == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.delete);
                        close-menu();
                    }
                }

                rotate-ccw-item := MenuItem {
                    cmd: Cmd.rotate-ccw;
                    icon: @image-url("../../font-awesome/svgs/solid/rotate-left.svg");
                    enabled: Data.current-tab.features.rotate == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.rotate-ccw);
                        close-menu();
                    }
                }

                rotate-cw-item := MenuItem {
                    cmd: Cmd.rotate-cw;
                    icon: @image-url("../../font-awesome/svgs/solid/rotate-right.svg");
                    enabled: Data.current-tab.features.rotate == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.rotate-cw);
                        close-menu();
                    }
                }

                flip-h-item := MenuItem {
                    cmd: Cmd.flip-horizontal;
                    enabled: Data.current-tab.features.flip == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.flip-horizontally);
                        close-menu();
                    }
                }

                flip-v-item := MenuItem {
                    cmd: Cmd.flip-vertical;
                    enabled: Data.current-tab.features.flip == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.flip-vertically);
                        close-menu();
                    }
                }

                mirror-h-item := MenuItem {
                    cmd: Cmd.mirror-horizontal;
                    icon: @image-url("../../bootstrap-icons/icons/symmetry-vertical.svg");
                    enabled: Data.current-tab.features.mirror == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.mirror-horizontally);
                        close-menu();
                    }
                }

                mirror-v-item := MenuItem {
                    cmd: Cmd.mirror-vertical;
                    icon: @image-url("../../bootstrap-icons/icons/symmetry-horizontal.svg");
                    enabled: Data.current-tab.features.mirror == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.mirror-vertically);
                        close-menu();
                    }
                }

                snap-to-grid-item := MenuItem {
                    cmd: Cmd.snap-to-grid;
                    enabled: Data.current-tab.features.snap-to-grid == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.snap-to-grid);
                        close-menu();
                    }
                }

                lock-item := MenuItem {
                    cmd: Cmd.lock;
                    enabled: Data.current-tab.features.lock == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.lock);
                        close-menu();
                    }
                }

                unlock-item := MenuItem {
                    cmd: Cmd.unlock;
                    enabled: Data.current-tab.features.unlock == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.unlock);
                        close-menu();
                    }
                }

                reset-rexts-item := MenuItem {
                    cmd: Cmd.device-reset-text-all;
                    enabled: Data.current-tab.features.reset-texts == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.reset-texts);
                        close-menu();
                    }
                }

                MenuSeparator { }

                line-width-increase-item := MenuItem {
                    cmd: Cmd.line-width-increase;
                    icon: @image-url("../../font-awesome/svgs/solid/caret-up.svg");
                    enabled: Data.current-tab.features.modify-line-width == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.line-width-increase);
                        close-menu();
                    }
                }

                line-width-decrease-item := MenuItem {
                    cmd: Cmd.line-width-decrease;
                    icon: @image-url("../../font-awesome/svgs/solid/caret-down.svg");
                    enabled: Data.current-tab.features.modify-line-width == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.line-width-decrease);
                        close-menu();
                    }
                }

                line-width-set-item := MenuItem {
                    cmd: Cmd.line-width-set;
                    enabled: Data.current-tab.features.modify-line-width == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.line-width-set);
                        close-menu();
                    }
                }

                MenuSeparator { }

                find-item := MenuItem {
                    cmd: Cmd.find;
                    icon: @image-url("../../font-awesome/svgs/solid/magnifying-glass.svg");
                    enabled: Data.current-tab.features.find == FeatureState.enabled;

                    clicked => {
                        focus-search();
                        close-menu();
                    }
                }

                find-next-item := MenuItem {
                    cmd: Cmd.find-next;
                    enabled: Data.current-tab.features.find == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.find-next);
                        close-menu();
                    }
                }

                find-previous-item := MenuItem {
                    cmd: Cmd.find-previous;
                    enabled: Data.current-tab.features.find == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.find-previous);
                        close-menu();
                    }
                }

                MenuSeparator { }

                properties-item := MenuItem {
                    cmd: Cmd.properties;
                    icon: @image-url("../../font-awesome/svgs/solid/pen-to-square.svg");
                    enabled: Data.current-tab.features.edit-properties == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.edit-properties);
                        close-menu();
                    }
                }
            }
        }

        view-menu-item := MainMenuItem {
            text: @tr("View");
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: view-menu-popup := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                new-window-item := MenuItem {
                    cmd: Cmd.window-new;

                    clicked => {
                        Backend.trigger(Action.window-new);
                        close-menu();
                    }
                }

                close-window-item := MenuItem {
                    cmd: Cmd.window-close;

                    clicked => {
                        Backend.trigger(Action.window-close);
                        close-menu();
                    }
                }

                split-window-item := MenuItem {
                    text: @tr("Split Window");
                    icon: @image-url("../../bootstrap-icons/icons/window-split.svg");
                    status-tip: @tr("Split the current window into one more section");

                    clicked => {
                        Backend.trigger-section(Data.sections.length - 1, WindowSectionAction.split);
                        close-menu();
                    }
                }

                MenuSeparator { }

                grid-interval-increase-item := MenuItem {
                    cmd: Cmd.grid-increase;
                    enabled: Data.current-tab.features.grid == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.grid-interval-increase);
                        close-menu();
                    }
                }

                grid-interval-decrease-item := MenuItem {
                    cmd: Cmd.grid-decrease;
                    enabled: Data.current-tab.features.grid == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.grid-interval-decrease);
                        close-menu();
                    }
                }

                grid-interval-set-item := MenuItem {
                    cmd: Cmd.grid-properties;
                    enabled: Data.current-tab.features.grid == FeatureState.enabled;

                    clicked => {
                        focus-grid-interval();
                        close-menu();
                    }
                }

                MenuSeparator { }

                show-pin-numbers-item := MenuItem {
                    cmd: Cmd.show-pin-numbers;
                    enabled: Data.current-tab.type == TabType.schematic;
                    checked: Data.current-section.schematic-tabs[Data.current-section.current-tab-index].show-pin-numbers;

                    clicked => {
                        Data.current-section.schematic-tabs[Data.current-section.current-tab-index].show-pin-numbers = !Data.current-section.schematic-tabs[Data.current-section.current-tab-index].show-pin-numbers;
                        close-menu();
                    }
                }

                planes-hide-item := MenuItem {
                    cmd: Cmd.plane-hide-all;
                    enabled: Data.current-tab.type == TabType.board-2d;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.planes-hide);
                        close-menu();
                    }
                }

                planes-show-item := MenuItem {
                    cmd: Cmd.plane-show-all;
                    enabled: Data.current-tab.type == TabType.board-2d;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.planes-show);
                        close-menu();
                    }
                }

                planes-rebuild-item := MenuItem {
                    cmd: Cmd.plane-rebuild-all;
                    enabled: Data.current-tab.type == TabType.board-2d;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.planes-rebuild);
                        close-menu();
                    }
                }

                ignore-locks-item := MenuItem {
                    property <bool> ignore: Data.current-section.board-2d-tabs[Data.current-section.current-tab-index].ignore-placement-locks;

                    cmd: Cmd.ignore-locks;
                    icon: ignore ? @image-url("../../font-awesome/svgs/solid/lock-open.svg") : @image-url("../../font-awesome/svgs/solid/lock.svg");
                    enabled: Data.current-tab.type == TabType.board-2d;
                    checked: ignore;

                    clicked => {
                        Data.current-section.board-2d-tabs[Data.current-section.current-tab-index].ignore-placement-locks = !ignore;
                        close-menu();
                    }
                }

                MenuSeparator { }

                toggle-background-image-item := MenuItem {
                    cmd: Cmd.toggle-background-image;
                    enabled: Data.current-tab.features.background-image == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.toggle-background-image);
                        close-menu();
                    }
                }

                toggle-3d-item := MenuItem {
                    cmd: Cmd.toggle-3d;
                    enabled: (Data.current-tab.type == TabType.board-2d) || (Data.current-tab.type == TabType.board-3d) || ((Data.current-tab.type == TabType.package) && (Data.current-package-tab.page-index == 2));

                    clicked => {
                        if Data.current-tab.type == TabType.board-2d {
                            Backend.trigger-board(Data.current-board-2d-tab.project-index, Data.current-board-2d-tab.board-index, BoardAction.open-3d);
                        } else if Data.current-tab.type == TabType.board-3d {
                            Backend.trigger-board(Data.current-board-3d-tab.project-index, Data.current-board-3d-tab.board-index, BoardAction.open-2d);
                        } else if Data.current-tab.type == TabType.package {
                            Data.current-section.package-tabs[Data.current-section.current-tab-index].view-3d = !Data.current-package-tab.view-3d;
                        }
                        close-menu();
                    }
                }

                MenuSeparator { }

                zoom-in-item := MenuItem {
                    cmd: Cmd.zoom-in;
                    enabled: Data.current-tab.features.zoom == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.zoom-in);
                        close-menu();
                    }
                }

                zoom-out-item := MenuItem {
                    cmd: Cmd.zoom-out;
                    enabled: Data.current-tab.features.zoom == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.zoom-out);
                        close-menu();
                    }
                }

                zoom-fit-item := MenuItem {
                    cmd: Cmd.zoom-fit-content;
                    enabled: Data.current-tab.features.zoom == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.zoom-fit);
                        close-menu();
                    }
                }

                flip-view-item := MenuItem {
                    property <bool> flip: Data.current-section.board-2d-tabs[Data.current-section.current-tab-index].flip-view;

                    cmd: Cmd.flip-view;
                    enabled: Data.current-tab.type == TabType.board-2d;

                    clicked => {
                        Data.current-section.board-2d-tabs[Data.current-section.current-tab-index].flip-view = !flip;
                        close-menu();
                    }
                }
            }
        }

        library-menu-item := MainMenuItem {
            property <LibraryData> library: Data.libraries[Data.current-library-tab.library-index];

            text: @tr("Library");
            visible: (Data.current-tab.type == TabType.library) && (!project-menu-item.visible);
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: library-menu-popup := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                save-library-item := MenuItem {
                    cmd: Cmd.save;
                    text: @tr("Save Library");  // More specific.
                    enabled: Data.current-tab.features.save == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.save);
                        close-menu();
                    }
                }

                close-library-item := MenuItem {
                    text: @tr("Close Library");  // More specific.
                    status-tip: @tr("Close the currently opened library");
                    icon: @image-url("../../font-awesome/svgs/solid/xmark.svg");

                    clicked => {
                        Backend.trigger-library-element(library.path, LibraryElementAction.close);
                        close-menu();
                    }
                }

                open-library-folder-item := MenuItem {
                    cmd: Cmd.file-manager;

                    clicked => {
                        Backend.trigger-library-element(library.path, LibraryElementAction.open-folder);
                        close-menu();
                    }
                }

                MenuSeparator { }

                import-eagle-library-item := MenuItem {
                    cmd: Cmd.import-eagle-library;

                    clicked => {
                        Backend.trigger-library-element(library.path, LibraryElementAction.import-eagle-library);
                        close-menu();
                    }
                }

                import-kicad-library-item := MenuItem {
                    cmd: Cmd.import-kicad-library;

                    clicked => {
                        Backend.trigger-library-element(library.path, LibraryElementAction.import-kicad-library);
                        close-menu();
                    }
                }

                MenuSeparator { }

                new-component-catewgory-item := MenuItem {
                    text: @tr("New Component Category");
                    icon: @image-url("../../font-awesome/svgs/solid/file-circle-plus.svg");

                    clicked => {
                        Backend.trigger-library(library.path, LibraryAction.new-component-category);
                        close-menu();
                    }
                }

                new-package-category-item := MenuItem {
                    text: @tr("New Package Category");
                    icon: @image-url("../../font-awesome/svgs/solid/file-circle-plus.svg");

                    clicked => {
                        Backend.trigger-library(library.path, LibraryAction.new-package-category);
                        close-menu();
                    }
                }

                new-symbol-item := MenuItem {
                    text: @tr("New Symbol");
                    icon: @image-url("../../font-awesome/svgs/solid/file-circle-plus.svg");

                    clicked => {
                        Backend.trigger-library(library.path, LibraryAction.new-symbol);
                        close-menu();
                    }
                }

                new-package-item := MenuItem {
                    text: @tr("New Package");
                    icon: @image-url("../../font-awesome/svgs/solid/file-circle-plus.svg");

                    clicked => {
                        Backend.trigger-library(library.path, LibraryAction.new-package);
                        close-menu();
                    }
                }

                new-component-item := MenuItem {
                    text: @tr("New Component");
                    icon: @image-url("../../font-awesome/svgs/solid/file-circle-plus.svg");

                    clicked => {
                        Backend.trigger-library(library.path, LibraryAction.new-component);
                        close-menu();
                    }
                }

                new-device-item := MenuItem {
                    text: @tr("New Device");
                    icon: @image-url("../../font-awesome/svgs/solid/file-circle-plus.svg");

                    clicked => {
                        Backend.trigger-library(library.path, LibraryAction.new-device);
                        close-menu();
                    }
                }

                new-organization-item := MenuItem {
                    text: @tr("New Organization");
                    icon: @image-url("../../font-awesome/svgs/solid/file-circle-plus.svg");

                    clicked => {
                        Backend.trigger-library(library.path, LibraryAction.new-organization);
                        close-menu();
                    }
                }
            }
        }

        category-menu-item := MainMenuItem {
            text: @tr("Category");
            visible: ((Data.current-tab.type == TabType.component-category) || (Data.current-tab.type == TabType.package-category)) && (!project-menu-item.visible);
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: category-menu-popup := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                save-category-item := MenuItem {
                    cmd: Cmd.save;
                    text: @tr("Save Category");  // More specific.
                    enabled: Data.current-tab.features.save == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.save);
                        close-menu();
                    }
                }

                close-category-item := MenuItem {
                    text: @tr("Close Category");  // More specific.
                    status-tip: @tr("Close the currently opened category");
                    icon: @image-url("../../font-awesome/svgs/solid/xmark.svg");

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.close);
                        close-menu();
                    }
                }

                open-category-folder-item := MenuItem {
                    cmd: Cmd.file-manager;

                    clicked => {
                        if Data.current-tab.type == TabType.component-category {
                            Backend.trigger-library-element(Data.current-component-category-tab.path, LibraryElementAction.open-folder);
                        } else {
                            Backend.trigger-library-element(Data.current-package-category-tab.path, LibraryElementAction.open-folder);
                        }
                        close-menu();
                    }
                }
            }
        }

        symbol-menu-item := MainMenuItem {
            text: @tr("Symbol");
            visible: (Data.current-tab.type == TabType.symbol) && (!project-menu-item.visible);
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: symbol-menu-popup := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                save-symbol-item := MenuItem {
                    cmd: Cmd.save;
                    text: @tr("Save Symbol");  // More specific.
                    enabled: Data.current-tab.features.save == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.save);
                        close-menu();
                    }
                }

                close-symbol-item := MenuItem {
                    text: @tr("Close Symbol");  // More specific.
                    status-tip: @tr("Close the currently opened symbol");
                    icon: @image-url("../../font-awesome/svgs/solid/xmark.svg");

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.close);
                        close-menu();
                    }
                }

                reload-symbol-item := MenuItem {
                    text: @tr("Reload Symbol From Disk");
                    status-tip: @tr("Discard all modifications and reload the currently opened symbol from disk");
                    icon: @image-url("../../font-awesome/svgs/solid/arrows-rotate.svg");

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.reload-from-disk);
                        close-menu();
                    }
                }

                open-symbol-folder-item := MenuItem {
                    cmd: Cmd.file-manager;

                    clicked => {
                        Backend.trigger-library-element(Data.current-symbol-tab.path, LibraryElementAction.open-folder);
                        close-menu();
                    }
                }
            }
        }

        package-menu-item := MainMenuItem {
            text: @tr("Package");
            visible: (Data.current-tab.type == TabType.package) && (!project-menu-item.visible);
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: package-menu-popup := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                save-package-item := MenuItem {
                    cmd: Cmd.save;
                    text: @tr("Save Package");  // More specific.
                    enabled: Data.current-tab.features.save == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.save);
                        close-menu();
                    }
                }

                close-package-item := MenuItem {
                    text: @tr("Close Package");  // More specific.
                    status-tip: @tr("Close the currently opened package");
                    icon: @image-url("../../font-awesome/svgs/solid/xmark.svg");

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.close);
                        close-menu();
                    }
                }

                reload-package-item := MenuItem {
                    text: @tr("Reload Package From Disk");
                    status-tip: @tr("Discard all modifications and reload the currently opened package from disk");
                    icon: @image-url("../../font-awesome/svgs/solid/arrows-rotate.svg");

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.reload-from-disk);
                        close-menu();
                    }
                }

                open-package-folder-item := MenuItem {
                    cmd: Cmd.file-manager;

                    clicked => {
                        Backend.trigger-library-element(Data.current-package-tab.path, LibraryElementAction.open-folder);
                        close-menu();
                    }
                }
            }
        }

        component-menu-item := MainMenuItem {
            text: @tr("Component");
            visible: (Data.current-tab.type == TabType.component) && (!project-menu-item.visible);
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: component-menu-popup := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                save-component-item := MenuItem {
                    cmd: Cmd.save;
                    text: @tr("Save Component");  // More specific.
                    enabled: Data.current-tab.features.save == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.save);
                        close-menu();
                    }
                }

                close-component-item := MenuItem {
                    text: @tr("Close Component");  // More specific.
                    status-tip: @tr("Close the currently opened component");
                    icon: @image-url("../../font-awesome/svgs/solid/xmark.svg");

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.close);
                        close-menu();
                    }
                }

                open-component-folder-item := MenuItem {
                    cmd: Cmd.file-manager;

                    clicked => {
                        Backend.trigger-library-element(Data.current-component-tab.path, LibraryElementAction.open-folder);
                        close-menu();
                    }
                }
            }
        }

        device-menu-item := MainMenuItem {
            text: @tr("Device");
            visible: (Data.current-tab.type == TabType.device) && (!project-menu-item.visible);
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: device-menu-popup := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                save-device-item := MenuItem {
                    cmd: Cmd.save;
                    text: @tr("Save Device");  // More specific.
                    enabled: Data.current-tab.features.save == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.save);
                        close-menu();
                    }
                }

                close-device-item := MenuItem {
                    text: @tr("Close Device");  // More specific.
                    status-tip: @tr("Close the currently opened device");
                    icon: @image-url("../../font-awesome/svgs/solid/xmark.svg");

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.close);
                        close-menu();
                    }
                }

                open-device-folder-item := MenuItem {
                    cmd: Cmd.file-manager;

                    clicked => {
                        Backend.trigger-library-element(Data.current-device-tab.path, LibraryElementAction.open-folder);
                        close-menu();
                    }
                }
            }
        }

        organization-menu-item := MainMenuItem {
            text: @tr("Organization");
            visible: (Data.current-tab.type == TabType.organization) && (!project-menu-item.visible);
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: organization-menu-popup := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                save-organization-item := MenuItem {
                    cmd: Cmd.save;
                    text: @tr("Save Organization");  // More specific.
                    enabled: Data.current-tab.features.save == FeatureState.enabled;

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.save);
                        close-menu();
                    }
                }

                close-organization-item := MenuItem {
                    text: @tr("Close Organization");  // More specific.
                    status-tip: @tr("Close the currently opened organization");
                    icon: @image-url("../../font-awesome/svgs/solid/xmark.svg");

                    clicked => {
                        Helpers.trigger-current-tab-action(TabAction.close);
                        close-menu();
                    }
                }

                open-organization-folder-item := MenuItem {
                    cmd: Cmd.file-manager;

                    clicked => {
                        Backend.trigger-library-element(Data.current-organization-tab.path, LibraryElementAction.open-folder);
                        close-menu();
                    }
                }
            }
        }

        project-menu-item := MainMenuItem {
            text: @tr("Project");
            visible: Data.current-project.valid;
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: project-menu-popup := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                project-setup-item := MenuItem {
                    cmd: Cmd.project-setup;

                    clicked => {
                        Helpers.trigger-current-project-action(ProjectAction.open-setup-dialog);
                        close-menu();
                    }
                }

                update-project-library-item := MenuItem {
                    cmd: Cmd.project-library-update;

                    clicked => {
                        Helpers.trigger-current-project-action(ProjectAction.update-library);
                        close-menu();
                    }
                }

                MenuSeparator { }

                save-project-item := MenuItem {
                    cmd: Cmd.save;
                    text: @tr("Save Project");  // More specific.
                    enabled: Data.current-project.writable;

                    clicked => {
                        Helpers.trigger-current-project-action(ProjectAction.save);
                        close-menu();
                    }
                }

                close-project-item := MenuItem {
                    cmd: Cmd.project-close;

                    clicked => {
                        Helpers.trigger-current-project-action(ProjectAction.close);
                        close-menu();
                    }
                }

                open-project-folder-item := MenuItem {
                    cmd: Cmd.file-manager;

                    clicked => {
                        Helpers.trigger-current-project-action(ProjectAction.open-folder);
                        close-menu();
                    }
                }

                export-lppz-item := MenuItem {
                    cmd: Cmd.export-lppz;

                    clicked => {
                        Helpers.trigger-current-project-action(ProjectAction.export-lppz);
                        close-menu();
                    }
                }

                MenuSeparator { }

                bill-of-materials-item := MenuItem {
                    cmd: Cmd.bill-of-materials;

                    clicked => {
                        if (Data.current-tab.type == TabType.board-2d) || (Data.current-tab.type == TabType.board-3d) {
                            Helpers.trigger-current-tab-action(TabAction.bill-of-materials);
                        } else {
                            Backend.trigger-project(Data.current-schematic-tab.project-index, ProjectAction.bill-of-materials);
                        }
                        close-menu();
                    }
                }

                output-jobs-item := MenuItem {
                    cmd: Cmd.output-jobs;

                    clicked => {
                        Helpers.trigger-current-project-action(ProjectAction.open-output-jobs);
                        close-menu();
                    }
                }

                MenuSeparator { }

                new-sheet-item := MenuItem {
                    cmd: Cmd.sheet-new;

                    clicked => {
                        Helpers.trigger-current-project-action(ProjectAction.new-sheet);
                        close-menu();
                    }
                }

                rename-sheet-item := MenuItem {
                    cmd: Cmd.sheet-rename;
                    enabled: Data.current-tab.type == TabType.schematic;

                    clicked => {
                        Helpers.trigger-current-schematic-action(SchematicAction.rename);
                        close-menu();
                    }
                }

                remove-sheet-item := MenuItem {
                    cmd: Cmd.sheet-remove;
                    enabled: Data.current-tab.type == TabType.schematic;

                    clicked => {
                        Helpers.trigger-current-schematic-action(SchematicAction.delete);
                        close-menu();
                    }
                }

                erc-item := MenuItem {
                    cmd: Cmd.dock-erc;
                    enabled: Data.current-project.valid;

                    clicked => {
                        Data.current-rule-check-board-index = -1;
                        Data.panel-page = PanelPage.rule-check;
                        close-menu();
                    }
                }

                MenuSeparator { }

                new-board-item := MenuItem {
                    cmd: Cmd.board-new;
                    enabled: Data.current-project.valid;

                    clicked => {
                        Helpers.trigger-current-project-action(ProjectAction.new-board);
                        close-menu();
                    }
                }

                copy-board-item := MenuItem {
                    cmd: Cmd.board-copy;
                    enabled: (Data.current-tab.type == TabType.board-2d) || (Data.current-tab.type == TabType.board-3d);

                    clicked => {
                        Helpers.trigger-current-board-action(BoardAction.copy);
                        close-menu();
                    }
                }

                remove-board-item := MenuItem {
                    cmd: Cmd.board-remove;
                    enabled: (Data.current-tab.type == TabType.board-2d) || (Data.current-tab.type == TabType.board-3d);

                    clicked => {
                        Helpers.trigger-current-board-action(BoardAction.delete);
                        close-menu();
                    }
                }

                run-quick-check-item := MenuItem {
                    cmd: Cmd.run-quick-check;
                    enabled: Data.current-tab.type == TabType.board-2d;

                    clicked => {
                        Helpers.trigger-current-board-action(BoardAction.run-quick-check);
                        Data.current-rule-check-board-index = Data.current-board-2d-tab.board-index;
                        Data.panel-page = PanelPage.rule-check;
                        close-menu();
                    }
                }

                run-drc-item := MenuItem {
                    cmd: Cmd.run-design-rule-check;
                    enabled: Data.current-tab.type == TabType.board-2d;

                    clicked => {
                        Helpers.trigger-current-board-action(BoardAction.run-drc);
                        Data.current-rule-check-board-index = Data.current-board-2d-tab.board-index;
                        Data.panel-page = PanelPage.rule-check;
                        close-menu();
                    }
                }

                board-setup-item := MenuItem {
                    cmd: Cmd.board-setup;
                    enabled: (Data.current-tab.type == TabType.board-2d) || (Data.current-tab.type == TabType.board-3d);

                    clicked => {
                        Helpers.trigger-current-board-action(BoardAction.open-setup-dialog);
                        close-menu();
                    }
                }
            }
        }

        help-menu-item := MainMenuItem {
            text: @tr("Help");
            active: current-menu-text == self.text;

            clicked => {
                menu-clicked(self.text);
            }

            hovered => {
                menu-hovered(self.text);
            }

            if self.active: help-menu-popup := MenuOverlay {
                x: 0;
                y: parent.height;
                opening-width: parent.width;

                shortcuts-reference-item := MenuItem {
                    cmd: Cmd.keyboard-shortcuts-reference;

                    clicked => {
                        Backend.trigger(Action.keyboard-shortcuts-reference);
                        close-menu();
                    }
                }

                user-manual-item := MenuItem {
                    cmd: Cmd.documentation-online;

                    clicked => {
                        Backend.open-url(Constants.user-manual-url);
                        close-menu();
                    }
                }

                support-item := MenuItem {
                    cmd: Cmd.support;
                    icon: @image-url("../../font-awesome/svgs/regular/comments.svg");

                    clicked => {
                        Backend.open-url(Constants.support-url);
                        close-menu();
                    }
                }

                donate-item := MenuItem {
                    cmd: Cmd.donate;

                    clicked => {
                        Backend.open-url(Constants.donate-url);
                        close-menu();
                    }
                }

                website-item := MenuItem {
                    cmd: Cmd.website;

                    clicked => {
                        Backend.open-url(Constants.website-url);
                        close-menu();
                    }
                }

                MenuSeparator { }

                about-librepcb-item := MenuItem {
                    cmd: Cmd.about-librepcb;

                    clicked => {
                        Data.panel-page = PanelPage.about;
                        close-menu();
                    }
                }
            }
        }

        if global-buttons-l.preferred-width > global-buttons-l.padding-left: MenuBarSeparator { }

        global-buttons-l := HorizontalLayout {
            horizontal-stretch: 0;
            padding-top: 5px;
            padding-bottom: 5px;
            padding-left: 5px;
            spacing: 5px;

            if Data.current-tab.features.save != FeatureState.not-supported: save-btn := MenuBarButton {
                cmd: Cmd.save;
                enabled: Data.current-tab.features.save == FeatureState.enabled;

                clicked => {
                    Helpers.trigger-current-tab-action(TabAction.save);
                }
            }

            if Data.current-tab.features.undo != FeatureState.not-supported: undo-btn := MenuBarButton {
                cmd: Cmd.undo;
                tooltip: undo-text;
                enabled: Data.current-tab.features.undo == FeatureState.enabled;

                clicked => {
                    Helpers.trigger-current-tab-action(TabAction.undo);
                }
            }

            if Data.current-tab.features.redo != FeatureState.not-supported: redo-btn := MenuBarButton {
                cmd: Cmd.redo;
                tooltip: redo-text;
                enabled: Data.current-tab.features.redo == FeatureState.enabled;

                clicked => {
                    Helpers.trigger-current-tab-action(TabAction.redo);
                }
            }

            if Data.current-tab.read-only: Rectangle {
                width: self.preferred-width + 20px;

                read-only-badge := Badge {
                    width: self.preferred-width;
                    background: Data.theme.warning;
                    text-color: Data.theme.warning-text;
                    border-color: self.background;
                    text: @tr("read-only").to-lowercase();
                }
            }
        }

        Rectangle {
            horizontal-stretch: 1;

            HorizontalLayout {
                property <length> total-space: root.width - sections-start-x;
                property <length> section-width: total-space / Data.sections.length;
                property <length> offset: sections-start-x - parent.x - (self.width / 2);

                x: max(min(section-width * (0.5 + Data.current-section-index) + offset, parent.width - self.width - 10px), 0);
                width: self.preferred-width;
                padding-top: 5px;
                padding-bottom: 5px;
                spacing: 5px;

                common-buttons-l := HorizontalLayout {
                    spacing: 5px;

                    if (Data.current-tab.type == TabType.board-2d) || (Data.current-tab.type == TabType.board-3d): board-setup-btn := MenuBarButton {
                        cmd: Cmd.board-setup;

                        clicked => {
                            if Data.current-tab.type == TabType.board-2d {
                                Backend.trigger-board(Data.current-board-2d-tab.project-index, Data.current-board-2d-tab.board-index, BoardAction.open-setup-dialog);
                            } else {
                                Backend.trigger-board(Data.current-board-3d-tab.project-index, Data.current-board-3d-tab.board-index, BoardAction.open-setup-dialog);
                            }
                        }
                    }

                    if Data.current-tab.features.export-graphics != FeatureState.not-supported: export-pdf-btn := MenuBarButton {
                        cmd: Cmd.export-pdf;
                        enabled: Data.current-tab.features.export-graphics == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.export-pdf);
                        }
                    }

                    if Data.current-tab.features.export-graphics != FeatureState.not-supported: print-btn := MenuBarButton {
                        cmd: Cmd.print;
                        enabled: Data.current-tab.features.export-graphics == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.print);
                        }
                    }

                    if Data.current-tab.type == TabType.board-3d: export-step-btn := MenuBarButton {
                        cmd: Cmd.export-step;

                        clicked => {
                            Backend.trigger-board(Data.current-board-3d-tab.project-index, Data.current-board-3d-tab.board-index, BoardAction.export-step);
                        }
                    }
                }

                if (common-buttons-l.preferred-width > 0) && (edit-buttons-l.preferred-width > 0): MenuBarSeparator { }

                edit-buttons-l := HorizontalLayout {
                    spacing: 5px;

                    if Data.current-tab.features.cut != FeatureState.not-supported: cut-btn := MenuBarButton {
                        cmd: Cmd.clipboard-cut;
                        icon: @image-url("../../font-awesome/svgs/solid/scissors.svg");
                        enabled: Data.current-tab.features.cut == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.cut);
                        }
                    }

                    if Data.current-tab.features.copy != FeatureState.not-supported: copy-btn := MenuBarButton {
                        cmd: Cmd.clipboard-copy;
                        icon: @image-url("../../font-awesome/svgs/regular/copy.svg");
                        enabled: Data.current-tab.features.copy == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.copy);
                        }
                    }

                    if Data.current-tab.features.paste != FeatureState.not-supported: paste-btn := MenuBarButton {
                        cmd: Cmd.clipboard-paste;
                        icon: @image-url("../../font-awesome/svgs/solid/paste.svg");
                        enabled: Data.current-tab.features.paste == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.paste);
                        }
                    }

                    if Data.current-tab.features.remove != FeatureState.not-supported: remove-btn := MenuBarButton {
                        cmd: Cmd.remove;
                        icon: @image-url("../../font-awesome/svgs/solid/trash-can.svg");
                        enabled: Data.current-tab.features.remove == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.delete);
                        }
                    }

                    if Data.current-tab.features.rotate != FeatureState.not-supported: rotate-ccw-btn := MenuBarButton {
                        cmd: Cmd.rotate-ccw;
                        icon: @image-url("../../font-awesome/svgs/solid/rotate-left.svg");
                        enabled: Data.current-tab.features.rotate == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.rotate-ccw);
                        }
                    }

                    if Data.current-tab.features.rotate != FeatureState.not-supported: rotate-cw-btn := MenuBarButton {
                        cmd: Cmd.rotate-cw;
                        icon: @image-url("../../font-awesome/svgs/solid/rotate-right.svg");
                        enabled: Data.current-tab.features.rotate == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.rotate-cw);
                        }
                    }

                    if Data.current-tab.features.flip != FeatureState.not-supported: flip-btn := MenuBarButton {
                        cmd: Cmd.flip-horizontal;
                        enabled: Data.current-tab.features.flip == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.flip-horizontally);
                        }
                    }

                    if Data.current-tab.features.mirror != FeatureState.not-supported: mirror-btn := MenuBarButton {
                        cmd: Cmd.mirror-horizontal;
                        icon: @image-url("../../bootstrap-icons/icons/symmetry-vertical.svg");
                        enabled: Data.current-tab.features.mirror == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.mirror-horizontally);
                        }
                    }

                    if Data.current-tab.features.move-align != FeatureState.not-supported: move-align-btn := MenuBarButton {
                        cmd: Cmd.move-align;
                        icon: @image-url("../../font-awesome/svgs/solid/up-down-left-right.svg");
                        enabled: Data.current-tab.features.move-align == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.move-align);
                        }
                    }

                    if Data.current-tab.features.snap-to-grid != FeatureState.not-supported: snap-to-grid-btn := MenuBarButton {
                        cmd: Cmd.snap-to-grid;
                        enabled: Data.current-tab.features.snap-to-grid == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.snap-to-grid);
                        }
                    }

                    if Data.current-tab.features.reset-texts != FeatureState.not-supported: reset-text-btn := MenuBarButton {
                        cmd: Cmd.device-reset-text-all;
                        enabled: Data.current-tab.features.reset-texts == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.reset-texts);
                        }
                    }

                    if Data.current-tab.features.lock != FeatureState.not-supported: lock-btn := MenuBarButton {
                        cmd: Cmd.lock;
                        enabled: Data.current-tab.features.lock == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.lock);
                        }
                    }

                    if Data.current-tab.features.unlock != FeatureState.not-supported: unlock-btn := MenuBarButton {
                        cmd: Cmd.unlock;
                        enabled: Data.current-tab.features.unlock == FeatureState.enabled;
                        color-enabled: Data.theme.base-text-error;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.unlock);
                        }
                    }

                    if Data.current-tab.features.edit-properties != FeatureState.not-supported: properties-btn := MenuBarButton {
                        cmd: Cmd.properties;
                        icon: @image-url("../../font-awesome/svgs/solid/pen-to-square.svg");
                        enabled: Data.current-tab.features.edit-properties == FeatureState.enabled;

                        clicked => {
                            Helpers.trigger-current-tab-action(TabAction.edit-properties);
                        }
                    }
                }
            }
        }

        search-edt := LineEdit {
            // Ugly hack to avoid accidentally focusing the search bar (can
            // happen unintentionally when closing a window section), which
            // would open the dropdown and is thus very annoying. Also the
            // search edit shall not be part of the tab cycle as it can be
            // focused by keyboard shortcut. Still waiting for Slint feature
            // https://github.com/slint-ui/slint/pull/9091.
            // Note: A drawback of this workaround is that the first
            // double-click doesn't select the text.
            property <bool> accept-focus: false;
            if !self.has-focus: TouchArea {
                mouse-cursor: MouseCursor.text;
                clicked => {
                    search-edt.accept-focus = true;
                    search-edt.focus();
                }
            }

            y: 2px;
            height: parent.height - 2 * self.y;
            max-width: self.enabled ? 300px : 0;
            horizontal-stretch: 0;
            font-size: 11px;
            text: Data.current-tab.find-term;
            autocompletions: Data.current-tab.find-autocompletions;
            placeholder-text: @tr("Quick Find") + (Cmd.find.shortcut.is-empty ? "" : (" (" + Cmd.find.shortcut + ")"));
            enabled: Data.current-tab.features.find == FeatureState.enabled;
            visible: self.enabled;

            changed enabled => {
                if (!self.enabled) && self.has-focus {
                    focus-root();
                }
            }

            changed has-focus => {
                if self.has-focus {
                    if accept-focus {
                        Helpers.trigger-current-tab-action(TabAction.find-refresh-suggestions);
                    } else {
                        focus-root();
                    }
                }
                accept-focus = false;
            }

            text-edited(text) => {
                Data.current-section.tabs[Data.current-section.current-tab-index].find-term = text;
            }

            autocompletion-accepted(text) => {
                Data.current-section.tabs[Data.current-section.current-tab-index].find-term = text;
                Helpers.trigger-current-tab-action(TabAction.find-next);
            }

            key-pressed(event) => {
                if event.text == Key.Return {
                    Helpers.trigger-current-tab-action(TabAction.find-next);
                    return accept;
                } else if event.text == Key.Escape {
                    if self.text.is-empty {
                        focus-root();
                    } else {
                        Data.current-section.tabs[Data.current-section.current-tab-index].find-term = "";
                    }
                    return accept;
                }
                reject
            }
        }

        // In preview mode, provide a button to switch theme. This is handy
        // during development, to quickly review the UI in both themes.
        if Data.preview-mode: MenuBarButton {
            property <bool> is-dark: Data.theme == Themes.dark;

            y: (parent.height - self.height) / 2;
            height: 15px;
            icon: {
                if is-dark {
                    @image-url("../../bootstrap-icons/icons/sun-fill.svg")
                } else {
                    @image-url("../../bootstrap-icons/icons/sun.svg")
                }
            };

            clicked => {
                if Data.preview-mode {
                    Data.theme = is-dark ? Themes.light : Themes.dark;
                } else {
                    Backend.toggle-theme()
                }
            }
        }
    }
}