Ego programmo ergo sum

Generare numeri casuali con Qt

2010-08-19T19:43:00.028+02:00

Come si generano numeri a caso usando Qt ?

Eccovi un piccolo gadget che premendo un pulsante genera dei numeri casuali e li visualizza in una casella di testo.

Già che mi trovavo gliene ho fatti generare sei, così potremo anche tentare la fortuna di tanto i tanto, hai visto mai ...

-------------------------

Questa opera è pubblicata sotto una Licenza Creative Commons.

Tutto quello che viene pubblicato in questo Blog è rilasciato sotto licenza Creative Commons Attribuzione-Non commerciale-Condividi allo stesso modo 2.5 Italia

ovvero, in sintesi:

- puoi liberamente modificare, distribuire, esporre in pubblico tutto ciò che è presente in questo Blog

- non puoi usare i contenuti del Blog per scopi commerciali

- devi citare l'autore: Franco Babbo - bytewalker su egoprogrammo.blogspot.com

- devi condividerlo allo stesso modo.

per altre informazioni:

http://creativecommons.org/licenses/by-nc-sa/2.5/it/

------------------------------

Senza dilungarmi troppo riporto direttamente i file di interfaccia ed implementazione della classe principale.

Se avete seguito i post precedenti non dovreste avere problemi a creare un proggetto e quindi un applicazione funzionante con Qt SDK.

Per qualsiasi dubbio, comunque, "non siate timidi" e contattatemi.

Ciao,
Franco.

finestraprincipale.h
---------------------------------

#ifndef FINESTRAPRINCIPALE_H
#define FINESTRAPRINCIPALE_H

#include <QWidget>
#include <QTime>

namespace Ui {
    class FinestraPrincipale;
}

class FinestraPrincipale : public QWidget
{
    Q_OBJECT

public:
    explicit FinestraPrincipale(QWidget *parent = 0);
    ~FinestraPrincipale();

public slots:
   void on_estraipushButton_clicked();

protected:
    void changeEvent(QEvent *e);

private:
    Ui::FinestraPrincipale *ui;
};

#endif // FINESTRAPRINCIPALE_H

---------------------------------

finestraprincipale.cpp
---------------------------------

#include "finestraprincipale.h"
#include "ui_finestraprincipale.h"

FinestraPrincipale::FinestraPrincipale(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::FinestraPrincipale)
{
    ui->setupUi(this);
}

FinestraPrincipale::~FinestraPrincipale()
{
    delete ui;
}

void FinestraPrincipale::on_estraipushButton_clicked()
{
    //inizializzo il generatore di numeri casuali
    QTime midnight(0,0,0);
    qsrand(midnight.secsTo(QTime::currentTime()));

    int n;
    QString testo="";

    ui->estrazionelineEdit->setText(testo);

    //genero sei numeri casuali da 1 a 90
    //e li concateno in una stringa di testo
    for(int i=0;i<6;i++)
    {
        n = 1+ qrand() % 90;
        testo+=QString::number(n);
        testo+=" ";
    }

    //stampo la stringa così ottenuta
    ui->estrazionelineEdit->setText(testo);;
}

void FinestraPrincipale::changeEvent(QEvent *e)
{
    QWidget::changeEvent(e);
    switch (e->type()) {
    case QEvent::LanguageChange:
        ui->retranslateUi(this);
        break;
    default:
        break;
    }
}
---------------------------------

Hello World: l'evoluzione della specie !! Parte 4 ... dispositivi mobili - codice sorgente

2010-08-10T12:37:00.002+02:00

Con l'esempio di programmazione di oggi svilupperemo una piccola applicazione che gira sulle seguenti piattaforme:

- Linux Desktop

- Maemo 5 su N900

-------------------------

Questa opera è pubblicata sotto una Licenza Creative Commons.

Tutto quello che viene pubblicato in questo Blog è rilasciato sotto licenza Creative Commons Attribuzione-Non commerciale-Condividi allo stesso modo 2.5 Italia

ovvero, in sintesi:

- puoi liberamente modificare, distribuire, esporre in pubblico tutto ciò che è presente in questo Blog

- non puoi usare i contenuti del Blog per scopi commerciali

- devi citare l'autore: Franco Babbo - bytewalker su egoprogrammo.blogspot.com

- devi condividerlo allo stesso modo.

