6.14.2 Oggetti finestra

Gli oggetti finestra, come restituiti da initscr() e newwin() visti sopra, possiedono i seguenti metodi:

addch( [y, x,] ch[, attr])
Note: Con carattere si intende un carattere C (un codice ASCII), invece di un carattere Python (una stringa di lunghezza 1). (Questa nota è valida ogni volta che la documentazione menziona un carattere.) La funzione built-in ord() è utile per convertire stringhe in codici.

Scrive il carattere ch alla posizione (y, x) con attributi attr, sovrascrivendo ogni carattere precedentemente scritto in quella locazione. In modo predefinito, la posizione e gli attributi del carattere sono le impostazioni correnti per l'oggetto finestra.

addnstr( [y, x,] str, n[, attr])
Scrive al più n caratteri della stringa str alla posizione (y, x) con attributi attr, sovrascrivendo qualsiasi cosa si trovi in precedenza sul display.

addstr( [y, x,] str[, attr])
Scrive la stringa str alla posizione (y, x) con attributi attr, sovrascrivendo qualsiasi cosa si trovi in precedenza sul display.

attroff( attr)
Rimuove l'attributo attr dall'insieme di ``background'' applicato a tutte le scritture sulla finestra corrente.

attron( attr)
Aggiunge l'attributo attr all'insieme di ``background'' applicato a tutte le scritture sulla finestra corrente.

attrset( attr)
Imposta ad attr l'insieme degli attributi di ``background''. Questo insieme ha inizialmente il valore impostato a 0 (nessun attributo).

bkgd( ch[, attr])
Imposta la proprieta di sfondo della finestra al carattere ch, con attributi attr. La modifica viene quindi applicata ad ogni locazione di carattere in quella finestra:

bkgdset( ch[, attr])
Imposta lo sfondo della finestra. Lo sfondo di una finestra consiste di un carattere e di ogni combinazione di attributi. La parte degli attributi dello sfondo viene combinata (tramite OR) con tutti i caratteri non vuoti che vengono scritti sulla finestra. Sia i caratteri che le parti di attributi dello sfondo vengono combinati con i caratteri vuoti. Lo sfondo diventa una proprietà del carattere e si sposta con il carattere in ogni operazione di inserimento/cancellazione di riga/carattere.

border( [ls[, rs[, ts[, bs[, tl[, tr[, bl[, br]]]]]]]])
Disegna un bordo attorno ai lati della finestra. Ogni parametro specifica il carattere da utilizzare per una specifica parte del bordo; vedete la tabella sotto per ulteriori dettagli. I caratteri possono venire specificati come interi o come stringhe di un carattere.

Note: In caso di valore 0 per ogni parametro, verrà utilizzato il carattere predefinito per quel parametro. Non possono venire utilizzati parametri a parola chiave. I predefiniti vengono elencati in questa tabella:

Parametro  Descrizione  Valore predefinito 
ls Lato sinistro ACS_VLINE
rs Lato destro ACS_VLINE
ts Vertice ACS_HLINE
bs Base ACS_HLINE
tl Angolo in alto a sinistra ACS_ULCORNER
tr Angolo in alto a destra ACS_URCORNER
bl Angolo in basso a sinistra ACS_BLCORNER
br Angolo in basso a destra ACS_BRCORNER

box( [vertch, horch])
Simile a border(), ma sia ls che rs sono vertch, e sia ts che bs sono horch. I caratteri di angolo predefiniti vengono sempre usati da questa funzione.

clear( )
Come erase(), ma causa anche il ridisegno dell'intera finestra alla prossima chiamata a refresh().

clearok( yes)
Se yes vale 1, la prossima chiamata a refresh() pulirà completamente la finestra.

clrtobot( )
Cancella dal cursore fino alla fine della finestra: tutte le righe sotto il cursore vengono cancellate, e quindi viene eseguito l'equivalente di clrtoeol().

clrtoeol( )
Cancella dal cursore alla fine della riga.

cursyncup( )
Aggiorna la posizione corrente del cursore di tutti gli antenati della finestra, in modo da riflettere la posizione corrente del cursore della finestra.

delch( [x, y])
Cancella ogni carattere alla posizione (y, x).

