PieSeries QML Type

Présente les données sous forme de graphiques circulaires. Plus d'informations...

• Liste de tous les membres, y compris les membres hérités
• PieSeries fait partie de Qt Graphs QML Types for 2D.

Propriétés

• angleSpanLabelVisibility : enumeration (since 6.10)
• angleSpanVisibleLimit : real (since 6.10)
• count : int
• endAngle : real
• holeSize : real
• horizontalPosition : real
• pieSize : real
• startAngle : real
• sum : real
• verticalPosition : real

Signaux

• added(list<PieSlice> slices)
• angleSpanLabelVisibilityChanged(LabelVisibility visibility) (since 6.10)
• angleSpanVisibleLimitChanged(real limit) (since 6.10)
• clicked(PieSlice slice)
• countChanged()
• doubleClicked(PieSlice slice)
• endAngleChanged()
• holeSizeChanged()
• horizontalPositionChanged()
• pieSizeChanged()
• pressed(PieSlice slice)
• released(PieSlice slice)
• removed(list<PieSlice> slices)
• startAngleChanged()
• sumChanged()
• verticalPositionChanged()

Méthodes

• PieSlice append(string label, real value)
• PieSlice at(int index)
• void clear()
• PieSlice find(string label)
• bool remove(PieSlice slice)
• bool remove(int index)
• void removeMultiple(int index, int count)
• bool replace(list<PieSlice> slices)
• bool replace(PieSlice oldSlice, PieSlice newSlice)
• bool replace(int index, PieSlice slice)
• bool take(PieSlice slice)

Description détaillée

Une série de camemberts se compose de tranches définies à l'aide du type PieSlice. Les tranches peuvent avoir n'importe quelle valeur, car le type PieSeries calcule le pourcentage d'une tranche par rapport à la somme de toutes les tranches de la série pour déterminer la taille réelle de la tranche dans le graphique.

La taille et la position des parts sur le graphique sont contrôlées à l'aide de valeurs relatives comprises entre 0,0 et 1,0. Ces valeurs se rapportent au rectangle du graphique.

Par défaut, la tarte est définie comme une tarte complète. Un camembert partiel peut être créé en définissant un angle de départ et une plage d'angles pour la série. Un camembert complet représente 360 degrés, où 0 est à 12 heures.

L'exemple QML suivant montre comment créer un graphique à secteurs simple.

import QtQuick
import QtGraphs

Item {
    id: mainView
    width: 1280
    height: 720

    GraphsView {
        anchors.fill: parent
        theme: GraphsTheme {
             colorScheme: GraphsTheme.ColorScheme.Dark
             theme: GraphsTheme.Theme.QtGreen
        }
        PieSeries {
            id: pieSeries
            PieSlice {
                value: 1
            }
            PieSlice {
                value: 2
            }
        }
    }
}

Voir également PieSlice et GraphsView.

Documentation sur les propriétés

angleSpanLabelVisibility : enumeration [since 6.10]

Mode de visibilité des étiquettes.

Le mode qui détermine les étiquettes qui seront cachées si elles sont en dessous de la limite de la portée angulaire définie avec angleSpanVisibleLimit. N'a pas d'effet si angleSpanVisibleLimit n'a pas été défini.

Cette propriété a été introduite dans Qt 6.10.

Voir aussi angleSpanVisibleLimit.

angleSpanVisibleLimit : real [since 6.10]

Limite de la portée angulaire pour la visibilité de l'étiquette.

L'étendue d'angle qui sera utilisée comme limite de visibilité pour l'étiquette d'une tranche. Une tranche dont la portée angulaire est inférieure à cette valeur verra sa visibilité modifiée en fonction de l'adresse angleSpanLabelVisibility définie pour la série. La valeur par défaut est 0, ce qui signifie qu'aucune tranche ne sera masquée, quelle que soit la valeur de angleSpanLabelVisibility.

Cette propriété a été introduite dans Qt 6.10.

Voir aussi angleSpanLabelVisibility.

count : int [read-only]

Le nombre de tranches dans la série.

endAngle : real

L'angle final de la tarte.

Une tarte complète fait 360 degrés, 0 degré étant à 12 heures.

La valeur par défaut est 360.

holeSize : real

La taille du trou du beignet.

Lors de la définition de la propriété pieSize, cette propriété est ajustée si nécessaire, afin de s'assurer que la taille du trou n'est pas supérieure à la taille de la tarte.

La valeur par défaut est 0.0.

horizontalPosition : real

La position horizontale de la tarte.

La valeur est relative au rectangle du graphique, de sorte que :

• 0,0 correspond à la gauche absolue.
• 1.0 correspond à la droite absolue.

La valeur par défaut est 0,5 (centre).

Voir aussi verticalPosition.

pieSize : real

La taille de la tarte.

La valeur est relative au rectangle du graphique, de sorte que :

