dockcontainer — `u_pbt_dockcontainer` #

← Riferimento dei componenti · Sommario della guida

Pannelli ancorabili in stile Visual Studio: ancoraggio tramite trascinamento, impilamento in schede, separatori ridimensionabili, finestre mobili, nascondi automaticamente — e salvataggio/ripristino della disposizione.

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

In breve #

Userobject	`u_pbt_dockcontainer`
Classe degli item	`n_pbt_dock_panel` (un pannello)
Serve per	Dare a una finestra PowerBuilder l'ergonomia di un IDE moderno: l'utente organizza da sé i propri pannelli e ritrova la disposizione alla sessione successiva

Come in tab, ogni pannello ospita un vero controllo PowerBuilder (dragobject): userobject, DataWindow o un altro componente PBToolboxAI. Vedere Ospitare veri controlli PowerBuilder.

Avvio rapido #

// event open della finestra : i controlli dei pannelli sono gia posati su di essa
uo_dock.of_add_panel(/*key*/ "document", /*position*/ "", /*relative_to*/ "", /*size*/ 0, /*title*/ "Documento", /*content*/ uo_editor)

// L'esploratore, agganciato all'inizio del documento, largo 260 pixel
uo_dock.of_add_panel(/*key*/ "explorer", /*position*/ uo_dock.POSITION_START, /*relative_to*/ "document", /*size*/ 260, /*title*/ "Esplora risorse", /*content*/ uo_tree)

// Le proprieta, agganciate alla fine del documento, larghe 300 pixel
uo_dock.of_add_panel(/*key*/ "properties", /*position*/ uo_dock.POSITION_END, /*relative_to*/ "document", /*size*/ 300, /*title*/ "Proprieta", /*content*/ uo_props)

// L'area centrale : dall'ancoraggio non e chiudibile, ne mobile, ne nascondibile
uo_dock.is_main = "document"

Proprietà #