deleteln( )
Cancella la riga su cui si trova il cursore. Tutte le righe seguenti vengono spostate in alto di una riga.

derwin( [nlines, ncols,] begin_y, begin_x)
Un'abbreviazione di ``finestra derivata'', derwin() ha lo stesso effetto della chiamata a subwin(), eccetto che begin_y e begin_x sono relativi all'origine della finestra, piuttosto che all'intero schermo. Restituisce un oggetto finestra per la finestra derivata.

echochar( ch[, attr])
Aggiunge un carattere ch con attributo attr, e chiama immediatamente refresh() sulla finestra.

enclose( y, x)
Verifica che la coppia di coordinate di cella di carattere passata relativa allo schermo sia contenuta nella finestra data, restituendo vero o falso. È utile per determinare quale sotto insieme delle finestre dello schermo racchiude la locazione di un evento del mouse.

erase( )
Pulisce la finestra.

getbegyx( )
Restituisce una tupla (y, x) di coordinate dell'angolo in alto a sinistra.

getch( [x, y])
Prende un carattere. Notate che non è necessario che l'intero restituito si trovi nell'intervallo ASCII: tasti funzione, tasti del tastierino numerico e altri restituiscono numeri più alti di 256. Nella modalità no-delay, se non c'è input viene restituito -1.

getkey( [x, y])
Prende un carattere, restituiendo una stringa invece di un intero, come fa getch(). Tasti funzione, tasti del tastierino numerico ed altri restituiscono una stringa a byte multipli, contenente il nome del tasto. Nella modalità no-delay, viene sollevata un'eccezione in caso di mancanza di input.

getmaxyx( )
Restituisce una tupla (y, x) contenente l'altezza e la larghezza della finestra.

getparyx( )
Restituisce le coordinate iniziali di questa finestra relative alla sua finestra madre in due variabili intere y e x. Restituisce -1,-1 se questa finestra non ha madre.

getstr( [x, y])
Legge una stringa dall'utente, con proprietà di editing di riga elementare.

getyx( )
Restituisce una tupla (y, x) della posizione corrente del cursore, relativa all'angolo in alto a sinistra della finestra.

hline( [y, x,] ch, n)
Mostra una linea orizzontale che inizia a (y, x) e di lunghezza n, composta da caratteri ch.

idcok( flag)
Se flag è falso, non viene più utilizzata da curses la funzionalità hardware di inserimento/cancellazione dei caratteri del terminale; se flag è vero, l'utilizzo dell'inserimento e cancellazione dei caratteri viene abilitato. Al momento dell'inizializzazione di curses, viene abilitato in modalità predefinita l'utilizzo dei caratteri inserisci/cancella.

idlok( yes)
Se viene chiamato con yes uguale a 1, curses cercherà di sfruttare le semplificazioni hardware di elaborazione di riga. Altrimenti, la possibilità di inserimento/cancellazione delle righe viene disabilitata.

immedok( flag)
Se flag è vero, ogni modifica nell'immagine della finestra provocherà l'immediato aggiornamento della finestra stessa; non dovrete più chiamare refresh() da voi stessi. In ogni caso, questo potrebbe degradare le prestazioni in modo considerevole, a causa delle ripetute chiamate a wrefresh. Questa opzione viene disabilitata in modo predefinito.

inch( [x, y])
Restituisce il carattere nella finestra alla posizione data. Gli 8 bit di fondo sono il carattere vero e proprio, gli 8 bit di testa sono gli attributi.

insch( [y, x,] ch[, attr])
Disegna il carattere ch alla posizione (y, x) con attributi attr, spostando la riga dalla posizione x a destra di un carattere.

insdelln( nlines)
Inserisce nlines righe nella finestra specificata al di sopra della riga corrente. Le nlines righe di fondo vengono perdute. In caso di nlines negativo, vengono cancellate nlines righe a partire da quella sotto il cursore, e vengono spostate in alto le righe rimanenti. Le nlines righe di fondo vengono rimosse. La posizione corrente del cursore rimane la stessa.

insertln( )
Inserisce una riga vuota sotto il cursore. Tutte le righe seguenti vengono spostate in basso di una riga.

