 |  | |
|
| | |
|
| |
Appunti sull'uso della libreria VCL
Indice
Oggetti fondamentali del framework VCL..
Descrizione di alcune classi fondamentali
Una classe fondamentale che è necessario conoscere è TControl.
Da essa infatti sono derivate le seguenti classi che verranno descritte nel presente paragrafo.
Gli attributi di TControl che vengono più spesso utilizzati 929c28j sono i seguenti :
Caption = serve per specificare il nome che comparirà sul controllo
Name = identificatore dell'oggetto all'interno del codice
ShowHint = attiva la visualizzazione dei suggerimenti per l'oggetto
Visible = abilita la visibilità dell'oggetto
Width = larghezza dell'oggetto espressa in pixel
Ve ne sono in realtà molte altre ma al momento ci interessano solo queste.
Per ogni classe derivante da TControl (o da qualsiasi altra classe predefinita da BCB), è necessario verificare la visibilità dei metodi e delle proprietà perchè essa dipende da come sono state ereditate le varie classi all'interno della gerarchia di classi di BCB.
TButton (Palette Standard)
Serve per gestire un semplice pulsante sul form e consente l'accesso a Caption.
Al momento dello sviluppo dell'applicazione è possibile associare una funzione membro della classe form (del form che è in costruzione) alla pressione di un pulsante facendo doppio click su pulsante stesso.
TLabel (Palette Standard)
Serve per visualizzare delle label sul form e consente l'accesso a Caption.
TEdit (Palette Standard)
Può essere usata per gestire semplici input di tipo testo.
La proprietà Text serve per specificare il nome che comparirà nella edit-box alla sua creazione.
TMemo (Palette Standard)
Viene usata per gestire brevi documenti di testo (appunti).
La proprietà Text rappresenta il nome della Memo.
Tramite la proprietà Lines (che è di tipo TStrings) possiamo gestire il testo scritto nell'istanza della classe in uso.
TComboBox (Palette Standard)
Tramite la proprietà Items (di tipo TStrings) è poi possibile sia run-time (con il metodo Add) che in fase di sviluppo, selezionare quali debbano essere le voci della lista nella combo-box.
La proprietà Text contiene la stringa (di tipo AnsiString) selezionata all'interno della ComboBox.
TListBox (Palette Standard)
Tramite la proprietà Items (di tipo TStrings) è poi possibile sia run-time (con il metodo Add) che in fase di sviluppo, selezionare quali debbano essere le voci della lista nella list-box.
Per accedere all'elemento selezionato nella ListBox possiamo usare la proprietà ItemIndex di ListBox unitamente alla proprietà Strings[] di Items.
Possiamo cancellare l'elemento selezionato all'interno dell'elenco tramite la chiamata al metodo DeleleSelected().
TCheckBox (Palette Standard)
Sono fondamentali per l'utilizzo delle istanze di questa classe la proprietà Checked che vale true se il pulsante è selezionato e false in caso contrario, e l'evento OnClick.
In corrispondenza di tale evento infatti è possibile descrivere il comportamento che l'applicazione dovrà avere in seguito al click del mouse sulla checkbox stessa.
La proprietà Caption serve per specificare il nome che comparirà per la check-box sul form.
TMainMenu (Palette Standard)
Serve per inserire menu utente nel form.
Il doppio click sull'oggetto trascinato sul form permette di accedere alla creazione del menu che risulta molto intuitiva e se ne tralascia pertanto la descrizione in questa sede.
TScrollBar (Palette Standard)
Visualizza una barra di scorrimento.
Le proprietà Max e Position servono rispettivamente per settare il valore di fondo scala e il valore intero corrispondente alla posizione assunta dall'indicatore sulla barra stessa.
TStringGrid (Palette Additional)
Serve per gestire strutture dati sotto forma di matrice di stringhe (AnsiString).
Nella proprietà Options troviamo la sottoproprietà GoEditing. Settata a true, questa proprietà permette all'utente di inserire a tempo di esecuzione dei valori all'interno della matrice.
La proprietà Cells (tipo AnsiString) permette di accedere alle celle della griglia facendo uso degli opportuni indici di riga e di colonna nel modo seguente :
StringGrid1->Cells[colonna][riga];
La numerazione delle righe e delle colonne parte da 0.
Il numero totale di righe e colonne di cui la griglia è composta sono contenuti rispettivamente nelle proprietà RowCount e ColCount.
Possiamo anche accedere a colonne o righe intere tramite le proprietà Cols e Rows rispettivamente (entrambe di tipo *TStrings).
TLabeledEdit (Palette Additional)
Questo controllo è l'unione di una TLabel e una TEdit.
Le proprietà e i metodi sono esattamente i medesimi descritti ai punti precedenti, semplicemente unificati in un unico controllo.
La proprietà che permette di accedere alle proprietà della label associata alla edit è EditLabel.
Caption è la proprietà del controllo che specifica la stringa che verrà visualizzata a video in corrispondenza del controllo.
TRadioGroup (Palette Standard)
Questa classe serve per permetter all'utente di fare una scelta fra più alternative.
La proprietà che deve essere usata per la gestione di una istanza della classe TRadioGroup è ItemIndex (come TListBox).
Essa contiene il numero intero corrispondente alla scelta (interna al gruppo) che è stata selezionata. Questo aggiornamento avviene in modo trasparente all'utente.
Tramite la proprietà Items (di tipo TStrings) è poi possibile sia run-time (con il metodo Add) che in fase di sviluppo, selezionare quali debbano essere le voci fra cui poter scegliere all'interno del gruppo di bottoni.
TForm
Color è il colore di sfondo del form.
Per introdurre diversi form all'interno della applicazione è necessario seguire i seguenti passi :
TPanel (Palette Standard)
I pannelli possono proficuamente essere utilizzati per separare diverse sezioni all'interno del medesimo form.
TFrame (Palette Standard)
Il loro utilizzo è molto simile ai pannelli ma a differenza di essi è possibile riutilizzare il medesimo frame in diverse form semplicemente inserendolo in una delle palette previste da BCB.
Inoltre mentre la proprietà Caption di TPanel permette di dare un nome visibile all'utente che sia diverso dall'identificatore del pannello all'interno del codice, TFrame assegna il medesimo nome all'identificatore del frame e al titolo del frame medesimo.
Per i contenitori possono risultare utili le seguenti proprietà :
ControlCount : memorizza il numero di componenti presenti all'interno del pannello
Può risultare utile la seguente riga di codice, che permette di accedere ai bottoni del contenitore Panel1 via indice :
TButton* B = dynamic_cast<TButton*>(Panel1->Controls[i]);
(gentile suggerimento del Prof. Conti Maurizio)
Un altro utilizzo abbastanza utile è quello di usare il contenitore per far apparire e scomparire a comando dell'utente tutti i controlli posizionati su esso. Questo può essere fatto semplicemente settando a false
la proprietà Visibile del contenitore.
TTimer (Palette System)
Questa classe risulta fondamentale nella gestione del sincronismo all'interno dell'appliczione.
Semplicemente associando una funzione all'evento OnTimer è possibile eseguire periodicamente delle istruzioni.
TTimer si differenzia da tutte le altre perché un'istanza di questa classe non determina alcun elemento grafico sul form a tempo di esecuzione.
La proprietà fondamentali che dobbiamo gestire è Interval la quale scandisce il tempo in ms che trascorrre fra due occorrenze diverse dell'evento OnTimer().
TOpenDialog / TSaveDialog (Palette Dialogs)
Richiamando il metodo Execute() di TOpenDialog (risp. TSaveDialog) viene aperta la finestra standard di Windows per aprire (risp. salvare) un file.
Le proprietà che possono risultare interessanti sono le seguenti :
Title : (tipo AnsiString)specifica il titolo della finestra di dialogo che viene aperta
Filter : (tipo AnsiString) specifica quali file debbano essere visualizzati.
La stringa assegnata a Filter è composta nel modo seguente : prima del pipe ("|") si specifica la scritta di informazione che viene comunicata all'utente nella finestra di dialogo aperta, la parte dopo il pipe specifica quali tipi di file debbano effettivamente essere elencati. Qualora si volesse visualizzare più formati sarebbe necessario separarli da ";" :
OpenDialog1->Filter="File di testo | *.txt ;*.pdf ;*.doc ;*.rtf";
Possiamo combinare i filtri nel modo seguente :
OpenDialog1->Filter="Testo semplice | *.txt ;*.rtf |Testo complesso |*.doc; *.pdf";
Le cartelle vengono comunque visualizzate.
FileName (tipo AnsiString) : e' il nome del file selezionato dall'utente quando ha chiuso la finestra
di dialogo premendo il pulsante OK.
TFontDialog (Palette Dialogs)
Richiamando il metodo Execute() di TFontDialog viene aperta una finestra standard di Windows per la gestione dei caratteri.
Quando l'utente preme OK in tale finestra Execute() ritorna il valore true e le informazioni di rappresentazione del carattere vengno memorizzate nella proprietà Font di TFontDialog.
Per assegnare le caratteristiche specificate nella finestra di dialogo a Label1 possiamo pertanto scrivere quanto segue :
Label1->Font=FontDialog1->Font;
Quando l'utente preme CANCEL nella finestra di dialogo Execute() ritorna il valore false.
TColorDialog (Dialogs)
Richiamando il metodo Execute() di TColorDialog viene aperta una finestra standard di Windows per la gestione dei colori.
Quando l'utente preme OK in tale finestra Execute() ritorna il valore true e le informazioni riguardanti il colore vengno memorizzate nella proprietà Color di TColorDialog.
Per assegnare le caratteristiche specificate nella finestra di dialogo a Label1 possiamo pertanto scrivere quanto segue :
Label1->Color=ColorDialog1->Color;
Quando l'utente preme CANCEL nella finestra di dialogo Execute() ritorna il valore false.
Alcune classi che è certamente bene conoscere perché di uso assai frequente sono AnsiString e TStrings.
Questa classe serve a gestire delle stringhe in modo dinamico e trasparente all'utente.
I caratteri che memorizza possono essere solamente quelli del codice ASCII (ANSI) standard, che usa 8 bit per la codifica di un carattere.
Possiamo ricordare i seguenti metodi :
confronta
restituisce la posizione della sottostringa substr indicata all'interno della AnsiString
converte un valore float in una stringa secondo vari parametri opzionali
inserisce la stringa str nella posizione Index
restituisce la lunghezza della stringa
converte la stringa nel tipo double
converte la stringa nel tipo int
come ToInt() ma restituisce il valore default se la stringa non è interpretabile come intero
Possiamo manipolare le varie istanze della classe AnsiString mediante i seguenti operatori con evidente significato di simboli :
|
|
|
|
|
|
|
|
< |
<= |
> |
>= |
L'unica nota che si ritiene utile in questa sede è quella relativa all'uso dell'operatore [].
Esso serve per accedere all'i-esimo carattere della stringa, contando i caratteri a partire da 1 (non da 0).
Così ad esempio è possibile usare le seguenti istruzioni per visualizzare in una finestra standard di Windows i caratteri che compongono una stringa scritta dall'utente all'interno della casella di testo Edit1 :
for(int i=1;i<=Edit1->Text.Length();i++)
ShowMessage((AnsiString)Edit1->Text[i]);
E' la classe base per manipolare una lista di stringhe.
Le proprietà fondamentali della classe sono le seguenti :
conta gli elementi che compongono l'elenco delle strighe.
serve per accedere alla stringa (già esistente) di indice Index all'interno dell'elenco. La prima ha indice 0.
I metodi fondamentali sono i seguenti :
inserisce una nuova stringa all'interno dell'elenco
aggiunge un elenco al'elenco
funzionamento identico a Add ma non ritorna la posizione di indice dell'ultima stringa inserita
cancella tutte le stringhe presenti nell'elenco
cancella la stringa di indice Index
ritorna l'indice della stringa str all'interno dell'elenco
inserisce la stringa str nella posizione Index
carica nella TStrings corrente il contenuto del file specificato con NomeFile
salva il contenuto della TStrings corrente nel file specificato con NomeFile
La presente collezione di esercizi non ha lo scopo di risultare esaustiva ma semplicemente esemplificativa dell'utilizzo dei componenti descritti precedentemente.
Si precisa che la soluzione presentata non è "la migliore", anzi eventuali suggerimenti sono certamente ben accettati.
Si raccomanda però di sforzarsi di risolvere i problemi prima di leggere la soluzione che deve essere vista nell'ottica di un confronto costruttivo fra metodologie di programmazione, non come un sistema per avere "una soluzione per ogni caso". Tale tentativo sarebbe infatti sterile tenendo conto della vasta casistica di esercizi che anche solo con l'ausilio dei componenti di base è possibile realizzare.
Costruire un form che permetta di gestire due Memo secondo le seguenti specifiche :
Prevedere inoltre la chiusura della form tramite voce di un menu utente.
Soluzione:
Unit1.h
#ifndef Unit1H
#define Unit1H
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Dialogs.hpp>
class TForm1 : public TForm
extern PACKAGE TForm1 *Form1;
#endif
Unit1.cpp
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::CopiaClick( TObject *Sender )
void __fastcall TForm1::ApriClick( TObject *Sender )
void __fastcall TForm1::SalvaClick( TObject *Sender )
Realizzare un form che assegnato un testo ne esegua lo shift verso destra o verso sinistra a discrezione dell'utente di un numero di caratteri scelto sempre a discrezione dell'utente.
Soluzione:
Unit1.h
#ifndef Unit1H
#define Unit1H
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
class TForm1 : public TForm
extern PACKAGE TForm1 *Form1;
#endif
Unit1.cpp
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::Button1Click(TObject *Sender)
Str[1]=aux;
}//fine singola rotazione a destra
else
Str[lunghezza]=aux;
}//fine else
}//fine rotazione
Label1->Caption=Str;
Realizzare il prodotto "riga*colonna" e la somma (algebrica) di due matrici assegnate dall'utente a tempo di esecuzione.
Soluzione:
Unit1.h
#ifndef Unit1H
#define Unit1H
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Grids.hpp>
#include <ExtCtrls.hpp>
#include <Menus.hpp>
class TForm1 : public TForm
extern PACKAGE TForm1 *Form1;
#endif
Unit1.cpp
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::CalcolaProdotto(TObject *Sender)
void __fastcall TForm1::CalcolaSomma(TObject *Sender)
void __fastcall TForm1::Chiudi1Click(TObject *Sender)
ESERCIZIO 4
Realizzare un form che permetta di inserire stringhe all'interno a una memo attraverso il solo utilizzo di una casella di testo.
Si preveda inoltre la possibilità di cancellare singolarmente le stringhe inserite, di cambiare il colore di sfondo della memo e di chiudere il form tramite la pressione di un pulsante.
Soluzione:
Unit1.h
#ifndef MemoH
#define MemoH
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Dialogs.hpp>
class TForm1 : public TForm
extern PACKAGE TForm1 *Form1;
#endif
Unit1.cpp
#include <vcl.h>
#pragma hdrstop
#include "Memo.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner)
void __fastcall TForm1::InsertClick(TObject *Sender)
//-------- ----- ------ -------- ----- ------ ----- ----- --------- ----- --------void __fastcall TForm1::DeleteClick(TObject *Sender)
void __fastcall TForm1::ColorClick(TObject *Sender)
void __fastcall TForm1::ExitClick(TObject *Sender)
Inserire elementi all'interno di una lista di stringhe tramite una casella di testo e la pressione di un pulsante.
Devono inoltre essere previste la funzionalità di saluto tramite una finestra di messaggio di Windows della stringa selezionata nella lista (se nessuna stringa è selezionata non deve essere visualizzata alcuna finestra) e la cancellazione delle stringhe.
La cancellazione deve avvenire nel modo seguente: se viene selezionata una voce nella lista tale voce dovrà essere selezionata indipendentemente dal contenuto della casella di testo mentre se non è selezionata alcuna stringa della lista dovrà essere cancellata la stringa presente nella casella di testo.
Soluzione:
Unit1.h
#ifndef Src_ListBoxH
#define Src_ListBoxH
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
class TForm1 : public TForm
extern PACKAGE TForm1 *Form1;
#endif
Unit1.cpp
#include <vcl.h>
#pragma hdrstop
#include "Src_ListBox.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)
void __fastcall TForm1::Button1Click(TObject *Sender)
void __fastcall TForm1::InserisciClick(TObject *Sender)
void __fastcall TForm1::CancellaClick(TObject *Sender)
Realizzare una applicazione che permetta di inserire stringhe all'interno di una lista a combinazione.
Alla pressione del pulsante opportuno deve essere visualizzata una finestra di Windows che contiene un saluto alla stringa selezionata nella lista.
Prevedere inoltre un pulsante, che sempre attraverso una finestra standard di Windows, permetta di visualizzare il numero corrente di elementi presenti nella lista.
Soluzione:
Unit1.h
#ifndef Src_ComboBoxH
#define Src_ComboBoxH
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
class TForm1 : public TForm
extern PACKAGE TForm1 *Form1;
#endif
Unit1.cpp
#include <vcl.h>
#pragma hdrstop
#include "Src_ComboBox.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::Button1Click(TObject *Sender)
void __fastcall TForm1::Button3Click(TObject *Sender)
void __fastcall TForm1::Button2Click(TObject *Sender)
Costruire una applicazione Windows che permetta di visualizzare alternativamente 3 pannelli ognuno dei quali presenta il proprio nome e il contatore di accessi ad esso.
Si preveda inoltre un pulsante che consenta di modificare il font del contatore stesso all'interno dei tre pannelli. Si supponga che lo stesso tipo di font scelto dall'utente venga poi assegnato ai tre contatori.
Soluzione:
Unit1.h
#ifndef Unit1H
#define Unit1H
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include <Dialogs.hpp>
class TForm1 : public TForm
extern PACKAGE TForm1 *Form1;
#endif
Unit1.cpp
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::RadioGroup1Click(TObject *Sender)
//fine switch
void __fastcall TForm1::TipoFontClick(TObject *Sender)
Elaborare una applicazione Windows che permetta di settare il colore dello sfondo o del testo di una label alternativamente mediante 3 barre di scorrimento associate alle componenti RGB del colore medesimo.
Soluzione:
Unit1.h
#ifndef Unit1H
#define Unit1H
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
class TForm1 : public TForm
extern PACKAGE TForm1 *Form1;
#endif
Unit1.cpp
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::CambiaColore(TObject *Sender)
//fine switch
GESTIONE DI TASTIERA E MOUSE
Considereremo i seguenti fondamentali eventi nella gestione di mouse e tastiera tramite BCB:
E' importante notare subito che l'evento viene rilevato solamente se avviene quando la finestra (o il controllo se l'evento è previsto anche per un controllo) è attiva (o attivo).
Per intercettare l'evento in ogni caso è necessario fare uso delle API di Windows (vedi HOOK di Windows).
Analizziamo separatamente le intestazioni di definizione di funzioni associate agli eventi corrispondenti.
Notiamo anzitutto che a tutte le member function seguenti viene passato un puntatore che permetta alla member function stessa di accedere alle proprietà e ai metodi dell'oggetto che la ha richiamata (TObject *Sender
Intestazione:
void __fastcall TForm1::ClickSingolo(TObject *Sender)
Richiamata alla pressione del tasto sinistro del mouse. Ha il vantaggio di essere molto semplice ma assai poco flessibile, pertanto è sconsigliabile se l'applicazione richiede un certo grado di controllo.
Intestazione:
void __fastcall (__closure *TMouseMoveEvent)( System::TObject* Sender,
Classes::TShiftState Shift,
int X,
int Y
Richiamata quando il puntatore del mouse viene mosso sul controllo.
Permette di risalire alle seguenti informazioni:
Intestazione:
void __fastcall TForm1::MouseDown( TObject *Sender,
TMouseButton Button,
TShiftState Shift,
int X,
int Y
Richiamata alla pressione di un tasto del mouse quando il puntatore del mouse è sul controllo, permette di risalire alle seguenti informazioni:
Occurs when the user releases a mouse button that was pressed with the mouse pointer over a component.
void __fastcall (__closure *TMouseEvent)(
System::TObject* Sender,
TMouseButton Button,
Classes::TShiftState Shift,
int X, int Y
Richiamata al rilascio di un tasto del mouse quando il puntatore del mouse è sul controllo, permette di risalire alle seguenti informazioni:
Intestazione:
void __fastcall TForm1::PulsantePremuto(TObject *Sender, char &Key)
Viene richiamata quando viene premuto un tasto della tastiera al quale sia associato un codice ASCII.
Key specifica il caratere ASCII del tasto premuto sulla tastiera.
Intestazione:
void __fastcall TForm1::PulsanteAbbassato( TObject *Sender,
WORD &Key,
TShiftState Shift
Viene richiamata quando viene premuto un tasto qualsiasi (della tastiera o del mouse) e permette di risalire alle seguenti informazioni :
Il codice virtuale dei tasti può essere ottenuto tramite la guida di C++ Builder ed essendo tali codici di tipo enumerativo, è possibile utilizzarli all'interno di uno blocco switch (ad esempio) per facilitarne l'uso.
I codici virtuali sono tutti codificati in un formato del tipo VK_TASTO.
Ad esempio, il codice virtuale di alcuni tasti è riportato nella tabella seguente:
|
Tasto sulla tastiera |
Codice tasto virtuale |
|
freccia direzionale in alto |
VK_UP |
|
freccia direzionale in basso |
VK_DOWN |
|
freccia direzionale a destra |
VK_RIGHT |
|
freccia direzionale a sinistra |
VK_LEFT |
|
tasto HOME |
VK_HOME |
|
tasto END |
VK_END |
|
tasto funzione F1 |
VK_F1 |
|
Pulsante sinistro del mouse |
VK_LBUTTON |
|
Pulsante destro del mouse |
VK_RBUTTON |
|
Numero 1 sul tastierino numerico |
VK_NUMPAD1 |
Per i caratteri del codice ASCII il codice
virtuale corrisponde al codice ASCII stesso (ad esempio il tasto "
A titolo di completezza, per autonomia nella verifica delle informazioni date sino ad ora si riporta di seguito la tabella dei codici ASCII:
|
Privacy |
Articolo informazione
Commentare questo articolo:Non sei registratoDevi essere registrato per commentare ISCRIVITI |
Copiare il codice nella pagina web del tuo sito. |
Copyright InfTub.com 2024
