form — `u_pbt_form` #

← Riferimento dei componenti · Sommario della guida

form è un'intera schermata di inserimento in un solo controllo: campi tipizzati — testo, numero, elenco, pulsanti di opzione, data, ora, colore, casella di controllo, password, e-mail, testo lungo, immagine, etichette, stelle — disposti in colonne e in sezioni che si comprimono, ognuno con la sua etichetta che sale nel bordo. Le regole di ogni campo (obbligatorio, limiti, schema, maschera…) e i vostri errori di business si verificano insieme; of_is_dirty dice cosa è cambiato dal caricamento, of_load_row / of_save_row leggono e scrivono una riga di DataWindow. Il vostro pulsante OK chiama of_validate.

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

In breve #

Userobject	`u_pbt_form`
Classi di item	`n_pbt_form_section` (sezione) → `n_pbt_form_field` (campo)
Serve a	Sostituire una schermata di inserimento fatta di decine di controlli posati a mano con un modulo a tema che si dispone da solo e verifica ciò che si digita: scheda cliente, ordine, impostazioni, un passo di una procedura guidata
Valori	Sempre testo, uno per uno (`of_field(indirizzo).is_value`); tutti insieme e tipizzati con `of_values`; una riga di DataWindow con `of_load_row` / `of_save_row`
Opzioni opt-in	`ib_veto_changes`

Avvio rapido #

// Two columns ; a name at the top, then a section
uo_form.ii_columns = 2
uo_form.of_add_field(/*keys*/ "name", /*label*/ "Name", /*type*/ u_pbt_form.TYPE_STRING, /*value*/ "")
uo_form.of_field(/*keys*/ "name").ib_required = true
uo_form.of_add_section(/*key*/ "order", /*title*/ "Order")
uo_form.of_add_field(/*keys*/ "order/qty", /*label*/ "Quantity", /*type*/ u_pbt_form.TYPE_NUMBER, /*value*/ "1")
uo_form.of_add_field(/*keys*/ "order/due", /*label*/ "Due on", /*type*/ u_pbt_form.TYPE_DATE, /*value*/ "")

// event clicked of cb_ok
// Local variables
n_pbt_json lnv_json

// Every error shown at once, the keyboard on the first
if uo_form.of_validate() > 0 then return

// Valid : read the values, typed, along the same addresses
lnv_json.of_load(/*json*/ uo_form.of_values())
of_save_order(lnv_json.of_get_string(/*path*/ "name"), lnv_json.of_get_number(/*path*/ "order/qty"))

Un indirizzo per campo #

Un campo si designa con il suo indirizzo: la sola chiave al primo livello ("name"), la sezione poi il campo uniti da / in una sezione ("order/qty") — un livello, mai di più. Una sezione si designa con la sola chiave. Al primo livello, una chiave nomina una cosa sola: una sezione e un campo in cima non possono condividerla. Gli eventi portano lo stesso indirizzo, quello che avete scritto; la chiave di un campo (il suo ultimo livello) è anche il nome della colonna che leggono of_load_row e of_save_row.

// A section by its key, a field by its address
uo_form.of_section(/*key*/ "order").ib_collapsed = true
uo_form.of_field(/*keys*/ "order/qty").is_value = "3"

I tipi di campo #

Il tipo si sceglie una volta, in of_add_field, e dà il controllo. Il valore invece è sempre testo — dato, letto, consegnato dagli eventi — scritto allo stesso modo qualunque sia la lingua della postazione. Un elenco, una data e un colore si aprono nelle finestre native condivise da tutta la libreria, con i colori del tema.