insnstr( [y, x,] str, n [, attr])
Inserisce una stringa di caratteri (tanti caratteri quanti ne possano stare sulla riga) prima del carattere sotto il cursore, fino al massimo di n caratteri. Se n è zero o negativo, viene inserita l'intera stringa. Tutti i caratteri alla destra del cursore vengono spostati a destra, causando la perdita dei caratteri più a destra nella riga. La posizione del cursore non viene modificata (dopo essersi spostata in y, x, se specificato).

instr( [y, x][, n])
Restituisce una stringa di caratteri, estratta dalla finestra a partire dalla posizione corrente del cursore, o da y, x se specificato. Gli attributi vengono rimossi dai caratteri. Se n viene specificato, instr() restituisce una stringa lunga al massimo n caratteri (escluso il NUL finale).

is_linetouched( line)
Restituisce vero se la riga specificata è stata modificata dall'ultima chiamata a refresh(); altrimenti restituisce falso. Solleva l'eccezione curses.error se la riga line risulta non valida per la finestra data.

is_wintouched( )
Restituisce vero se la finestra specificata è stata modificata dall'ultima chiamata a refresh(); altrimenti restituisce false.

keypad( yes)
Se yes viene impostato a 1, le sequenze di escape generate da alcuni tasti (tastierino numerico, tasti funzione) verranno interpretate da curses. Se yes viene impostato a 0, le sequenze di escape verranno lasciate invariate nel flusso di input.

leaveok( yes)
Se yes viene impostato a 1, ad ogni aggiornamento il cursore viene lasciato dove si trova, invece di rimanere alla ``cursor position''. Questo riduce i movimenti del cursore dove possibile. Se possibile il cursore verrà reso invisibile.

Se yes viene impostato a 0, il cursore si troverà sempre alla ``cursor position'' dopo un aggiornamento.

move( new_y, new_x)
Sposta il cursore in (new_y, new_x).

mvderwin( y, x)
Sposta la finestra dentro la sua finestra madre. I parametri relativi allo schermo della finestra restano invariati. Questa procedura viene utilizzata per mostrare parti differenti della finestra madre alla stessa posizione fisica sullo schermo.

mvwin( new_y, new_x)
Sposta la finestra in modo che il suo angolo in alto a sinistra si trovi in (new_y, new_x).

nodelay( yes)
Se yes viene impostato ad 1, getch() sarà non bloccante.

notimeout( yes)
Se yes viene impostato ad 1, le sequenze di escape non avranno un time out.

Se yes viene impostato a 0, dopo qualche millisecondo, una sequenza di escape non verrà interpretata, e resterà invariata nel flusso di input.

noutrefresh( )
Segna per un refresh ma attende. Questa funzione aggiorna la struttura dei dati che rappresentaino lo stato desiderato della finestra, ma non impone un aggiornamento dello schermo fisico. Per ottenerlo, chiamate doupdate().

overlay( destwin[, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol])
Sovrappone la finestra in cima a destwin. Le finestre non devono necessariamente avere la stessa dimensione, viene copiata solo la regione che si sovrappone. Questa copia non è distruttiva, ciò significa che il carattere dello sfondo corrente non sovrascrive i vecchi contenuti di destwin.

Per ottenere un controllo fine sulla granatura della regione copiata, si può utilizzare la seconda forma di overlay(). sminrow e smincol sono le coordinate in alto a sinistra della finestra sorgente, e le altre variabili segnano un rettangolo nella finestra di destinazione.

overwrite( destwin[, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol])
Sovrascrive la finestra in cima a destwin. Le finestre non devono necessariamente avere la stessa dimensione, viene copiata solo la regione che si sovrappone. Questa copia è distruttiva, ciò significa che il carattere di sfondo corrente sovrascrive i vecchi contenuti di destwin.

Per ottenere un ontrollo fine sulla granatura della regione copiata, si può utilizzare la seconda forma di overwrite(). sminrow e smincol sono le coordinate in alto a sinistra della finestra sorgente, e le altre variabili segnano un rettangolo nella finestra di destinazione.

putwin( file)
Scrive nell'oggetto file passato tutti i dati associati alla finestra. Queste informazioni possono venire recuperate in seguito, utilizzando la funzione getwin().

redrawln( beg, num)
Indica che le num righe dello schermo a partire dalla riga beg, sono corrotte e dovrebbero venire completamente ridisegnate nella prossima chiamata a refresh().