Proprietà	Tipo	Predefinito	Ruolo
`is_main`	string	`""`	Chiave del pannello principale: l'area di documento centrale, che non può essere né nascosta né staccata e su cui nessun pannello viene impilato. Impostata prima dell'aggiunta di quel pannello, viene conservata e applicata dal suo `of_add_panel`; `""` rimuove il pannello principale
`ib_veto_close`	boolean	`false`	Opt-in: chiedere prima che un pannello si chiuda — la croce della sua intestazione, Chiudi / Chiudi gli altri nel menu, la croce di un pannello scorrevole e `of_close_panel` (solleva `ue_panel_closing`, che può rifiutare; un ordine rifiutato restituisce `-4`). Disattivato per impostazione predefinita, come ogni evento annullabile della libreria: impostate `true` per tenere aperto un pannello che contiene lavoro non salvato
`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

Posizioni di ancoraggio #

Le costanti del componente alimentano as_position in of_add_panel e of_move_panel:

Costante	Valore	Effetto
`POSITION_START`	`"start"`	Il nuovo pannello si ancora sul lato di inizio lettura del pannello di riferimento (a sinistra con scrittura da sinistra a destra)
`POSITION_END`	`"end"`	… sul lato di fine lettura
`POSITION_TOP`	`"top"`	… al di sopra
`POSITION_BOTTOM`	`"bottom"`	… al di sotto
`POSITION_STACK`	`"stack"`	Il pannello viene impilato come scheda sul pannello di riferimento. Valore adottato se `as_position` è vuoto

Proprietà di un pannello — `n_pbt_dock_panel` #

Ottenute tramite of_panel(chiave).

Proprietà	Tipo	Predefinito	Ruolo
`is_title`	string	`""`	Titolo visualizzato sulla scheda del pannello; vuoto (nessun titolo dato), la scheda mostra la chiave e il pannello principale non ha intestazione — dargli un titolo in seguito la fa apparire. Accetta il testo formattato con tag
`is_short_title`	string	`""`	Forma breve del titolo, per i punti in cui lo spazio manca: la barra di bordo di un pannello appuntato (sempre — è una striscia sottile) e la scheda di una pila, ma solo quando il titolo completo non ci sta più, cosa che viene misurata e non indovinata. L'intestazione del pannello conserva il titolo completo. `""` = nessuna forma breve
`ib_visible`	boolean	`true`	Mostra o nasconde questo pannello. Il pannello principale non si nasconde; nascondere un pannello mobile ne chiude la finestra, e tornerà ancorato al suo posto. Rimostrato, passa in primo piano nella sua pila (`ue_panel_selected` segue); in un gruppo ripiegato, la sua linguetta torna sulla guida
`ib_pinned`	boolean	`true`	`true` = bloccato in posizione; `false` = l'intero gruppo del pannello (schede comprese) si ripiega a linguette sul bordo. Una linguetta apre il suo pannello al passaggio del mouse (dopo 400 ms) o subito al clic; aperto al passaggio, si richiude quando il mouse lo lascia e il focus non vi si trova, aperto al clic resta fino a un clic altrove. Il pulsante puntina dell'intestazione solleva `ue_panel_pinned` per ogni pannello del gruppo, e così impostare `ib_pinned` dal codice (un ordine lo solleva come il gesto); un pannello spostato in un gruppo ripiegato si ripiega con esso, e `ue_panel_pinned` lo dice
`ib_front`	boolean	`true`	Sola lettura: `true` quando questo pannello è quello che la sua pila mostra (ancorato, bloccato, in primo piano nella sua barra di schede). Chiesto al componente a ogni lettura: segue i clic, gli ordini del suo codice, un pannello chiuso o staccato davanti a lui. `ue_panel_selected` dice quando cambia
`ib_closable`	boolean	`true`	L'utente può chiudere questo pannello (croce dell'intestazione, croce del pannello scorrevole, Chiudi / Chiudi gli altri nel menu)? Impostata all'aggiunta da `of_add_panel(…, ab_closable)`, modificabile in qualsiasi momento: la croce e le voci del menu seguono subito. `of_close_panel` rifiuta (`-5`) un pannello non chiudibile
`is_header_color`	string	`""`	Colore dell'intestazione di questo pannello. Vuoto = decide il tema; `HEADER_COLOR_ACCENT` segue l'accento del tema (e continua a seguirlo dopo un cambio di tema, cosa che un codice fisso non farebbe); altrimenti un `#rrggbb`. Il colore di testo leggibile viene calcolato
`is_border_color`	string	`""`	Colore del bordo di questo pannello, stessa grammatica. Contorna la cornice e l'intestazione, che hanno ciascuna il proprio: colorarne una sola lascia una giunzione visibile. Segue il pannello nel suo riquadro a scomparsa
`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_back_color`	long	`-1`	Sfondo della scheda di QUESTO pannello in una pila, e della sua linguetta sul bordo una volta sbloccato (`-1` = quello del componente, che segue il tema). L'intestazione di un pannello da solo prende `is_header_color`
`il_text_color`	long	`-1`	Colore del testo della scheda e della linguetta di QUESTO pannello (`-1` = quello del componente)
`il_back_color_hover`	long	`-1`	Sfondo della scheda e della linguetta di QUESTO pannello al passaggio (`-1` = quello del componente)
`il_text_color_hover`	long	`-1`	Colore del testo della scheda e della linguetta di QUESTO pannello al passaggio (`-1` = quello del componente)
`il_accent`	long	`-1`	Accento di QUESTO pannello (`-1` = accento del componente); l'intestazione lo segue quando `is_header_color` vale `HEADER_COLOR_ACCENT`

Metodi #

