chartpie — `u_pbt_chartpie` #

← Riferimento dei componenti · Sommario della guida

Grafico a torta: torta, ciambella o mezza ruota. Ogni angolo è una quota del tutto — la legenda nasconde una fetta, le altre ne prendono il posto.

▶ Vederlo dal vivo — Applicazione dimostrativa, riquadro Pie chart : l'anteprima, il codice che lo produce e questa pagina, affiancati.

In breve #

Userobject	`u_pbt_chartpie`
Classe di elementi	`n_pbt_chartpie_slice (of_item(key))`
Serve a	Mostrare come si ripartisce un tutto — vendite per regione, ticket per stato, budget consumato
Principio	Voi aggiungete fette (una chiave, un nome, un valore); angoli, percentuali, legenda e animazione sono affar nostro

Avvio rapido #

// 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#"

Una fetta è una QUOTA del tutto #

Voi date valori, mai angoli: il componente somma le fette mostrate e dà a ciascuna l'angolo della sua quota di quella somma. Nascondere una fetta — con un clic nella legenda, o tramite ib_visible — la chiude sul posto: le altre si ridividono la ruota, e #percent#, id_percent e of_total() seguono. Un valore negativo non ha angolo: è disegnato come zero e si rilegge come l'avete dato.

Gli angoli si contano in gradi, 0 in alto, nel senso del disegno: ii_start_angle = -90 e ii_sweep_angle = 180 danno la metà superiore di un cerchio — un indicatore. La ruota è adattata allo spazio che quell'angolo occupa: una mezza ruota è disegnata grande il doppio.

Proprietà #

