ActionToolBar.qml

/*
 *   Copyright 2018 Marco Martin <mart@kde.org>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Library General Public License as
 *   published by the Free Software Foundation; either version 2, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Library General Public License for more details
 *
 *   You should have received a copy of the GNU Library General Public
 *   License along with this program; if not, write to the
 *   Free Software Foundation, Inc.,
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

import QtQuick 2.7
import QtQuick.Layouts 1.2
import QtQuick.Controls 2.5 as Controls
import org.kde.kirigami 2.5 as Kirigami
import "private"

Item {
    id: root
    property list<QtObject> actions

    property list<QtObject> hiddenActions

    property bool flat: true

    property int display: Controls.Button.TextBesideIcon

    property int position: parent && parent.hasOwnProperty("position")
            ? parent.position
            : Controls.ToolBar.Header

    implicitHeight: actionsLayout.implicitHeight

    implicitWidth: actionsLayout.implicitWidth

    Layout.minimumWidth: moreButton.implicitWidth

    Layout.fillWidth: true

    RowLayout {
        id: actionsLayout
        anchors.fill: parent
        //anchors.rightMargin: moreButton.width
        
        spacing: Kirigami.Units.smallSpacing
        property var overflowSet: []

        // TODO use Array.findIndex once we depend on Qt 5.9
        function findIndex(array, cb) {
            for (var i = 0, length = array.length; i < length; ++i) {
                if (cb(array[i])) {
                    return i;
                }
            }
            return -1;
        }
        RowLayout {
            Layout.minimumWidth: 0
            Layout.fillHeight: true
            Repeater {
                model: root.actions
                delegate: PrivateActionToolButton {
                    id: actionDelegate
                    flat: root.flat
                    opacity: x + width <= parent.width
                    enabled: opacity

                    display: root.display
                    visible: !modelData.hasOwnProperty("visible") || modelData.visible
                    Layout.fillWidth: false
                    Layout.alignment: Qt.AlignVCenter
                    Layout.minimumWidth: implicitWidth
                    kirigamiAction: modelData
                    onOpacityChanged: updateOverflowSet()
                    function updateOverflowSet() {
                        var index = actionsLayout.findIndex(actionsLayout.overflowSet, function(act) {
                            return act === modelData});

                        if ((opacity > 0 || (modelData.hasOwnProperty("visible") || !modelData.visible)) && index > -1) {
                            actionsLayout.overflowSet.splice(index, 1);
                        } else if (opacity === 0 && (!modelData.hasOwnProperty("visible") || modelData.visible) && index === -1) {
                            actionsLayout.overflowSet.push(modelData);
                        }
                        actionsLayout.overflowSetChanged();
                    }
                    Connections {
                        target: modelData
                        ignoreUnknownSignals: !modelData.hasOwnProperty("visible")
                        onVisibleChanged: actionDelegate.updateOverflowSet();
                    }
                    Component.onCompleted: {
                        actionDelegate.updateOverflowSet();
                    }
                }
            }
        }

        Item {
            Layout.fillWidth: true
            visible: root.Layout.fillWidth
        }

        Controls.ToolButton {
            id: moreButton

            Layout.alignment: Qt.AlignRight
            Kirigami.Icon {
                anchors.centerIn: parent
                source: "overflow-menu"
                width: Kirigami.Units.iconSizes.smallMedium
                height: width
            }

            //checkable: true
            checked: menu.visible
            visible: hiddenActions.length > 0 || actionsLayout.overflowSet.length > 0;
            onClicked: menu.visible ? menu.close() : menu.open()

            ActionsMenu {
                id: menu
                y: root.position == Controls.ToolBar.Footer ? -height : moreButton.height
                x: -width + moreButton.width
                actions: root.actions
                submenuComponent: Component {
                    ActionsMenu {
                       Binding {
                           target: parentItem
                           property: "visible"
                           value: actionsLayout.findIndex(actionsLayout.overflowSet, function(act) {return act === parentAction}) > -1 &&  (parentAction.hasOwnProperty("visible") ? parentAction.visible === undefined || parentAction.visible : !parentAction.hasOwnProperty("visible"))
                       }
                    }
                }
                itemDelegate: ActionMenuItem {
                    visible: actionsLayout.findIndex(actionsLayout.overflowSet, function(act) {return act === ourAction}) > -1 &&  ( ourAction.hasOwnProperty("visible") ? ourAction.visible === undefined || ourAction.visible : !ourAction.hasOwnProperty("visible"))
                }
                Instantiator {

                    model: root.hiddenActions
                    delegate: QtObject {
                        readonly property QtObject action: modelData
                        property QtObject item: null

                        Component.onDestruction: if (item) item.destroy()

                        function create() {
                            if (!action.children || action.children.length === 0) {
                                item = menu.itemDelegate.createObject(null, { ourAction: action });
                                menu.addItem(item)
                            } else if (menu.submenuComponent) {
                                item = menu.submenuComponent.createObject(null, { title: action.text, actions: action.children });
                                menu.addMenu(item)
                            }
                            //break the binding
                            item.visible = true;
                        }
                        function remove() {
                            if (!action.children || action.children.length === 0) {
                                menu.removeItem(item)
                            } else if (menu.submenuComponent) {
                                menu.removeMenu(item)
                            }
                        }
                    }

                    onObjectAdded: object.create()
                    onObjectRemoved: object.remove()
                }
            }
        }
    }
}