Metodo	Ruolo
`of_add_panel (string as_key, string as_position, string as_relative_to, integer ai_size, string as_title, dragobject ado_content)`	Aggiunge un pannello chiudibile e ospita il controllo. `as_relative_to` = chiave del pannello contro cui si ancora (vuoto = la radice); `ai_size` = dimensione iniziale in pixel (`0` = automatica). Restituisce `0` una volta applicato, `-5` per una chiave vuota, già presa o contenente `/` o una barra verticale, un controllo già ospitato o che contiene il dock, un `as_relative_to` sconosciuto o un impilamento (`POSITION_STACK`) sul pannello principale, o una posizione sconosciuta — nulla viene toccato, `-6` in modalità demo quando il dock porta già i suoi tre pannelli (il controllo resta al suo posto, visibile), `-2` se il componente non è creato
`of_add_panel (…, boolean ab_closable)`	Idem, con `ab_closable = false` per un pannello senza pulsante di chiusura. Restituisce `0` una volta applicato, `-5` per una chiave vuota, già presa o contenente `/` o una barra verticale, un controllo già ospitato o che contiene il dock, un `as_relative_to` sconosciuto o un impilamento (`POSITION_STACK`) sul pannello principale, o una posizione sconosciuta — nulla viene toccato, `-6` in modalità demo quando il dock porta già i suoi tre pannelli (il controllo resta al suo posto, visibile), `-2` se il componente non è creato
`of_select_panel (string as_key)`	Rende visibile un pannello: in primo piano nella sua pila, il suo pannello a scomparsa aperto quando il gruppo è ripiegato, la sua finestra portata davanti quando è mobile. Quando un pannello ancorato passa in primo piano nella sua pila, segue `ue_panel_selected`, come per un clic sulla sua scheda. Restituisce `0` una volta applicato, `-5` per una chiave sconosciuta o un pannello NASCOSTO (mostrarlo è compito di `ib_visible`), `-2` se il componente non è creato
`of_move_panel (string as_key, string as_target, string as_position)`	Riorganizza dal codice, come una scheda rilasciata su una guida di ancoraggio: `as_target` designa il gruppo del pannello mirato — un altro pannello della sua pila designa lo stesso gruppo, è così che si divide una pila —, vuoto = il bordo esterno del dock. Un pannello spostato in un gruppo ripiegato si ripiega con esso (`ue_panel_pinned` segue), e il pannello che passa davanti in una pila solleva `ue_panel_selected`. Restituisce `0` una volta applicato, `-5` per una chiave sconosciuta, una destinazione (`as_target`) sconosciuta o che è il pannello stesso, una posizione sconosciuta, un impilamento sul pannello principale o un impilamento DEL pannello principale, `-2` se il componente non è creato
`of_move_panel (string as_key, string as_target, string as_position, integer ai_index)`	Lo stesso, indicando il rango del pannello nella pila della destinazione (1 = primo, `0` o meno = ultimo) — un rango che il mouse non sa ancora dare: una scheda rilasciata su un gruppo arriva sempre per ultima. Solo una pila è un elenco ordinato: l'indice viene ignorato per `POSITION_START` / `END` / `TOP` / `BOTTOM`. Restituisce `0` una volta applicato, `-5` per una chiave sconosciuta, una destinazione (`as_target`) sconosciuta o che è il pannello stesso, una posizione sconosciuta, un impilamento sul pannello principale o un impilamento DEL pannello principale, `-2` se il componente non è creato
`of_float_panel (string as_key)`	Stacca il pannello in una vera finestra mobile spostabile e ridimensionabile; un pannello già staccato in precedenza ritrova il posto della sua finestra. Chiudendola il pannello si riancora (`ue_panel_docked`). Non il pannello principale (`is_main`): è la zona documento attorno a cui si dispongono gli altri, costruisce la propria intestazione e non può essere né staccato, né nascosto, né chiuso. Segue `ue_panel_floated`, come per il pulsante dell'intestazione, il doppio clic sull'intestazione o sulla scheda, o Stacca nel menu del clic destro. Restituisce `0` una volta applicato, `-5` per una chiave sconosciuta, il pannello principale o un pannello NASCOSTO, `-2` se il componente non è creato
`of_close_panel (string as_key)`	Chiude il pannello come la sua croce: viene nascosto (`ib_visible = true` lo mostra di nuovo) e segue `ue_panel_closed`. Con `ib_veto_close = true`, viene posto prima `ue_panel_closing`. Restituisce `0` una volta applicato, `-4` quando il vostro `ue_panel_closing` ha rifiutato (il pannello resta), `-5` per una chiave sconosciuta, il pannello principale, un pannello nascosto o non chiudibile (`ib_closable = false`), `-2` se il componente non è creato
`of_notify_panel (string as_key)`	Segnala contenuti nuovi: se il pannello non è visibile, la sua scheda mostra un contatore di elementi non visti, azzerato alla selezione. Restituisce `0` una volta applicato, `-5` per un argomento non valido (chiave vuota, indirizzo errato), `-2` se il componente non è creato
`of_clear_notify (string as_key)`	Azzera quel contatore senza mostrare il pannello. Selezionare la scheda era l unico altro modo, il che è sbagliato quando il Suo codice sa che il contenuto stesso è sparito. Restituisce `0` una volta applicato, `-5` per un argomento non valido (chiave vuota, indirizzo errato), `-2` se il componente non è creato
`of_remove_panel (string as_key)`	Rimuove il pannello e restituisce il controllo alla sua finestra d'origine, al suo posto, alla sua dimensione e con la visibilità che aveva prima di `of_add_panel` — visibile se lo era: per un pannello che si chiude e può tornare, `of_close_panel` (o `ib_visible = false`) lo nasconde senza restituirlo. Restituisce `0` una volta applicato, `-5` per un argomento non valido (chiave vuota, indirizzo errato), `-2` se il componente non è creato
`of_active_panel ( )`	Restituisce la chiave del pannello attivo: quello che ha la tastiera — un controllo del suo contenuto ha il focus, o la sua scheda o intestazione è stata cliccata per ultima. Vuota quando la tastiera è in un altro controllo della stessa finestra; una finestra di messaggio, un menu o un'altra finestra non cambiano nulla. Non è il pannello in primo piano nella sua pila (`ib_front` del pannello). Chiesto al componente a ogni chiamata; `ue_active_panel_changed` dice quando cambia
`of_get_layout ( )`	Restituisce la disposizione corrente (albero delle suddivisioni, rapporti, schede, visibilità, pannelli mobili e posto della loro finestra) sotto forma di stringa, da memorizzare in un file, in una base dati o nel registro
`of_set_layout (string as_json)`	Ripristina una disposizione ottenuta con `of_get_layout`. I pannelli devono essere stati ricreati prima della chiamata; quelli assenti dalla disposizione — o tutti, se non ne conosce nessuno — raggiungono un gruppo accanto agli altri, mai il pannello principale. I pannelli mobili ritrovano la loro finestra al suo posto, riportata su uno schermo se il loro non c'è più; una disposizione che non nomina alcun pannello principale mantiene quello corrente. `ue_layout_changed` viene sollevato una volta; i pannelli che rimette in primo piano non sollevano `ue_panel_selected`. Restituisce `0` una volta applicato, `-5` per un testo che non è una disposizione (non JSON, o senza `tree`): il dock resta allora com'è, `-2` se il componente non è creato
`of_panel (string as_key)`	Handle `n_pbt_dock_panel` del pannello (creato al primo accesso)
`of_refresh_panel (string as_key)`	Aggiorna il rendering di un pannello costruito fuori schermo, senza sfarfallio. Restituisce `0`, `-5` se la chiave non designa alcun pannello, `-2` se il componente non è creato
`of_relayout ( )`	Ricalcola e ripubblica tutte le aree affinché i controlli ospitati vengano riposizionati. Restituisce `0` una volta applicato, `-2` se il componente non è creato
`of_reset ( )`	Svuota il contenitore: ogni controllo ospitato viene restituito alla sua finestra d'origine, gli handle dei pannelli vengono liberati, la disposizione memorizzata viene cancellata. Restituisce `0` una volta applicato, `-2` se il componente non è creato
`of_set_redraw (boolean)`	Raggruppa una raffica di modifiche in un unico rendering. Restituisce `0` una volta applicato, `-2` se il componente non è creato
`of_save_as_png (string)` · `of_save_as_jpg (string)`	Esporta il rendering come immagine. Restituisce `0` una volta scritta l'immagine, `-4` se la scrittura fallisce, `-2` se il componente non è creato