Proprietà	Tipo	Predefinito	Ruolo
`is_title`	string	`""`	Titolo del grafico, sopra la ruota. Marcatura accettata
`ib_show_legend`	boolean	`true`	Mostra la legenda. Cliccare una voce nasconde la sua fetta e solleva `ue_slice_toggled`
`is_legend_location`	string	`end`	Dove va la legenda (costanti `LEGEND_*`): accanto alla ruota (`END`, `START`, in colonna) o sopra e sotto (`TOP`, `BOTTOM`, affiancate). `START`/`END` sono logiche: seguono il senso di lettura. Una posizione sconosciuta vale `end`, e si rilegge così
`ib_legend_values`	boolean	`false`	Scrive il valore e la quota di ogni fetta nella legenda, dopo il suo nome
`ib_value_tooltip`	boolean	`true`	Il pannello che nomina la fetta sotto il puntatore — o quella della tastiera — con valore e quota. Non è `is_tooltip`, la descrizione del componente intero. Il tooltip di una fetta (il suo `is_tooltip`) è scritto in questo pannello, anche a `false`
`ib_data_labels`	boolean	`false`	Un'etichetta per fetta, che dice ciò che dice `is_label_format`, dove la mette `is_label_position`. In una fetta troppo stretta l'etichetta è omessa piuttosto che scritta sulle vicine
`is_label_format`	string	`""`	Ciò che dice un'etichetta: `#value#` il valore, `#percent#` la sua quota del tutto, `#label#` il suo nome (senza marcatura), `#key#` la sua chiave, `#total#` il totale; `#participation#` dice ciò che dice `#percent#`. Il resto è scritto così com'è. Vuoto = il valore da solo
`is_label_position`	string	`inside`	Dove vanno le etichette (costanti `LABEL_*`): `INSIDE`, sulla fetta, in nero o in bianco a seconda di ciò che vi si legge; `OUTSIDE`, accanto alla ruota, collegate alla loro fetta da una linea e distanziate perché nessuna si sovrapponga
`id_inner_radius`	double	`0`	Il buco, in frazione del raggio: `0` una torta, `0.6` una ciambella (limitato a 0..0,9). La ruota scivola dall'una all'altra
`is_center_text`	string	`""`	Testo nel buco di una ciambella, marcatura accettata. Segnaposto: `#total#` il totale delle fette mostrate (nel formato dei numeri), `#count#` il loro numero; `#hover_label#`, `#hover_value#`, `#hover_percent#` la fetta sotto il puntatore o quella della tastiera — a riposo, il tutto: Totale, il totale, 100 %; `#percent:key#` e `#value:key#` la quota e il valore di una fetta, tenuti aggiornati qualunque cosa facciano i valori (un indicatore scrive da sé il suo «72 %»). Una chiave sconosciuta non scrive nulla. In una torta non si scrive nulla
`ii_start_angle`	integer	`0`	Dove inizia la prima fetta, in gradi: `0` in alto, `90` a destra, `-90` a sinistra (450 si rilegge 90)
`ii_sweep_angle`	integer	`360`	Quanta parte del cerchio si dividono le fette, in gradi (limitata a 10..360). Con `ii_start_angle = -90`, `180` disegna la metà superiore — un indicatore
`ib_clockwise`	boolean	`true`	Le fette si susseguono in senso orario, o nell'altro. Le frecce della tastiera seguono l'ordine del disegno
`is_sort`	string	`"none"`	L'ordine del disegno (costanti `SORT_*`): `NONE` l'ordine in cui le fette sono state date, `DESC` la più grande per prima, `ASC` la più piccola per prima. La ruota, la legenda e la tastiera lo seguono; il modello mantiene il suo ordine — `of_get_values`, `of_count` e i colori della tavolozza non si muovono. Un valore sconosciuto vale `none`
`id_hover_push_out`	double	`0.08`	Di quanto la fetta sotto il puntatore — o quella della tastiera — esce, in frazione del raggio (limitato a 0..0,4). Si somma al suo `id_push_out`. `0` = niente si muove
`ib_track_hover`	boolean	`false`	Adesione a `ue_slice_hovered`: un evento sollevato a ogni movimento del puntatore è inviato solo a un'applicazione che l'ha chiesto
`is_format`	string	`""`	Il formato di tutti i numeri che il grafico scrive — etichette, legenda, pannello dei valori, testo centrale — nella sintassi di un formato DataWindow: `#,##0.00`, `$#,##0`, `#,##0 "unità"`, sezioni positivo;negativo;zero. I separatori sono quelli della lingua di visualizzazione. Vuoto (o un formato non numerico) = il numero così com'è, al millesimo. Le quote (`#percent#`) si scrivono sempre al decimo
`id_others_threshold`	double	`0`	Raggruppa le fette piccole: ogni fetta la cui quota del tutto è sotto questa percentuale entra in una fetta «Altri», disegnata per ultima in un grigio neutro — la legenda la mostra al loro posto. I membri sono giudicati su tutte le fette, mostrate o nascoste: nascondere una fetta grande non fa mai uscire le piccole, e la fetta più grande non vi entra mai. La sua chiave è `OTHERS_KEY` (`"__others"`) in tutti gli eventi, il suo valore è la somma dei suoi membri mostrati, `of_others_keys` li nomina, `of_item(OTHERS_KEY)` ne legge valore e quota o la nasconde. Una sola fetta piccola mantiene il proprio settore. `0` = mai
`ii_others_top`	integer	`0`	Raggruppa per numero: le N fette più grandi mantengono il loro settore, tutte le altre entrano in «Altri» (almeno due, come per la soglia). Si somma a `id_others_threshold`: una fetta entra appena una delle due regole lo dice. `0` = nessuna regola del genere
`is_others_label`	string	`""`	Il nome della fetta «Altri». Marcatura accettata nella legenda e nel pannello dei valori; le etichette e il riassunto letto da un lettore di schermo ne scrivono il testo semplice. Vuoto = la parola della lingua di visualizzazione (Others, Altri…)
`ib_auto_height`	boolean	`false`	Il componente annuncia la sua altezza ideale e l'userobject vi si adatta (`ue_auto_height`). La larghezza la detta: una mezza ruota è alta la metà
`ib_enabled`	boolean	`true`	Disattivato, il grafico mostra sempre ciò che mostra ma non risponde più: né clic, né doppio clic, né tastiera, né legenda, ed esce dall'ordine di tabulazione
`ib_animated`	boolean	`true`	La ruota arriva animata — si apre dalla sua partenza, fetta dopo fetta — e i nuovi valori scivolano: i bordi tra le fette si muovono insieme, la ruota non mostra mai un buco né una fetta sulla sua vicina; una fetta tolta si richiude al suo posto. Una postazione impostata per ridurre le animazioni non anima mai, e la ruota arriva nello stesso punto
`ii_anim_duration`	integer	`450`	Durata dell'arrivo e di ogni movimento, in millisecondi (limitata a 0..5000)
`is_anim_easing`	string	`ease-out`	La curva del movimento (costanti `EASING_*`, i nomi di LiveCharts2): `back-out` supera poi torna, `bounce-out` rimbalza, `elastic-out` scatta
`ii_anim_delay`	integer	`40`	Solo all'arrivo (una ruota che non aveva nulla sullo schermo), lo sfasamento tra due fette, in millisecondi (da 0 a 1000): la ruota si apre fetta dopo fetta, mai più di 600 ms dopo in tutto, qualunque sia il numero di fette. `0` = tutte insieme. Un cambio di valori fa sempre scivolare tutte le fette insieme
`is_theme_style`	string	`""`	Stile visivo del componente (costanti `THEME_STYLE_*`); vuoto = quello dell'applicazione, seguito a ogni cambio
`is_theme_mode`	string	`""`	Variante chiara o scura (costanti `THEME_MODE_*`); vuoto = quella dell'applicazione, seguita a ogni cambio
`il_theme_accent`	long	`-1`	Colore di accento di questo componente (`-1` = accento del tema)
`is_tooltip`	string	`""`	Descrizione comando semplice mostrata al passaggio sul componente
`is_super_tooltip_title`	string	`""`	Titolo della descrizione arricchita (prevale su `is_tooltip`)
`is_super_tooltip_text`	string	`""`	Testo della descrizione arricchita (markup ricco accettato)
`is_super_tooltip_image`	string	`""`	Immagine della descrizione arricchita

