El manual de usuario de KDevelop: Guía de referencia para el Entorno Integrado de Desarrollo KDevelop para sistemas Unix, versión 1.2.
Anterior | Capítulo 4. Desarrollo con KDevelop | Siguiente

# 4.3. El proceso de desarrollo

El desarrollo de una aplicación con KDevelop puede dividirse, como norma general, en dos partes: en la primera se genera el esqueleto del programa con el asistente de aplicaciones , la segunda consiste en el desarrollo del programa con el resto de herramientas que proporciona KDevelop y depende de la habilidad que tenga como programador. Para describir el proceso de desarrollo, hemos dado por hecho que usted desea crear una aplicación Qt o KDE , lo que significa utilizar la mayor parte de las posibilidades que KDevelop ofrece para este tipo de proyectos, para que tenga un "¿Cómo..." (o HOW-TO en inglés) general.

## 4.3.1. Creando el esqueleto del programa

Habitualmente, para empezar a crear su aplicación, lo primero que hará será llamar al asistente de aplicaciones , introducir el nombre del proyecto, y generar el programa. Para hacer esto, el asistente crea un fichero de proyecto para la aplicación e inserta aspectos del KDevelop en el fichero Makefile.am que se utilizará posteriormente al extender la aplicación. El fichero de proyecto es el que tiene que cargar cuando desee abrir el proyecto posteriormente.

Se accede al asistente de aplicaciones desde el menú "Proyecto", en la entrada "Nuevo...". Cuando el asistente aparezca, tiene que elegir el tipo de proyecto en la primera página. Pulsando "Siguiente >>" llegará a la siguiente página, en la que tiene que introducir el nombre del proyecto, la versión, el directorio, y sus datos personales. La página 3 ofrece algunas opciones para el uso de un sistema de control de versiones, mientras que las 4 y 5 permiten editar las cabeceras de los ficheros de cabecera y de implementación . Si ya tiene alguna cabecera en un fichero y desea utilizarla como plantilla, también puede hacerlo. La última página contiene las ventanas de salida y de errores. Cuando pulse en "Crear", su aplicación será generada, y las acciones que se realicen podrán ser observadas en la ventana de salida . Si en ella aparece la palabra READY, significa que el asistente de aplicaciones ha terminado y ya puede pulsar "Salir" para volver al entorno de programación. Para crear el binario, elija "Make" en el menú "Construir" o pulse el botón correspondiente en la barra de herramientas. Puede probar las funciones que ya están presentes en el programa eligiendo "Ejecutar" en el menú "Construir".

## 4.3.2. Desarrollando una aplicación

Esta sección describe la fase de desarrollo de una aplicación con KDevelop y el editor de diálogos , además de mostrar todo lo que se puede realizar con el EID.

El proceso de desarrollo se compone, habitualmente, de los siguientes pasos: se editan los ficheros fuente, se compilan y se enlazan para crear el binario final, se buscan los errores que hayan aparecido durante el proceso anterior o durante la depuración , se añade la documentación y las traducciones. El problema es que todos estos pasos pueden acabar intercalandose entre ellos y no es fácil describir una forma general con la que crear una aplicación. Normalmente, lo más habitual es crear primero todas las partes visibles del proyecto, tales como la vista principal y los diálogos de configuración. Después se genera el código fuente y se implementan todas las conexiones que deben realizarse, como cambiar las barras de menús y de herramientas, añadir mensajes de ayuda (para los menús) a la barra de estado, y llenar las nuevas funciones miembro con los objetos que muestren los diálogos. Después se suele compilar la apliación y probar sus funciones, arreglar los errores que se encuentren, y volver a probarla. Las siguientes secciones explican como se realiza todo esto. Por supuesto, cuando realice su propia aplicación, puede que elija otra forma de hacerla. KDevelop le da suficiente facilidad para que decida que es lo que quiere hacer en cada momento.

### 4.3.2.1. Interfaces de usuario