Event #

Event	Attivato quando
`ue_panel_selected (string as_key)`	Un pannello ancorato passa in primo piano nel suo gruppo: clic sulla sua scheda, frecce della barra di schede, `of_select_panel` (anche un ordine del suo codice lo solleva), e ogni altro modo in cui una pila cambia il pannello mostrato — un pannello impilato su di essa, quello davanti chiuso, staccato, spostato o rimosso, un pannello riagganciato o rimostrato. Dopo `ue_panel_closed`, `ue_panel_floated` o `ue_panel_docked` quando è uno di essi ad averlo fatto. Una disposizione ripristinata non lo annuncia; `n_pbt_dock_panel.ib_front` rilegge lo stato
`ue_panel_closed (string as_key)`	Un pannello viene chiuso: la croce della sua intestazione, Chiudi o Chiudi gli altri nel menu del clic destro sull'intestazione o sulla scheda, la croce di un pannello scorrevole, oppure `of_close_panel` (anche un ordine del suo codice lo solleva). Il pannello viene nascosto (`ib_visible = true` lo mostra di nuovo); con `ib_veto_close = true`, solo dopo che `ue_panel_closing` lo ha permesso
`ue_panel_closing (string as_key)` → boolean	Annullabile, posto prima che un pannello si chiuda — la croce della sua intestazione, Chiudi o Chiudi gli altri nel menu (una domanda per pannello), la croce di un pannello scorrevole, oppure `of_close_panel` —, e solo quando `ib_veto_close = true` (disattivato per impostazione predefinita). Restituite `false` per tenere aperto il pannello (lavoro non salvato): `ue_panel_closed` non segue, e `of_close_panel` restituisce `-4`
`ue_panel_pinned (string as_key, boolean ab_pinned)`	Un pannello viene bloccato (`true`) o sbloccato in nascondi automaticamente (`false`): pulsante puntina dell'intestazione, pulsante di ancoraggio del pannello a scomparsa, oppure `ib_pinned` impostato dal suo codice (anche un ordine lo solleva), o un pannello spostato in un gruppo ripiegato o fuori da esso
`ue_panel_floated (string as_key)`	Un pannello viene staccato in finestra mobile: pulsante dell'intestazione, doppio clic sull'intestazione o sulla scheda, Stacca nel menu del clic destro, oppure `of_float_panel` (anche un ordine del suo codice lo solleva). Una disposizione ripristinata (`of_set_layout`) riapre le sue finestre e solleva invece `ue_layout_changed`, una volta
`ue_panel_docked (string as_key)`	L'UTENTE riancora un pannello mobile: chiude la sua finestra, o fa doppio clic sulla sua barra del titolo — il pannello ritrova il suo posto
`ue_active_panel_changed (string as_key)`	Il pannello attivo cambia: un controllo di un altro pannello prende il focus (un clic, il tasto Tab, un `SetFocus` del suo codice), o la scheda o l'intestazione di un pannello viene cliccata. `as_key` è vuota quando la tastiera passa a un altro controllo della stessa finestra, fuori dal dock; una finestra di messaggio, un menu o un'altra finestra non cambiano nulla. `of_active_panel` lo rilegge
`ue_layout_changed (string as_json)`	La disposizione è cambiata (trascinamento, ridimensionamento, ancoraggio, una finestra mobile spostata o ridimensionata, ma anche un pannello chiuso, nascosto, selezionato, rinominato, o un altro pannello principale). Il parametro porta la nuova disposizione, pronta per essere salvata. Raggruppato: una raffica racchiusa tra `of_set_redraw(false)` … `of_set_redraw(true)` (la costruzione del dock) lo solleva una volta, alla ripresa, come `of_set_layout`; così pure modifiche distanti meno di 40 ms
`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`)