Metodi #

Metodo	Ruolo
`of_add_slice ( string as_key, string as_label, double ad_value { , long al_color } )`	Aggiunge una fetta: la sua chiave, il suo nome (marcatura accettata) e il suo valore; l'overload con un colore lo fissa, senza è la tavolozza a scegliere (un insieme per un tema chiaro, uno per un tema scuro). Restituisce `0` una volta aggiunta, `-5` se la chiave è vuota, contiene `/` o `	`, inizia con` __ `(le chiavi del grafico stesso, come` OTHERS_KEY`) o è già presa (un'aggiunta non sostituisce mai una fetta),` -2` se il componente non è creato
`of_clear ( )`	Toglie tutte le fette — i loro handle se ne vanno con esse — e dimentica le righe di `of_from_datastore`: un `of_map` o un `of_reload` successivo non le riporta. Le impostazioni restano, anche i ruoli di `of_map`; al loro posto è disegnata una ruota vuota. Restituisce `0` una volta svuotato, `-2` se il componente non è creato
`of_from_datastore (datastore ads)`	Alimenta il grafico da un DataStore: una riga = una fetta. Una colonna gioca un ruolo quando porta il suo nome (`key`, `label`, `value`, `color`) o quando `of_map` lo dice; serve una colonna `ROLE_VALUE`. Senza colonna `ROLE_KEY`, la chiave di una fetta è il suo numero di riga; con essa, le righe che condividono una chiave sono sommate in una sola fetta (nome e colore della prima) — un anno di vendite diventa una fetta per categoria, senza ciclo. Numeri e date sono letti come la DataWindow li scrive sulla postazione (virgola decimale, date regionali: una data diventa `yyyy-mm-dd`). Un secondo caricamento aggiorna le fette sul posto: una chiave che ritorna mantiene ciò che l'utente e il vostro codice le hanno dato (nascosta dalla legenda, scostata, un colore del codice, il suo tooltip) e il suo handle; le fette delle chiavi sparite se ne vanno; le fette aggiunte a mano restano, dopo quelle delle righe. Restituisce `0` una volta caricato — una riga la cui chiave è vuota, contiene `/` o `	`, inizia con` __ `o è tenuta da una fetta aggiunta a mano è scartata, e` of_get_last_error `dice quante —,` -5 `se il DataStore non è valido, nessuna colonna gioca` ROLE_VALUE `o una colonna nominata da` of_map `non c'è (`of_get_last_error `la nomina),` -2` se il componente non è creato
`of_from_datastore (datawindow adw)`	La stessa cosa dalle righe di una DataWindow — quella che l'utente vede accanto al grafico. I suoi dati sono condivisi con un DataStore di passaggio: una DataWindow che non può condividerli è rifiutata (`-5`, con il motivo). Restituisce `0` una volta caricato, `-5` come sopra, `-2` se il componente non è creato
`of_from_datastore (datawindowchild adwc)`	La stessa cosa dalle righe di un DataWindowChild (una DataWindow a discesa, un report annidato). Restituisce `0` una volta caricato, `-5` come sopra, `-2` se il componente non è creato
`of_get_last_error ( )`	Perché l'ultima chiamata è stata rifiutata (un ruolo di `of_map` che le righe non hanno…), o quante righe l'ultimo `of_from_datastore` ha scartato e perché; altrimenti l'ultimo errore della DLL, come per ogni componente
`of_get_values ( ref string as_keys[], ref double ad_values[] )`	Riempie i due array con le fette che il grafico tiene ora, nell'ordine in cui sono state date (`is_sort` cambia solo il disegno), e restituisce il loro numero — ciò che legge il grafico, non ciò che è stato inviato
`of_item ( string as_key )`	L'handle `n_pbt_chartpie_slice` di una fetta, per leggere o cambiare nome, valore, colore, scostamento o visibilità. `of_item(OTHERS_KEY)` è sempre valido: la fetta «Altri», il suo valore, la sua quota, la sua visibilità (`of_has` non la nomina: è del grafico, non vostra). Una chiave che il grafico non ha dà un handle che non cambia nulla e legge valori vuoti — una proprietà non può rispondere -5: verificate prima con `of_has` una chiave venuta da fuori
`of_map ( string as_role, string as_column )`	Dà un ruolo a una colonna quando il suo nome non lo dice: `of_map(ROLE_VALUE, "amount")`. Ruoli: `ROLE_KEY` (le righe di una stessa chiave sono sommate), `ROLE_LABEL`, `ROLE_VALUE`, `ROLE_COLOR` (un long `RGB()` o `#rrggbb`). Prima di `of_from_datastore`, o dopo: le righe sono allora rilette sul posto. La colonna è giudicata dal prossimo `of_from_datastore` (`-5` lì se manca); quando le righe già date non l'hanno, non sono rilette — il ruolo attende le righe che state per dare, e `of_get_last_error` lo dice. Una colonna vuota rende il ruolo alla colonna che porta il suo nome. Restituisce `0` una volta impostato, `-5` se il ruolo non è una costante `ROLE_`, `-2` se il componente non è creato
`of_others_keys ( ref string as_keys[] )`	Riempie l'array con le chiavi delle fette raggruppate in «Altri» adesso (vedi `id_others_threshold` e `ii_others_top`), nell'ordine in cui sono state date, e restituisce il loro numero — `0` quando nessuna fetta è raggruppata. Ciò di cui parla un clic su `OTHERS_KEY`
`of_reload ( )`	Rilegge le righe dell'ultimo `of_from_datastore` — dopo un `Retrieve`, dopo una modifica — e aggiorna le fette sul posto, come un secondo `of_from_datastore`. Restituisce `0` una volta riletto, `-5` se non è stata data nessuna riga (o `of_clear` le ha dimenticate, o il DataStore è stato distrutto), `-2` se il componente non è creato
`of_remove_slice ( string as_key )`	Toglie una fetta; le altre ne prendono il posto, il suo handle è distrutto. Restituisce `0` una volta tolta, `-5` se nessuna fetta ha questa chiave, `-2` se il componente non è creato
`of_set_values ( string as_keys[], double ad_values[] )`	Nuovi valori per più fette in una chiamata — ciò che un cruscotto chiama a ogni aggiornamento: i bordi tra le fette scivolano insieme verso i nuovi angoli, la ruota non apre mai un buco. Restituisce `0` una volta applicato, `-5` se i due array hanno lunghezze diverse o una chiave non è presente (allora nulla è applicato), `-2` se il componente non è creato
`of_total ( )`	Il totale delle fette mostrate — ciò che vale il 100 % adesso: una fetta nascosta dalla legenda non conta, né un valore negativo
`of_reset ( )`	Svuota il grafico — handle delle fette compresi — e riporta tutte le proprietà al valore d'origine. Restituisce `0` una volta fatto, `-2` se il componente non è creato