Costante	Controllo	Il valore, come testo
`TYPE_STRING`	Casella di testo; una maschera (`is_mask`, sintassi di un EditMask) mostra i suoi letterali durante la digitazione; un pulsante «…» (`ib_ellipsis`) apre la vostra ricerca	Il testo così com'è; mascherato, senza i suoi letterali (`5551234567`)
`TYPE_TEXTAREA`	Testo su più righe; Invio va a capo	Il testo, a capo compresi
`TYPE_NUMBER`	Casella di testo che legge un numero nella lingua di visualizzazione: il suo separatore decimale o un punto, il suo raggruppamento delle migliaia ben formato (`1,000` vale mille in inglese, `1.500` millecinquecento in tedesco, `1 234,5` in francese). Un'immissione ambigua (`1,5` in inglese, `1 2`) o che non è un numero resta a schermo con il messaggio Not a number tradotto, e il valore in essere non si muove; Su / Giù lo aumentano o lo diminuiscono del suo passo (`id_step`)	Con il punto: `"12.5"`; `""` = vuoto. Conservato cifra per cifra; `12.50` ridigitato per `12.5` non è un cambiamento
`TYPE_BOOLEAN`	Un interruttore (predefinito) o una casella di controllo (`is_boolean_style`), con l'etichetta accanto	`"true"` · `"false"`
`TYPE_ENUM`	Pulsante che apre l'elenco condiviso; le sue opzioni si aggiungono una per una (`of_add_option`)	Il valore dell'opzione scelta, mai il suo testo; un valore che nessuna opzione offre è mantenuto e mostrato com'è, come un DataWindow senza tabella dei codici
`TYPE_RADIO`	Un pulsante di opzione per opzione, affiancati; le frecce passano dall'uno all'altro	Il valore dell'opzione scelta
`TYPE_DATE`	Pulsante che apre il calendario condiviso; la data appare nel formato della lingua di visualizzazione	`"yyyy-mm-dd"`
`TYPE_TIME`	Casella di testo: `9:5` diventa `09:05`; ciò che non è un'ora di 24 h resta a schermo con il suo messaggio	`"hh:mm"`
`TYPE_COLOR`	Pulsante con il campione del colore, che apre il selettore condiviso	Il long RGB scritto come testo: `String(RGB(255, 0, 0))` = `"255"`
`TYPE_PASSWORD`	Casella di testo mascherata	Il testo così com'è
`TYPE_EMAIL`	Casella di testo che verifica la forma di un indirizzo	Il testo così com'è
`TYPE_IMAGE`	Un'immagine, non un inserimento: mai validata, mai in `of_values`; con `ii_rowspan` copre più righe (la foto di una scheda)	La sua sorgente: un file, o `mono:` / `tint:` seguito da un percorso (con i colori del tema); un indirizzo `http://` è rifiutato
`TYPE_TAGS`	Etichette come pillole in una casella: si digita una parola poi Invio, una virgola o Tab; Backspace nell'immissione vuota toglie l'ultima, ogni pillola ha la sua croce, Sinistra / Destra le percorrono. Le opzioni del campo (`of_add_option`) sono suggerimenti filtrati durante la digitazione; `ib_options_only` le rende le sole scelte, `ii_max_tags` ne limita il numero	Le etichette unite da una virgola e uno spazio: `"vip, b2b"` (il valore dell'opzione per un suggerimento scelto). La virgola è il separatore: mai dentro un'etichetta; scritta dal codice divide, gli spazi attorno spariscono, la stessa etichetta due volte (senza badare alle maiuscole) resta una volta
`TYPE_RATING`	Stelle da cliccare, `ii_star_count` (5 per impostazione predefinita), mezze stelle con `ib_half_stars`. Il passaggio del mouse mostra un'anteprima senza spostare nulla; un clic sul valore in essere lo cancella. Da tastiera: frecce, Home / Fine, una cifra, 0 o Canc. Una stella piena prende l'accento del componente	Il numero di stelle: `"4"`, `"3.5"`; `""` = nessuna valutazione (anche 0). Scritto dal codice, arrotondato al passo e tenuto entro le stelle; un testo o un negativo è rifiutato

La validazione #

Ogni campo porta le sue regole: ib_required (una casella obbligatoria deve essere spuntata), is_min / is_max (un numero, una data, un'ora), ii_max_length, is_pattern (un'espressione regolare che il valore intero deve seguire), is_mask (una maschera riempita), is_match (uguale a un altro campo), e la forma di un e-mail, di un numero o di un'ora. La vostra applicazione vi aggiunge i suoi errori di business (is_error: già preso), che restano finché l'utente non modifica il campo. Nulla appare in rosso finché l'utente non ha lasciato un campo: un modulo nuovo non è rosso. of_is_valid e of_invalid_keys rispondono senza mostrare nulla; of_validate mostra tutto insieme e mette la tastiera sul primo campo in errore. Un campo nascosto, disattivato o in sola lettura non è giudicato dalle sue regole: l'utente non potrebbe correggerlo.

// A customer code : two capital letters, then four digits
uo_form.of_field(/*keys*/ "code").is_pattern = "[A-Z]{2}[0-9]{4}"
uo_form.of_field(/*keys*/ "code").is_pattern_message = "Two capital letters, then four digits"

// A rule only your database knows
if of_email_taken(uo_form.of_field(/*keys*/ "email").is_value) then
    uo_form.of_field(/*keys*/ "email").is_error = "Already used by another customer"
end if

Proprietà #

Proprietà	Tipo	Predefinito	Ruolo
`ii_columns`	integer	`1`	Numero di colonne, da 1 a 12 (un valore fuori dai limiti vi è riportato). Ogni sezione segue. Un campo ne copre di più con `ii_colspan`, inizia in una colonna data con `ii_col`, copre più righe con `ii_rowspan`; gli altri campi riempiono le celle libere
`ib_readonly`	boolean	`false`	Il modulo intero in sola lettura: ogni valore si legge, nessuno si cambia — una scheda da consultare. Il vostro codice può sempre scrivere i valori
`ib_veto_changes`	boolean	`false`	Opt-in: chiedere prima di scrivere un valore dell'utente (solleva `ue_value_changing`, che può rifiutare: il campo mostra di nuovo il vecchio valore). Un valore scritto dal vostro codice non chiede mai
`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 d'accento di questo componente (`-1` = accento dell'applicazione, o quello del tema)
`is_tooltip`	string	`""`	Tooltip semplice mostrato al passaggio del mouse sul componente
`is_super_tooltip_title`	string	`""`	Titolo del tooltip avanzato (prevale su `is_tooltip`)
`is_super_tooltip_text`	string	`""`	Testo del tooltip avanzato (markup avanzato accettato)
`is_super_tooltip_image`	string	`""`	Immagine del tooltip avanzato

Proprietà di una sezione — `n_pbt_form_section` #

Proprietà	Tipo	Predefinito	Ruolo
`is_title`	string	`""`	Titolo dell'intestazione. Accetta il testo formattato con tag. Vuoto, l'intestazione mostra la chiave
`ib_collapsed`	boolean	`false`	`true` comprime la sezione: la sua intestazione resta, i suoi campi si nascondono — mantengono i loro valori e restano giudicati. Segue `ue_section_toggled`, come per un clic sull'intestazione. Riletta in diretta
`ib_visible`	boolean	`true`	`false` toglie la sezione, e tutti i suoi campi, dal modulo; mantengono i loro valori (`of_values` li restituisce sempre) e non sono giudicati
`is_tooltip`	string	`""`	Tooltip semplice mostrato al passaggio del mouse sull'item
`is_super_tooltip_title`	string	`""`	Titolo del tooltip avanzato dell'item (prevale su `is_tooltip`)
`is_super_tooltip_text`	string	`""`	Testo del tooltip avanzato dell'item (markup avanzato accettato)
`is_super_tooltip_image`	string	`""`	Immagine del tooltip avanzato dell'item
`il_accent`	long	`-1`	Accento dell'intestazione della sezione: la linea sotto il suo titolo lo prende (`-1` = quello del componente). I suoi campi tengono il loro
`il_back_color`	long	`-1`	Sfondo dell'intestazione della sezione, in `RGB(r,g,b)` (`-1` = quello che dà il tema)
`il_text_color`	long	`-1`	Colore del testo dell'intestazione della sezione (`-1` = quello che dà il tema)
`il_back_color_hover`	long	`-1`	Sfondo dell'intestazione della sezione sotto il puntatore (`-1` = quello che dà il tema)
`il_text_color_hover`	long	`-1`	Colore del testo dell'intestazione della sezione sotto il puntatore (`-1` = quello che dà il tema)

Proprietà di un campo — `n_pbt_form_field` #

Proprietà	Tipo	Predefinito	Ruolo
`is_value`	string	`""`	Il valore, come testo (vedere i tipi). Scriverlo non solleva nulla, come `SetItem`; leggerlo dà il valore corrente, chiunque l'abbia scritto — ciò che si sta digitando conta. Un valore che il tipo non può contenere (una data che non esiste, un testo in un numero) è rifiutato: il vecchio resta e `of_get_last_error` dice perché
`is_label`	string	`""`	L'etichetta, nel campo: sale nel bordo quando il campo ha un valore o la tastiera. Accetta il testo formattato con tag. Una stella segue l'etichetta di un campo obbligatorio. Vuota, la chiave
`is_placeholder`	string	`""`	Un suggerimento in un campo di testo vuoto mentre ha la tastiera
`is_help`	string	`""`	Una riga di aiuto sotto il campo (testo formattato con tag); si nasconde quando un errore prende il suo posto
`is_error`	string	`""`	Un errore di business della vostra applicazione (già preso): mostrato subito, il modulo non valido, finché l'utente non modifica il campo o `of_clear_errors`; `""` lo cancella. Letto, dà il messaggio che il campo mostra — o mostrerà quando l'utente lo lascerà: l'errore di business, altrimenti quello delle sue regole, `""` se è valido. Su un campo che l'utente non può raggiungere (nascosto, disattivato) è mantenuto e si rilegge, ma non conta: il modulo resta valido finché il campo non torna
`is_min`	string	`""`	Il valore più piccolo accettato per un numero (con il punto), una data (`yyyy-mm-dd`) o un'ora (`hh:mm`); il messaggio dice Minimum e il limite. Un limite che il tipo non legge è ignorato; `""` = nessuno — per un numero, l'estremo basso della SpinRange della sua colonna di DataWindow (`of_load_row`). Letto, dà il limite in vigore
`is_max`	string	`""`	Il valore più grande accettato, letto come `is_min`; il messaggio dice Maximum e il limite
`is_pattern`	string	`""`	Un'espressione regolare (sintassi JavaScript) che il valore intero deve seguire: `[A-Z]{2}[0-9]{4}` accetta `AB1234`, non `xAB1234`. Un valore vuoto è lasciato a `ib_required`
`is_pattern_message`	string	`""`	Il messaggio quando `is_pattern` fallisce; vuoto: Invalid format, tradotto
`is_mask`	string	`""`	Una maschera di inserimento. Su un `TYPE_STRING`, la sintassi di un EditMask di PowerBuilder: `#` una cifra, `!` un carattere qualsiasi in maiuscolo, `^` un carattere qualsiasi in minuscolo, `a` una lettera o una cifra, `X` un carattere qualsiasi, il resto scritto per l'utente mentre digita (`(###) ###-####`); il cursore resta dopo ciò che è stato digitato. Il valore tiene solo ciò che è stato digitato nelle caselle, come un EditMask (`5551234567`, pronto per una colonna di cifre); un valore del codice è il valore grezzo, senza i suoi letterali (`312345678` sotto `+33 # ## ## ## ##`), i letterali iniziali si scrivono appena il campo prende la tastiera, un valore che non riempie tutte le caselle è Incomplete, e impostare una maschera dopo un valore non cambia nulla di ciò che l'utente ha fatto. Dopo `of_load_row`, una maschera vuota prende l'EditMask della colonna. Su un `TYPE_NUMBER`: una maschera numerica nella sintassi di PowerBuilder (EditMask, formato DataWindow): `#` una cifra facoltativa, `0` una cifra obbligatoria, `,` il raggruppamento, `.` il separatore decimale, `%` il numero mostrato moltiplicato per 100, letterali (`$`, un testo tra virgolette, `\x`) e sezioni `positivo;negativo` (`"$#,##0;($#,##0)"`). La virgola e il punto indicano i separatori della lingua di visualizzazione. Durante la digitazione il raggruppamento compare man mano che arrivano le cifre, i decimali sono limitati alla maschera, le lettere sono rifiutate, il cursore mantiene il suo posto tra le cifre e un numero incollato è letto nella lingua di visualizzazione; lasciando il campo la maschera completa (`12` diventa `12,00`). Il valore mantiene il numero come lo scrive il codice (`"1234.5"`), senza raggruppamento né simbolo. Un limite inferiore (`is_min`) di 0 o più rifiuta il segno meno; i limiti si applicano lasciando il campo, e il loro messaggio li mostra attraverso la maschera; vuoto su un `TYPE_NUMBER` (predefinito): il campo si digita secondo il suo `is_format` privato dei letterali (`$#,##0.00` si digita `#,##0.00`, `#,##0 "px"` si digita `#,##0`; un `%` resta, è una scala)
`is_format`	string	`""`	Un `TYPE_NUMBER`: il suo formato di visualizzazione, come il numero si mostra quando il campo non ha la tastiera — stessa sintassi di `is_mask`, con i suoi letterali: `#,##0 "px"` mostra `575 px`, `$#,##0.00;($#,##0.00)` un prezzo, `0.0%` un tasso (0,125 mostra `12,5%`). Quando il campo prende la tastiera il suo testo diventa quello di `is_mask` (`575`), il cursore mantiene il suo posto tra le cifre; lasciandolo torna il testo di visualizzazione. Il passaggio non cambia mai il valore e non solleva nulla: `ue_value_changed` riporta solo ciò che l'utente ha digitato, il numero nudo. Vuoto: il campo mostra il suo `is_mask`
`is_boolean_style`	string	`"switch"`	Un `TYPE_BOOLEAN`: come è disegnato. `BOOLEAN_SWITCH` (predefinito): un interruttore, una pista e un pallino che scivola verso la fine, nel colore d'accento del componente, quando è acceso — un'impostazione acceso / spento. `BOOLEAN_CHECKBOX`: la classica casella di controllo — un consenso, una scelta tra opzioni. Entrambi rispondono a Spazio e a un clic sull'etichetta, danno lo stesso valore e gli stessi eventi; disattivati o in sola lettura restano leggibili. Il pallino scivola in un quarto di secondo, per niente quando Windows chiede meno animazioni; in una lingua scritta da destra a sinistra scivola verso sinistra
`ii_max_tags`	integer	`0`	Un `TYPE_TAGS`: il numero massimo di etichette (`0` = senza limite). Una in più digitata dall'utente è rifiutata: resta nell'immissione con il messaggio At most N; un elenco più lungo scritto dal codice è mantenuto, e il campo non è valido (`of_is_valid`, `is_error`) — mostrato una volta toccato il campo o dopo `of_validate`, mai subito
`ib_options_only`	boolean	`false`	Un `TYPE_TAGS`: `true` limita le sue etichette alle opzioni del campo (`of_add_option`) — un testo che non ne nomina nessuna (con il suo testo o il suo valore, senza maiuscole né accenti) è rifiutato con Not in the list. `false`: ogni testo è un'etichetta, le opzioni sono solo suggerimenti
`ii_star_count`	integer	`5`	Un `TYPE_RATING`: il numero di stelle, da `1` a `10` (un numero fuori è riportato dentro). Il valore in essere vi è mantenuto, senza evento: impostare il numero prima di un valore oltre cinque
`ib_half_stars`	boolean	`false`	Un `TYPE_RATING`: `true` permette le mezze stelle — la prima metà della stella sotto il puntatore (nel senso di lettura), Sinistra / Destra di mezza stella — e il valore si scrive `"3.5"`. Disattivato, il valore in essere è arrotondato a una stella intera, senza evento: attivarlo prima di un mezzo valore
`is_match`	string	`""`	L'indirizzo di un altro campo a cui questo deve essere uguale — ripetere una password, un e-mail. Il messaggio segue ogni cambiamento dell'uno o dell'altro
`is_prefix`	string	`""`	Un testo breve nel campo, prima del valore (un simbolo di valuta); non fa parte del valore
`is_suffix`	string	`""`	Un testo breve nel campo, dopo il valore (un'unità); non fa parte del valore
`ii_max_length`	integer	`0`	Il testo più lungo accettato (`0` = senza limite) da un `TYPE_STRING`, `TYPE_TEXTAREA`, `TYPE_PASSWORD` o `TYPE_EMAIL` — un numero o un'ora non ha lunghezza, ignorato; `0` prende il Limit della sua colonna di DataWindow (`of_load_row`), letto dà la lunghezza in vigore: la digitazione si ferma lì, un contatore appare sotto un campo di testo; un valore più lungo scritto dal codice è Too long. Su un `TYPE_TAGS`: l'etichetta più lunga — un incollaggio di più etichette non è mai tagliato, ognuna è giudicata
`ii_colspan`	integer	`1`	Quante colonne copre il campo (al massimo `ii_columns`); `-1` = tutta la larghezza
`ii_rowspan`	integer	`1`	Quante righe copre il campo — un'immagine accanto a più campi; i successivi riempiono le celle libere accanto
`ii_col`	integer	`0`	La colonna in cui il campo inizia, a partire da 1; `0` = dove lo mette il flusso. Il tasto Tab segue l'ordine dello schermo — prima i campi in cima, poi ogni sezione —, qualunque sia la colonna
`ib_required`	boolean	`false`	Il campo deve essere compilato — una casella deve essere spuntata (una casella Accetto), un campo di etichette contenerne una, una valutazione avere una stella. Una stella segue la sua etichetta; l'errore Required appare quando l'utente lascia il campo o a `of_validate`. Una colonna il cui stile di modifica dice Required lo rende obbligatorio anch'essa (`of_load_row`); letto, dà lo stato in vigore
`ib_readonly`	boolean	`false`	Mostra il valore senza lasciarlo cambiare: un testo può ancora essere selezionato e copiato; un elenco, una data, un colore, un interruttore o pulsanti di opzione mantengono la tastiera (Tab li raggiunge, un lettore di schermo dice sola lettura) ma non si aprono né cambiano. Non giudicato dalle sue regole; il vostro codice può sempre scrivere `is_value`
`ib_enabled`	boolean	`true`	`false` disattiva il campo: niente tastiera (esce dall'ordine di tabulazione), niente clic, non giudicato dalle sue regole
`ib_visible`	boolean	`true`	`false` toglie il campo dal modulo; mantiene il suo indirizzo e il suo valore (`of_values` lo restituisce sempre) e non è giudicato
`is_column`	string	`""`	La colonna del DataWindow che `of_load_row` e `of_save_row` leggono e scrivono per questo campo; `""` (predefinito) = la sua chiave, l'ultimo livello del suo indirizzo. Due sezioni possono così portare la stessa chiave (`billing/town`, `shipping/town`) legata a due colonne, e un campo tenere una chiave leggibile per una colonna chiamata `cust_nm`
`id_step`	double	`0`	Un `TYPE_NUMBER`: ciò che Su / Giù (e i suoi pulsanti, `ib_spin`) aggiungono o tolgono, tenuto tra `is_min` e `is_max`; `0` (predefinito) = lo SpinIncr della sua colonna di DataWindow (`of_load_row`), altrimenti 1. Un passo è un gesto dell'utente: `ue_value_changed` è sollevato (e `ue_value_changing` posto prima con `ib_veto_changes`). Un campo vuoto parte da `is_min`, altrimenti da 0; un passo negativo è rifiutato
`ib_ellipsis`	boolean	`false`	Un campo di testo (`TYPE_STRING`, `TYPE_NUMBER`, `TYPE_EMAIL`…): `true` mostra un pulsante … alla sua fine — la vostra ricerca, un cliente, un articolo. Un clic su di esso, o Ctrl+Invio nel campo, solleva `ue_ellipsis_clicked`; resta fuori dall'ordine di Tab. Funziona anche su un campo in sola lettura (un valore scelto solo dalla ricerca), mai su un campo disattivato
`ib_spin`	boolean	`false`	Un `TYPE_NUMBER`: `true` mostra due piccoli pulsanti alla sua fine, su e giù, che aggiungono o tolgono `id_step` tra `is_min` e `is_max` — un gesto dell'utente (`ue_value_changed`). Anche la rotellina lo fa finché il campo ha la tastiera; i pulsanti restano fuori dall'ordine di Tab (Su / Giù nel campo fanno lo stesso) e si nascondono su un campo in sola lettura. Una colonna il cui EditMask dice Spin li dà con `of_load_row`, con il suo SpinIncr come passo e la sua SpinRange come limiti. Ignorato dagli altri tipi; letto, dà lo stato in vigore
`of_type ( )` → `string`	—	—	Il tipo dato a `of_add_field` (una costante `TYPE_*`). Sola lettura: un tipo si sceglie una volta
`of_is_dirty ( )` → `boolean`	—	—	`TRUE` quando questo campo differisce dal suo riferimento (vedere `of_is_dirty` del modulo)
`of_is_valid ( )` → `boolean`	—	—	`TRUE` quando questo campo non porta alcun errore; `is_error` dice quale
`is_tooltip`	string	`""`	Tooltip semplice mostrato al passaggio del mouse sull'item
`is_super_tooltip_title`	string	`""`	Titolo del tooltip avanzato dell'item (prevale su `is_tooltip`)
`is_super_tooltip_text`	string	`""`	Testo del tooltip avanzato dell'item (markup avanzato accettato)
`is_super_tooltip_image`	string	`""`	Immagine del tooltip avanzato dell'item
`il_accent`	long	`-1`	Accento del campo: il suo bordo lo prende quando ha la tastiera, e la sua etichetta una volta risalita (`-1` = quello del componente)
`il_back_color`	long	`-1`	Sfondo del campo, in `RGB(r,g,b)` (`-1` = quello che dà il tema)
`il_text_color`	long	`-1`	Colore del testo del campo (`-1` = quello che dà il tema)
`il_back_color_hover`	long	`-1`	Sfondo del campo sotto il puntatore (`-1` = quello che dà il tema)
`il_text_color_hover`	long	`-1`	Colore del testo del campo sotto il puntatore (`-1` = quello che dà il tema)

Metodi #

Sul componente #

Metodo	Ruolo
`of_add_section (string as_key, string as_title)` → long	Aggiunge una sezione in fondo: un'intestazione che si comprime, sottolineata dall'accento, sotto la quale si aggiungono poi i campi `"chiave/nome"`. Un titolo vuoto mostra la chiave. Restituisce `0` una volta aggiunta, `-5` per una chiave vuota, che contiene `/` o `	`, o già presa da una sezione o da un campo in cima,` -2` se il componente non è creato
`of_add_field (string as_keys, string as_label, string as_type, string as_value)` → long	Aggiunge un campo al suo indirizzo, in fondo a ciò che lo contiene: la sua sezione o la cima del modulo. `as_type` è una costante `TYPE_*`, `as_value` il suo valore come testo (la sorgente di un'immagine). Restituisce `0` una volta aggiunto, `-5` per un indirizzo già preso (un campo, o una sezione al primo livello), un livello vuoto, più di due livelli, una sezione mai aggiunta, una chiave che contiene `	`, un tipo sconosciuto o un valore che il tipo non può contenere (`of_get_last_error `dice perché),` -2` se il componente non è creato
`of_add_option (string as_keys, string as_value, string as_text)` → long	Aggiunge una opzione, in fondo, a un elenco `TYPE_ENUM`, a pulsanti `TYPE_RADIO` o ai suggerimenti di un `TYPE_TAGS`: `as_value` è ciò che il campo contiene (e ciò che dà `ue_value_changed`), `as_text` ciò che l'utente legge, come testo semplice (`""` mostra il valore). Restituisce `0` una volta aggiunta, `-5` per un indirizzo che non è un elenco, pulsanti di opzione né etichette, un valore già offerto, un valore che contiene `	`o` / `(`of_keys_at `lo unisce all'indirizzo del campo) — e per le etichette un valore vuoto o con una virgola —,` -2` se il componente non è creato
`of_remove_option (string as_keys, string as_value)` → long	Toglie una opzione da un elenco, da pulsanti di opzione o da etichette, tramite il suo valore; il valore del campo resta com'è. Restituisce `0` una volta tolta, `-5` per un indirizzo che non è un elenco, pulsanti di opzione né etichette, o un valore che non offre, `-2` se il componente non è creato
`of_clear_options (string as_keys)` → long	Toglie tutte le opzioni di un elenco, di pulsanti di opzione o di etichette, per caricare un altro elenco senza perdere il campo, il suo handle né il suo stato; il suo valore resta com'è. Restituisce `0` una volta svuotato, `-5` per un indirizzo che non è un elenco, pulsanti di opzione né etichette, `-2` se il componente non è creato
`of_remove_field (string as_keys)` → long	Toglie un campo tramite il suo indirizzo, con il suo handle; il resto del modulo mantiene il suo stato. Restituisce `0` una volta tolto, `-5` per un indirizzo mai aggiunto, `-2` se il componente non è creato
`of_remove_section (string as_key)` → long	Toglie una sezione e tutti i suoi campi, con i loro handle. Restituisce `0` una volta tolta, `-5` per una sezione mai aggiunta, `-2` se il componente non è creato
`of_clear ( )` → long	Svuota il modulo: sezioni, campi e i loro handle. A differenza di `of_reset`, le colonne, la sola lettura e la domanda restano. Restituisce `0` una volta svuotato, `-2` se il componente non è creato
`of_section (string as_key)` → `n_pbt_form_section`	L'handle di una sezione, tramite la sua chiave: titolo, compressione, visibilità, colori e tooltip. Creato al primo accesso
`of_field (string as_keys)` → `n_pbt_form_field`	L'handle di un campo, tramite il suo indirizzo: `of_field("order/qty").is_value = "3"`. Creato al primo accesso
`of_values ( )` → string	Tutti i valori insieme, letti in diretta, in un oggetto JSON: i campi in cima, poi ogni sezione come oggetto a sé — nascosti compresi, immagini escluse; ciò che l'utente sta ancora digitando è confermato prima, come fa `AcceptText`: `ue_value_changing` posto con `ib_veto_changes`, poi `ue_value_changed` sollevato — entrambi prima della lettura, mai nel mezzo: il vostro OK legge ciò che è a schermo. Tipizzati: un numero è un numero (scritto cifra per cifra, `null` se vuoto), un booleano un booleano, un colore il suo long RGB, il resto testo. Si legge con `n_pbt_json`, tramite lo stesso indirizzo: `lnv_json.of_get_number("order/qty")`
`of_load (string as_json)` → long	Carica un record: un oggetto JSON di valori per indirizzo — i campi in cima, poi un oggetto per sezione, o chiavi `"order/qty"` —, la forma che restituisce `of_values`; numeri e booleani possono essere tipizzati — un numero di più di 15 cifre è letto cifra per cifra, un booleano vale `true`, `false`, `1` o `0` (ogni altro valore è rifiutato). I valori si scrivono in silenzio e diventano il riferimento di `of_is_dirty`; gli errori mostrati e gli errori di business si cancellano. Un campo che l'oggetto non nomina mantiene il suo valore. Restituisce `0` una volta caricato, `-5` per un testo che non è un oggetto JSON, o un valore che il suo campo non può contenere (`abc` per un numero) — nulla è scritto allora, `of_get_last_error` nomina i campi —, `-2` se il componente non è creato
`of_load_row (powerobject apo_data, long al_row)` → long	Carica una riga di un DataWindow, di un DataStore o di un DataWindowChild: ogni campo prende il valore della sua colonna — quella che nomina `is_column`, altrimenti la sua chiave (l'ultimo livello del suo indirizzo) —, tipizzato — una data `yyyy-mm-dd`, un'ora `hh:mm`, un numero con il punto, un booleano letto tramite il valore On di una colonna casella di controllo (altrimenti `1`, `Y`, `true`…). Ciò che il DataWindow dice della colonna arriva con essa, riletto a ogni caricamento: un campo senza etichetta mostra il testo d'intestazione della sua colonna, un campo senza maschera né formato prende il suo EditMask e il suo Format (un numero `$#,##0`), un elenco o pulsanti di opzione senza opzioni proprie offrono la sua tabella dei codici o le righe del suo DropDownDataWindow; un campo senza regole proprie diventa obbligatorio quando lo stile di modifica dice Required e limitato al suo Limit, e un numero il cui EditMask dice Spin riceve i suoi pulsanti (`ib_spin`), il suo passo (SpinIncr) e i suoi limiti (SpinRange). La riga successiva dello stesso DataWindow non ridisegna alcun campo: quello che ha la tastiera la tiene. Come `of_load`, i valori diventano il riferimento. Restituisce `0` una volta caricata, `-5` per un oggetto che non è né un DataWindow, né un DataStore, né un DataWindowChild, una riga che non esiste, o un valore che il suo campo non può contenere (nulla cambia allora: né un valore né ciò che dice il DataWindow), `-2` se il componente non è creato
`of_save_row (powerobject apo_data, long al_row)` → long	Scrive i valori che l'utente ha cambiato (dal riferimento: `of_load_row`, `of_reset_update`) in una riga di un DataWindow, di un DataStore o di un DataWindowChild: ogni campo cambiato nella sua colonna (`is_column`, altrimenti la sua chiave), con `SetItem`, tipizzato per la colonna (data, datetime, ora, numero, testo; un booleano come valore On / Off di una colonna casella di controllo, `1` / `0` in una colonna numerica, `true` / `false` in una colonna testo; un campo vuoto scrive un NULL — un testo vuoto, un NULL dove la sua colonna dice NilIsNull, una stringa vuota altrimenti, come il DataWindow). Un campo che l'utente non ha cambiato non è scritto: la riga mantiene il suo stato, il vostro `Update` invia solo ciò che è cambiato. Un `TYPE_DATE` mantiene l'ora di una colonna datetime, un `TYPE_TIME` la sua data. Ciò che l'utente sta ancora digitando è confermato prima, e `ue_value_changed` sollevato, prima di ogni lettura; l'`Update` resta vostro. Restituisce `0` una volta scritta, `-5` per un oggetto che non è né un DataWindow, né un DataStore, né un DataWindowChild, o una riga che non esiste, `-4` quando una colonna è rimasta com'era — un `SetItem` rifiutato, un campo il cui tipo la colonna non può contenere (un `TYPE_STRING` in una colonna data), o un valore con decimali per una colonna intera (`3.5` stelle in un long: `SetItem` lo arrotonderebbe): `of_get_last_error` nomina la prima, gli altri campi cambiati sono scritti comunque —, `-2` se il componente non è creato
`of_is_valid ( )` → boolean	`TRUE` quando nessun campo mostrato porta un errore: ogni campo obbligatorio compilato (una casella obbligatoria spuntata), ogni regola seguita, nessun errore di business. Letto in diretta, senza mostrare nulla; un errore di business conta solo su un campo che l'utente può raggiungere (mostrato e attivo)
`of_invalid_keys (ref string as_keys[])` → long	Riempie `as_keys[]` con gli indirizzi dei campi in errore, nell'ordine dello schermo, senza mostrare nulla, e restituisce il loro numero (`0` = il modulo è valido)
`of_validate ( )` → long	Mostra tutti gli errori insieme e mette la tastiera sul primo campo in errore (`ue_focus_changed`) — ciò che chiama il vostro pulsante OK prima di salvare. La tastiera lascia il pulsante per il modulo: il tasto successivo va al campo; ciò che l'utente sta ancora digitando è confermato prima, e un lettore di schermo legge subito i messaggi. Restituisce il numero di campi in errore (`0` = il modulo è valido, nulla si muove), `-2` se il componente non è creato
`of_clear_errors ( )` → long	Cancella tutti gli errori di business (`is_error` scritto dal vostro codice); gli errori delle regole restano. Restituisce `0` una volta applicato, `-2` se il componente non è creato
`of_is_dirty ( )` → boolean	`TRUE` quando almeno un campo differisce dal suo riferimento: il valore dato all'aggiunta, o ciò che ne hanno fatto `of_load`, `of_load_row` o `of_reset_update`; ciò che l'utente sta ancora digitando è confermato prima. Un numero scritto diversamente (`12.50` per `12.5`) è lo stesso valore
`of_dirty_keys (ref string as_keys[])` → long	Riempie `as_keys[]` con gli indirizzi dei campi modificati dal riferimento, nell'ordine dello schermo, e restituisce il loro numero
`of_reset_update ( )` → long	I valori a schermo diventano il riferimento: `of_is_dirty` risponde di nuovo `FALSE`. Da chiamare una volta riuscito il vostro `Update`, come `ResetUpdate` di un DataWindow. Restituisce `0` una volta applicato, `-2` se il componente non è creato
`of_revert ( )` → long	Rimette ogni campo al suo valore di riferimento, in silenzio, e nasconde gli errori — l'Annulla dell'utente. Restituisce `0` una volta applicato, `-2` se il componente non è creato
`of_focus_field (string as_keys)` → long	Mette la tastiera su un campo, come un clic: la sua sezione compressa si apre prima (`ue_section_toggled`), segue `ue_focus_changed`. Restituisce `0` una volta fatto, `-5` per un indirizzo mai aggiunto o un campo che l'utente non può raggiungere (nascosto, disattivato — compreso quello che aveva la tastiera —, un'immagine, oltre il limite della demo), `-2` se il componente non è creato
`of_current_key ( )` → string	Indirizzo del campo che ha la tastiera — o l'aveva per ultimo, mentre la tastiera è altrove nella finestra: `"order/qty"`, `""` se ancora nessuno. Sempre quello corrente, letto dal componente; è anche ciò che dà `ue_focus_changed`
`of_get_last_error ( )` → string	Perché l'ultima scrittura è stata rifiutata: un valore che il tipo non può contenere (`is_value` non ha codice di ritorno; un'immagine `http://`, un numero infinito come `1e400`), un `is_pattern` che il modulo non sa leggere, un valore rifiutato da `of_load`, una colonna lasciata da `of_save_row`. Vuoto quando è passata; altrimenti l'ultimo errore della libreria, come per ogni componente
`of_reset ( )` → long	Svuota il modulo poi rimette ogni proprietà del componente al suo valore predefinito: una colonna, né sola lettura né domanda. Restituisce `0` una volta applicato, `-2` se il componente non è creato

Su una sezione e su un campo #

Una sezione contiene campi; un elenco o dei pulsanti di opzione contengono le loro opzioni, designate dal loro valore. I tre metodi le percorrono.

Metodo	Ruolo
`of_count ( )` → long	Numero di campi della sezione, nascosti compresi; numero di opzioni di un elenco, di pulsanti di opzione o di etichette (`0` per gli altri tipi)
`of_keys_at (long al_index)` → string	Indirizzo del campo di rango `al_index` (a partire da 1) — `"order/qty"`, riutilizzabile così com'è in `of_field`; su un elenco, l'indirizzo seguito dal valore dell'opzione. `""` fuori dai limiti
`of_has (string as_key)` → boolean	La sezione contiene questo campo? L'elenco offre questo valore?

Eventi #

Event	Attivato quando
`ue_value_changed (string as_keys, string as_value)`	L'utente ha cambiato un valore: un'immissione confermata lasciando il campo o con Invio, una casella spuntata, un pulsante di opzione, un'opzione, una data o un colore scelti (Su / Giù percorrono un elenco, Canc svuota un elenco, una data o un colore). `as_keys` è l'indirizzo del campo, `as_value` il suo nuovo valore come testo; è già scritto. Un valore scritto dal vostro codice non solleva nulla, come `SetItem`. Ciò che l'utente sta ancora digitando quando il vostro codice legge il modulo (`of_values`, `of_save_row`, `is_value`…) è confermato in quel momento, come fa `AcceptText`: l'evento è sollevato lì, prima della lettura
`ue_value_changing (string as_keys, string as_value)` → boolean	Annullabile, posto prima che un valore dell'utente sia scritto, e solo quando `ib_veto_changes = true` (disattivato per impostazione predefinita). Restituire `FALSE` rifiuta: il campo mostra di nuovo il vecchio valore, che `of_field(as_keys).is_value` restituisce ancora durante l'evento. Restituite `TRUE` per accettare. Quando il vostro codice legge il modulo (`of_values`, `of_validate`, `is_value`…) mentre l'utente sta ancora digitando in un campo, la domanda è posta subito, prima della lettura: la lettura restituisce il valore che avete accettato
`ue_focus_changed (string as_from_keys, string as_keys)`	Il campo che ha la tastiera è cambiato: un clic, il tasto Tab, il vostro codice (`of_focus_field`, `of_validate` — anche un ordine lo solleva, come `SetColumn`), o il campo è sparito: tolto, nascosto, svuotato (`as_keys` vale allora `""`). La tastiera che lascia il modulo per un altro controllo della finestra non solleva nulla
`ue_section_toggled (string as_key, boolean ab_collapsed)`	Una sezione si è compressa (`ab_collapsed = TRUE`) o espansa: un clic sulla sua intestazione (Invio o Spazio quando ha la tastiera), il suo `ib_collapsed` impostato dal vostro codice, o `of_focus_field` su un campo di una sezione compressa
`ue_ellipsis_clicked (string as_keys)`	Il pulsante … di un campo (`ib_ellipsis`) è stato cliccato, o Ctrl+Invio premuto nel campo: aprite la vostra ricerca (un cliente, un articolo) e scrivete ciò che l'utente ha scelto in `of_field(as_keys).is_value`. Ciò che era digitato è già confermato (`ue_value_changing` posto prima con `ib_veto_changes`, `ue_value_changed` sollevato). Mai sollevato per un campo disattivato
`ue_ready ( )`	Il componente ha terminato il caricamento; tutto ciò che è stato inviato prima è stato riprodotto
`ue_runtime_missing ( )`	Il runtime WebView2 è assente: il componente resta vuoto
`ue_bg_color (long al_color)`	Il componente ha calcolato il colore di sfondo del proprio tema; l'userobject lo ha già adottato (`backcolor`)

Tastiera e mouse #

Gesto	Effetto
Tab, Maiusc+Tab	Passano da un campo all'altro, nell'ordine dello schermo: i campi in cima, poi ogni sezione, prima la sua intestazione; un campo disattivato è saltato; i pulsanti di opzione sono un arresto, le frecce scelgono
Invio in un campo di una riga	Conferma l'immissione poi passa alla finestra: il suo pulsante predefinito (il vostro OK) legge un modulo aggiornato. Con `ib_veto_changes`, la pagina non chiede nulla: l'immissione resta in attesa, e la lettura del pulsante predefinito la conferma (`ue_value_changing` posto in quel momento) — senza pulsante predefinito, la conferma l'uscita dal campo
Esc	In un campo che l'utente ha modificato, rimette il suo valore; altrimenti passa alla finestra: il suo pulsante Annulla
Elenco, data, colore: Invio, Spazio, F4, Alt+Giù	Aprono la finestra condivisa (elenco, calendario, selettore di colore); Invio si ferma lì, non passa al pulsante predefinito della finestra — nemmeno su un'intestazione di sezione, che comprime o espande
Elenco: Su / Giù	Opzione precedente / successiva, senza aprire l'elenco
Elenco, data, colore: Canc, Backspace	Svuotano il valore
Etichette: Invio, virgola, Tab	Aggiungono ciò che è digitato (Tab tiene la tastiera nel campo); Backspace nell'immissione vuota toglie l'ultima etichetta; Sinistra / Destra percorrono le etichette, Canc toglie quella evidenziata; Giù apre i suggerimenti, Esc li chiude
Stelle: frecce, Home / Fine, cifre, Canc	Destra / Su una stella in più (mezza con `ib_half_stars`), Sinistra / Giù una in meno — invertite in una lingua scritta da destra a sinistra; Home una stella, Fine tutte; una cifra altrettante stelle; 0, Canc o Backspace cancellano la valutazione
Numero: Su / Giù	Aggiungono o tolgono il passo del campo (`id_step`, 1 per impostazione predefinita), tenuto tra `is_min` e `is_max`: segue `ue_value_changed`. Con `ib_spin`, i suoi due pulsanti fanno lo stesso, e la rotellina finché ha la tastiera
Ctrl+Invio, clic su …	Un campo con `ib_ellipsis`: conferma ciò che è digitato poi solleva `ue_ellipsis_clicked` — la vostra ricerca
Clic su un'intestazione di sezione	Comprime o espande la sezione (`ue_section_toggled`)

Esempi #

Una scheda cliente #

// The whole form in one paint, two columns
uo_form.of_set_redraw(/*on*/ false)
uo_form.ii_columns = 2

// Identity : two required names, an e-mail, a phone with its mask
uo_form.of_add_section(/*key*/ "identity", /*title*/ "Identity")
uo_form.of_add_field(/*keys*/ "identity/first_name", /*label*/ "First name", /*type*/ u_pbt_form.TYPE_STRING, /*value*/ "")
uo_form.of_field(/*keys*/ "identity/first_name").ib_required = true
uo_form.of_add_field(/*keys*/ "identity/last_name", /*label*/ "Last name", /*type*/ u_pbt_form.TYPE_STRING, /*value*/ "")
uo_form.of_field(/*keys*/ "identity/last_name").ib_required = true
uo_form.of_add_field(/*keys*/ "identity/email", /*label*/ "E-mail", /*type*/ u_pbt_form.TYPE_EMAIL, /*value*/ "")
uo_form.of_add_field(/*keys*/ "identity/phone", /*label*/ "Phone", /*type*/ u_pbt_form.TYPE_STRING, /*value*/ "")
uo_form.of_field(/*keys*/ "identity/phone").is_mask = "(###) ###-####"

// Account : a credit limit with a bound, shown as a price and typed without the
// dollar sign ; a list ; a switch
uo_form.of_add_section(/*key*/ "account", /*title*/ "Account")
uo_form.of_add_field(/*keys*/ "account/credit_limit", /*label*/ "Credit limit", /*type*/ u_pbt_form.TYPE_NUMBER, /*value*/ "2500")
uo_form.of_field(/*keys*/ "account/credit_limit").is_format = "$#,##0.00"
uo_form.of_field(/*keys*/ "account/credit_limit").is_max = "50000"
uo_form.of_add_field(/*keys*/ "account/country", /*label*/ "Country", /*type*/ u_pbt_form.TYPE_ENUM, /*value*/ "gb")
uo_form.of_add_option(/*keys*/ "account/country", /*value*/ "gb", /*text*/ "United Kingdom")
uo_form.of_add_option(/*keys*/ "account/country", /*value*/ "fr", /*text*/ "France")
uo_form.of_add_field(/*keys*/ "account/vip", /*label*/ "VIP customer", /*type*/ u_pbt_form.TYPE_BOOLEAN, /*value*/ "false")

// Shown at once, the keyboard on the first field
uo_form.of_set_redraw(/*on*/ true)
uo_form.of_focus_field(/*keys*/ "identity/first_name")

Modificare una riga di DataWindow #

La chiave di ogni campo è il nome della sua colonna: il modulo legge la riga, l'utente la modifica, il modulo la scrive.

// The current row of dw_customers fills the form ; nothing is dirty yet
uo_form.of_load_row(/*data*/ dw_customers, /*row*/ dw_customers.GetRow())

// event clicked of cb_save
if uo_form.of_validate() > 0 then return

// Write the values back into the row, then save it
if uo_form.of_save_row(/*data*/ dw_customers, /*row*/ dw_customers.GetRow()) < 0 then
    MessageBox("Save", uo_form.of_get_last_error())
    return
end if

// Saved : what is on screen is the new reference
if dw_customers.Update() = 1 then
    COMMIT USING SQLCA;
    uo_form.of_reset_update()
end if

Etichette e stelle #

Una recensione di prodotto: un voto su cinque con mezze stelle, ed etichette libere con suggerimenti. I due valori restano testo, che of_save_row scrive in una colonna numerica e in una colonna di testo.

// Local variables
string ls_score, ls_tags

// The score : five stars, half stars set BEFORE a half value
uo_form.of_add_field(/*keys*/ "score", /*label*/ "Overall", /*type*/ u_pbt_form.TYPE_RATING, /*value*/ "")
uo_form.of_field(/*keys*/ "score").ib_half_stars = true
uo_form.of_field(/*keys*/ "score").is_value = "3.5"

// Tags : free text, the options are suggestions, five at most
uo_form.of_add_field(/*keys*/ "tags", /*label*/ "Tags", /*type*/ u_pbt_form.TYPE_TAGS, /*value*/ "office, led")
uo_form.of_add_option(/*keys*/ "tags", /*value*/ "eco", /*text*/ "Eco-friendly")
uo_form.of_add_option(/*keys*/ "tags", /*value*/ "usb", /*text*/ "USB powered")
uo_form.of_field(/*keys*/ "tags").ii_max_tags = 5

// Read back : "3.5" and "office, led"
ls_score = uo_form.of_field(/*keys*/ "score").is_value
ls_tags = uo_form.of_field(/*keys*/ "tags").is_value

Avvisare prima di perdere delle modifiche #

// event closequery of the window
if not uo_form.of_is_dirty() then return 0

// Changes since the load : ask, and put them back if the user gives up
if MessageBox("Customer", "Discard your changes ?", Question!, YesNo!) = 2 then return 1
uo_form.of_revert()
return 0

Buone pratiche #

Un valore è un testo: un numero si scrive con il punto ("12.5"), un booleano "true"/"false", un colore String(RGB(…)), una data "yyyy-mm-dd", un'ora "hh:mm" — qualunque sia la lingua della postazione. Per valori tipizzati, of_values e n_pbt_json.
Il vostro pulsante OK decide: of_validate mostra gli errori e ne restituisce il numero; il modulo non salva nulla da solo.
Chiamate i campi come le colonne: of_load_row e of_save_row fanno allora tutto il lavoro; altrimenti is_column nomina la colonna di un campo.
ib_readonly piuttosto che ib_enabled = false per un valore che l'utente deve leggere: un testo in sola lettura si seleziona e si copia.
Modalità dimostrativa: senza chiave, il modulo disegna 6 campi, i primi mostrati nell'ordine dello schermo — un campo di una sezione compressa conta anch'esso, espanderla non ridisegna nulla; gli altri restano in memoria e in of_values, ma non sono né disegnati né giudicati (vedere Licenza).

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.