Condividi tramite


Sequenze del terminale virtuale della console

Le sequenze di terminale virtuale sono sequenze di caratteri di controllo che possono controllare lo spostamento del cursore, il colore della console e altre operazioni quando vengono scritte nel flusso di output. Le sequenze possono anche essere ricevute nel flusso di input in risposta a una sequenza di informazioni di query del flusso di output o come codifica dell'input utente quando viene impostata la modalità appropriata.

Per configurare questo comportamento, è possibile usare le funzioni GetConsoleMode e SetConsoleMode. Alla fine di questo documento è incluso un esempio della modalità consigliata per abilitare i comportamenti del terminale virtuale.

Il comportamento delle sequenze seguenti si basa su VT100 e sulle tecnologie dell'emulatore di terminale derivate, in particolare sull'emulatore di terminale xterm. Per altre informazioni sulle sequenze di terminale, visitare i siti Web agli indirizzi http://vt100.net e http://invisible-island.net/xterm/ctlseqs/ctlseqs.html.

Sequenze di output

Le sequenze di terminale seguenti vengono intercettate dall'host della console quando vengono scritte nel flusso di output, se il flag ENABLE_VIRTUAL_TERMINAL_PROCESSING viene impostato nell'handle del buffer dello schermo usando la funzione SetConsoleMode. Si noti che il flag DISABLE_NEWLINE_AUTO_RETURN può essere utile anche per simulare il comportamento di posizionamento e scorrimento del cursore di altri emulatori di terminale in relazione ai caratteri scritti nella colonna finale in qualsiasi riga.

Posizionamento semplice del cursore

In tutte le descrizioni seguenti ESC è sempre rappresentato dal valore esadecimale 0x1B. Non è necessario includere spazi nelle sequenze di terminale. Le singole sequenze di terminale possono essere suddivise, in qualsiasi posizione di caratteri o byte, in più chiamate sequenziali a WriteFile o WriteConsole, ma è consigliabile includere l'intera sequenza in una sola chiamata. Per informazioni su come vengono usate in pratica le sequenze, vedere l'esempio alla fine di questo argomento.

Nella tabella seguente vengono descritte le sequenze di escape semplici con un solo comando di azione subito dopo il carattere ESC. Queste sequenze non hanno parametri e hanno effetto immediato.

Tutti i comandi inclusi in questa tabella sono generalmente equivalenti alla chiamata dell'API della console SetConsoleCursorPosition per posizionare il cursore.

Lo spostamento del cursore verrà limitato dal riquadro di visualizzazione corrente nel buffer. Lo scorrimento, se disponibile, non si verificherà.

Sequence Sintassi abbreviata Comportamento
ESC M Istanza riservata Indice inverso: esegue l'operazione inversa di \n, sposta il cursore verso l'alto di una riga, mantiene la posizione orizzontale, scorre il buffer, se necessario*
ESC 7 DECSC Salva posizione cursore in memoria**
ESC 8 DECSR Ripristinare la posizione del cursore dalla memoria**

Nota

* Se sono presenti margini di scorrimento impostati, l'istanza riservata all'interno dei margini scorrerà solo il contenuto dei margini e lascerà invariato il riquadro di visualizzazione. (vedere Margini di scorrimento).

**Non verrà salvato alcun valore in memoria fino al primo utilizzo del comando salva. L'unico modo per accedere al valore salvato è tramite il comando di ripristino.

Posizionamento del cursore