Con il mouse #

Oltre al trascinamento delle schede e degli splitter, tre gesti agiscono su un pannello — mai sul pannello principale:

Gesto	Effetto
Doppio clic sull'intestazione di un gruppo o su una scheda	Stacca il pannello (per l'intestazione: il pannello attivo del gruppo) in una finestra mobile — `ue_panel_floated`
Doppio clic sulla barra del titolo di una finestra mobile	Riancora il pannello al suo posto, come la croce della finestra — `ue_panel_docked`
Clic destro sull'intestazione, su una scheda o su una linguetta della guida	Menu Stacca / Nascondi automaticamente / Chiudi / Chiudi gli altri (gli altri pannelli chiudibili dello stesso gruppo). Nascondi automaticamente è spuntato quando il gruppo è ripiegato: sceglierlo ripiega il gruppo, o lo riblocca — `ue_panel_pinned`. Una voce che non può fare nulla è disattivata; con `ib_veto_close = true`, ogni chiusura pone `ue_panel_closing` — una domanda per pannello

Da tastiera #

Il contenuto di un pannello è un vero controllo PowerBuilder: lì la tastiera appartiene al suo codice, come in qualunque finestra. Ciò di cui si occupa il componente è la propria cornice — intestazioni, schede, splitter:

Tasto	Effetto
Frecce su una scheda	Passano al pannello precedente / successivo del gruppo e lo selezionano. Una barra di schede è un solo arresto di tabulazione
Inizio / Fine su una scheda	Primo / ultimo pannello del gruppo
Frecce su uno splitter	Spostano la separazione del 2 %, solo lungo l'asse dello splitter
Pag su / Pag giù su uno splitter	Lo stesso, a passi del 10 %
Maiusc+F10 o il tasto Menu su una scheda, un pulsante dell'intestazione o una linguetta della guida	Apre il menu del pannello sotto l'elemento (con il clic destro, si apre al puntatore)
Esc	Abbandona un trascinamento in corso, altrimenti richiude il pannello scorrevole aperto da un pulsante di bordo; senza nulla di ciò, il tasto va alla finestra (il suo pulsante Annulla)