La interfaz de usuario es la parte de la aplicación que se le muestra al usuario, además de con la que interactúa. Por lo tanto, esta interfaz está compuesta habitualmente de las barras de menús, herramientas, y estado, además de una vista principal que sería, por ejemplo, aquella en la que se introduce texto, en un editor. El asistente de aplicaciones puede crear aplicaciones que ya contengan la mayor parte de la estructura de la interfaz de usuario, incluyendo menús y botones. Cuando desarrolle sus propias aplicaciones tendrá que ampliar la estructura, para darle a la aplicacion todas las posibilidades de interacción que usted desee. Parte del trabajo consiste en diseñar diálogos, por ejemplo para cambiar el tamaño de una brocha en un programa de dibujo. Esto puede realizarse fácilmente con el editor de diálogos incorporado. Ahora, ¿como crear diálogos que sean agradables a la vista? La respuesta está en la biblioteca Qt , que es en realidad una herramienta para crear interfaces de usuario (IGU). Para ello ofrece un conjunto base de controles , como etiquetas para mostrar texto, campos de texto para la entrada de texto, botones... Además de estos objetos de "bajo nivel" (respecto a la IGU), también ofrece diálogos estándar listos para usar, por ejemplo diálogos de impresión . Las bibliotecas KDE están basadas en la biblioteca Qt y contienen sustitutos para algunos de los diálogos, además de controles adicionales que pueden ser utilizados en su aplicación. Todo esto significa que, cuando empiece a diseñar el comportamiento de su aplicación de cara al usuario, debería familiarizarse con los controles que tanto Qt como KDE ofrecen. La documentación en línea de la biblioteca Qt ofrece imágenes de la mayoría de ellos, por lo que le recomendamos que le eche un vistazo en cuanto pueda. Después, le recomendamos que se informe sobre la biblioteca KDE-UI, que ofrece controles adicionales. Otras bibliotecas como la KHTML ofrecen controles muy especializados, que son usados por muchos programas. Su función es simplificar el diseño de aplicaciones, al igual que los diálogos predefinidos que vienen con la biblioteca Qt. Cuando diseñe sus propios diálogos, le recomendamos que utilice estos controles especializados. Un diálogo está formado, básicamente, por un grupo de controles combinados para crear la interfaz, siendo programado en código C++ dentro de una clase que deriva de `QWidget` o de una clase de diálogo más especializada, que a su vez es derivada de `QWidget`. Esto significa que el programa que utilice el control necesita un objeto de la clase de dicho objeto. Con esto se acaba prácticamente todo lo que necesita para entender como se utilizan los diálogos o vistas. El editor de diálogos de KDevelop permite construir diálogos e interfaces de usuario de forma visual, evitando que tenga que crear los diálogos en C++ directamente (que es la forma difícil de crear interfaces). Salte al editor de diálogos eligiendo la entrada correspondiente del menú "Ver" (o pulsando en el botón de la barra de herramientas). Verá que la apariencia del KDevelop ha variado pero que, por ejemplo, las barras de menús y herramientas son muy similares. Esto facilita el cambio entre los dos modos de trabajo, y hará que se sienta comfortable en los dos en poco tiempo. Desde el editor puede construir sus vistas y diálogos como desee, y modificar las propiedades de todos los elementos que utilice. Cuando termine, seleccione "Generar fuentes..." desde el menú "Construir"; el programa se encargará del resto. Puede comprobar si todo fue bien pulsando en "Ejecutar make" o "Ejecutar", para construir la aplicación con los nuevos ficheros fuente. Pero no espere que los diálogos estén disponibles desde el principio. Se requiere algo de programación primero, pero no se preocupe, no será muy difícil. Si desea más información sobre la creación de diálogos, vea el capítulo El editor de diálogos, también podrá encontrar ejemplos y guías de estilo en el manual de programación.

### 4.3.2.2. Incluir nuevos elementos

Tras haber creado la interfaz de usuario y haber generado sus ficheros fuente, está preparado para que su aplicación utilice estos nuevos elementos. Como se ha descrito arriba, una aplicación basada en IGU contiene barras y una vista principal; además la vista principal interacciona con las barras, que son parte de la clase principal de la aplicación, y con el objeto documento que esté abierto. Usando el lenguaje del diseño orientado a objetos, la arquitectura usada se podría definir como un modelo "Documento-Vista-Controlador". Este modelo describe las funciones básicas de los objetos de una aplicación dependiendo de su papel dentro del programa. El Controlador representa al coordinador de la aplicación principal, ofreciendo la interacción con el usuario a través de la barra de menús y, opcionalmente, de las barras de herramientas y de estado. La clase Documento se encarga de la tarea de mostrar el documento con el que el usuario está trabajando. Esto implica que la clase Documento debe ser la encargada de realizar las acciones del tipo cargar/guardar documentos. La Vista es el centro de la ventana de la aplicación, mostrando visualmente al usuario una parte del documento y ofreciéndole facilidades para manipular los datos. Como las barras de herramientas, menús y estado ya están creadas, su trabajo consistirá en crear la vista principal y los diálogos adicionales con los que el usuario pueda configurar cualquier opción, o acceder a funciones adicionales.