Eventi #

Evento	Scatta quando
`ue_slice_clicked (string as_key, double ad_value)`	Una fetta è stata cliccata — o confermata con Invio o Spazio sulla fetta della tastiera (Tab fino al grafico, poi le frecce): la sua chiave e il suo valore — `OTHERS_KEY` e la somma delle sue fette per la fetta «Altri». Il clic è giudicato dove la fetta riposa: vicino al centro, il vuoto che lascia una fetta puntata uscendo è ancora suo. Una fetta nascosta non ha niente da cliccare
`ue_slice_dblclicked (string as_key, double ad_value)`	Doppio clic su una fetta: la sua chiave e il suo valore — il punto in cui aprire le righe che ci sono dietro (un drill down: un secondo `of_from_datastore` con le righe di quella fetta). I due clic precedenti hanno sollevato `ue_slice_clicked`, come in una DataWindow; Invio resta un clic
`ue_slice_rclicked (string as_key, long al_x, long al_y)`	Clic destro su una fetta, o tasto Menu (Maiusc+F10) sulla fetta della tastiera. `al_x`, `al_y`: dove, in pixel di schermo — il puntatore, o il centro della fetta per il tasto Menu, mai dove si trova il mouse. Un componente `contextmenu` vi si apre: `uo_menu.of_show(al_x, al_y)`
`ue_slice_toggled (string as_key, boolean ab_visible)`	L'utente ha nascosto o rimostrato una fetta con un clic nella legenda (o con Invio / Spazio sulla sua voce: la legenda è un solo punto di Tab, le frecce la percorrono). Anche l'ultima fetta si può nascondere: la ruota dice allora Tutte le fette sono nascoste. Ciò che il grafico mostra non è allora più ciò che l'applicazione ha inviato. Impostare `ib_visible` è un valore, come spuntare una casella: questo evento riporta il gesto dell'utente
`ue_slice_hovered (string as_key)`	Solo con `ib_track_hover`: il puntatore o la tastiera raggiunge un'altra fetta — la sua chiave; una chiave vuota quando le lascia tutte: il puntatore fuori dalla ruota, Esc, il focus che lascia il grafico
`ue_auto_height (long al_height)`	Con `ib_auto_height`: l'userobject è appena stato ridimensionato alla sua altezza ideale