Uno splitter è un separator focalizzabile che annuncia la propria posizione; i pulsanti dell'intestazione (staccare, nascondere, chiudere) portano un nome, e il pannello attivo di un gruppo è contrassegnato con aria-selected. Uno spostamento da tastiera risale in ue_layout_changed esattamente come un trascinamento con il mouse.

Esempi #

Una finestra in stile IDE #

// event open : ogni contenuto e un vero controllo PB posato sulla finestra
uo_dock.of_add_panel(/*key*/ "document", /*position*/ "", /*relative_to*/ "", /*size*/ 0, /*title*/ "Documento", /*content*/ uo_editor)
uo_dock.of_add_panel(/*key*/ "explorer", /*position*/ uo_dock.POSITION_START, /*relative_to*/ "document", /*size*/ 260, /*title*/ "Esplora risorse", /*content*/ uo_tree)
uo_dock.of_add_panel(/*key*/ "properties", /*position*/ uo_dock.POSITION_END, /*relative_to*/ "document", /*size*/ 300, /*title*/ "Proprieta", /*content*/ uo_props)
uo_dock.of_add_panel(/*key*/ "output", /*position*/ uo_dock.POSITION_BOTTOM, /*relative_to*/ "document", /*size*/ 200, /*title*/ "Output", /*content*/ uo_console)

// Un secondo pannello impilato come scheda su "properties"
uo_dock.of_add_panel(/*key*/ "help", /*position*/ uo_dock.POSITION_STACK, /*relative_to*/ "properties", /*size*/ 0, /*title*/ "Guida", /*content*/ uo_help)

// Il documento e l'area centrale
uo_dock.is_main = "document"

Memorizzare e ripristinare la disposizione dell'utente #

// event close della finestra : salvare cio che l'utente ha organizzato
// Local variables
string ls_layout

// La disposizione corrente, pronta da riporre
ls_layout = uo_dock.of_get_layout()
of_save_setting(/*name*/ "main_dock", /*value*/ ls_layout)

// event open : LEGGERE la disposizione salvata, POI creare i pannelli
// Local variables
string ls_layout

// Prima l'impostazione : costruire il dock solleva ue_layout_changed, che potrebbe sovrascriverla
ls_layout = of_read_setting(/*name*/ "main_dock")

// Poi i pannelli e la disposizione, in UNA raffica : un solo ue_layout_changed, alla ripresa
uo_dock.of_set_redraw(/*on*/ false)
of_create_panels()

// E la disposizione dell'ultima chiusura, se esiste
if ls_layout <> "" then uo_dock.of_set_layout(/*json*/ ls_layout)

// Fine della raffica
uo_dock.of_set_redraw(/*on*/ true)

L'ordine è tassativo: of_set_layout non crea alcun pannello, si limita a ricollocare quelli già esistenti. E l'impostazione si legge prima della costruzione: ogni of_add_panel cambia la disposizione, e un ue_layout_changed che la salva scriverebbe una disposizione costruita a metà sopra quella che stavate per ripristinare.

Seguire le modifiche in continuo #

// event ue_layout_changed di uo_dock : (string as_json)
// Sollevato una volta per raffica di modifiche (la costruzione, una disposizione ripristinata) : salvato cosi com'e.
of_save_setting(/*name*/ "main_dock", /*value*/ as_json)

Pilotare un pannello tramite il suo handle #