Para construir su vista principal, el código generado para su aplicación ya contiene una clase llamada &<;SuAplicación&>;View, que hereda de la clase `QWidget` (esta clase es la clase mínima necesaria para manejar interfaces gráficas en aplicaciones Qt, y por tanto también en aplicaciones KDE ). En general, hay tres formas de ampliar la clase dada:

- eliminando la estructura de vista de documentos y utilizando uno de los controles "grandes" incluidos, que ya contienen una gran número de funciones. Tan sólo tiene que eliminar la clase View y reemplazar el objeto view por otro.

- cambiando la herencia de la clase View. Cambie la herencia, por ejemplo, a la clase QMultiLineEdit y su aplicación será un editor.

- si su vista principal consiste de distintas partes, cree los controles y sus clases con el editor de diálogos , y cree los objetos de estas clases en los constructores de la clase View, al combinarse crearán la vista principal.

Con los diálogos, el proceso es algo diferente. La forma normal de llamar a un diálogo sería a través de una entrada de menú, o de un icono de la barra de herramientas. Tras haber construido el diálogo y haber generado los fuentes, la clase está disponible para crear un objeto que será el diálogo. Lo primero que hay que hacer es buscar un lugar apropiado en el menú en que añadir la entrada que, al ser seleccionada, mostrará el diálogo. Si los menús existentes no se corresponden con la función del diálogo, cree un nuevo menú, igual que el resto, y añada la entrada y la ranura a la que llamar cuando se seleccione el elemento. Entonces implemente la ranura, creando una instancia de la clase diálogo y llamando al diálogo con las funciones miembro proporcionadas por la clase base. También debe proporcionar un identificador a la entrada de menú. La aplicación princpial tiene listados todos los identificadores ya utilizados en el fichero resource.h, por lo que lo único que tiene que hacer es añadir el identificador y darle un nuevo número. Con esto ya se ha acabado, aunque también podría añadir otro icono a la barra de herramientas, y añadir un mensaje de ayuda para la barra de estado. En cualquier caso, su aplicación ofrece ahora una nueva opción al usuario. Lo único que hay que hacer ahora es añadir la implementación de los metodos que utilizará el diálogo. Para acabar, llame a la herramienta make, o ejecute la aplicación, y los ficheros modificados serán recompilados; el resultado de los cambios podra ser entonces comprobado rápidamente.

### 4.3.2.3. El proceso completo de desarrollo

Arriba se ha hablado de la manera habitual de comenzar a trabajar en una nueva aplicación, usando KDevelop, y de como ampliar la interfaz de usuario. Estos son los pasos más habituales en los que el EID le ayuda, pero KDevelop no sólo ofrece herramientas para crear aplicaciones e interfaces. A continuación, se dará una pequeña descripción de las principales facilidades que KDevelop ofrece para mejorar el desarrollo de aplicaciones.

#### 4.3.2.3.1. Administración del código

KDevelop ofrece una gran cantidad de opciones para que el programador alcance su meta en el menor tiempo posible. Como se ha descrito arriba, el asistente de aplicaciones y el editor de diálogos reducen la cantidad de tiempo que se necesitaría para conseguir el mismo resultado manualmente. Pero no se ha hablado de la principal tarea del programador: implementar el correcto funcionamiento de la aplicación. La pregunta es, ¿por qué utilizar KDevelop como entorno de desarrollo, incluso para crear aplicaciones sin IGU ?

Implicitamente, el EID se encarga de controlar su proyecto; esto es: no tiene que preocuparse de guardar los cambios, de generar el fichero Makefile , etc. Se está proporcionando una completa administración del proyecto, siendo aquídonde KDevelop ofrece todas sus posibilidades, en cualquier tipo de desarrollo en C++. Es fácil entender que, al hacer que el programador se olvide de la administración del proyecto, se consigue una mayor concentración en la programación del código. Por otro lado, el código suele estar distribuido en diversos ficheros a lo largo del proyecto, para separar ciertas partes. Normalmente, esto significaría que el desarrollador tendría que encargarse de crear cada uno de estos ficheros, y de insertar las líneas que todos ellos suelen llevar como norma general, como las cabeceras con la fecha y el nombre del autor, la licencia con que se distribuye el código, etc. Además, esto implicaría que el desarrollador se acordara, en todo momento, de en que ficheros se encuentra cada función, declaración e implementación de cada clase. Para evitar todo esto, KDevelop contiene la herramienta de clases, que proporciona una serie de acciones que facilitan el trabajo del desarrollador y permiten que se centre en los objetos, clases , estructuras y métodos que contiene la aplicación, en lugar de en sus ficheros. El generador de clases le permite crear una nueva clase, pudiendo especificar su documentación, sus atributos y si posee algún tipo de herencia. En lo que al trabajo orientado a objetos se refiere, el navegador de clases le posibilita localizar sus objetos; no importa en que parte del código estén. El navegador recorre todos los fuentes y se actualiza para mostrar información actualizada sobre los objetos, permitiéndole acceder a cualquier nuevo código directamente. Mediante los menús contextuales, el navegador le ofrece aún más posibilidades, como mostrar la implementación de la clase o la declaración de sus funciones miembro . Con esto, la adición de miembros se hace mediante diálogos, no hace falta buscar el fichero y la línea en la que se ha de introducir el código. Por último, puede obtener una visión más directa de las clases de su proyecto con la ayuda del diálogo de clases , que le muestra un árbol en el que se puede ver el uso, los contenidos y la herencia de las clases y sus objetos. Para obtener una información más detallada, vea el apartado sobre el navegador de clases.