redrawwin( )
Corregge l'intera finestra, ridisegnandola completamente nella prossima chiamata a refresh().

refresh( [pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])
Aggiorna il display immediatamente (sincronizza lo schermo reale con i precendenti metodi di disegno/cancellazione).

I 6 argomenti facoltativi possono venire specificati solo quando la finestra è un pad creato con newpad(). Gli argomenti aggiuntivi sono necessari in quanto indicano quale parte del pad e dello schermo vengono impiegate. pminrow e pmincol specificano l'angolo in alto a sinistra del rettangolo che deve essere mostrato sul pad. sminrow, smincol, smaxrow e smaxcol, specificano i bordi del rettangolo che deve essere mostrato sullo schermo. L'angolo in basso a destra del rettangolo da mostrare sul pad viene calcolato dalle coordinate dello schermo, visto che i rettangoli devono essere della stessa dimensione. Entrambi i rettangoli devono essere interamente contenuti nelle rispettive strutture. Valori negativi di pminrow, pmincol, sminrow o smincol, vengono trattati come se fossero zero.

scroll( [lines = 1])
Fa scorrere lo schermo o le regioni scorrevoli verso l'alto di lines linee.

scrollok( flag)
Controlla ciò che accade quando il cursore di una finestra viene mosso fuori dal bordo della finestra o della regione di scorrimento, come risultato ad esempio di un'azione di fine riga sulla linea di fondo, o digitando l'ultimo carattere dell'ultima linea. Se flag è falso, il cursore viene lasciato sulla riga di fondo. Se flag è vero, la finestra viene fatta scorrere in alto di una riga. Notate che per ottenere l'effetto di scorrimento fisico sul terminale, è necessario chiamare anche idlok().

setscrreg( top, bottom)
Imposta le regione di scorrimento dalla riga top alla riga bottom. Tutte le azioni di scorrimento avranno luogo in questa regione.

standend( )
Disabilita l'attributo standout. Su alcuni terminali può avere l'effetto collaterale di disabilitare tutti gli attributi.

standout( )
Abilita l'attributo A_STANDOUT.

subpad( [nlines, ncols,] begin_y, begin_x)
Restituisce una sotto finestra, il cui angolo in alto a sinistra si trova in (begin_y, begin_x), e la cui larghezza/altezza è ncols/nlines.

subwin( [nlines, ncols,] begin_y, begin_x)
Restituisce una sotto finestra, il cui angolo in alto a sinistra si trova in (begin_y, begin_x), e la cui larghezza/altezza è ncols/nlines.

In modo predefinito, la sotto finestra si estenderà a partire dalla posizione specificata verso l'angolo in basso a destra della finestra.

syncdown( )
Corregge ogni locazione nella finestra che è stata corretta in una qualsiasi delle sue finestre antenate. Questa procedura viene chiamata da refresh(), quindi non dovrebbe essere mai necessario chiamarla manualmente.

syncok( flag)
Se viene chiamata con flag impostata a vero, allora syncup() viene chiamata automaticamente ogni volta che avviene una modifica sulla finestra.

syncup( )
Corregge tutte le locazioni negli antenati nella finestra che sono state modificate nella finestra stessa.

timeout( delay)
Imposta il comportamento bloccante o non bloccante alla lettura dell'input per la finestra. Se delay è negativo, viene usata la lettura bloccante (che attende indefinitivamente l'input). Se delay viene impostato a zero, allora viene usata la lettura non bloccante, e getch() restituirà -1 in caso di assenza di input in attesa. Se delay è positivo, allora getch() attenderà delay millisecondi, e restituirà -1 se non sopraggiungerà alcun input al termine di questo periodo.

touchline( start, count)
Simula che count righe siano state modificate, a partire dalla riga start.

touchwin( )
Simula che l'intera finestra sia stata modificata, per scopi di ottimizzazione del disegno.

untouchwin( )
Segna tutte le righe nella finestra come se non fossero state modificate dall'ultima chiamata a refresh().

vline( [y, x,] ch, n)
Mostra una linea verticale che inizia a (y, x) e di lunghezza n, composta da caratteri ch.

Vedete Circa questo documento... per informazioni su modifiche e suggerimenti.