Development/Tutorials/First program (it): Difference between revisions

Latest revision as of 18:15, 15 July 2012

Hello World

Collezione di Tutorial	Tutorial per Principianti
Prerequisiti	C++, Qt, KDE4 development environment
A Seguire	Tutorial 2 - KXmlGuiWindow
Ulteriori Letture	CMake

Prefazione

Il tuo primo programma dovrebbe salutare il mondo con un amichevole "Ciao Mondo", giusto? Per farlo, useremo un KMessageBox personalizzando uno dei pulsanti.

Tip

Per avere più informazioni su qualunque classe che incontri, Konqueror offre una veloce scorciatoia. Per cercare informazioni circa KMessageBox, basta digitare "kde:kmessagebox" in Konqueror e sarai portato alla documentazione.

Tip

Vorresti poter usare KDevelop per i tuoi progetti, il quale fa molte cose carine come il completamento del codice, facile accesso alla documentazione delle API, supporto per il debugging.

Leggi questo tutorial per configurare KDevelop correttamente. Puoi controllare se il setup è andato a buon fine aprendo un'applicazione KDE4 esistente con KDevelop.

Tuttavia hai ancora bisogno di editare a mano i files di CMake.

Il Codice

Tutto il codice di cui abbiamo bisogno starà in un file, main.cpp. Crealo con il codice qua sotto:

#include <KApplication>
#include <KAboutData>
#include <KCmdLineArgs>
#include <KMessageBox>
#include <QByteArray>

int main (int argc, char *argv[])
{
    KAboutData aboutData(
                         // Il nome del programma, usato internamente.
                         "tutorial1",
                         // Il nome nel catalogo messaggi.
                         // Se nullo, verrà usato il nome del programma.
                         0,
                         // Una stringa con il nome del programma.
                         // Quella che verrà effettivamente visualizzata.
                         ki18n("Tutorial 1"),
                         // La stringa con la versione del programma.
                         "1.0",
                         // Piccola descrizione su cosa fa il programma.
                         ki18n("Visualizza una finestra KMessageBox."),
                         // La licenza con la quale il codice è rilasciato.
                         KAboutData::License_GPL,
                         // Copyright
                         ki18n("(c) 2007"),
                         // Testo opzionale mostrato in "Informazioni su".
                         // Può contenere qualunque informazione desiderata.
                         ki18n("Un po' di testo..."),
                         // La stringa con la homepage del programma.
                         QByteArray("http://tutorial.com/"),
                         // L'indirizzo email per la segnalazione di bug.
                         QByteArray("[email protected]"));

    KCmdLineArgs::init( argc, argv, &aboutData );
    KApplication app;
    KGuiItem yesButton( i18n( "Ciao" ), QString(),
                        i18n( "Questo è un tooltip" ),
                        i18n( "Questo è un testo di aiuto CheCos'è?." ) );
    KMessageBox::questionYesNo( 0, i18n( "Ciao Mondo" ),
                                i18n( "Ciao" ), yesButton );
    return 0;
}

Il primo codice specifico di KDE che incontriamo in questo programma è KAboutData. Questa è la classe utilizzata per immagazzinare le informazioni sul programma, come ad esempio una piccola descrizione, gli autori, o le informazioni sulla licenza. Praticamente ogni applicazione KDE dovrebbe usare questa classe.

Poi arriviamo a KCmdLineArgs. Questa è la classe che si usa quando si vogliono specificare istruzioni da riga di comando per, ad esempio, aprire il programma con uno specifico file. Comunque, in questo tutorial, semplicemente lo inizializziamo con l'oggetto KAboutData che abbiamo appena creato, in modo da poter usare le opzioni --version o --author

Quindi adiamo a creare l'oggetto KApplication. Ciò bisogna farlo esattamente una volta in ogni programma, visto che è necessario per cose come l'i18n.

Ora che abbiamo finito con le operazioni indispensabili di KDE, possiamo cominciare a fare cose interessanti con la nostra applicazione. Creeremo una finestra pop-up, ma personalizzeremo uno dei pulsanti. Per la personalizzazione avremo bisogno di un oggetto KGuiItem. Il primo argomento del costruttore di KGuiItem è il testo che apparirà sull'oggetto (nel nostro caso, un pulsante). Quindi ci sarà un opzione per inserire un'icona, ma non ne vogliamo una così gli mettiamo QString. Impostiamo quindi il tooltip (quello che appare quando fermi il puntatore su un elemento) ed infine il testo "Che Cos'è?" (accessibile tramite click col tasto destro, con Shift-F1 oppure cliccando su "?" nella barra del titolo e poi sul pulsante "Ciao").