per altre informazioni:

http://creativecommons.org/licenses/by-nc-sa/2.5/it/

------------------------------

Tenete presente, comunque, che sebbene il codice sia praticamente lo stesso e funzioni perfettamente in entrambi gli ambienti, questo esempio è ottimizzato per il dispositivo mobile e non per il desktop.

Si tratta del caro vecchio Hello World con l'aggiunta di un pulsante, tanto per fare un passetto avanti nella programmazione.

Una avvertenza: dato che questo blog è attualmente ancora neonato non ho la benchè minima idea di quale sia o sarà la tipologia di lettori (anche se qualcuno ha già mostrato interesse e di questo ringranzio molto).

Darò quindi per scontate, per il momento, parecchie cose, come se chi mi sta leggendo abbia tutto, o quasi, lo skill necessario con i tool di sviluppo che usati.

Tuttavia, dato che alcuni di tali tool possono non essere comunissimi (Mad Developer ad esempio) mi rendo conto che questo può disorientare.

Quindi se volete realizzare questo programma e avete dei dubbi NON ESITATE A CHIEDERE (non siate timidi come recita il gadget :-)

Se date un'occhiata ai post precedenti troverete tutti i particolari sull'ambiente operativo e sui tool di sviluppo usati.

>Lanciate Qt Creator SDK.

Fate:

> File -> New File or Project -> Mobile Qt Application -> OK
> Name: scrivete HelloWorld
> Setup Target: Selezionate tutto
> Class Information: scegliete
Class Name = HelloClass
Base Class = QWidget

A questo punto:

- è stata creata una nuova directory HelloMaemo
- sono stati creati quattro file:

helloworld.h    (interfaccia della classe HelloClass)
helloworld.cpp    (implementazione della classe HelloClass)
main.cpp            (applicazione della classe HelloClass)
helloworld.ui       (la nostra form)

date un occhiata al filesystem così vi rendete conto meglio.

Siete entrati nell'ambiente di svilppo. Conto molto sulla vostra capacità di trovare gli oggetti cui farò riferimento senza che mi dilunghi troppo in descrizioni. Si trovano nelle solite barre dei menù e pannelli vari del vostro SDK.

> Aprite la cartella Forms
> Doppio click su hellohelloworld.ui

Vedrete una form vuota. Se date un'occhiata alle proprietà (barra a destra) noterete che è 800x480. Dato che corrisponde proprio alla risoluzione del terminale mobile può sembrare ottimale ma non è così perché questa impostazione non tiene conto della barra del titolo. Comunque di questo parleremo un'altra volta, per ora lasciate così (semmai fate delle prove per divertirvi a vedere cosa succede ma sappiate che ci sono delle misure precise di cui tenere conto).

Trascinando i vari oggetti (da sinistra a destra sulla form):

> Aggiungete un pulsante (pushButton)
> Aggiungete una casella di testo (lineEdit)

Nella barra laterale sinistra, in basso, noterete l'iconcina di un computer. Cliccando avrete l'opportunità di selezionare il target della compilazioe scegliendo tra Desktop, Simulatore, Dispositivo Remoto

> Selezionate il target "Qt Simulator"
> Fate Build -> Run qmake

E' stata creata una cartella HelloWorld-Build-Simulator con dentro il Makefile (potete controllare con esplora risorse o quel che è).

> Fate Build -> Build project HelloWorld

Sono stati aggiunti i file:

HelloWorld       (eseguibile)
ui_hellohelloworld.h    (interfaccia oggetti form)
main.o    (file oggetto dell'applicazione)
helloclass.o               (flie oggetto della classe)
moc_helloclass.o       (fle oggetto del moc "meta object compiler)
moc_helloclass.cpp    (codice del moc)

date un occhiata per sincerarvene.

> Provate a dare il run (tasto verde play)

Il simulatore viene lanciato (bello vero?) e dentro potrete ammirare la vostra form. Ovviamente se premete il pulsante non succede un accidente. Infatti dobbiamo aggiungere le SLOT (è così che Qt chiama le care vecchie funzioni).

> Nel file helloclass.h aggiungete le due seguenti righe di codice:

private slots:
void on_pushButton_clicked();

subito prima della parentesi graffa di chiusura.

> Nel file helloclass.cpp aggiungete il seguente codice

void HelloClass:n_pushButton_clicked()
{
     ui->lineEdit->setText("Hello World !!");
}

in fondo al file, dopo tutto quello che vedete.

> Lanciate con il tasto play il simulatore.
> Premete il pulsante e nella casellina di testo stavolt apparirà "Hello World !!"

> Tornate alla form, se volete, ed aggiustate le dimensioni degli oggetti a vosto piacimento.

Adeso viene il bello.

> Accendete l'interfaccia Wi-Fi del N900 e del computer se non lo è già.
> Lanciate Mad Developer

> Impostate la password in Qt

> In Qt selezionate come target Maemo Device
> Lanciate la compilazione ed il Run Cliccando play

> La vostra applicazione sta girando su N900 !

Alla prossima ....

Hello World: l'evoluzione della specie !! Parte 3 ... dispositivi mobili - l'ambiente di sviluppo

2010-08-09T12:59:00.004+02:00

Volete creare un'applicazione per dispositivi mobili basati su Maemo 5 o Symbian? Siete capitati nel post(o) giusto!

-------------------------

Questa opera è pubblicata sotto una Licenza Creative Commons.

Tutto quello che viene pubblicato in questo Blog è rilasciato sotto licenza Creative Commons Attribuzione-Non commerciale-Condividi allo stesso modo 2.5 Italia

ovvero, in sintesi:

- puoi liberamente modificare, distribuire, esporre in pubblico tutto ciò che è presente in questo Blog

- non puoi usare i contenuti del Blog per scopi commerciali

- devi citare l'autore: Franco Babbo - bytewalker su egoprogrammo.blogspot.com

- devi condividerlo allo stesso modo.

per altre informazioni:

http://creativecommons.org/licenses/by-nc-sa/2.5/it/

----------------------------------------------------------------

Come probabilmente saprete, visto che vi interessano i dispositivi mobili, Maemo 5 è la release di una versione Linux Debian attualmente usata sul tablet N900.

Da non molto è stata rilasciata la nuova release denominata Meego (non Maemo 6) ed è molto promettente visto che l'intento è quello di rendere questo sistema operativo adatto a praticamente tutti i dispositivi mobili (tablet, netbook, smartphone e persino navigatori).

Ad ogni modo tutti gli esempi che riporterò saranno basati su Maemo 5 e testati su N900 che, attualmente, è l'unico dispositvo che lo supporta. C'è da scommettere comunque che le tecniche ed i procedimenti di cui faremo uso saranno facilmente adattabili ai diversi terminali che "discenderanno" in qualche modo da Maemo.

Fino a qualche mese fa sviluppare applicazioni Maemo non era proprio agevole. Occorreva installare un'ambiente operativo ospite (la scratchbox) all'interno di Linux (meglio se Debian like, tipo Ubuntu), scrivere il codice, compilarlo, lanciare a mano il server grafico per far girare il simulatore del dispositivo, compilare il programma e finalmente vederlo in azione.

Da non moltissimo, per fortuna, è stata rilasciata una versione di Qt Creator che integra anche un simulatore per N900 e altri dispositivi basati su Symbian.

I vari esempi che presenterò sono stati sviluppati usando la seguente versione:

Qt Creator 1.3.83
Based on Qt 4.7.0 (32 bit)
Built on Apr 22 2010 at 12:07:43

Praticamente un Qt 4.7 con la possibilità di sviluppare applicativi Desktop e mobili (Maemo 5 e Symbian), di testarli con un simulatore e soprattutto di inviarli al dispositivo e farli girare.

La cosa interessante è che si tratta di un SDK multipiattaforma e pertanto, se scaricate la versione per il vostro sistema operativo, è possibile sviluppare applicazioni Desktop adatte ad ambienti non Linux senza "soffrire" più di tanto.

Per poter testare le vostre applicazioni su N900 dovete anche scaricare ed installare un software per il vostro dispositivo mobile: Mad Developer, che semplifica enormemente tutte le operazioni di invio file e lancio delle applicazioni.

Non ho mai provato con dispositivi Symbian ma, che io sappia, in questo caso dovete trasferire e lanciare a mano l'eseguibile sul vostro terminale.

Ora siamo pronti per creare insieme la nostra prima applicazione mobile.

Al prossimo post ...

Hello World: l'evoluzione della specie !! Parte 2 ... il codice

2010-08-05T13:16:00.008+02:00

Questa opera è pubblicata sotto una Licenza Creative Commons.

Tutto quello che viene pubblicato in questo Blog è rilasciato sotto licenza Creative Commons Attribuzione-Non commerciale-Condividi allo stesso modo 2.5 Italia

ovvero, in sintesi:

- puoi liberamente modificare, distribuire, esporre in pubblico tutto ciò che è presente in

questo Blog

- non puoi usare i contenuti del Blog per scopi commerciali

- devi citare l'autore: Franco Babbo - bytewalker su egoprogrammo.blogspot.com

- devi condividerlo allo stesso modo.

per altre informazioni:

http://creativecommons.org/licenses/by-nc-sa/2.5/it/

Benvenuti nella seconda parte di “Hello World”: l'evoluzione della specie.
(terzo post in ordine cronologico)

Al solito una piccola premessa. Lo so che non vedete l'ora di iniziare a programmare, ma penso sia utile soffermarci un attimo, proprio per non perdere tempo dopo. Infatti le poche precisazioni che seguono mi permetteranno di non ripetermi troppo spesso.

Tutti gli esempi sono stati sviluppati nel seguente ambiente operativo e con le seguenti modalità.

Sistema operativo:
Linux Ubuntu 10.04 - Lucid Lynx - rilasciata nell'aprile 2010 e supportata fino ad aprile 2013

Compilatore:
g++ (Ubuntu 4.4.3-4ubuntu5) 4.4.3

Editor:
Ho usato sempre l'editor installato nell'SDK ...

Qt Creator 1.3.1
Based on Qt 4.6.2 (32 bit)
Built on Mar 10 2010 at 19:53:55

... ma anche gedit (con gli opportuni settaggi per l'evidenziazione del codice sorgente) andrà benissimo.
Ovviamente potete usare qualunque altro editor di vostro gradimento, a seconda anche del sistema operativo che stato usando, purchè generi testo semplice (altrimenti il compilatore si arrabbia).

Nomi di file, directory e classi: ovviamente potete usare i nomi che preferite ma tenete presente che devono essere coerenti tra loro se fanno parte di un progetto.

Andiamo ad incominciare ...

hello1

Ecco il codice sorgente:
----------------------------------------
//Semplice Hello World modalità testo

#include
using namespace std;

int main(int argc, char *argv[])
{
cout << "Hello World!!" << endl;
return 0;
}
----------------------------------------

Ed ecco le istruzioni per compilarlo:
- create una cartella tanto per mantenere un po d'ordine: Hello1
- create un file di testo e chiamatelo hello1.cpp
- aprite la console e spostatevi sotto la directory Hello1
- lanciate il compilatore: g++ -o hello1 hello1.cpp
- date il comando ls noterete che oltre al file sorgente hello1.cpp è stato creato il file eseguibile hello1
- lanciatelo con il comando ./hello osserverete il messaggio “Hello World!!” in console

hello2

Ecco il codice:

------------------------------------------

//dimostrazione di un semplice Hello World grafico con le librerie Qt #include
#include

int main(int argc, char *argv[])
{
QApplication a(argc, argv);

QLabel *hello_label = new QLabel("Hello World!!");

hello_label->show();

return a.exec();

}
--------------------------------------------

Istuzioni per la compilazione:

- create una directory Hello2
- create un file hello2.cpp e copiate il codice
- andate sotto la directory Hello2
- fate ls per dare un occhiata ai file, ovviamente per ora c'è solo hello2.cpp
- date il comando qmake -project
- fate ls: è stato creato il file hello2.pro
- date il comando qmake Hello2.pro (occhio a maiuscole / minuscole, il file ha il nome della directory)
- è stato creato il file MakeFile che contiene le direttive necessarie al compilatore per creare il vostro eseguibile
- date il comando make
- con ls noterete che sono stati creati i file Hello2.o ed Hello2 (che è il vostro eseguibile)
- lanciatelo con ./Hello2

apparirà la finestra (con il messaggio “Hello World!!”); ridimensionatela se necessario
Noterete che è una finestra molto semplice, ritagliata intorno al testo Hello World!! Questo perchè è priva di Layout; ne parleremo in seguito.

hello3

Stavolta usremo solo Qt, senza mai (necessariamente) usare la console.
- aprite Qt creator
- fate File --> New File or Project
- selezionate Qt 4 Gui Application
- scrivete il nome del proggetto: Hello3 e selezionate la directory che preferite
- fate Next
- lasciate inalterate le scelte in Select Required Modules e proseguite
- scrivete come nome di classe HelloClass e selezionate come Base Class “Qwidget”
- NOTA: osservate i nomi dei file header, sorgente e form
- fate Next
- fate Finish

A questo punto sarà stata creata una directoy nella posizione da voi scelta chiamata Hello3. Nella directory trovano posto i tre file di cui sopra più il file Hello3.pro creato anch'esso da Qt.

- aprite la cartella Forms (dentro Qt creator non dal vostro file manager)
- fate doppio click su helloclass.ui
- noterete una finestra vuota pronta per essere riempita di widget
- trascinate, dalla barra a sinistra, il widget TextLabel sulla Form a destra
- fate doppio click nella label e scrivete Hello World !! (o quello che vi pare)
- dalla barra dei Menù fate Build --> Run qmake
- NOTA: se date un occhiata al filesystem noterete che è stato aggiunto il MakeFile
- adesso fate Build --> Build Hello3.pro
- noterete che sono stati aggiunti numersi altri file: helloclass.o, main.o, moc_helloclass.o, Hello3.o, moc_helloclass.cpp e sopratutto il nostro eseguibile Hello3
- fate doppio click su Hello3 ed avrete la vostra finestra con relativo saluto

Di tutti questi file di progetto discuteremo in un secondo tempo. Per notate solo che:
- non avete scritto una riga di codice
- la finestra è più grande rispetto ad Hello2, ha la misura che avete scelto (o avreste potuto scegliere) dentro Qt usando il mouse.

Ma dei diversi aspetti dei programmi che abbiamo svilppato parleremo un'altra volta.

Per ora Buon divertimento ...

Hello World: l'evoluzione della specie !! Parte 1 - introduzione

2010-08-03T23:07:00.004+02:00

Questa opera è pubblicata sotto una Licenza Creative Commons.

Tutto quello che viene pubblicato in questo Blog è rilasciato sotto licenza Creative Commons Attribuzione-Non commerciale-Condividi allo stesso modo 2.5 Italia

ovvero, in sintesi:

- puoi liberamente modificare, distribuire, esporre in pubblico tutto ciò che è presente in

questo Blog

- non puoi usare i contenuti del Blog per scopi commerciali

- devi citare l'autore: Franco Babbo - bytewalker su egoprogrammo.blogspot.com

- devi condividerlo allo stesso modo.

per altre informazioni:

http://creativecommons.org/licenses/by-nc-sa/2.5/it/

Nella serie di post che seguono mostrerò come implementare il classico

"Hello World!!"

usando diverse tecniche di programmazione, tutte basate sul C++.

In particolare:
hello1.cpp: scritto con un quasiasi editor di testo, compilato da prompt, fornisce un output in console
hello2.cpp: scritto con un quasiasi editor di testo, compilato da prompt, fornisce un output grafico
hello3.cpp: scritto e compilato attraverso un SDK, fornisce un output grafico

Ci sono diversi motivi per cui ho deciso di fornire questi esempi.

1. Chi si avvicina per la prima volta al C++ troverà in un colpo solo, per quanto molto semplici, tre esempi funzionanti con cui smanettare, con le relative procedure per testarli sulle proprie macchine, che vanno dalla semplice modalità testo all'interfaccia grafica evoluta.

2. Visti come sequenza temporale potrebbero rappresentare un escursus storico dai tempi in cui era possibile solo I/O in modalità testo fino ai giorni nostri quando, tipicamente, l'interazione con l'utente avviene attraverso interfacce grafiche molto evolute.

3. La conoscenza dello sviluppo in modalità testo, sebbene possa (erroneamente) essere ritenuta antiquata, permette di conoscere dettagli sull'implemantazione del codice che potrebbero sfuggire quando si usano ambienti di sviluppo evoluti tipo SDK.

4. La modaità testo e quella grafica sono parimenti importanti ma di questo potremo discutere in un altro post

Ai prossimi post per lo sviluppo del codice ...

Di cosa parleremo ...

2010-08-01T12:32:00.006+02:00

... di programmazione, ovviamente.

In particolare cercherò, nei post che seguono, di fornire qualche indicazione, spero utile, per creare programmi adatti sia al mondo Desktop che a quello dei dispositivi mobili.

Nel fare questo, però, mi piacerebbe mostrare mostrare, di volta in volta (o sarebbe più opportuno dire "di tanto in tanto") come si possano costruire programmi con funzionalità simili sia servendosi della cara vecchia "console", a forza di click - click sulla tastiera, sia a colpi di mouse trascinando quà e là per il monitor gli oggetti che costituiscono le nostre finestre.

Vorrei dire la mia sulla utilità delle diverse tecniche di programmazione, fermo restando il fatto che entrambe presentano i loro vantaggi e svantaggi.
Soprattutto mi piacerebbe discutere (non dico sfatare perchè, appunto, sono solo opinioni personali) sull'idea spesso diffusa che la programmazione "da prompt" appartenga al passato e tutto il resto al futuro.

Avete presente lo schemino degli insiemi che si interscano? Bene penso che viaggeremo spesso "nell'area tratteggiata", per scoprire cosa i due mondi hanno in comune, navigando a volte verso l'uno, a volte verso l'altro emisfero, a seconda di come ci trascinerà la corrente, senza allontanarci troppo però, che non vorrei perdermi ... in chiacchiere.

Permettetemi comunque, prima di iniziare, giusto qualche altra piccola precisazione:

-----------------------------------------------------------------------------------------------------------

Questa opera è pubblicata sotto una Licenza Creative Commons.

Tutto quello che viene pubblicato in questo Blog è rilasciato sotto licenza Creative Commons Attribuzione-Non commerciale-Condividi allo stesso modo 2.5 Italia

ovvero, in sintesi:

- puoi liberamente modificare, distribuire, esporre in pubblico tutto ciò che è presente in

questo Blog

- non puoi usare i contenuti del Blog per scopi commerciali

- devi citare l'autore: Franco Babbo - bytewalker su egoprogrammo.blogspot.com

- devi condividerlo allo stesso modo.

per altre informazioni:

http://creativecommons.org/licenses/by-nc-sa/2.5/it/

------------------------------------------------------------------------------------------------------------

Inoltre:

A
Questo tipo di attivita la svolgo solo per il piacere di farlo, senza alcun fine commerciale.

Solo la passione per informatica ed elettronica e la ferma volontà di diffondere la conoscenza mi danno la pazienza necessaria a passare un sacco di tempo al computer, provando e riprovando, fino ad ottenere un qualcosa che volga (spero) la pena di essere condiviso. Pertanto, se ritenete che le informazioni che troverete vi siano state di una qualche minima utilità, chiederei gentilmente di farmelo sapere, in modo che io abbia, perlomeno, la consapevolezza che vale la pena continuare.

B
Dato che, in campo tecnico, moltissime applicazioni sono scritte in C / C++, interi sistemi operativi addirittura, credo di non sbagliare basando la quasi totalità degli esempi che troverete in questo Blog su questi linguaggi di programmazione.

Per la parte grafica, in particolare, farò riferimento alle librerie Qt che, come forse saprete, consentono di sviluppare applicazioni multipiattaforma.

Dato che lo scopo principale di questo Blog è, in fin dei conti, la libera diffusione della conoscenza, la maggior parte degli esempi saranno sviluppati prevalentemente in ambiente Linux che è opensource e quindi libero da qualsiasi forma di copyright. Spesso inoltre mi capiterà di usare OS X come ambiente di sviluppo il quale e affine a Linux come impostazione e come questo ha C / C++ nel dna.

I programmi che fornirò come esempio saranno tutti testati prima di essere messi online. Tuttavia se per qualsiasi recondito motivo qualcosa dovesse andare storto sulle vostre macchine non siete autorizzati a prendervela con il sottoscritto :-)

Sarebbe auspicabile che, a un certo punto, da tutto questo scaturisse un progetto di sviluppo comune, opensource e senza fini commerciali, che desse vita a qualche tipo di software, utile ed interessante o magari semplicemente divertente, da condividere in rete.

Detto questo, datemi un po di tempo per organizzare il materiale che ho preparato ma, nel frattempo, se siete interessati non esitate a farmelo sapere.

Al prossimo post ...