Proprietà di elemento #

Lette e scritte sull'handle di una fetta: uo_pie.of_item(/*key*/ "north").id_value = 450. Ogni lettura interroga il grafico.

Proprietà	Tipo	Predefinito	Ruolo
`is_label`	string	`""`	Il nome della fetta, come lo mostrano la legenda e il pannello; vuoto = la sua chiave
`id_value`	double	`0`	Il suo valore; il suo angolo è la sua quota del totale, e vi scivola
`il_color`	long	`-1`	Il suo colore; `-1` = il colore della tavolozza. I colori di elemento ereditati (`il_accent`, `il_back_color`, `il_text_color` e le loro varianti al passaggio) non hanno alcun effetto su una fetta: decide `il_color`
`id_push_out`	double	`0`	La fa uscire dalla ruota per metterla in evidenza, in frazione del raggio (limitato a 0..0,4)
`ib_visible`	boolean	`true`	Nasconde la fetta senza toglierla: le altre si ridividono la ruota, la legenda tiene una via di ritorno
`id_percent`	double	`0`	La sua quota di ciò che la ruota mostra, da 0 a 100; 0 quando è nascosta (sola lettura). Ogni quota si scrive al decimo: tre fette uguali leggono 33,3 % ciascuna, 99,9 % insieme — le quote non sono mai forzate a fare 100
`is_tooltip`	string	`""`	Il suo tooltip, scritto nel pannello che nomina la fetta sotto il puntatore (o quella della tastiera) — mai una seconda bolla. Con `ib_value_tooltip` a `false`, il pannello si apre comunque per esso, senza le cifre. Markup accettato
`is_super_tooltip_title`	string	`""`	Il titolo in grassetto del suo tooltip, scritto nel pannello sotto il suo nome
`is_super_tooltip_text`	string	`""`	Il testo del suo tooltip, nel pannello. Markup accettato
`is_super_tooltip_image`	string	`""`	Un'immagine in cima al suo tooltip, nel pannello (percorso del bundle, percorso assoluto o `resources.dll:nome`)