• 0.0 est la taille minimale du camembert (le camembert n'est pas dessiné).
• 1.0 est la taille maximale de la tarte qui peut s'adapter au graphique.

Lors du réglage de cette propriété, la propriété holeSize est ajustée si nécessaire, afin de s'assurer que la taille du trou n'est pas supérieure à la taille de la tarte.

La valeur par défaut est 0.7.

startAngle : real

L'angle de départ de la tarte.

Une tarte complète fait 360 degrés, où 0 degré est à 12 heures.

La valeur par défaut est 0.

sum : real [read-only]

La somme de toutes les tranches.

La série tient compte de la somme de toutes les tranches qu'elle détient.

verticalPosition : real

La position verticale de la tarte.

La valeur est relative au rectangle du graphique, de sorte que :

• 0,0 est le sommet absolu.
• 1.0 est le bas absolu.

La valeur par défaut est 0,5 (centre).

Voir également horizontalPosition.

Documentation sur les signaux

added(list<PieSlice> slices)

Ce signal est émis lorsque les tranches spécifiées par slices sont ajoutées à la série.

[since 6.10] angleSpanLabelVisibilityChanged(LabelVisibility visibility)

Ce signal est émis lorsque le mode visible de la limite de la portée angulaire a été modifié. Le paramètre visibility contient le nouveau mode visible.

Ce signal a été introduit dans Qt 6.10.

[since 6.10] angleSpanVisibleLimitChanged(real limit)

Ce signal est émis lorsque la limite de la portée angulaire a été modifiée. Le paramètre limit contient la nouvelle limite.

Ce signal a été introduit dans Qt 6.10.

clicked(PieSlice slice)

Ce signal est émis lorsque l'on clique ou que l'on tape sur le site slice.

countChanged()

Ce signal est émis lorsque le nombre de tranches change.

Voir également count.

doubleClicked(PieSlice slice)

Ce signal est émis lorsque le site slice fait l'objet d'un double clic ou d'une double pression. Ce signal est toujours émis après clicked.

endAngleChanged()

Ce signal est émis lorsque l'angle de fin de tarte change.

Voir également endAngle.

holeSizeChanged()

Ce signal est émis lorsque la taille du trou du donut change.

Voir également holeSize.

horizontalPositionChanged()

Ce signal est émis lorsque la position horizontale change.

Voir aussi horizontalPosition.

pieSizeChanged()

Ce signal est émis lorsque la taille de la tarte change.

Voir aussi pieSize.

pressed(PieSlice slice)

Ce signal est émis lorsque l'utilisateur clique ou tape sur le site slice et maintient le bouton ou le geste de la souris enfoncé.

released(PieSlice slice)

Ce signal est émis lorsque l'utilisateur relâche un bouton de la souris ou un geste précédemment appuyé sur le site slice.

removed(list<PieSlice> slices)

Ce signal est émis lorsque les tranches spécifiées par slices sont retirées de la série.

startAngleChanged()

Ce signal est émis lorsque l'angle de départ du gâteau change.

Voir également startAngle.

sumChanged()

Ce signal est émis lorsque la somme de toutes les tranches change.

Voir également sum.

verticalPositionChanged()

Ce signal est émis lorsque la position verticale change.

Voir également verticalPosition.

Documentation de la méthode

PieSlice append(string label, real value)

Ajoute à la tarte une nouvelle tranche portant l'étiquette label et la valeur value.

PieSlice at(int index)

Renvoie la tranche à la position spécifiée par index. Retourne null si l'index n'est pas valide.

void clear()

Supprime toutes les parts de la tarte.

PieSlice find(string label)

Renvoie la première tranche qui porte l'étiquette label. Retourne null si l'étiquette n'est pas trouvée.

bool remove(PieSlice slice)

Retire de la tarte la part spécifiée par slice. Retourne true si le retrait a été effectué avec succès, false dans le cas contraire.

bool remove(int index)

Retire de la tarte la part spécifiée par index. Retourne true si le retrait a été effectué avec succès, false dans le cas contraire.

void removeMultiple(int index, int count)

Supprime une série de tranches comme spécifié par index et count. L'appel passe par toutes les tranches même si la suppression de l'une d'entre elles échoue.

bool replace(list<PieSlice> slices)

Remplace complètement toutes les tranches actuelles par slices. La taille n'a pas besoin de correspondre. Retourne faux si l'un des PieSlice de slices n'est pas valide.

bool replace(PieSlice oldSlice, PieSlice newSlice)

Remplace la tranche spécifiée par oldSlice par newSlice. Retourne true si la suppression a réussi, false sinon. oldSlice est détruit en cas de succès.

bool replace(int index, PieSlice slice)

Remplace la part spécifiée par slice de la tarte à index. Retourne true si le remplacement a réussi, false sinon.

bool take(PieSlice slice)

Prend une seule tranche, spécifiée par slice, de la série. Ne supprime pas l'objet tranche. Retourne true en cas de succès.