Le tabelle seguenti includono le sequenze di tipo CSI (Control Sequence Introducer). Tutte le sequenze CSI iniziano con ESC (0x1B) seguite da [ (parentesi quadra sinistra, 0x5B) e possono contenere parametri di lunghezza variabile per specificare altre informazioni per ogni operazione. Tali informazioni saranno rappresentate dalla sintassi abbreviata <n>. Ogni tabella riportata di seguito è raggruppata per funzionalità, con note sotto ogni tabella che illustrano il funzionamento del gruppo.

Se non diversamente specificato, le regole seguenti si applicano a tutti i parametri:

  • <n> rappresenta la distanza di spostamento ed è un parametro facoltativo
  • Se <n> viene omesso o è uguale a 0, verrà considerato come 1
  • <n> non può essere maggiore di 32.767 (valore short massimo)
  • <n> non può essere un valore negativo

Tutti i comandi inclusi in questa sezione sono generalmente equivalenti alla chiamata dell'API della console SetConsoleCursorPosition.

Lo spostamento del cursore verrà limitato dal riquadro di visualizzazione corrente nel buffer. Lo scorrimento, se disponibile, non si verificherà.

Sequence Codice Descrizione Comportamento
ESC [ <n> A CUU Cursore su Cursore su di <n>
ESC [ <n> B CUD Cursore giù Cursore giù di <n>
ESC [ <n> C CUF Cursore avanti Cursore avanti (verso destra) di <n>
ESC [ <n> D CUB Cursore indietro Cursore indietro (verso sinistra) di <n>
ESC [ <n> E CNL Cursore riga successiva Cursore giù di <n> righe dalla posizione corrente
ESC [ <n> F CPL Cursore riga precedente Cursore su <n> righe dalla posizione corrente
ESC [ <n> G CHA Cursore assoluto orizzontale Il cursore si sposta orizzontalmente alla posizione <n> nella riga corrente
ESC [ <n> d VPA Assoluto posizione riga verticale Il cursore si sposta verticalmente alla posizione <n> nella colonna corrente
ESC [ <y> ; <x> H CUP Posizione cursore *Cursore si sposta su <x>; <Coordinata y> all'interno del riquadro di visualizzazione, dove <x> è la colonna della <linea y>
ESC [ <y> ; <x> f HVP Posizione verticale orizzontale *Cursore si sposta su <x>; <Coordinata y> all'interno del riquadro di visualizzazione, dove <x> è la colonna della <linea y>
ESC [ s ANSISYSSC Salvataggio cursore - Emulazione Ansi.sys **Senza parametri, esegue un'operazione di salvataggio del cursore come DECSC
ESC [ u ANSISYSRC Ripristino cursore - Emulazione Ansi.sys **Senza parametri, esegue un'operazione di ripristino del cursore come DECRC

Nota

I parametri *<x> e <y> hanno le stesse limitazioni di <n> precedenti. Se <x> e <y> vengono omessi, verranno impostati su 1;1.

**ANSI.sys documentazione cronologica è disponibile in https://msdn.microsoft.com/library/cc722862.aspx ed è implementata per praticità/compatibilità.

Visibilità del cursore

I comandi seguenti controllano la visibilità del cursore e del relativo stato intermittente. Le sequenze DECTCEM sono generalmente equivalenti alla chiamata dell'API della console SetConsoleCursorInfo per attivare o disattivare la visibilità del cursore.

Sequence Codice Descrizione Comportamento
ESC [ ? 12 h ATT160 Abilitazione cursore di testo intermittente Avvia lo stato intermittente del cursore
ESC [ ? 12 l ATT160 Disabilitazione cursore di testo intermittente Interrompe lo stato intermittente del cursore
ESC [ ? 25 h DECTCEM Abilitazione cursore di testo in modalità Mostra Mostra il cursore
ESC [ ? 25 l DECTCEM Abilitazione cursore di testo in modalità Nascondi Nasconde il cursore

Suggerimento

Le sequenze di abilitazione terminano con un carattere H minuscolo (h), mentre le sequenze di disabilitazione terminano con un carattere L minuscolo (l).

Forma cursore

I comandi seguenti controllano e consentono la personalizzazione della forma del cursore.

Sequence Codice Descrizione Comportamento
ESC [ 0 SP q DECSCUSR Forma utente Forma cursore predefinita configurata dall'utente
ESC [ 1 SP q DECSCUSR Blocco lampeggiante Forma del cursore a blocchi lampeggiante
ESC [ 2 SP q DECSCUSR Blocco costante Forma cursore a blocchi costante
ESC [ 3 SP q DECSCUSR Sottolineatura lampeggiante Blinking sottolineatura forma cursore
ESC [ 4 SP q DECSCUSR Sottolineatura costante Forma cursore sottolineatura costante
ESC [ 5 SP q DECSCUSR Barra lampeggiante Forma cursore barra lampeggiante
ESC [ 6 SP q DECSCUSR Barra fissa Forma cursore barra costante

Nota

SP è un carattere di spazio letterale (0x20) nella posizione intermedia ed è seguito da q (0x71) nella posizione finale.

Posizionamento del riquadro di visualizzazione

Tutti i comandi inclusi in questa sezione sono generalmente equivalenti alla chiamata dell'API della console ScrollConsoleScreenBuffer per spostare il contenuto del buffer della console.

Attenzione I nomi dei comandi sono fuorvianti. Il termine "scorrere" si riferisce alla direzione di spostamento del testo durante l'operazione, non alla modalità di spostamento del riquadro di visualizzazione.

Sequence Codice Descrizione Comportamento
ESC [ <n> S Unità di streaming (SU) Scorrere verso l'alto Scorrimento del testo verso l'alto di <n>. Operazione nota anche come "panoramica in basso", dove le nuove righe vengono compilate a partire dalla parte inferiore dello schermo
ESC [ <n> T DS Scorrere verso il basso Scorrimento verso il basso di <n>. Operazione nota anche come "panoramica in alto", dove le nuove righe vengono compilate a partire dalla parte superiore dello schermo

Il testo viene spostato a partire dalla riga in cui si trova il cursore. Se il cursore si trova nella riga centrale del riquadro di visualizzazione, lo scorrimento verso l'alto determinerà lo spostamento della metà inferiore del riquadro e l'inserimento di righe vuote in fondo. Lo scorrimento verso il basso determinerà lo spostamento della metà superiore delle righe del riquadro di visualizzazione e l'inserimento di nuove righe in cima.

È inoltre importante notare che lo scorrimento verso l'alto e lo scorrimento verso il basso dipendono anche dai margini di scorrimento. Lo scorrimento verso l'alto e lo scorrimento verso il basso non influiranno sulle righe esterne ai margini di scorrimento.

Il valore predefinito per <n> è 1 che facoltativamente può essere omesso.

Modifica del testo

Tutti i comandi inclusi in questa sezione sono generalmente equivalenti alla chiamata delle API della console FillConsoleOutputCharacter, FillConsoleOutputAttribute e ScrollConsoleScreenBuffer per modificare il contenuto del buffer di testo.

Sequence Codice Descrizione Comportamento
ESC [ <n> @ ICH Inserimento carattere Inserisce <n> spazi nella posizione corrente del cursore, spostando tutto il testo esistente verso destra. All'uscita dallo schermo, il testo a destra viene rimosso.
ESC [ <n> P DCH Eliminazione carattere Elimina <n> caratteri nella posizione corrente del cursore, scalando gli spazi dal bordo destro dello schermo.
ESC [ <n> X ECH Cancellazione carattere Cancella <n> caratteri dalla posizione corrente del cursore sovrascrivendoli con uno spazio.
ESC [ <n> L IL Inserisci riga Inserisce <n> righe nel buffer in corrispondenza della posizione del cursore. La riga in cui si trova il cursore e le righe sottostanti verranno spostate verso il basso.
ESC [ <n> M DL Elimina riga Elimina <n> righe dal buffer, a partire dalla riga in cui si trova il cursore.

Nota

Per IL e DL sono interessate solo le righe incluse nei margini di scorrimento (vedere Margini di scorrimento). Se non è impostato alcun margine, i bordi predefiniti corrispondono al riquadro di visualizzazione corrente. Se le righe vengono spostate sotto i margini, vengono rimosse. Quando le righe vengono eliminate, vengono inserite righe vuote in fondo ai margini. Le linee esterne al riquadro di visualizzazione non sono mai interessate.

Per ognuna delle sequenze, il valore predefinito di <n>, se omesso, è 0.

Per i comandi seguenti il parametro <n> ha 3 valori validi:

  • 0 cancella il contenuto dalla posizione corrente del cursore (inclusa) alla fine della riga o del display
  • 1 cancella il contenuto dall'inizio della riga o del display fino alla posizione corrente del cursore inclusa
  • 2 cancella il contenuto di tutta la riga o di tutto il display
Sequence Codice Descrizione Comportamento
ESC [ <n> J ED Cancellazione nel display Sostituisce tutto il testo presente nel riquadro di visualizzazione o nello schermo, specificato da <n> con spazi
ESC [ <n> K EL Cancellazione nella riga Sostituisce tutto il testo presente nella riga con il cursore specificato da <n> con spazi

Formattazione del testo

Tutti i comandi inclusi in questa sezione sono generalmente equivalenti alla chiamata delle API della console SetConsoleTextAttribute per regolare la formattazione di tutte le operazioni di scrittura future nel buffer di testo di output della console.

Questo comando è speciale in quanto la posizione <n> indicata di seguito può accettare da 0 a 16 parametri separati da punti e virgola.

Se non è specificato alcun parametro, si considera come se fosse specificato un singolo parametro 0.

Sequence Codice Descrizione Comportamento
ESC [ <n> m SGR Impostazione rendering grafica Imposta il formato dello schermo e del testo come specificato da <n>

La seguente tabella di valori può essere usata in <n> per rappresentare modalità di formattazione diverse.

Le modalità di formattazione vengono applicate da sinistra a destra. Se si applicano opzioni di formattazione concorrenti, l'opzione più a destra avrà la precedenza.

Per le opzioni che specificano i colori, i colori verranno usati come definito nella tabella dei colori della console, che può essere modificata usando l'API SetConsoleScreenBufferInfoEx. Se la tabella viene modificata in modo che la posizione "blu" visualizzi una sfumatura di rosso RGB, tutte le chiamate a Blu primo piano visualizzeranno il colore rosso fino a quando questa opzione non viene modificata.

Valore Descrizione Comportamento
0 Valori predefiniti Ripristina lo stato predefinito di tutti gli attributi precedente alla modifica
1 Grassetto/Brillante Applica il flag di luminosità/intensità al colore di primo piano
22 Nessun grassetto/brillante Rimuove il flag luminosità/intensità dal colore di primo piano
4 Sottolineato Aggiunge la sottolineatura
24 Nessuna sottolineatura Rimuove la sottolineatura
7 Negativa Scambia i colori di primo piano e di sfondo
27 Positivo (non negativo) Ripristina il valore normale di primo piano/sfondo
30 Nero primo piano Applica il colore nero non grassetto/brillante in primo piano
31 Rosso primo piano Applica il colore rosso non grassetto/brillante in primo piano
32 Verde primo piano Applica il colore verde non grassetto/brillante in primo piano
33 Giallo primo piano Applica il colore giallo non grassetto/brillante in primo piano
34 Blu primo piano Applica il colore blu non grassetto/brillante in primo piano
35 Magenta primo piano Applica il color magenta non grassetto/brillante in primo piano
36 Ciano primo piano Applica il color ciano non grassetto/brillante in primo piano
37 Bianco primo piano Applica il colore bianco non grassetto/brillante in primo piano
38 Valore esteso primo piano Applica il valore di colore esteso al primo piano (vedere i dettagli di seguito)
39 Valore predefinito primo piano Applica solo la parte in primo piano delle impostazioni predefinite (vedere 0)
40 Nero sfondo Applica il colore nero non grassetto/brillante allo sfondo
41 Rosso sfondo Applica il colore rosso non grassetto/brillante allo sfondo
42 Verde sfondo Applica il colore verde non grassetto/brillante allo sfondo
43 Giallo sfondo Applica il colore giallo non grassetto/brillante allo sfondo
44 Blu sfondo Applica il colore blu non grassetto/brillante allo sfondo
45 Magenta sfondo Applica il color magenta non grassetto/brillante allo sfondo
46 Ciano sfondo Applica il color ciano non grassetto/brillante allo sfondo
47 Bianco sfondo Applica il colore bianco non grassetto/brillante allo sfondo
48 Valore esteso sfondo Applica il valore di colore esteso allo sfondo (vedere i dettagli di seguito)
49 Valore predefinito sfondo Applica solo la parte dello sfondo delle impostazioni predefinite (vedere 0)
90 Nero primo piano brillante Applica il colore nero grassetto/brillante in primo piano
91 Rosso primo piano brillante Applica il colore rosso grassetto/brillante in primo piano
92 Verde primo piano brillante Applica il colore verde grassetto/brillante in primo piano
93 Giallo primo piano brillante Applica il colore giallo grassetto/brillante in primo piano
94 Blu primo piano brillante Applica il colore blu grassetto/brillante in primo piano
95 Magenta primo piano brillante Applica il color magenta grassetto/brillante in primo piano
96 Ciano primo piano brillante Applica il color ciano grassetto/brillante in primo piano
97 Bianco primo piano brillante Applica il colore bianco grassetto/brillante allo sfondo
100 Nero sfondo brillante Applica il colore nero grassetto/brillante allo sfondo
101 Rosso sfondo brillante Applica il colore rosso grassetto/brillante allo sfondo
102 Verde sfondo brillante Applica il colore verde grassetto/brillante allo sfondo
103 Giallo sfondo brillante Applica il colore giallo grassetto/brillante allo sfondo
104 Blu sfondo brillante Applica il colore blu grassetto/brillante allo sfondo
105 Magenta sfondo brillante Applica il color magenta grassetto/brillante allo sfondo
106 Ciano sfondo brillante Applica il color ciano grassetto/brillante allo sfondo
107 Bianco sfondo brillante Applica il colore bianco grassetto/brillante allo sfondo

Colori estesi

Alcuni emulatori di terminale virtuale supportano una tavolozza di colori più estesa dei 16 colori forniti dalla console di Windows. Per questi colori estesi, la console di Windows sceglierà il colore appropriato più vicino dalla tavola dei 16 colori esistente per la visualizzazione. Diversamente dai valori SGR tipici sopraindicati, i valori estesi utilizzano parametri aggiuntivi dopo l'indicatore iniziale, in base alle informazioni riportate nella tabella seguente.

Sottosequenza SGR Descrizione
38 ; 2 ; <r> ; <g> ; <b> Impostare il colore di primo piano sul valore RGB specificato in <r>, <g>, <b> parameters*
48 ; 2 ; <r> ; <g> ; <b> Impostare il colore di sfondo sul valore RGB specificato in <r>, <g>, <b> parameters*
38 ; 5 ; <s> Impostare il colore di primo piano su <s> index in 88 o 256 color table*
48 ; 5 ; <s> Impostare il colore di sfondo su <s> index in 88 o 256 color table*

*Le tavolozze dei colori 88 e 256 gestite internamente per il confronto sono basate sull'emulatore del terminale xterm. Non è possibile modificare le tabelle di confronto o di arrotondamento in questa fase.

Colori dello schermo

Il comando seguente consente all'applicazione di impostare i valori della tavolozza dei colori dello schermo su qualsiasi valore RGB.

I valori RGB devono essere valori esadecimali compresi tra 0 e ff e separati dal carattere barra (ad esempio, rgb:1/24/86).

Si noti che questa sequenza è una sequenza "Comando del sistema operativo" OSC e non un CSI come molte delle altre sequenze elencate e, ad esempio, inizia con "\x1b]", non "\x1b[". Come sequenze OSC, vengono terminate con un terminatore di stringa rappresentato come <ST> e trasmesso con ESC \ (0x1B 0x5C). BEL (0x7) può essere usato invece come carattere di terminazione, ma la forma più lunga è preferibile.

Sequence Descrizione Comportamento
ESC ] 4 ; <i> ; rgb: <r> / <g> / <b><ST> Modifica colori schermo Imposta l'indice <i> della tavolozza dei colori dello schermo sui valori RGB specificati in <r>, <g>, <b>

Modifiche della modalità

Si tratta di sequenze che controllano le modalità di input. Esistono due diversi set di modalità di input, ovvero la modalità tasti cursore e la modalità tasti del tastierino. La modalità tasti cursore controlla le sequenze generate dai tasti di direzione, nonché da Home e Fine, mentre la modalità tasti del tastierino controlla le sequenze generate principalmente dai tasti sul tastierino numerico, nonché dai tasti funzione.

Ognuna di queste modalità è una semplice impostazione booleana. La modalità tasti cursore è impostata su normale (impostazione predefinita) o applicazione e la modalità tasti del tastierino è impostata su numerica (impostazione predefinita) o applicazione.

Per le sequenze generate in queste modalità, vedere le sezioni Tasti cursore e Tastierino numerico.

Sequence Codice Descrizione Comportamento
ESC = DECKPAM Abilitazione modalità applicazione tastierino I tasti del tastierino generano le relative sequenze in modalità applicazione.
ESC > DECKPNM Abilitazione modalità numerica tastierino I tasti del tastierino genereranno le relative sequenze in modalità numerica.
ESC [ ? 1 ora DECCKM Abilitazione modalità applicazione tasti cursore I tasti del tastierino generano le relative sequenze in modalità applicazione.
ESC [ ? 1 l DECCKM Disabilitazione modalità applicazione tasti cursore (usare la modalità normale) I tasti del tastierino genereranno le relative sequenze in modalità numerica.

Stato delle query

Tutti i comandi di questa sezione sono in genere equivalenti alla chiamata alle API della console Get* per recuperare informazioni sullo stato del buffer della console corrente.

Nota

Queste query genereranno le risposte nel flusso di input della console immediatamente dopo essere state riconosciute nel flusso di output mentre è impostata ENABLE_VIRTUAL_TERMINAL_PROCESSING. Il flag ENABLE_VIRTUAL_TERMINAL_INPUT non si applica ai comandi di query perché si presuppone che un'applicazione che effettua la query voglia sempre ricevere la risposta.

Sequence Codice Descrizione Comportamento
ESC [ 6 n DECXCPR Segnalazione posizione cursore Generare la posizione del cursore come ESC [ <r> ; <c> R Where <r> = cursor row and <c> = cursor column
ESC [ 0 c DA Attributi dispositivo Segnala l'identità del terminale. Emetterà "\x1b[?1; 0c", che indica "VT101 senza opzioni".

Tabulazioni

Mentre la console di Windows prevede tradizionalmente che le schede siano a larghezza esclusiva di otto caratteri, *nix applicazioni che usano determinate sequenze possono modificare dove le tabulazioni si trovano all'interno delle finestre della console per ottimizzare lo spostamento del cursore da parte dell'applicazione.

Le sequenze seguenti consentono a un'applicazione di impostare le posizioni delle tabulazioni nella finestra della console, rimuoverle e spostarsi da una posizione all'altra.

Sequence Codice Descrizione Comportamento
ESC H HTS Tabulazione orizzontale impostata Imposta una tabulazione nella colonna corrente in cui si trova il cursore.
ESC [ <n> I CHT Tabulazione orizzontale (in avanti) del cursore Sposta il cursore nella colonna successiva (stessa riga) con una tabulazione. Se non sono presenti altre tabulazioni, il cursore si sposta nell'ultima colonna della riga. Se il cursore si trova nell'ultima colonna, passa alla prima colonna della riga successiva.
ESC [ <n> Z CBT Tabulazione cursore indietro Sposta il cursore nella colonna precedente (stessa riga) con una tabulazione. Se non sono presenti altre tabulazioni, sposta il cursore nella prima colonna. Se il cursore si trova nella prima colonna, non viene spostato.
ESC [ 0 g TBC Cancellazione tabulazione (colonna corrente) Cancella la tabulazione, se presente, nella colonna corrente. In caso contrario, non esegue alcuna operazione.
ESC [ 3 g TBC Cancellazione tabulazione (tutte le colonne) Cancella tutte le tabulazioni attualmente impostate.
  • Per CHT e CBT, <n> è un parametro facoltativo (valore predefinito = 1) che indica il numero di volte in cui spostare il cursore nella direzione specificata.
  • Se non sono presenti tabulazioni impostate tramite HTS, CHT e CBT, la prima e l'ultima colonna della finestra verranno considerate come le uniche due tabulazioni.
  • L'uso di HTS per impostare una tabulazione causerà anche che la console passi alla tabulazione successiva nell'output di un carattere TAB (0x09, '\t'), allo stesso modo di CHT.

Designare il set di caratteri

Le sequenze seguenti consentono a un programma di modificare il mapping del set di caratteri attivo. In questo modo un programma può generare caratteri ASCII a 7 bit, ma visualizzarli come altri glifi nello schermo del terminale. Attualmente gli unici due set di caratteri supportati sono ASCII (impostazione predefinita) e il set di caratteri grafici speciali DEC. Per un elenco di tutti i caratteri rappresentati dal set di caratteri grafici speciali DEC, visitare il sito Web all'indirizzo http://vt100.net/docs/vt220-rm/table2-4.html.

Sequence Descrizione Comportamento
ESC ( 0 Designazione set di caratteri DEC Line Drawing Abilita la modalità DEC Line Drawing
ESC ( B Designazione set di caratteri ASCII Stati Uniti Abilita la modalità ASCII (impostazione predefinita)

In particolare, la modalità DEC Line Drawing viene usata per disegnare i bordi nelle applicazioni console. La tabella seguente illustra il mapping tra caratteri ASCII e caratteri DEC Line Drawing.

Hex ASCII DEC Line Drawing
0x6a j
0x6b k
0x6c l
0x6d m
0x6e n
0x71 q
0x74 t
0x75 u
0x76 v
0x77 w
0x78 x

Margini di scorrimento

Le sequenze seguenti consentono a un programma di configurare l'"area di scorrimento" dello schermo interessata dalle operazioni di scorrimento. Si tratta di un subset delle righe regolate quando lo schermo scorre in altro modo, ad esempio in un'istanza riservata o '\n'. Questi margini influiscono anche sulle righe modificate da Inserimento riga (IL) ed Eliminazione riga (DL), Scorrimento verso l'alto (SU) e Scorrimento verso il basso (SD).

I margini di scorrimento possono essere utili soprattutto per fare in modo che una parte dello schermo non scorra quando il resto dello schermo viene riempito, ad esempio con una barra del titolo nella parte superiore o una barra di stato nella parte inferiore dell'applicazione.

Per DECSTBM sono disponibili due parametri facoltativi, <t> e <b>, usati per specificare le righe che rappresentano la riga superiore e quella inferiore dell'area di scorrimento incluse. Se i parametri vengono omessi, <t> viene impostato automaticamente su 1 e <b> sull'altezza del riquadro di visualizzazione corrente.

I margini di scorrimento vanno considerati per buffer. È quindi importante che il buffer alternativo e il buffer principale mantengano impostazioni separate dei margini di scorrimento (di conseguenza, un'applicazione a schermo intero nel buffer alternativo non comprometterà i margini del buffer principale).

Sequence Codice Descrizione Comportamento
ESC [ <t> ; <b r> DECSTBM Impostazione area di scorrimento Imposta i margini di scorrimento VT del riquadro di visualizzazione.

Titolo della finestra

I comandi seguenti consentono all'applicazione di impostare il titolo della finestra della console sul parametro <stringa> specificato. Per essere accettata, la stringa deve contenere meno di 255 caratteri. L'operazione è equivalente alla chiamata di SetConsoleTitle con la stringa specificata.

Si noti che queste sequenze sono sequenze di "comando del sistema operativo" OSC e non un CSI come molte delle altre sequenze elencate e, di conseguenza, inizia con "\x1b]", non "\x1b[". Come sequenze OSC, vengono terminate con un terminatore di stringa rappresentato come <ST> e trasmesso con ESC \ (0x1B 0x5C). BEL (0x7) può essere usato invece come carattere di terminazione, ma la forma più lunga è preferibile.

Sequence Descrizione Comportamento
ESC ] 0 ; <Stringa><SAN> Impostazione titolo finestra Imposta il titolo della finestra della console su <stringa>.
ESC ] 2 ; <Stringa><SAN> Impostazione titolo finestra Imposta il titolo della finestra della console su <stringa>.

Il carattere di terminazione qui è il carattere "Bell", '\x07'

Buffer alternativo dello schermo

*Le applicazioni di stile Nix spesso utilizzano un buffer dello schermo alternativo, in modo che possano modificare l'intero contenuto del buffer, senza influire sull'applicazione che li ha avviati. Il buffer alternativo è esattamente delle dimensioni della finestra, senza area di scrollback.

Per un esempio di questo comportamento, si prenda in considerazione quando vim viene avviato da bash. Vim usa l'intero schermo per modificare il file e quindi, tornando a bash, lascia invariato il buffer originale.

Sequence Descrizione Comportamento
ESC [ ? 1 0 4 9 h Uso buffer alternativo dello schermo Passa a un nuovo buffer alternativo dello schermo.
ESC [ ? 1 0 4 9 l Uso buffer principale dello schermo Passa al buffer principale.

Larghezza della finestra

Le sequenze seguenti possono essere usate per controllare la larghezza della finestra della console. Sono approssimativamente equivalenti alla chiamata dell'API della console SetConsoleScreenBufferInfoEx per impostare la larghezza della finestra.

Sequence Codice Descrizione Comportamento
ESC [ ? 3 h DECCOLM Impostazione numero di colonne su 132 Imposta la larghezza della console su una larghezza pari a 132 colonne.
ESC [ ? 3 l DECCOLM Impostazione numero di colonne su 80 Imposta la larghezza della console su una larghezza pari a 80 colonne.

Soft reset

La sequenza seguente può essere usata per reimpostare i valori predefiniti di determinate proprietà. Le proprietà seguenti vengono reimpostate sui valori predefiniti indicati di seguito (sono elencate anche le sequenze che controllano tali proprietà):

  • Visibilità cursore: visibile (DECTEM)
  • Tastierino numerico: modalità numerica (DECNKM)
  • Modalità tasti cursore: modalità normale (DECCKM)
  • Margini superiore e inferiore: Top=1, Bottom=Altezza console (DECSTBM)
  • Set di caratteri: US ASCII
  • Rendering grafico: impostazione predefinita/disattivata (SGR)
  • Salva stato cursore: posizione iniziale (0,0) (DECSC)
Sequence Codice Descrizione Comportamento
ESC [ ! p DECSTR Soft reset Ripristina i valori predefiniti di determinate impostazioni del terminale.

Sequenze di input

Le sequenze di terminale seguenti vengono generate dall'host della console nel flusso di input se il flag ENABLE_VIRTUAL_TERMINAL_INPUT è impostato sull'handle del buffer di input usando il flag SetConsoleMode.

Sono disponibili due modalità interne che controllano le sequenze generate per i tasti di input specificati: la modalità tasti cursore e la modalità tasti del tastierino. Queste modalità sono descritte nella sezione Modifiche della modalità.

Tasti cursore

Key Modalità normale Modalità applicazione
Freccia SU ESC [ A ESC O A
Freccia GIÙ ESC [ B ESC O B
Freccia DESTRA ESC [ C ESC O C
Freccia SINISTRA ESC [ D ESC O D
Home ESC [ H ESC O H
Fine ESC [ F ESC O F

Inoltre, se si preme CTRL con uno qualsiasi di questi tasti, vengono generate le sequenze seguenti, indipendentemente dalla modalità tasti cursore:

Key Qualsiasi modalità
CTRL + freccia SU ESC [ 1 ; 5 A
CTRL + freccia GIÙ ESC [ 1 ; 5 B
CTRL + freccia DESTRA ESC [ 1 ; 5 C
CTRL + freccia SINISTRA ESC [ 1 ; 5 D

Tastierino numerico e tasti funzione

Key Sequence
Backspace 0x7f (DEL)
Sospendi 0x1a (SUB)
ESC 0x1b (ESC)
Inserisci ESC [ 2 ~
Elimina ESC [ 3 ~
Pagina su ESC [ 5 ~
Pagina giù ESC [ 6 ~
F1 ESC O P
F2 ESC O Q
F3 ESC O R
F4 ESC O S
F5 ESC [ 1 5 ~
F6 ESC [ 1 7 ~
F7 ESC [ 1 8 ~
F8 ESC [ 1 9 ~
F9 ESC [ 2 0 ~
F10 ESC [ 2 1 ~
F11 ESC [ 2 3 ~
F12 ESC [ 2 4 ~

Modificatori

Alt viene trattato anteponendo alla sequenza un carattere di escape: ESC <c> dove <c> è il carattere passato dal sistema operativo. La combinazione di tasti ALT + CTRL viene gestita allo stesso modo, tranne per il fatto che il sistema operativo avrà preliminarmente spostato il tasto <c> sul carattere di controllo appropriato che verrà inoltrato all'applicazione.

Il tasto CTRL viene in genere passato esattamente come viene ricevuto dal sistema. Si tratta in genere di un singolo carattere spostato nello spazio riservato al carattere di controllo (0x0-0x1f). Ad esempio, CTRL+@ (0x40) diventa NUL (0x00), CTRL+[ (0x5b) diventa ESC (0x1b) e così via. Alcune combinazioni di tasti CTRL vengono trattate appositamente in base alla tabella seguente:

Key Sequence
CTRL+SPAZIO 0x00 (NUL)
CTRL + freccia SU ESC [ 1 ; 5 A
CTRL + freccia GIÙ ESC [ 1 ; 5 B
CTRL + freccia DESTRA ESC [ 1 ; 5 C
CTRL + freccia SINISTRA ESC [ 1 ; 5 D

Nota

La combinazione CTRL sinistra + ALT destra viene trattata come ALT GR. Quando entrambi gli elementi vengono visualizzati insieme, vengono rimossi e il valore Unicode del carattere presentato dal sistema viene passato nella destinazione. Il sistema eseguirà la conversione preliminare dei valori di ALT GR in base alle impostazioni di input di sistema correnti.

Esempi

Esempio di sequenze di terminale SGR

Il codice seguente fornisce alcuni esempi di formattazione del testo.

#include <stdio.h>
#include <wchar.h>
#include <windows.h>

int main()
{
    // Set output mode to handle virtual terminal sequences
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hOut == INVALID_HANDLE_VALUE)
    {
        return GetLastError();
    }

    DWORD dwMode = 0;
    if (!GetConsoleMode(hOut, &dwMode))
    {
        return GetLastError();
    }

    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    if (!SetConsoleMode(hOut, dwMode))
    {
        return GetLastError();
    }

    // Try some Set Graphics Rendition (SGR) terminal escape sequences
    wprintf(L"\x1b[31mThis text has a red foreground using SGR.31.\r\n");
    wprintf(L"\x1b[1mThis text has a bright (bold) red foreground using SGR.1 to affect the previous color setting.\r\n");
    wprintf(L"\x1b[mThis text has returned to default colors using SGR.0 implicitly.\r\n");
    wprintf(L"\x1b[34;46mThis text shows the foreground and background change at the same time.\r\n");
    wprintf(L"\x1b[0mThis text has returned to default colors using SGR.0 explicitly.\r\n");
    wprintf(L"\x1b[31;32;33;34;35;36;101;102;103;104;105;106;107mThis text attempts to apply many colors in the same command. Note the colors are applied from left to right so only the right-most option of foreground cyan (SGR.36) and background bright white (SGR.107) is effective.\r\n");
    wprintf(L"\x1b[39mThis text has restored the foreground color only.\r\n");
    wprintf(L"\x1b[49mThis text has restored the background color only.\r\n");

    return 0;
}

Nota

Nell'esempio precedente la stringa '\x1b[31m' è l'implementazione di ESC [ <n> m con <n> 31.

La figura seguente mostra l'output dell'esempio di codice precedente.

output of the console using the sgr command

Esempio di abilitazione dell'elaborazione del terminale virtuale

Il codice seguente fornisce un esempio della modalità consigliata per abilitare l'elaborazione del terminale virtuale per un'applicazione. Lo scopo dell'esempio è dimostrare quanto segue:

  1. La modalità esistente deve sempre essere recuperata tramite GetConsoleMode e analizzata prima di essere impostata con SetConsoleMode.

  2. Controllare se SetConsoleMode restituisce 0 e GetLastError restituisce ERROR_INVALID_PARAMETER è il meccanismo corrente per determinare quando viene eseguito in un sistema di livello inferiore. Un'applicazione che riceve ERROR_INVALID_PARAMETER con uno dei flag di modalità console più recenti nel campo bit dovrebbe ridurre normalmente il comportamento e riprovare.

#include <stdio.h>
#include <wchar.h>
#include <windows.h>

int main()
{
    // Set output mode to handle virtual terminal sequences
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hOut == INVALID_HANDLE_VALUE)
    {
        return false;
    }
    HANDLE hIn = GetStdHandle(STD_INPUT_HANDLE);
    if (hIn == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    DWORD dwOriginalOutMode = 0;
    DWORD dwOriginalInMode = 0;
    if (!GetConsoleMode(hOut, &dwOriginalOutMode))
    {
        return false;
    }
    if (!GetConsoleMode(hIn, &dwOriginalInMode))
    {
        return false;
    }

    DWORD dwRequestedOutModes = ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN;
    DWORD dwRequestedInModes = ENABLE_VIRTUAL_TERMINAL_INPUT;

    DWORD dwOutMode = dwOriginalOutMode | dwRequestedOutModes;
    if (!SetConsoleMode(hOut, dwOutMode))
    {
        // we failed to set both modes, try to step down mode gracefully.
        dwRequestedOutModes = ENABLE_VIRTUAL_TERMINAL_PROCESSING;
        dwOutMode = dwOriginalOutMode | dwRequestedOutModes;
        if (!SetConsoleMode(hOut, dwOutMode))
        {
            // Failed to set any VT mode, can't do anything here.
            return -1;
        }
    }

    DWORD dwInMode = dwOriginalInMode | dwRequestedInModes;
    if (!SetConsoleMode(hIn, dwInMode))
    {
        // Failed to set VT input mode, can't do anything here.
        return -1;
    }

    return 0;
}

Esempio di alcune funzionalità dell'aggiornamento dell'anniversario

L'esempio seguente è destinato a essere un esempio di codice più affidabile che usa una serie di sequenze di escape per modificare il buffer, con particolare attenzione alle funzionalità aggiunte nell'aggiornamento dell'anniversario per Windows 10.

Questo esempio usa il buffer alternativo dello schermo, la modifica delle tabulazioni, l'impostazione dei margini di scorrimento e la modifica del set di caratteri.

// System headers
#include <windows.h>

// Standard library C-style
#include <wchar.h>
#include <stdlib.h>
#include <stdio.h>

#define ESC "\x1b"
#define CSI "\x1b["

bool EnableVTMode()
{
    // Set output mode to handle virtual terminal sequences
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hOut == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    DWORD dwMode = 0;
    if (!GetConsoleMode(hOut, &dwMode))
    {
        return false;
    }

    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    if (!SetConsoleMode(hOut, dwMode))
    {
        return false;
    }
    return true;
}

void PrintVerticalBorder()
{
    printf(ESC "(0"); // Enter Line drawing mode
    printf(CSI "104;93m"); // bright yellow on bright blue
    printf("x"); // in line drawing mode, \x78 -> \u2502 "Vertical Bar"
    printf(CSI "0m"); // restore color
    printf(ESC "(B"); // exit line drawing mode
}

void PrintHorizontalBorder(COORD const Size, bool fIsTop)
{
    printf(ESC "(0"); // Enter Line drawing mode
    printf(CSI "104;93m"); // Make the border bright yellow on bright blue
    printf(fIsTop ? "l" : "m"); // print left corner 

    for (int i = 1; i < Size.X - 1; i++)
        printf("q"); // in line drawing mode, \x71 -> \u2500 "HORIZONTAL SCAN LINE-5"

    printf(fIsTop ? "k" : "j"); // print right corner
    printf(CSI "0m");
    printf(ESC "(B"); // exit line drawing mode
}

void PrintStatusLine(const char* const pszMessage, COORD const Size)
{
    printf(CSI "%d;1H", Size.Y);
    printf(CSI "K"); // clear the line
    printf(pszMessage);
}

int __cdecl wmain(int argc, WCHAR* argv[])
{
    argc; // unused
    argv; // unused
    //First, enable VT mode
    bool fSuccess = EnableVTMode();
    if (!fSuccess)
    {
        printf("Unable to enter VT processing mode. Quitting.\n");
        return -1;
    }
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hOut == INVALID_HANDLE_VALUE)
    {
        printf("Couldn't get the console handle. Quitting.\n");
        return -1;
    }

    CONSOLE_SCREEN_BUFFER_INFO ScreenBufferInfo;
    GetConsoleScreenBufferInfo(hOut, &ScreenBufferInfo);
    COORD Size;
    Size.X = ScreenBufferInfo.srWindow.Right - ScreenBufferInfo.srWindow.Left + 1;
    Size.Y = ScreenBufferInfo.srWindow.Bottom - ScreenBufferInfo.srWindow.Top + 1;

    // Enter the alternate buffer
    printf(CSI "?1049h");

    // Clear screen, tab stops, set, stop at columns 16, 32
    printf(CSI "1;1H");
    printf(CSI "2J"); // Clear screen

    int iNumTabStops = 4; // (0, 20, 40, width)
    printf(CSI "3g"); // clear all tab stops
    printf(CSI "1;20H"); // Move to column 20
    printf(ESC "H"); // set a tab stop

    printf(CSI "1;40H"); // Move to column 40
    printf(ESC "H"); // set a tab stop

    // Set scrolling margins to 3, h-2
    printf(CSI "3;%dr", Size.Y - 2);
    int iNumLines = Size.Y - 4;

    printf(CSI "1;1H");
    printf(CSI "102;30m");
    printf("Windows 10 Anniversary Update - VT Example");
    printf(CSI "0m");

    // Print a top border - Yellow
    printf(CSI "2;1H");
    PrintHorizontalBorder(Size, true);

    // // Print a bottom border
    printf(CSI "%d;1H", Size.Y - 1);
    PrintHorizontalBorder(Size, false);

    wchar_t wch;

    // draw columns
    printf(CSI "3;1H");
    int line = 0;
    for (line = 0; line < iNumLines * iNumTabStops; line++)
    {
        PrintVerticalBorder();
        if (line + 1 != iNumLines * iNumTabStops) // don't advance to next line if this is the last line
            printf("\t"); // advance to next tab stop

    }

    PrintStatusLine("Press any key to see text printed between tab stops.", Size);
    wch = _getwch();

    // Fill columns with output
    printf(CSI "3;1H");
    for (line = 0; line < iNumLines; line++)
    {
        int tab = 0;
        for (tab = 0; tab < iNumTabStops - 1; tab++)
        {
            PrintVerticalBorder();
            printf("line=%d", line);
            printf("\t"); // advance to next tab stop
        }
        PrintVerticalBorder();// print border at right side
        if (line + 1 != iNumLines)
            printf("\t"); // advance to next tab stop, (on the next line)
    }

    PrintStatusLine("Press any key to demonstrate scroll margins", Size);
    wch = _getwch();

    printf(CSI "3;1H");
    for (line = 0; line < iNumLines * 2; line++)
    {
        printf(CSI "K"); // clear the line
        int tab = 0;
        for (tab = 0; tab < iNumTabStops - 1; tab++)
        {
            PrintVerticalBorder();
            printf("line=%d", line);
            printf("\t"); // advance to next tab stop
        }
        PrintVerticalBorder(); // print border at right side
        if (line + 1 != iNumLines * 2)
        {
            printf("\n"); //Advance to next line. If we're at the bottom of the margins, the text will scroll.
            printf("\r"); //return to first col in buffer
        }
    }

    PrintStatusLine("Press any key to exit", Size);
    wch = _getwch();

    // Exit the alternate buffer
    printf(CSI "?1049l");

}