Esempi #

Una ciambella e il suo totale #

// 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"

Una mezza ruota come indicatore #

// 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 cruscotto che vive #

// 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)

Aprire le righe dietro una fetta #

// 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)

Da 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 sullo schermo, riletta sul posto #

// 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()

Le fette piccole in «Altri» #

// 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

Buone pratiche #

Poche fette. Oltre sei o sette, l'occhio non confronta più angoli vicini: raggruppate le piccole in una fetta «Altri» (id_others_threshold), o passate al grafico cartesiano.
Ordinate le fette dalla più grande alla più piccola (is_sort = SORT_DESC), partendo dall'alto: la lettura segue il senso del disegno.
Etichette fuori quando le fette sono strette: restano leggibili, collegate alla loro fetta, invece di essere omesse.
Spegnete l'animazione su un cruscotto che si aggiorna, oppure tenetela e chiamate of_set_values: le fette scivolano invece di ricominciare il loro arrivo.
Il grafico conserva il senso del disegno in un'applicazione da destra a sinistra — anche le etichette esterne si scrivono da sinistra a destra, lontano dalla ruota; solo la legenda START/END e le sue frecce seguono il senso di lettura.
Un'immagine del grafico (of_save_as_png, la stampa) è presa una volta posato lo scivolamento: inutile spegnere prima l'animazione.
Un colore che significa qualcosa (in ritardo, speso) si imposta con il_color; lasciate il resto alla tavolozza, che cambia con il tema chiaro o scuro.

Ereditato dalla base comune #

Questi membri esistono su tutti i componenti visivi — non sono propri di questo. Sono descritti una sola volta, nei capitoli trasversali; questa tabella dice solo dove leggerli.

Membri	Ruolo	Descritto in
`of_count` · `of_keys_at` · `of_has`	Percorrere ciò che il componente contiene	3.2 Gli item
`of_reset`	Riportare il componente a zero	3.6 Riportare un componente a zero: `of_reset()`
`of_register_shortcut` · `of_clear_shortcuts`	Scorciatoie da tastiera del componente	3.5 Le scorciatoie da tastiera
`of_is_created` · `of_is_ready` · `of_get_last_error`	Se è nato, se è pronto, cosa è fallito	3.7 Diagnostica
`of_save_as_png` · `of_save_as_jpg`	Esportare il rendering in immagine	3.8 Esportare il rendering come immagine
`of_set_redraw`	Raggruppare le modifiche in un solo ridisegno	3.10 Buone pratiche
`of_preload_icons`	Icone mostrate senza ritardo	Visualizzazione istantanea: `of_icon`
`of_set_translation`	Tradurre una dicitura del componente	5.2 Adattare un'etichetta: `of_set_translation`
`of_focus_webview`	Dare il focus al componente	6.4 Tastiera e focus
`of_print` · `of_print_to_pdf`	Stampare, o scrivere un PDF	6.9 Stampare
`of_set_property` · `of_get_property` · `of_component_name`	Pilotare una proprietà per nome	3.1 Il motore delle proprietà
`is_accessible_name` · `is_accessible_description`	Il nome e la descrizione che dice un lettore di schermo	3.4 Proprietà ed event opzionali

Due aiuti non sono ereditati: of_icon e of_escape_markup vivono su n_pbt_utils. Ne dichiari uno — n_pbt_utils lnv_utils, niente da creare — e li chiami su di esso.