// Local variables
n_pbt_dock_panel lnv_panel

// Il pannello delle proprieta : un titolo che conta le modifiche, compresso sul suo bordo
lnv_panel = uo_dock.of_panel(/*key*/ "properties")
lnv_panel.is_title  = "Proprietà (3 modificate)"
lnv_panel.ib_pinned = false        // si ripiega a linguetta sul bordo

// Nascondere un pannello riservato agli amministratori
uo_dock.of_panel(/*key*/ "audit").ib_visible = gb_administrator

Attirare l'attenzione su un pannello in secondo piano #

// Un'elaborazione in background ha scritto nella console : segnalare senza rubare il focus
uo_dock.of_notify_panel(/*key*/ "output")

Riorganizzare dal codice #

// Spostare un pannello come se l'utente avesse trascinato la sua scheda
uo_dock.of_move_panel(/*key*/ "output", /*target*/ "document", /*position*/ "bottom")

// Impilarlo come scheda su un altro pannello
uo_dock.of_move_panel(/*key*/ "help", /*target*/ "properties", /*position*/ "stack")

Staccare un pannello su un secondo schermo #

// Finestra mobile nativa : l'utente puo posarla su un altro schermo
uo_dock.of_float_panel(/*key*/ "properties")

// event ue_panel_docked di uo_dock : (string as_key)
// L'utente ha richiuso la finestra mobile : il pannello e tornato.
of_log(/*msg*/ "Pannello riancorato : " + as_key)

Chiudere un pannello, riaprirlo #

// event ue_panel_closed di uo_dock : (string as_key)
// Il pannello e solo nascosto : il suo controllo resta nel dock, nulla spunta sulla finestra.
st_status.Text = "Pannello chiuso: " + as_key

// Menu Visualizza, Proprieta : riaprire il pannello, in primo piano nella sua pila
uo_dock.of_panel(/*key*/ "properties").ib_visible = true

Chiudere un pannello lo nasconde: il suo controllo resta ospitato, e ib_visible = true lo riapre in primo piano nella sua pila. of_remove_panel restituisce il controllo alla finestra, al suo posto e visibile se lo era: riservatelo a un controllo che distruggete subito dopo.

Rifiutare la chiusura di un pannello con lavoro non salvato #

// event open della finestra : chiedere prima che un pannello si chiuda (disattivato per impostazione predefinita)
uo_dock.ib_veto_close = true

// ue_panel_closing event of uo_dock : (string as_key) returns boolean
// L'editor contiene ancora modifiche non salvate : il suo pannello resta aperto.
if as_key = "editor" then
    if ib_editor_modified then return false
end if
return true

// Il vostro codice pone la stessa domanda : -4 quando viene rifiutata
if uo_dock.of_close_panel(/*key*/ "editor") = -4 then
    st_status.Text = "Salvate il documento prima di chiudere l'editor."
end if

Buone pratiche #

Designi sempre un pannello principale con is_main: senza area centrale, l'utente può nascondere tutto e ritrovarsi davanti a una finestra vuota.
Legga la disposizione salvata prima di creare i pannelli, poi la salvi su ue_layout_changed anziché alla sola chiusura: così una chiusura anomala non fa perdere nulla, e la costruzione del dock non sovrascrive più ciò che stava per ripristinare.
of_set_layout viene dopo le chiamate of_add_panel, mai prima.
Utilizzi of_notify_panel per le elaborazioni in background: è meno invadente di una finestra di dialogo e l'informazione resta visibile.
Un controllo ospitato è una finestra nativa: si disegna al di sopra dello strato web, nessun effetto visivo del componente può passargli sopra.
Un controllo è ospitato da un solo contenitore: darlo a un secondo dock (o a un tab) lo toglie al primo. Un controllo che contiene il dock stesso viene rifiutato (-5).
Chiudere un pannello lo nasconde (ib_visible = true lo riapre); of_remove_panel restituisce il controllo alla finestra, visibile se lo era.
of_reset() prima di ogni ricostruzione: senza di esso, i controlli precedentemente ospitati restano riagganciati nel contenitore svuotato e il riutilizzo di una chiave non riesce.
Per semplici pagine esclusive, senza ancoraggio né finestre mobili, tab è più leggero.

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.