Ora che abbiamo il nostro pulsante, possiamo creare il nostro pop-up. Chiamiamo la funzione KMessageBox::questionYesNo() la quale, in modo predefinito, crea una finestra con due pulsanti "Si" e "No". Il secondo argomento compone il testo mostrato nella finestra sopra i due pulsanti. Il terzo è l'intestazione della finestra; e infine impostiamo il KGuiItem di (quello che normalmente è) il pulsante "Si" con il nostro KGuiItem yesButton appena creato.

Notare come tutto il testo visibile all'utente passa attraverso la funzione i18n(); questo è necessario per permettere la traduzione della UI. Più informazioni sulla localizzazione possono essere trovate nel tutorial sulla localizzazione.

Abbiamo finito per quanto riguarda il codice. Ora la compilazione e la prova.

Compilazione

Vorrai usare CMake come ambiente di compilazione. Devi fornire un file chiamato CMakeLists.txt, cmake usa questo file per generare tutti i Makefiles.

CMakeLists.txt

Crea un file di nome CMakeLists.txt nella stessa cartella di main.cpp con questo contenuto:

project (tutorial1)

find_package(KDE4 REQUIRED)
include_directories(${KDE4_INCLUDES})

set(tutorial1_SRCS
  main.cpp
)

kde4_add_executable(tutorial1 ${tutorial1_SRCS})
target_link_libraries(tutorial1 ${KDE4_KDEUI_LIBS})
install(TARGETS tutorial1  ${INSTALL_TARGETS_DEFAULT_ARGS})

La funzione find_package() trova tutti i pacchetti che hai richiesto (in questo caso KDE4) ed imposta alcune variabili che descrivono la posizione degli header e delle librerie del pacchetto. In questo caso useremo la variabile KDE4_INCLUDES contenente il percorso ai files header di KDE4.

Per permettere al compilatore di trovare questi files, passiamo quella variabile alla funzione include_directories() la quale aggiunge gli header di KDE4 al percorso di ricerca degli header.

Poi creiamo una variabile chiamata tutorial1_SRCS con la funzione set(). In questo caso la impostiamo con il nome del nostro unico file sorgente.

Quindi usiamo kde4_add_executable() per creare un eseguibile chiamato tutorial1 dai sorgenti elencati nella nostra variabile tutorial1_SRCS. In seguito, facciamo il link del nostro eseguibile alle librerie kdeui di KDE4 con target_link_libraries() e la variabile KDE4_KDEUI_LIBS precedentemente riempita dalla funzione find_package(). La riga che comincia con install scrive un target di default "install" dentro al Makefile.

Make ed Esecuzione

Puoi invocare CMake e make manualmente:

mkdir build && cd build
cmake .. # Nota questi due punti - non è una mancanza,
         # stanno per "cartella superiore".
make

Oppure, se hai preparato il tuo ambiente come descritto in Getting Started/Build/KDE4, puoi compilare questo codice con:

cmakekde

Quindi lancialo con:

./tutorial1

Continua

Ora puoi continuare verso usare KXmlGuiWindow.

