chartpie — `u_pbt_chartpie` #

← Référence des composants · Sommaire du guide

Graphique en secteurs : camembert, anneau ou demi-roue. Chaque angle est une part du tout — la légende masque une part, les autres reprennent sa place.

▶ Le voir en vrai — Application de démonstration, tuile Pie chart : l'aperçu, le code qui le produit et cette page, côte à côte.

En bref #

Userobject	`u_pbt_chartpie`
Classe d'items	`n_pbt_chartpie_slice (of_item(key))`
Sert à	Montrer comment un tout se partage — ventes par région, tickets par état, budget consommé
Principe	Vous posez des parts (une clé, un nom, une valeur) ; les angles, les pourcentages, la légende et l'animation sont à nous

Démarrage rapide #

// One slice per region : a key, a label and a value
uo_pie.of_add_slice(/*key*/ "north", /*label*/ "North", /*value*/ 420)
uo_pie.of_add_slice(/*key*/ "south", /*label*/ "South", /*value*/ 310)
uo_pie.of_add_slice(/*key*/ "east", /*label*/ "East", /*value*/ 260)

// The share of each region, written on its slice
uo_pie.ib_data_labels = true
uo_pie.is_label_format = "#percent#"

Une part est une PART du tout #

Vous donnez des valeurs, jamais des angles : le composant fait la somme des parts affichées et donne à chacune l'angle de sa part de cette somme. Masquer une part — d'un clic dans la légende, ou par ib_visible — la referme sur place : les autres se partagent de nouveau la roue, et #percent#, id_percent et of_total() suivent. Une valeur négative n'a pas d'angle : elle est dessinée comme zéro et se relit telle que vous l'avez donnée.

Les angles se comptent en degrés, 0 en haut, dans le sens du dessin : ii_start_angle = -90 et ii_sweep_angle = 180 donnent la moitié supérieure d'un cercle — une jauge. La roue est ajustée à la place que prend cet angle : une demi-roue est dessinée deux fois plus grande.

Propriétés #

