généralement, l'utilisation de implicitHeight/Width n'a de sens que dans les composants réutilisables.

il donne un indice, de la taille naturelle de l'article sans appliquer cette taille.

prenons un Image comme un exemple. La taille naturelle de l'image permet de faire correspondre un pixel du fichier image à un pixel de l'écran. Mais il nous permet de l'étirer, de sorte que la taille n'est pas appliquée et peut être remplacée.

disons que maintenant, nous voulons avoir une galerie avec des photos de dimension inconnue, et nous ne voulons pas grandir, mais seulement de la réduire si nécessaire. Nous avons donc besoin de stocker la taille normale de l'image. C'est, où l'implicite hauteur entre en jeu.

Image {
    width: Math.max(150, implicitWidth)
    height: Math.max(150, implicitHeight)
}

Dans les composants personnalisés, vous avez le choix sur la façon de définir les tailles.

Le seul choix est d'avoir toutes les dimensions par rapport aux composants root-nœud, peut-être comme ceci:

Item {
    id: root
    Rectangle {
        width: root.width * 0.2
        height: root.height * 0.2
        color: 'red'
    }
    Rectangle {
        x: 0.2 * root.width
        y: 0.2 * root.height
        width: root.width * 0.8
        height: root.height * 0.8
        color: 'green'
    }
}

dans ce cas, il n'y a pas de taille naturelle de l'objet. Tout fonctionne parfaitement pour chaque taille que vous avez défini pour le composant.

d'un autre côté, vous pourriez avoir un objet, qui a une taille naturelle - qui se produit, par exemple si vous avez valeurs absolues dans

Item {
    id: root
    property alias model: repeater.model
    Repeater {
        id: repeater
        delegate: Rectangle {
            width: 100
            height: 100
            x: 102 * index
            y: 102 * index
        }
    }
}

dans cet exemple, vous devez fournir à l'Utilisateur des informations sur la taille naturelle, où le contenu ne protuge pas l'article. L'utilisateur peut encore décider de définir une taille plus petite et de traiter la protrusion, par exemple en la coupant, mais il a besoin de la informations sur la taille naturelle pour prendre sa décision.

Dans de nombreux cas, childrenRect.height/width est une bonne mesure pour l' implcitHeight/Width, mais il y a des exemples où ce n'est pas une bonne idée. - par exemple, lorsque le contenu de l'élément a x: -500.

Un exemple concret est l' Flickable qui est spécifiquement conçu pour contenir des objets plus grands que sa propre taille. La taille de l' Flickable pour être égal au contenu ne serait pas naturel.

soyez également prudent, lorsque en utilisant scale dans les composantes personnalisées, car la childrenRect ne connaîtra pas la mise à l'échelle.

Item {
    id: root
    implicitWidth: child.width * child.scale
    implicitHeight: child.height * child.scale
    Rectangle {
        id: child
        width: 100
        height: 100
        scale: 3
        color: 'red'
    }
}

et à votre commentaire: Je ne comprends tout simplement pas pourquoi il est préférable de définir implicitWidth/Height au lieu de définir width/height de la dimension racine d'un composant.

implicitWidht/Height ne sont pas une nécessité - QtQuick pourrait s'en passer. Ils existent pour des raisons de commodité et doivent être Convention.

Règle

Si vous souhaitez définir la dimension d'un nœud racine d'un composant réutilisable, set implicitWidth/Height.

Dans certains cas, définissez-le pour les noeuds non-root, si les noeuds sont exposés en tant que propriété.

Ne le faites que si vous avez une raison (de nombreux composants officiels n'en ont pas).

Lorsque vous utilisez un composant, définissez width/height.