@@ Line 1: / Line 1: @@
-{{Template:I18n/Language Navigation Bar|Development/Tutorials/First_program}}
 {{TutorialBrowser_(it)|
-series=Beginner Tutorial|
+series=Tutorial per Principianti|
 name=Hello World|
@@ Line 8: / Line 8: @@
 pre=[http://mindview.net/Books/TICPP/ThinkingInCPP2e.html C++], [http://www.trolltech.com/products/qt/ Qt], [[Getting_Started/Build/KDE4|KDE4 development environment]]|
-next=[[Development/Tutorials/Using_KXmlGuiWindow|Tutorial 2 - KXmlGuiWindow]]|
+next=[[Development/Tutorials/Using_KXmlGuiWindow_(it)|Tutorial 2 - KXmlGuiWindow]]|
 reading=[[Development/Tutorials/CMake|CMake]]
 }}
-==Abstract==
+== Prefazione ==
-Your first program shall greet the world with a friendly "Hello World", what else? For that, we will use a {{class|KMessageBox}} and customise one of the buttons.
-[[image:introtokdetutorial1.png|frame|center]]
+Il tuo primo programma dovrebbe salutare il mondo con un amichevole "Ciao Mondo", giusto? Per farlo, useremo un {{class|KMessageBox}} personalizzando uno dei pulsanti.
+[[image:Ciaomondo_tutorial1.png|frame|center]]
+{{tip|Per avere più informazioni su qualunque classe che incontri, Konqueror offre una veloce scorciatoia. Per cercare informazioni circa KMessageBox, basta digitare "kde:kmessagebox" in Konqueror e sarai portato alla documentazione.}}
-{{tip|To get more information about any class you come across, Konqueror offers a quick shortcut. So to look for information about KMessageBox, just type "kde:kmessagebox" into Konqueror and you'll be taken to the documentation.}}
+{{tip|Vorresti poter usare KDevelop per i tuoi progetti, il quale fa molte cose carine come il completamento del codice, facile accesso alla documentazione delle API, supporto per il debugging.
+Leggi [[Getting_Started/Set_up_KDE_4_for_development#KDevelop|questo tutorial]] per configurare KDevelop correttamente. Puoi controllare se il setup è andato a buon fine aprendo un'applicazione KDE4 esistente con KDevelop.
+Tuttavia hai ancora bisogno di editare a mano i files di CMake.}}
-{{tip|
-You might want to use KDevelop for your projects, which does many nice things like code completion, easy access to API documentation or debugging support.
-Read [[Getting_Started/Set_up_KDE_4_for_development#KDevelop|this tutorial]] to set up KDevelop correctly for this task. You probably want to check if the setup is working by testing opening an existing KDE 4 application with KDevelop first.
+== Il Codice ==
-You still need to edit the CMake files by hand though.
+Tutto il codice di cui abbiamo bisogno starà in un file, <tt>main.cpp</tt>. Crealo con il codice qua sotto:
-}}
-==The Code==
+<syntaxhighlight lang="cpp-qt">
-All the code we need will be in one file, <tt>main.cpp</tt>. Create that file with the code below:
-<code cppqt>
 #include <KApplication>
 #include <KAboutData>
 #include <KCmdLineArgs>
 #include <KMessageBox>
+#include <QByteArray>
 int main (int argc, char *argv[])
 {
      KAboutData aboutData(
-                          // The program name used internally.
+                          // Il nome del programma, usato internamente.
                           "tutorial1",
-                          // The message catalog name
+                          // Il nome nel catalogo messaggi.
-                          // If null, program name is used instead.
+                          // Se nullo, verrà usato il nome del programma.
 ,
-                          // A displayable program name string.
+                          // Una stringa con il nome del programma.
+                         // Quella che verrà effettivamente visualizzata.
                           ki18n("Tutorial 1"),
-                          // The program version string.
+                          // La stringa con la versione del programma.
                           "1.0",
-                          // Short description of what the app does.
+                          // Piccola descrizione su cosa fa il programma.
-                          ki18n("Displays a KMessageBox popup"),
+                          ki18n("Visualizza una finestra KMessageBox."),
-                          // The license this code is released under
+                          // La licenza con la quale il codice è rilasciato.
                           KAboutData::License_GPL,
-                          // Copyright Statement
+                          // Copyright
                           ki18n("(c) 2007"),
-                          // Optional text shown in the About box.
+                          // Testo opzionale mostrato in "Informazioni su".
-                          // Can contain any information desired.
+                          // Può contenere qualunque informazione desiderata.
-                          ki18n("Some text..."),
+                          ki18n("Un po' di testo..."),
-                          // The program homepage string.
+                          // La stringa con la homepage del programma.
-                          "http://tutorial.com/",
+                          QByteArray("http://tutorial.com/"),
-                          // The bug report email address
+                          // L'indirizzo email per la segnalazione di bug.
-                          "[email protected]");
+                          QByteArray("[email protected]"));
      KCmdLineArgs::init( argc, argv, &aboutData );
      KApplication app;
-     KGuiItem yesButton( i18n( "Hello" ), QString(),
+     KGuiItem yesButton( i18n( "Ciao" ), QString(),
-                         i18n( "This is a tooltip" ),
+                         i18n( "Questo è un tooltip" ),
-                         i18n( "This is a WhatsThis help text." ) );
+                         i18n( "Questo è un testo di aiuto CheCos'è?." ) );
-     KMessageBox::questionYesNo( 0, i18n( "Hello World" ),
+     KMessageBox::questionYesNo( 0, i18n( "Ciao Mondo" ),
-                                 i18n( "Hello" ), yesButton );
+                                 i18n( "Ciao" ), yesButton );
-     return app.exec();
+     return 0;
 }
-</code>
+</syntaxhighlight>
-The first KDE specific code we come across in this program is {{class|KAboutData}}. This is the class used to store information about the program such as a short description, authors or license information. Pretty much every KDE application should use this class.
+Il primo codice specifico di KDE che incontriamo in questo programma è {{class|KAboutData}}. Questa è la classe utilizzata per immagazzinare le informazioni sul programma, come ad esempio una piccola descrizione, gli autori, o le informazioni sulla licenza. Praticamente ogni applicazione KDE dovrebbe usare questa classe.
+Poi arriviamo a {{class|KCmdLineArgs}}. Questa è la classe che si usa quando si vogliono specificare istruzioni da riga di comando per, ad esempio, aprire il programma con uno specifico file. Comunque, in questo tutorial, semplicemente lo inizializziamo con l'oggetto {{class|KAboutData}} che abbiamo appena creato, in modo da poter usare le opzioni <tt>--version</tt> o <tt>--author</tt>
-Then we come to {{class|KCmdLineArgs}}. This is the class one would use to specify command line switches to, for example, open the program with a specific file. However, in this tutorial, we simply initialise it with the {{class|KAboutData}} object we created so we can use the <tt>--version</tt> or <tt>--author</tt> switches.
+Quindi adiamo a creare l'oggetto {{class|KApplication}}. Ciò bisogna farlo esattamente una volta in ogni programma, visto che è necessario per cose come l'[[Development/Tutorials/Localization/i18n|i18n]].
-Then we create a {{class|KApplication}} object. This needs to be done exactly once in each program since it is needed for things such as [[Development/Tutorials/Localization/i18n|i18n]].
+Ora che abbiamo finito con le operazioni indispensabili di KDE, possiamo cominciare a fare cose interessanti con la nostra applicazione. Creeremo una finestra pop-up, ma personalizzeremo uno dei pulsanti. Per la personalizzazione avremo bisogno di un oggetto {{class|KGuiItem}}. Il primo argomento del costruttore di {{class|KGuiItem}} è il testo che apparirà sull'oggetto (nel nostro caso, un pulsante). Quindi ci sarà un opzione per inserire un'icona, ma non ne vogliamo una così gli mettiamo <tt>QString</tt>. Impostiamo quindi il tooltip (quello che appare quando fermi il puntatore su un elemento) ed infine il testo "Che Cos'è?" (accessibile tramite click col tasto destro, con Shift-F1 oppure cliccando su "?" nella barra del titolo e poi sul pulsante "Ciao").
-Now we've done all the necessary KDE setup, we can move on to doing interesting things with our application. We're going to create a popup box but we're going to customise one of the buttons. To do this customisation, we need to use a {{class|KGuiItem}} object. The first argument in the {{class|KGuiItem}} constructor is the text that will appear on the item (in our case, a button). Then we have an option of setting an icon for the button but we don't want one so we just give it <tt>QString()</tt>. We then set the tooltip (what appears when you hover over an item) and finally the "What's This?" (accessed through right-clicking or Shift-F1) text.
+Ora che abbiamo il nostro pulsante, possiamo creare il nostro pop-up. Chiamiamo la funzione <tt>{{class|KMessageBox}}::questionYesNo()</tt> la quale, in modo predefinito, crea una finestra con due pulsanti "Si" e "No". Il secondo argomento compone il testo mostrato nella finestra sopra i due pulsanti. Il terzo è l'intestazione della finestra; e infine impostiamo il KGuiItem di (quello che normalmente è) il pulsante "Si" con il nostro <tt>KGuiItem yesButton</tt> appena creato.
-Now we have our item, we can create our popup. We call the <tt>{{class|KMessageBox}}::questionYesNo()</tt> function which, by default, creates a message box with a "Yes" and a "No" button. The second argument is the text that will appear in the message box above the buttons. The third is the caption the window will have and finally we set the KGuiItem for (what would normally be) the "Yes" button to the <tt>KGuiItem guiItem</tt> we created.
+Notare come tutto il testo visibile all'utente passa attraverso la funzione i18n(); questo è necessario per permettere la traduzione della UI. Più informazioni sulla localizzazione possono essere trovate nel [[Development/Tutorials/Localization/i18n|tutorial sulla localizzazione]].
-Note that all user-visible text is passed through the i18n() function; this is necessary for the UI to be translatable. More information on localization can be found in the [[Development/Tutorials/Localization/i18n|localization tutorial]].
+Abbiamo finito per quanto riguarda il codice. Ora la compilazione e la prova.
-We're all done as far as the code is concerned. Now to build it and try it out.
+== Compilazione ==
-== Build ==
+Vorrai usare [[Development/Tutorials/CMake|CMake]] come ambiente di compilazione. Devi fornire un file chiamato CMakeLists.txt, cmake usa questo file per generare tutti i Makefiles.
-You want to [[Development/Tutorials/CMake|use CMake]] for your build environment. You provide a file CMakeLists.txt, cmake uses this file to generate all Makefiles out of it.
 === CMakeLists.txt ===
-Create a file named CMakeLists.txt in the same directory as main.cpp with this content:
-<code>
+Crea un file di nome CMakeLists.txt nella stessa cartella di main.cpp con questo contenuto:
+<syntaxhighlight lang="ini" line>
 project (tutorial1)
 find_package(KDE4 REQUIRED)
-include (KDE4Defaults)
 include_directories(${KDE4_INCLUDES})
-set(tutorial1_SRCS main.cpp)
+set(tutorial1_SRCS
+  main.cpp
+)
 kde4_add_executable(tutorial1 ${tutorial1_SRCS})
 target_link_libraries(tutorial1 ${KDE4_KDEUI_LIBS})
 install(TARGETS tutorial1  ${INSTALL_TARGETS_DEFAULT_ARGS})
-</code>
+</syntaxhighlight>
-The <tt>find_package()</tt> function locates the package that you ask it for (in this case KDE4) and sets some variables describing the location of the package's headers and libraries. In this case we will use the <tt>KDE4_INCLUDES</tt> variable which contains the path to the KDE4 header files.
-In order to allow the compiler to find these files, we pass that variable to the <tt>include_directories()</tt> function which adds the KDE4 headers to the header search path.
+La funzione <tt>find_package()</tt> trova tutti i pacchetti che hai richiesto (in questo caso KDE4) ed imposta alcune variabili che descrivono la posizione degli header e delle librerie del pacchetto. In questo caso useremo la variabile <tt>KDE4_INCLUDES</tt> contenente il percorso ai files header di KDE4.
-Next we create a variable called <tt>tutorial1_SRCS</tt> using the <tt>set()</tt> function. In this case we simply set it to the name of our only source file.
+Per permettere al compilatore di trovare questi files, passiamo quella variabile alla funzione <tt>include_directories()</tt> la quale aggiunge gli header di KDE4 al percorso di ricerca degli header.
-Then we use <tt>kde4_add_executable()</tt> to create an executable called <tt>tutorial1</tt> from the source files listed in our <tt>tutorial1_SRCS</tt> variable. Afterwards, we link our executable to the KDE4 kdeui library using <tt>target_link_libraries()</tt> and the <tt>KDE4_KDEUI_LIBS</tt> variable which was set by the <tt>find_package()</tt> function. The line starting with <tt>install</tt> writes a default "install" target into the Makefile.
+Poi creiamo una variabile chiamata <tt>tutorial1_SRCS</tt> con la funzione <tt>set()</tt>. In questo caso la impostiamo con il nome del nostro unico file sorgente.
-=== Make And Run ===
+Quindi usiamo <tt>kde4_add_executable()</tt> per creare un eseguibile chiamato <tt>tutorial1</tt> dai sorgenti elencati nella nostra variabile <tt>tutorial1_SRCS</tt>. In seguito, facciamo il link del nostro eseguibile alle librerie kdeui di KDE4 con <tt>target_link_libraries()</tt> e la variabile <tt>KDE4_KDEUI_LIBS</tt> precedentemente riempita dalla funzione <tt>find_package()</tt>. La riga che comincia con <tt>install</tt> scrive un target di default "install" dentro al Makefile.
-You can invoke CMake and make manually:
+=== Make ed Esecuzione ===
+Puoi invocare CMake e make manualmente:
   mkdir build && cd build
-  cmake .. # Note the two dots - this is no ellipsis, but "parent directory".
+  cmake .. # Nota questi due punti - non è una mancanza,
+          # stanno per "cartella superiore".
   make
-Or, if you set up your environment as described in [[Getting_Started/Build/KDE4|Getting Started/Build/KDE4]], you can compile this code with:
+Oppure, se hai preparato il tuo ambiente come descritto in [[Getting_Started/Build/KDE4|Getting Started/Build/KDE4]], puoi compilare questo codice con:
   cmakekde
-And launch it with:
+Quindi lancialo con:
   ./tutorial1
-==Moving On==
+== Continua ==
-Now you can move on to [[Development/Tutorials/Using_KXmlGuiWindow|using KXmlGuiWindow]].
+Ora puoi continuare verso [[Development/Tutorials/Using_KXmlGuiWindow|usare KXmlGuiWindow]].
 [[Category:C++]]