Propriété	Type	Défaut	Rôle
`is_title`	string	`""`	Titre du graphique, au-dessus de la roue. Balisage accepté
`ib_show_legend`	boolean	`true`	Affiche la légende. Cliquer une entrée masque sa part et lève `ue_slice_toggled`
`is_legend_location`	string	`end`	Où va la légende (constantes `LEGEND_*`) : à côté de la roue (`END`, `START`, en colonne) ou au-dessus et au-dessous (`TOP`, `BOTTOM`, côte à côte). `START`/`END` sont logiques : ils suivent le sens de lecture. Une position inconnue vaut `end`, et se relit telle
`ib_legend_values`	boolean	`false`	Écrit la valeur et la part de chaque tranche dans la légende, après son nom
`ib_value_tooltip`	boolean	`true`	Le panneau qui nomme la part sous le pointeur — ou celle du clavier — avec sa valeur et sa part. Ce n'est pas `is_tooltip`, l'info-bulle du composant entier. L'info-bulle d'une part (son `is_tooltip`) s'écrit dans ce panneau, même à `false`
`ib_data_labels`	boolean	`false`	Une étiquette par part, qui dit ce que dit `is_label_format`, là où la pose `is_label_position`. Dans une part trop étroite, l'étiquette est omise plutôt qu'écrite sur ses voisines
`is_label_format`	string	`""`	Ce que dit une étiquette : `#value#` la valeur, `#percent#` sa part du tout, `#label#` son nom (sans balisage), `#key#` sa clé, `#total#` le total ; `#participation#` dit ce que dit `#percent#`. Le reste est écrit tel quel. Vide = la valeur seule
`is_label_position`	string	`inside`	Où vont les étiquettes (constantes `LABEL_*`) : `INSIDE`, sur la part, en noir ou en blanc selon ce qui s'y lit ; `OUTSIDE`, à côté de la roue, reliées à leur part par un trait et écartées pour ne pas se chevaucher
`id_inner_radius`	double	`0`	Le trou, en fraction du rayon : `0` un camembert, `0.6` un anneau (borné à 0..0,9). La roue glisse de l'un à l'autre
`is_center_text`	string	`""`	Texte dans le trou d'un anneau, balisage accepté. Jetons : `#total#` le total des parts affichées (au format des nombres), `#count#` leur nombre ; `#hover_label#`, `#hover_value#`, `#hover_percent#` la part sous le pointeur ou celle du clavier — au repos, le tout : Total, le total, 100 % ; `#percent:key#` et `#value:key#` la part et la valeur d'une part, tenues à jour quelles que soient les valeurs (une jauge écrit elle-même son « 72 % »). Une clé inconnue n'écrit rien. Rien n'est écrit dans un camembert
`ii_start_angle`	integer	`0`	Où commence la première part, en degrés : `0` en haut, `90` à droite, `-90` à gauche (450 se relit 90)
`ii_sweep_angle`	integer	`360`	La portion du cercle que se partagent les parts, en degrés (bornée à 10..360). Avec `ii_start_angle = -90`, `180` dessine la moitié supérieure — une jauge
`ib_clockwise`	boolean	`true`	Les parts se suivent dans le sens des aiguilles d'une montre, ou dans l'autre. Les flèches du clavier suivent l'ordre du dessin
`is_sort`	string	`"none"`	L'ordre du dessin (constantes `SORT_*`) : `NONE` l'ordre où les parts ont été données, `DESC` la plus grande d'abord, `ASC` la plus petite d'abord. La roue, la légende et le clavier le suivent ; le modèle garde son ordre — `of_get_values`, `of_count` et les couleurs de la palette ne bougent pas. Une valeur inconnue vaut `none`
`id_hover_push_out`	double	`0.08`	De combien la part sous le pointeur — ou celle du clavier — ressort, en fraction du rayon (borné à 0..0,4). S'ajoute au `id_push_out` de la part. `0` = rien ne bouge
`ib_track_hover`	boolean	`false`	Abonnement à `ue_slice_hovered` : un événement levé à chaque mouvement du pointeur n'est envoyé qu'à une application qui l'a demandé
`is_format`	string	`""`	Le format de tous les nombres que le graphique écrit — étiquettes, légende, panneau des valeurs, texte central — dans la syntaxe d'un format de DataWindow : `#,##0.00`, `$#,##0`, `#,##0 "unités"`, sections positif;négatif;zéro. Les séparateurs sont ceux de la langue d'affichage. Vide (ou un format qui n'est pas numérique) = le nombre tel quel, au millième. Les parts (`#percent#`) s'écrivent toujours au dixième
`id_others_threshold`	double	`0`	Rassemble les petites parts : toute part dont la part du tout est sous ce pourcentage rejoint une part « Autres », dessinée en dernier dans un gris neutre — la légende la montre à leur place. Les membres sont jugés sur toutes les parts, affichées ou masquées : masquer une grosse part n'en fait jamais sortir les petites, et la plus grande part n'y entre jamais. Sa clé est `OTHERS_KEY` (`"__others"`) dans tous les événements, sa valeur est la somme de ses membres affichés, `of_others_keys` les nomme, `of_item(OTHERS_KEY)` lit sa valeur et sa part ou la masque. Une petite part seule garde son secteur. `0` = jamais
`ii_others_top`	integer	`0`	Rassemble par nombre : les N plus grandes parts gardent leur secteur, toutes les autres rejoignent « Autres » (deux au moins, comme pour le seuil). S'ajoute à `id_others_threshold` : une part entre dans « Autres » dès que l'une des deux règles le dit. `0` = pas de telle règle
`is_others_label`	string	`""`	Le nom de la part « Autres ». Balisage accepté dans la légende et le panneau des valeurs ; les étiquettes et le résumé lu par un lecteur d'écran en écrivent le texte brut. Vide = le mot de la langue d'affichage (Others, Autres…)
`ib_auto_height`	boolean	`false`	Le composant annonce sa hauteur idéale et l'userobject s'y ajuste (`ue_auto_height`). La largeur la dicte : une demi-roue est moitié moins haute
`ib_enabled`	boolean	`true`	Grisé, le graphique montre toujours ce qu'il montre mais ne répond plus : ni clic, ni double-clic, ni clavier, ni légende, et il sort de l'ordre de tabulation
`ib_animated`	boolean	`true`	La roue arrive animée — elle s'ouvre depuis son départ, part après part — et de nouvelles valeurs glissent : les bords entre les parts bougent ensemble, la roue ne montre jamais de trou ni une part sur sa voisine ; une part retirée se referme à sa place. Un poste réglé pour réduire les animations n'anime jamais, et la roue arrive au même endroit
`ii_anim_duration`	integer	`450`	Durée de l'arrivée et de chaque mouvement, en millisecondes (bornée à 0..5000)
`is_anim_easing`	string	`ease-out`	La courbe du mouvement (constantes `EASING_*`, les noms de LiveCharts2) : `back-out` dépasse puis revient, `bounce-out` rebondit, `elastic-out` claque
`ii_anim_delay`	integer	`40`	À l'arrivée seulement (une roue qui n'avait rien à l'écran), le décalage entre deux parts, en millisecondes (0 à 1000) : la roue s'ouvre part après part, jamais plus de 600 ms plus tard en tout, quel que soit le nombre de parts. `0` = toutes ensemble. Un changement de valeurs fait toujours glisser toutes les parts ensemble
`is_theme_style`	string	`""`	Style visuel du composant (constantes `THEME_STYLE_*`) ; vide = celui de l'application, suivi à chaque changement
`is_theme_mode`	string	`""`	Variante claire ou sombre (constantes `THEME_MODE_*`) ; vide = celle de l'application, suivie à chaque changement
`il_theme_accent`	long	`-1`	Couleur d'accent de ce composant (`-1` = accent du thème)
`is_tooltip`	string	`""`	Info-bulle simple affichée au survol du composant
`is_super_tooltip_title`	string	`""`	Titre de l'info-bulle enrichie (prend le pas sur `is_tooltip`)
`is_super_tooltip_text`	string	`""`	Texte de l'info-bulle enrichie (balisage riche accepté)
`is_super_tooltip_image`	string	`""`	Image de l'info-bulle enrichie

Méthodes #

Méthode	Rôle
`of_add_slice ( string as_key, string as_label, double ad_value { , long al_color } )`	Ajoute une part : sa clé, son nom (balisage accepté) et sa valeur ; la surcharge avec une couleur la fixe, sans elle la palette choisit (un jeu pour un thème clair, un pour un thème sombre). Renvoie `0` une fois ajoutée, `-5` si la clé est vide, contient `/` ou `	`, commence par` __ `(les clés du graphique lui-même, comme` OTHERS_KEY`) ou est déjà prise (un ajout ne remplace jamais une part),` -2` si le composant n'est pas créé
`of_clear ( )`	Retire toutes les parts — leurs poignées partent avec elles — et oublie les lignes de `of_from_datastore` : un `of_map` ou un `of_reload` ultérieur ne les ramène pas. Les réglages restent, les rôles de `of_map` aussi ; une roue vide est dessinée à leur place. Renvoie `0` une fois vidé, `-2` si le composant n'est pas créé
`of_from_datastore (datastore ads)`	Alimente le graphique depuis un DataStore : une ligne = une part. Une colonne joue un rôle quand elle porte son nom (`key`, `label`, `value`, `color`) ou quand `of_map` le dit ; il faut une colonne `ROLE_VALUE`. Sans colonne `ROLE_KEY`, la clé d'une part est son numéro de ligne ; avec elle, les lignes qui partagent une clé sont additionnées en une seule part (le nom et la couleur de la première) — un an de ventes devient une part par catégorie, sans boucle. Nombres et dates sont lus comme la DataWindow les écrit sur le poste (virgule décimale, dates régionales : une date devient `yyyy-mm-dd`). Un second chargement met les parts à jour sur place : une clé qui revient garde ce que l'utilisateur et votre code lui ont donné (masquée dans la légende, écartée, une couleur du code, son info-bulle) et sa poignée ; les parts des clés parties s'en vont ; les parts posées à la main restent, après celles des lignes. Renvoie `0` une fois chargé — une ligne dont la clé est vide, contient `/` ou `	`, commence par` __ `ou est tenue par une part posée à la main est écartée, et` of_get_last_error `dit combien —,` -5 `si le DataStore n'est pas valide, si aucune colonne ne joue` ROLE_VALUE `ou si une colonne nommée par` of_map `n'y est pas (`of_get_last_error `la nomme),` -2` si le composant n'est pas créé
`of_from_datastore (datawindow adw)`	La même chose depuis les lignes d'une DataWindow — celle que l'utilisateur voit à côté du graphique. Ses données sont partagées avec un DataStore de passage : une DataWindow qui ne peut pas les partager est refusée (`-5`, avec la raison). Renvoie `0` une fois chargé, `-5` comme ci-dessus, `-2` si le composant n'est pas créé
`of_from_datastore (datawindowchild adwc)`	La même chose depuis les lignes d'un DataWindowChild (une DataWindow déroulante, un rapport imbriqué). Renvoie `0` une fois chargé, `-5` comme ci-dessus, `-2` si le composant n'est pas créé
`of_get_last_error ( )`	Pourquoi le dernier appel a été refusé (un rôle de `of_map` que les lignes n'ont pas…), ou combien de lignes le dernier `of_from_datastore` a écartées et pourquoi ; sinon la dernière erreur de la DLL, comme pour tout composant
`of_get_values ( ref string as_keys[], ref double ad_values[] )`	Remplit les deux tableaux avec les parts que le graphique tient maintenant, dans l'ordre où elles ont été données (`is_sort` ne change que le dessin), et renvoie leur nombre — ce que lit le graphique, pas ce qui a été envoyé
`of_item ( string as_key )`	La poignée `n_pbt_chartpie_slice` d'une part, pour lire ou changer son nom, sa valeur, sa couleur, son écart ou sa visibilité. `of_item(OTHERS_KEY)` est toujours valide : la part « Autres », sa valeur, sa part, sa visibilité (`of_has` ne la nomme pas : elle est au graphique, pas à vous). Une clé que le graphique ne tient pas donne une poignée qui ne change rien et lit des valeurs vides — une propriété ne peut pas répondre -5 : vérifiez d'abord par `of_has` une clé venue d'ailleurs
`of_map ( string as_role, string as_column )`	Donne un rôle à une colonne quand son nom ne le dit pas : `of_map(ROLE_VALUE, "amount")`. Rôles : `ROLE_KEY` (les lignes d'une même clé sont additionnées), `ROLE_LABEL`, `ROLE_VALUE`, `ROLE_COLOR` (un long `RGB()` ou `#rrggbb`). Avant `of_from_datastore`, ou après : les lignes sont alors relues sur place. La colonne est jugée par le prochain `of_from_datastore` (`-5` là s'il ne l'a pas) ; quand les lignes déjà données ne l'ont pas, elles ne sont pas relues — le rôle attend les lignes que vous allez donner, et `of_get_last_error` le dit. Une colonne vide rend le rôle à la colonne qui porte son nom. Renvoie `0` une fois posé, `-5` si le rôle n'est pas une constante `ROLE_`, `-2` si le composant n'est pas créé
`of_others_keys ( ref string as_keys[] )`	Remplit le tableau avec les clés des parts rassemblées dans « Autres » maintenant (voir `id_others_threshold` et `ii_others_top`), dans l'ordre où elles ont été données, et renvoie leur nombre — `0` quand aucune part n'est rassemblée. Ce dont parle un clic sur `OTHERS_KEY`
`of_reload ( )`	Relit les lignes du dernier `of_from_datastore` — après un `Retrieve`, après une saisie — et met les parts à jour sur place, comme un second `of_from_datastore`. Renvoie `0` une fois relu, `-5` si aucune ligne n'a été donnée (ou si `of_clear` les a oubliées, ou si le DataStore a été détruit), `-2` si le composant n'est pas créé
`of_remove_slice ( string as_key )`	Retire une part ; les autres reprennent sa place, sa poignée est détruite. Renvoie `0` une fois retirée, `-5` si aucune part n'a cette clé, `-2` si le composant n'est pas créé
`of_set_values ( string as_keys[], double ad_values[] )`	De nouvelles valeurs pour plusieurs parts en un appel — ce qu'un tableau de bord appelle à chaque rafraîchissement : les bords entre les parts glissent ensemble vers leurs nouveaux angles, la roue n'ouvre jamais de trou. Renvoie `0` une fois appliqué, `-5` si les deux tableaux n'ont pas la même longueur ou si une clé n'est pas tenue (rien n'est alors appliqué), `-2` si le composant n'est pas créé
`of_total ( )`	Le total des parts affichées — ce que vaut 100 % maintenant : une part masquée dans la légende ne compte pas, ni une valeur négative
`of_reset ( )`	Vide le graphique — poignées de part comprises — et remet toutes les propriétés à leur valeur d'origine. Renvoie `0` une fois fait, `-2` si le composant n'est pas créé

Événements #

Événement	Déclenché quand
`ue_slice_clicked (string as_key, double ad_value)`	Une part a été cliquée — ou validée par Entrée ou Espace sur la part du clavier (Tab jusqu'au graphique, puis les flèches) : sa clé et sa valeur — `OTHERS_KEY` et la somme de ses parts pour la part « Autres ». Le clic est jugé là où la part repose : près du centre, le creux que laisse une part survolée en ressortant est encore le sien. Une part masquée n'a rien à cliquer
`ue_slice_dblclicked (string as_key, double ad_value)`	Double-clic sur une part : sa clé et sa valeur — l'endroit où ouvrir les lignes qui sont derrière (un forage : un second `of_from_datastore` avec les lignes de cette part). Les deux clics d'avant ont levé `ue_slice_clicked`, comme dans une DataWindow ; Entrée reste un clic
`ue_slice_rclicked (string as_key, long al_x, long al_y)`	Clic droit sur une part, ou touche Menu (Maj+F10) sur la part du clavier. `al_x`, `al_y` : l'endroit, en pixels écran — le pointeur, ou le milieu de la part pour la touche Menu, jamais là où traîne la souris. Un composant `contextmenu` s'y ouvre : `uo_menu.of_show(al_x, al_y)`
`ue_slice_toggled (string as_key, boolean ab_visible)`	L'utilisateur a masqué ou remontré une part d'un clic dans la légende (ou d'Entrée / Espace sur son entrée : la légende est un seul arrêt de Tab, les flèches la parcourent). La dernière part peut se masquer aussi : la roue dit alors Toutes les parts sont masquées. Ce que le graphique affiche n'est alors plus ce que l'application a envoyé. Poser `ib_visible` est une valeur, comme cocher une case : cet événement rapporte le geste de l'utilisateur
`ue_slice_hovered (string as_key)`	Avec `ib_track_hover` seulement : le pointeur ou le clavier atteint une autre part — sa clé ; une clé vide quand il les quitte toutes : le pointeur hors de la roue, Échap, le focus qui quitte le graphique
`ue_auto_height (long al_height)`	Avec `ib_auto_height` : l'userobject vient d'être redimensionné à sa hauteur idéale

Propriétés d'item #

Lues et écrites sur la poignée d'une part : uo_pie.of_item(/*key*/ "north").id_value = 450. Chaque lecture interroge le graphique.

Propriété	Type	Défaut	Rôle
`is_label`	string	`""`	Le nom de la part, tel que la légende et le panneau le montrent ; vide = sa clé
`id_value`	double	`0`	Sa valeur ; son angle est sa part du total, et elle y glisse
`il_color`	long	`-1`	Sa couleur ; `-1` = la couleur de la palette. Les couleurs d'item héritées (`il_accent`, `il_back_color`, `il_text_color` et leurs variantes de survol) n'ont aucun effet sur une part : `il_color` décide
`id_push_out`	double	`0`	La sort de la roue pour la mettre en avant, en fraction du rayon (borné à 0..0,4)
`ib_visible`	boolean	`true`	Masque la part sans la retirer : les autres se repartagent la roue, la légende garde un chemin de retour
`id_percent`	double	`0`	Sa part de ce que la roue montre, de 0 à 100 ; 0 quand elle est masquée (lecture seule). Chaque part s'écrit au dixième : trois parts égales lisent 33,3 % chacune, 99,9 % ensemble — les parts ne sont jamais forcées à faire 100
`is_tooltip`	string	`""`	Son info-bulle, écrite dans le panneau qui nomme la part sous le pointeur (ou celle du clavier) — jamais une seconde bulle. Avec `ib_value_tooltip` à `false`, le panneau s'ouvre quand même pour elle, sans les chiffres. Balisage accepté
`is_super_tooltip_title`	string	`""`	Le titre en gras de son info-bulle, écrit dans le panneau sous son nom
`is_super_tooltip_text`	string	`""`	Le texte de son info-bulle, dans le panneau. Balisage accepté
`is_super_tooltip_image`	string	`""`	Une image en tête de son info-bulle, dans le panneau (chemin du bundle, chemin absolu ou `resources.dll:nom`)

Exemples #

Un anneau et son total #

// A hole of 60 % of the radius : a doughnut
uo_pie.id_inner_radius = 0.6

// In the hole : the slice under the pointer, in bold above its name ;
// at rest, the total of the slices shown above the word Total
uo_pie.is_center_text = "[b]#hover_value#[/b][br]#hover_label#"

// Whole numbers with a thousands separator : a display format, as in a DataWindow
uo_pie.is_format = "#,##0"

Une demi-roue en jauge #

// From the left, over half a circle : the upper half
uo_pie.ii_start_angle = -90
uo_pie.ii_sweep_angle = 180
uo_pie.id_inner_radius = 0.62

// What is spent and what is left, in the colour they mean
uo_pie.of_add_slice(/*key*/ "spent", /*label*/ "Spent", /*value*/ 72, /*color*/ RGB(/*red*/ 15, /*green*/ 108, /*blue*/ 189))
uo_pie.of_add_slice(/*key*/ "left", /*label*/ "Remaining", /*value*/ 28, /*color*/ RGB(/*red*/ 150, /*green*/ 150, /*blue*/ 150))

// The share spent, in the hole : worked out by the chart, it follows every new value
uo_pie.is_center_text = "[b]#percent:spent#[/b][br]spent"

Un tableau de bord qui vit #

// Timer event of the window : new values for the same slices
// Local variables
string ls_keys[] = {"s1", "s2", "s3"}
double ld_load[]

// Read the figures, then hand them to the slices already on the chart : they
// SLIDE to their new angles instead of replaying their arrival
ld_load = wf_read_load()
uo_pie.of_set_values(/*keys*/ ls_keys, /*values*/ ld_load)

Ouvrir les lignes derrière une part #

// Event ue_slice_dblclicked of uo_pie : the key of the slice is the region
wf_open_orders(/*region*/ as_key, /*amount*/ ad_value)

// Event ue_slice_rclicked of uo_pie : (string as_key, long al_x, long al_y)
// Remember the slice, then open the contextmenu of the window where the gesture
// was made : the pointer, or the middle of the slice for the Menu key
is_menu_slice = as_key
uo_menu.of_show(/*x*/ al_x, /*y*/ al_y)

Depuis un DataStore #

// Local variables
long ll_rc

// One slice per category : the rows of a category are SUMMED into its slice
uo_pie.of_map(/*role*/ u_pbt_chartpie.ROLE_KEY, /*column*/ "category")
uo_pie.of_map(/*role*/ u_pbt_chartpie.ROLE_LABEL, /*column*/ "category")
uo_pie.of_map(/*role*/ u_pbt_chartpie.ROLE_VALUE, /*column*/ "amount")

// ONE call reads every row of the DataStore retrieved when the window opened
// (an instance variable), no loop
ll_rc = uo_pie.of_from_datastore(/*ads*/ ids_sales)

// A row with no category is skipped : the chart says how many
if uo_pie.of_get_last_error() <> "" then wf_status(uo_pie.of_get_last_error())

La DataWindow à l'écran, relue sur place #

// Open event of the window : the chart reads the DataWindow the user sees
uo_pie.of_map(/*role*/ u_pbt_chartpie.ROLE_KEY, /*column*/ "region")
uo_pie.of_map(/*role*/ u_pbt_chartpie.ROLE_VALUE, /*column*/ "amount")
uo_pie.of_from_datastore(/*adw*/ dw_sales)

// After a Retrieve : the slices follow IN PLACE - a region the user hid from
// the legend stays hidden, a new region gets its slice
dw_sales.Retrieve()
uo_pie.of_reload()

Les petites parts dans « Autres » #

// Every slice under 5 % of the total joins ONE slice, drawn last in grey,
// and only the six largest products keep a slice of their own
uo_pie.id_others_threshold = 5
uo_pie.ii_others_top = 6
uo_pie.is_others_label = "Other products"

// The largest first : the reader compares them from the top
uo_pie.is_sort = u_pbt_chartpie.SORT_DESC

// Event ue_slice_clicked of uo_pie : a click on Others opens the slices it holds
// Local variables
string ls_keys[]

// Others names the slices it gathered
if as_key = uo_pie.OTHERS_KEY then
	uo_pie.of_others_keys(/*keys*/ ls_keys)
	wf_open_products(/*keys*/ ls_keys)
end if

Bonnes pratiques #

Peu de parts. Au-delà de six ou sept, l'œil ne compare plus des angles voisins : regroupez les petites dans une part « Autres » (id_others_threshold), ou passez au graphique cartésien.
Ordonnez les parts de la plus grande à la plus petite (is_sort = SORT_DESC), en commençant en haut : la lecture suit le sens du dessin.
Des étiquettes dehors quand les parts sont étroites : elles restent lisibles, reliées à leur part, au lieu d'être omises.
Coupez l'animation sur un tableau de bord qui se rafraîchit, ou gardez-la et appelez of_set_values : les parts glissent au lieu de recommencer leur arrivée.
Le graphique garde le sens du dessin dans une application de droite à gauche — les étiquettes dehors aussi s'écrivent de gauche à droite, loin de la roue ; seules la légende START/END et ses flèches suivent le sens de lecture.
Une image du graphique (of_save_as_png, l'impression) est prise une fois le glissement posé : inutile de couper l'animation avant.
Une couleur qui veut dire quelque chose (en retard, dépensé) se pose par il_color ; laissez la palette au reste, elle change avec le thème clair ou sombre.

Hérité du socle commun #

Ces membres existent sur tous les composants visuels — ils ne sont pas propres à celui-ci. Ils sont détaillés une seule fois, dans les chapitres transverses ; cette table dit seulement où les lire.

Membres	Rôle	Détaillé dans
`of_count` · `of_keys_at` · `of_has`	Parcourir ce que le composant contient	3.2 Les items
`of_reset`	Remettre le composant à zéro	3.6 Remettre un composant à zéro : `of_reset()`
`of_register_shortcut` · `of_clear_shortcuts`	Raccourcis clavier du composant	3.5 Les raccourcis clavier
`of_is_created` · `of_is_ready` · `of_get_last_error`	S'il est né, s'il est prêt, ce qui a échoué	3.7 Diagnostic
`of_save_as_png` · `of_save_as_jpg`	Exporter le rendu en image	3.8 Exporter le rendu en image
`of_set_redraw`	Grouper les modifications en un seul repaint	3.10 Bonnes pratiques
`of_preload_icons`	Icônes affichées sans délai	Affichage instantané : `of_icon`
`of_set_translation`	Traduire un libellé du composant	5.2 Adapter un libellé : `of_set_translation`
`of_focus_webview`	Donner le focus au composant	6.4 Clavier et focus
`of_print` · `of_print_to_pdf`	Imprimer, ou écrire un PDF	6.9 Imprimer
`of_set_property` · `of_get_property` · `of_component_name`	Piloter une propriété par son nom	3.1 Le moteur de propriétés
`is_accessible_name` · `is_accessible_description`	Le nom et la description que dit un lecteur d'écran	3.4 Propriétés et events optionnels

Deux aides ne sont pas héritées : of_icon et of_escape_markup vivent sur n_pbt_utils. Déclarez-en une — n_pbt_utils lnv_utils, rien à créer — et appelez-les dessus.