Difference between revisions of "Development/Tutorials/First program (es)"

Jump to: navigation, search
m
(translation to spanish)
Line 1: Line 1:
{{Template:I18n/Language Navigation Bar|Development/Tutorials/First program}}
+
{{Template:I18n/Language Navigation Bar|Development/Tutorials/First_program}}
 +
{{TutorialBrowser_(es)|
  
{{TutorialBrowser|
+
series=Tutorial para principiantes|
  
series=Beginner Tutorial|
+
name=Hola Mundo|
  
name=¡Hola Mundo!|
+
pre=[http://mindview.net/Books/TICPP/ThinkingInCPP2e.html C++], [http://www.trolltech.com/products/qt/ Qt], [[Getting_Started/Build/KDE4|Entorno de desarrollo en KDE4]]|
 
 
pre=[http://mindview.net/Books/TICPP/ThinkingInCPP2e.html C++], [http://www.trolltech.com/products/qt/ Qt], [[Getting_Started/Build/KDE4|Entorno de Desarrollo KDE4]]|
 
  
 
next=[[Development/Tutorials/Using_KXmlGuiWindow|Tutorial 2 - KXmlGuiWindow]]|  
 
next=[[Development/Tutorials/Using_KXmlGuiWindow|Tutorial 2 - KXmlGuiWindow]]|  
Line 14: Line 13:
 
}}
 
}}
  
== Siempre hay una primera vez ... ==
+
==Resumen==
Nuestro primer programa consistirá en mostrar el más que "programáticamente" conocido y amistoso saludo: "¡Hola Mundo!". Para esto, usaremos un objeto de la Clase {{class|KMessageBox}} y modificaremos el texto de uno de los botones.
+
 
 +
Tu primer programa consistirá en saludar al mundo con el amigable "Hola Mundo", Para ellor, usaremos {{class|KMessageBox}} y personalizaremos uno de los botones.
 
[[image:introtokdetutorial1.png|frame|center]]
 
[[image:introtokdetutorial1.png|frame|center]]
  
{{tip|Si deseas obtener más información respecto a cualquier clase con la que te topes, Konqueror ofrece una rápida alternativa: por ejemplo, si buscas información sobre KMessageBox, sólamente tipea "kde:kmessagebox" en Konqueror y éste te llevará inmediatamente a la documentación correspondiente.}}
+
{{tip|Si deseas obtener más información respecto a cualquier clase con la que te topes, Konqueror te ofrece un acceso rápido. Por ejemplo, si estás buscando información sobre KMessageBox, simplemente teclea "kde:kmessagebox" en la barra de direcciones de Konqueror y éste te llevará a la documentación.}}
 
 
{{tip|
 
Puede ser que desees usar KDevelop para tus proyectos, ya que ofrece muchas ventajas y funcionalidades, como por ejemplo: completación de código, fácil acceso a documentación y soporte para correción de errores (Debugging).
 
  
Lee [[Getting_Started/Set_up_KDE_4_for_development#KDevelop|este tutorial]] para configurar KDevelop apropiadamente para esta tarea. Puedes comprobar si la configuración es correcta intentando abrir una aplicación KDE 4 con KDevelop.
+
{{tip|Quizas quieras usar KDevelop para tus proyectos, ya que ofrece muchas ventajas como completado de código, fácil acceso a la documentación de la API o soporte para depurar.
  
Todavía necesitarás editar los ficheros de CMake de forma manual.
+
Lee [[Getting_Started/Set_up_KDE_4_for_development#KDevelop|este tutorial]] para configurar correctamente KDevelop para esta tarea. Probablemente querrás comprobar si la configuración es correcta abriendo primero una aplicación en KDE4 que ya exista.  
  
 +
Quizá necesites editar los archivos CMake a mano.
 
}}
 
}}
  
== El Código ==
+
==El Código==
 
+
Todo el Código Fuente que necesitaremos estará en un solo archivo, que se llamará: <tt>main.cpp</tt>.. Crea este archivo con el siguiente código:
Todo el Código Fuente que necesitaremos estará en un solo archivo, que será llamado: <tt>main.cpp</tt>. Copia el siguiente código dentro de él:
 
 
<code cppqt>
 
<code cppqt>
#include <QString>
 
 
#include <KApplication>
 
#include <KApplication>
 
#include <KAboutData>
 
#include <KAboutData>
 +
#include <KCmdLineArgs>
 
#include <KMessageBox>
 
#include <KMessageBox>
#include <KCmdLineArgs>
 
#include <KLocalizedString>
 
  
 
int main (int argc, char *argv[])
 
int main (int argc, char *argv[])
 
{
 
{
     KAboutData aboutData("tutorial1",                 // El nombre interno de la aplicación
+
     KAboutData aboutData(
                         0,                           // El nombre del catálogo del mensaje; se usará el mombre interno si es NULL
+
                        // The program name used internally.
                         ki18n("Tutorial 1"),         // El nombre de la aplicación mostrado.
+
                        "tutorial1",
                         "1.0",                       // Cadena de texto con la versión del programa
+
                        // The message catalog name
                         ki18n("Ventana Emergente KMessageBox"),   // Descripción pequeña de lo que el programa hace.
+
                        // If null, program name is used instead.
                         KAboutData::License_GPL,     // Identificador de licencia
+
                         0,
                         ki18n("(c) 2007"),           // Texto de Copyright
+
                        // A displayable program name string.
                         ki18n("Alguna información..."),       // Texto que contenga información adicional de cualquier tipo.
+
                         ki18n("Tutorial 1"),
                         "http://tutorial.com",       // La Página Web oficial de la aplicación.
+
                        // The program version string.
                         "[email protected]");       // La dirección de correo electrónico para el reporte de bichos (Bugs).
+
                         "1.0",
 +
                        // Short description of what the app does.
 +
                         ki18n("Displays a KMessageBox popup"),
 +
                        // The license this code is released under
 +
                         KAboutData::License_GPL,
 +
                        // Copyright Statement
 +
                         ki18n("(c) 2007"),
 +
                        // Optional text shown in the About box.
 +
                        // Can contain any information desired.
 +
                         ki18n("Some text..."),
 +
                        // The program homepage string.
 +
                         "http://tutorial.com/",
 +
                        // The bug report email address
 +
                         "[email protected]");
  
 
     KCmdLineArgs::init( argc, argv, &aboutData );
 
     KCmdLineArgs::init( argc, argv, &aboutData );
 
     KApplication app;
 
     KApplication app;
     KGuiItem guiItem( QString( "Hola" ), QString(),
+
     KGuiItem yesButton( i18n( "Hello" ), QString(),
                      QString( "Este es un Tooltip" ),
+
                        i18n( "This is a tooltip" ),
                      QString( "Esto es un \"¿Qué es esto?\" ) );
+
                        i18n( "This is a WhatsThis help text." ) );
     KMessageBox::questionYesNo( 0, "¡Hola Mundo!", "Hola", guiItem );
+
     KMessageBox::questionYesNo( 0, i18n( "Hello World" ),
 +
                                i18n( "Hello" ), yesButton );
 
}
 
}
 
</code>
 
</code>
 +
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.
  
La primera forma específica de programación en KDE que encontramos en el código es la clase {{class|KAboutData}}. Esta clase tiene la función de almacenar la información general de la aplicación, como la descripción, los autores o la información de licencia. Toda aplicación KDE debería hacer uso de esta clase.
+
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.
 
 
Luego, la clase {{class|KCmdLineArgs}}. Esta clase es utilizada para procesar los argumentos que son ingresados a través de línea de comandos y derivar las pertinentes acciones según los argumentos; por ejemplo, ejecutar un programa para abrir un determinado archivo, pasándole su nombre a la aplicación como argumento de línea de comandos. Desde luego, en este tutorial, simplemente la iniciaremos con el objeto {{class|KAboutData}} que hemos creado, y así, por ejemplo, poder obtener la versión o los autores con los argumentos <tt>--version</tt> o <tt>--author</tt>, respectivamente.
 
  
En la línea 13 creamos un objeto de la clase {{class|KApplication}}. Es necesario aplicar esta sentencia, una vez, en cada programa, para activar módulos como [[Development/Tutorials/Localization/i18n|i18n]] y otros servicios base.
+
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]].
  
Ahora que tenemos lista toda la configuración base de nuestra aplicación, podemos agregar cosas más interesantes. Vamos a crear una ventana emergente o de mensaje (popup) personalizando el texto de uno de sus botones. Para hacer esta modificación, necesitaremos un objeto {{class|KGuiItem}}. El primer argumento del constructor de esta clase refiere al texto que aparecera en el Item (en nuestro caso, un botón). Como segundo argumento tenemos la opción de añadir un icono al botón, pero como no queremos uno, sólamente aplicamos <tt>QString()</tt> (cadena vacía). Tercero, establecemos el tooltip (o información emergente, que es el texto que aparece cuando se detiene el cursor sobre un item), y finalmente, la cadena de información "¿Qué es esto?" (que se activa con un click derecho del mouse o presionando Shift-F1).
+
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.
  
Ahora, ya listo nuestro item, podremos crear el Popup o Ventana Emergente. Haremos una llamada a la función <tt>KMessageBox::questionYesNo()</tt> que, por defecto, crea un Popup con los botones "" y "No". El segundo argumento es el texto que irá en el cuerpo del Popup, el tercer argumento es el título de la ventana, y finalmente, pasamos el objeto <tt>KGuiItem guiItem</tt> en remplazo del botón por defecto "Sí".
+
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.
  
 +
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]].
  
Hemos finalizado lo concerniente al código. Ahora, a compilar y probar.
+
We're all done as far as the code is concerned. Now to build it and try it out.
  
== Construcción ==
+
==Build==
Si el entorno está configurado como lo descrito en [[Getting Started/Build/KDE4]], podrás compilar este código con:
+
If you set up your environment as described in [[Getting Started/Build/KDE4]], you can compile this code with
 
+
g++ main.cpp -o tutorial1 \
+
g++ main.cpp -o tutorial1 \
 
  -I$QTDIR/include/Qt \
 
  -I$QTDIR/include/Qt \
 
  -I$QTDIR/include/QtCore \
 
  -I$QTDIR/include/QtCore \
Line 86: Line 95:
 
  -L$KDEDIR/lib \
 
  -L$KDEDIR/lib \
 
  -L$QTDIR/lib -lQtCore -lQtGui -lkdeui -lkdecore
 
  -L$QTDIR/lib -lQtCore -lQtGui -lkdeui -lkdecore
 +
and then run it with
 +
dbus-launch ./tutorial1
 +
 +
On some platforms, the libraries might have to be linked with -lQtCore4 and -lQtGui4.
 +
 +
If you are using a packaged Qt, you might have no single QTDIR. Adjust the paths accordingly in this case. Or just move on to the next section. :-D
  
y luego, correrlo con:
 
dbus-launch ./tutorial1
 
  
 +
*** The above is not correct. QTDIR is defined for Qt 3 only. Use cmake -query or pkg-config  to get the paths you're after. KDEDIR is even deprecated since KDE 3. Using kde4-config is the way to go, e.g. "kde4-config --expandvars --install include".
  
== Usando CMake ==
 
Si lo anterior ha funcionado, querrá utilizar [Development/Tutorials/CMake|CMake]], como el resto de KDE. Éste localizará automáticamente las librerías y ficheros de cabecera para KDE, Qt, etc., y le permitirá construir sus aplicaciones eficazmente en otros computadores.
 
  
 +
===Using CMake===
 +
If that worked, you may want to use [[Development/Tutorials/CMake|CMake]], just like the rest of KDE. This will automatically locate the libraries and headers for KDE, Qt etc. and will allow you to easily build your applications on other computers.
 
====CMakeLists.txt====
 
====CMakeLists.txt====
Crea un fichero en el mismo directorio que se encuentra <tt>main.cpp</tt>, llamado CmakeLists.txt, con este contenido:
+
Create a file named CMakeLists.txt in the same directory as main.cpp with this content:
 
 
 
<code>
 
<code>
 
project (tutorial1)
 
project (tutorial1)
  
 
find_package(KDE4 REQUIRED)
 
find_package(KDE4 REQUIRED)
include_directories( ${KDE4_INCLUDES} )
+
include_directories(${KDE4_INCLUDES})
  
 
set(tutorial1_SRCS main.cpp)
 
set(tutorial1_SRCS main.cpp)
Line 108: Line 121:
 
target_link_libraries(tutorial1 ${KDE4_KDEUI_LIBS})
 
target_link_libraries(tutorial1 ${KDE4_KDEUI_LIBS})
 
</code>
 
</code>
 +
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.
  
La función <tt>find_package()</tt> localiza el paquete determinado (en este caso, KDE4) y establece algunas variables describiendo el lugar de los las librerías y cabeceras del paquete. En este caso usaremos la variable <tt>KDE4_INCLUDES</tt>, que contiene la ruta de las cabeceras KDE4.
+
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.
  
En orden de posibilitar al compilador encontrar estos ficheros, pasaremos esta variable a la función <tt>include_directories()</tt>, la cual añade las cabeceras KDE4 a la ruta de búsqueda de las cabeceras del compilador.
+
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.
  
Luego crearemos una variable llamada <tt>tutorial1_SRCS</tt> usando la función <tt>set()</tt>. Esta vez vamos a, simplemente, asignarle el nombre de nuestro único fichero fuente.
+
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. Finally 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.
  
Después usaremos <tt>kde4_add_executable()</tt> para crear un ejecutable, llamado <tt>tutorial1</tt>, desde los ficheros fuentes listados en nuestra variable <tt>tutorial1_SRCS</tt>. Finalmente, enlazaremos nuestro ejecutable a la librería KDE4 kdeui, usando <tt>target_link_libraries()</tt> y la variable <tt>KDE4_KDEUI_LIBS</tt>, que fue configurada por la función <tt>find_package()</tt>.
+
====Make And Run====
 +
You can invoke CMake and make manually:
  
== Elaboración y Ejecución ==
+
mkdir build && cd build
Nuevamente, si el entorno está configurado como lo descrito en [[Getting Started/Build/KDE4]], podrás compilar con este comando:
+
cmake .. # Note the two dots - this is no ellipsis, but "parent directory".
 +
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:
 
  cmakekde
 
  cmakekde
  
Y lanzar la aplicación con:
 
./tutorial1.shell
 
  
== Prosiguiendo ...==
+
And launch it with:
Ahora, puedes continuar: [[Development/Tutorials/Using_KXmlGuiWindow|Utilizando KXmlGuiWindow]].
+
./tutorial1
 +
 
 +
==Moving On==
 +
Now you can move on to [[Development/Tutorials/Using_KXmlGuiWindow|using KXmlGuiWindow]].
  
 
[[Category:C++]]
 
[[Category:C++]]

Revision as of 22:46, 18 September 2008


Development/Tutorials/First_program

Hola Mundo
Serie   Tutorial para principiantes
Requisitos previos   C++, Qt, Entorno de desarrollo en KDE4
Siguiente   Tutorial 2 - KXmlGuiWindow
Lectura avanzada   CMake

Resumen

Tu primer programa consistirá en saludar al mundo con el amigable "Hola Mundo", Para ellor, usaremos KMessageBox y personalizaremos uno de los botones.

Introtokdetutorial1.png
Ktip.png
Tip
Si deseas obtener más información respecto a cualquier clase con la que te topes, Konqueror te ofrece un acceso rápido. Por ejemplo, si estás buscando información sobre KMessageBox, simplemente teclea "kde:kmessagebox" en la barra de direcciones de Konqueror y éste te llevará a la documentación.


Ktip.png
Tip
Quizas quieras usar KDevelop para tus proyectos, ya que ofrece muchas ventajas como completado de código, fácil acceso a la documentación de la API o soporte para depurar.

Lee este tutorial para configurar correctamente KDevelop para esta tarea. Probablemente querrás comprobar si la configuración es correcta abriendo primero una aplicación en KDE4 que ya exista.

Quizá necesites editar los archivos CMake a mano.


El Código

Todo el Código Fuente que necesitaremos estará en un solo archivo, que se llamará: main.cpp.. Crea este archivo con el siguiente código:

  1. include <KApplication>
  2. include <KAboutData>
  3. include <KCmdLineArgs>
  4. include <KMessageBox>

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

   KAboutData aboutData(
                        // The program name used internally.
                        "tutorial1",
                        // The message catalog name
                        // If null, program name is used instead.
                        0,
                        // A displayable program name string.
                        ki18n("Tutorial 1"),
                        // The program version string.
                        "1.0",
                        // Short description of what the app does.
                        ki18n("Displays a KMessageBox popup"),
                        // The license this code is released under
                        KAboutData::License_GPL,
                        // Copyright Statement
                        ki18n("(c) 2007"),
                        // Optional text shown in the About box.
                        // Can contain any information desired.
                        ki18n("Some text..."),
                        // The program homepage string.
                        "http://tutorial.com/",
                        // The bug report email address
                        "[email protected]");
   KCmdLineArgs::init( argc, argv, &aboutData );
   KApplication app;
   KGuiItem yesButton( i18n( "Hello" ), QString(),
                       i18n( "This is a tooltip" ),
                       i18n( "This is a WhatsThis help text." ) );
   KMessageBox::questionYesNo( 0, i18n( "Hello World" ),
                               i18n( "Hello" ), yesButton );

} The first KDE specific code we come across in this program is 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.

Then we come to 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 KAboutData object we created so we can use the --version or --author switches.

Then we create a KApplication object. This needs to be done exactly once in each program since it is needed for things such as i18n.

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 KGuiItem object. The first argument in the 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 QString(). 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.

Now we have our item, we can create our popup. We call the KMessageBox::questionYesNo() 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 KGuiItem guiItem we created.

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 localization tutorial.

We're all done as far as the code is concerned. Now to build it and try it out.

Build

If you set up your environment as described in Getting Started/Build/KDE4, you can compile this code with

g++ main.cpp -o tutorial1 \
-I$QTDIR/include/Qt \
-I$QTDIR/include/QtCore \
-I$QTDIR/include \
-I$KDEDIR/include/KDE \
-I$KDEDIR/include \
-L$KDEDIR/lib \
-L$QTDIR/lib -lQtCore -lQtGui -lkdeui -lkdecore

and then run it with

dbus-launch ./tutorial1

On some platforms, the libraries might have to be linked with -lQtCore4 and -lQtGui4.

If you are using a packaged Qt, you might have no single QTDIR. Adjust the paths accordingly in this case. Or just move on to the next section. :-D


      • The above is not correct. QTDIR is defined for Qt 3 only. Use cmake -query or pkg-config to get the paths you're after. KDEDIR is even deprecated since KDE 3. Using kde4-config is the way to go, e.g. "kde4-config --expandvars --install include".


Using CMake

If that worked, you may want to use CMake, just like the rest of KDE. This will automatically locate the libraries and headers for KDE, Qt etc. and will allow you to easily build your applications on other computers.

CMakeLists.txt

Create a file named CMakeLists.txt in the same directory as main.cpp with this content: 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}) The find_package() 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 KDE4_INCLUDES 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 include_directories() function which adds the KDE4 headers to the header search path.

Next we create a variable called tutorial1_SRCS using the set() function. In this case we simply set it to the name of our only source file.

Then we use kde4_add_executable() to create an executable called tutorial1 from the source files listed in our tutorial1_SRCS variable. Finally we link our executable to the KDE4 kdeui library using target_link_libraries() and the KDE4_KDEUI_LIBS variable which was set by the find_package() function.

Make And Run

You can invoke CMake and make manually:

mkdir build && cd build
cmake .. # Note the two dots - this is no ellipsis, but "parent directory".
make

Or, if you set up your environment as described in Getting Started/Build/KDE4, you can compile this code with:

cmakekde


And launch it with:

./tutorial1

Moving On

Now you can move on to using KXmlGuiWindow.


Content is available under Creative Commons License SA 4.0 unless otherwise noted.