#### 4.3.2.3.2. Construyendo y ejecutando su aplicación

KDevelop está diseñado para eliminar todos esos pasos que se deben realizar periódicamente, tales como la construcción y ejecución de su programa, además de la localización de errores en el código fuente.

Puede comenzar el proceso de construcción:

- pulsando en los botones "Construir" o "Reconstruir todo" de la barra de herramientas

- o seleccionando "Construir"/"Reconstruir todo" desde el menú Construir.

Para ejecutar su aplicación, elija:

- los botones "Ejecutar" o "Depurar" (que abrirá el depurador junto a su programa) de la barra de herramientas

- las entradas de menú correspondientes del menú Construir

- o seleccione "Ejecutar con argumentos" para lanzar su aplicación pasándole argumentos adicionales.

Para obtener más información sobre el proceso de construcción, vea el apartado Proyectos.

#### 4.3.2.3.3. Buscando errores en el programa

Como la aparición de errores es habitual, tanto durante el proceso de construcción (en el que son detectados por el compilador y en el que son llamados errores sintácticos, porque son resultado de errores de sintaxis en los fuentes) como durante la ejecución de la aplicación, estos errores tienen que ser detectados y eliminados por el programador. Para encontrar estos errores , el desarrollador necesita saber la razón exacta de su existencia. Como se ha mencionado, el compilador es capaz de detectar errores de sintaxis el solo, dando como resultado que el ejecutable no se cree (esto también puede pasar en enlazado, cuando el enlazador detecta "símbolos sin resolver"-vea Opciones de enlazado). Como se da una descripción del error lo más detallada posible, el error puede ser encontrado y eliminado. Durante el proceso de construcción, verá que aparece la ventana de salida mostrando los mensajes de la herramienta make y del compilador. En caso de que aparezcan errores o avisos , tan sólo pulse con el ratón sobre el mensaje de error y el editor mostrará el fichero afectado y moverá el cursor a la línea que contiene el error. Esto también puede ser realizarse desde las entradas del menú "Ver" "Siguiente error" y "Anterior error" o mediante sus atajos de teclado. Encontrará que estas funciones son muy útilas y ahorran mucho tiempo en ir a los errores, lo cual le dará más tiempo para solucionarlos.

Los errores en tiempo de ejecución, que ocurren durante la ejecución de la aplicación y suelen resultar en un dallo de segmentación, suelen ser más difíciles de encontrar. Para encontrarlos más fácilmente, puede decirle al compilador que añada información dentro del binario que permita observar su ejecución con el código fuente. Runtime Errors, which occur during execution and will mostly result in a segmentation fault, are sometimes hard to find. Un depurador es otro programa que le permite hacer esto, lanzando la aplicación y permitiéndole poner puntos de interrupción en el código para que la ejecución del mismo se detenga en ellos, de forma que pueda controlar las zonas críticas de la implementación y encontrar al menos de esta forma la línea que provocó el error. Encontrar la causa del error es una tarea que ya depende del programador. El depurador gdb viene con el compilador GNU y los programas del tipo ddd o KDbg son interfaces de usuario para facilitar su uso. KDevelop utiliza el KDbg y le permite comenzar el proceso de depurado desde la entrada "Inicio" del menú "Depurar" o desde el botón "Depurar" de la barra de herramientas. Para obtener más información sobre aplicaciones de depurado, vea el capítulo Proyectos y el manual de programación de KDevelop.

Anterior | Inicio | Siguiente
Breve descripción de las herramientas de KDevelop | Subir | Información adicional