updated sources and README

README.md

 
 1. Haber repasado los siguientes conceptos:
 
-    a. creación de objetos de una clase.
+  a. creación de objetos de una clase.
 
-    b. utilización de métodos "getters" para acceder a los atributos de un objeto.
+  b. utilización de métodos "getters" para acceder a los atributos de un objeto.
 
-    c. utilización de métodos "setters" para modificar los atributos de un objeto.
+  c. utilización de métodos "setters" para modificar los atributos de un objeto.
 
 2. Haber estudiado la documentación de la clase `Bird` disponible en [este enlace] (http://ada.uprrp.edu/~ranazario/bird-html/class_bird.html).
 
 
 ###Clases
 
-Una clase es un pedazo de código en donde se describe cómo serán los objetos. Se definen las variables o atributos de los datos que contendrá el objeto y las funciones o métodos que hacen algún procedimiento a los datos del objeto. Para declarar una clase debemos especificar los tipos que tendrán las variables y los prototipos de los métodos de la clase. 
-
-
-Si no se especifica lo contrario, los atributos y métodos definidos en una clase serán "privados". Esto quiere decir que esas variables solo se pueden acceder y cambiar por los métodos de la clase (*constructores*, *"setters"* y *"getters"*, entre otros). 
+Una clase es una plantilla para la creación de objetos que establece sus atributos y su comportamiento. Si no se especifica lo contrario, los atributos y métodos definidos en una clase serán "privados". Esto quiere decir que esas variables solo se pueden acceder y cambiar por los métodos de la clase (*constructores*, *"setters"* y *"getters"*, entre otros). 
 
 Lo siguiente es el esqueleto de la declaración de una clase:
 
 
 
 ```cpp
+
 class Bird : public QWidget
 {
-.
-.
-.
+
+//...
+
     Bird(int , EyeBrowType , QString , QString, QWidget *parent = 0) ;
     
     int getSize() const;
     void setEyebrow(EyeBrowType) ;
     void setFaceColor(QString) ;
     void setEyeColor(QString) ;
-.
-.
-.
+
+//...
+
 };
 ```
 ---
 
 La clase `Bird` que estarás usando en la sesión de hoy tiene dos constructores (funciones sobrecargadas):
 
-```cpp
-Bird (QWidget *parent=0)`
-```
+`Bird (QWidget *parent=0)`
 
-```cpp
-Bird (int, EyeBrowType, QString, QString, QWidget *parent=0)
-```
+`Bird (int, EyeBrowType, QString, QString, QWidget *parent=0)`
 
 Puedes ver las declaraciones de los prototipos de estos métodos en la declaración de la clase `Bird` en el archivo `bird.h` del proyecto. La documentación se encuentra en http://ada.uprrp.edu/~ranazario/bird-html/class_bird.html. El primer constructor, `Bird (QWidget *parent=0)`, es un método  que se puede invocar con uno o ningún argumento. Si al invocarlo no se usa argumento, el parámetro de la función toma el valor 0. 
 
 El constructor de una clase que se puede invocar sin usar argumentos es el *constructor* "*default*" de la clase; esto es, el constructor que se invoca cuando creamos un objeto usando una instrucción como:
 
-```cpp
-Bird pitirre;
-```
+`Bird pitirre;`
 
 Puedes ver las implementaciones de los métodos de la clase Birden el archivo `bird.cpp`. Nota que el primer constructor, `Bird (QWidget *parent=0)`, asignará valores aleatorios ("random") a cada uno de los atributos del objeto. Más adelante hay una breve explicación de la función `randInt`.
 
 Dale un vistazo a la documentación del segundo constructor, `Bird (int, EyeBrowType, QString, QString, QWidget *parent=0)`. Esta función requiere cuatro argumentos y tiene un quinto argumento que es opcional porque tiene un valor por defecto. Una manera para usar este constructor es creando un objeto como el siguiente:
 
-```cpp
-Bird guaraguao(200, Bird::UPSET, "blue", "red");
-```
+`Bird guaraguao(200, Bird::UPSET, "blue", "red");`
 
 
 ####"Setters" ("mutators")
 
 Puedes ver las declaraciones de los métodos en la Figura 1 y en la declaración de la clase `Bird` en  `bird.h`, y la implementación de algunos de los métodos en `bird.cpp`. El código en el siguiente ejemplo crea el objeto `bobo` de la clase `Bird` y luego cambia su tamaño a 333.
 
-```cpp
+```
 Bird bobo;
 bobo.setSize(333);
 ```
 
 Puedes ver las declaraciones de los métodos en la Figura 1 y en la declaración de la clase `Bird` en  `bird.h`, y las implementaciones de algunos de métodos en `bird.cpp`. El código en el siguiente ejemplo crea el objeto `piolin` de la clase `Bird` e imprime su tamaño.
 
-```cpp
+```
 Bird piolin;
 cout << piolin.getSize();
 ```
 
 **MainWindow:** El archivo `mainwindow.h` contiene la declaración de una clase llamada `MainWindow`. Los objetos que sean instancias de esta clase podrán utilizar los métodos sobrecargados
 
-```cpp
-void MainWindow::addBird(int x, int y, Bird &b)
-```
+`void MainWindow::addBird(int x, int y, Bird &b)`  
 
-```cpp
-void MainWindow::addBird(Bird &b)` 
-```
+`void MainWindow::addBird(Bird &b)` 
 
 que añadirán a la pantalla un dibujo del objeto de la clase `Bird` que es recibido como argumento. El código en el siguiente ejemplo crea un objeto `w` de la clase `MainWindow`, crea un objeto `zumbador` de la clase `Bird` y lo añade a la posición (200,200) de la pantalla `w` usando el primer método.
 
 
 
 ```cpp
+
 MainWindow w;
 Bird zumbador;
 w.addBird(200,200,zumbador);
 
 **randInt:** La clase `Bird` incluye el método
 
-```cpp
-int Bird::randInt(int min, int max)
-```
+`int Bird::randInt(int min, int max)`
 
 para generar números enteros aleatorios ("random") en el rango [min, max]. El método `randInt` depende de otra función para generar números aleatorios que requiere un primer elemento o *semilla* para ser evaluada. En este proyecto, ese primer elemento se genera con la invocación `srand(time(NULL)) ;`.
 
 
 
-!INCLUDE "../../eip-diagnostic/birds-objects/es/diag-birds-objects-01.html"
-
-!INCLUDE "../../eip-diagnostic/birds-objects/es/diag-birds-objects-02.html"
-
-!INCLUDE "../../eip-diagnostic/birds-objects/es/diag-birds-objects-03.html"
-
-!INCLUDE "../../eip-diagnostic/birds-objects/es/diag-birds-objects-04.html"
-
-!INCLUDE "../../eip-diagnostic/birds-objects/es/diag-birds-objects-05.html"
-
 ---
 
 ---
 En la experiencia de laboratorio de hoy utilizarás la clase `Bird` para practicar la creación de objetos, acceder y cambiar sus atributos.
 
 
-###Ejercicio 1
+###Ejercicio 1: Estudiar la clase `Bird`
 
 En este ejercicio te familiarizarás con la clase `Bird` y con algunos métodos asociados a la clase `MainWindow` que define la ventana en donde se despliegan resultados.
 
 
 3. En el archivo `main.cpp` (en Sources) la función `main` hace lo siguiente:
 
-    a. Crea un objeto aplicación de Qt, llamado `a`. Lo único que necesitas saber sobre este objeto es que gracias a él es que podemos crear una aplicación gráfica en Qt e interaccionar con ella.
+a. Crea un objeto aplicación de Qt, llamado `a`. Lo único que necesitas saber sobre este objeto es que gracias a él es que podemos crear una aplicación gráfica en Qt e interaccionar con ella.
 
-    b. Crea un objeto  de la clase MainWindow llamado `w`. Este objeto corresponde a la ventana que verás cuando corras la aplicación.
+ b. Crea un objeto  de la clase MainWindow llamado `w`. Este objeto corresponde a la ventana que verás cuando corras la aplicación.
 
-    c. Inicializa la semilla del generador de números aleatorios de Qt. Esto hará que los pájaros nuevos tengan tamaños, colores y cejas aleatorias (a menos que los forcemos a tener valores específicos).
+c. Inicializa la semilla del generador de números aleatorios de Qt. Esto hará que los pájaros nuevos tengan tamaños, colores y cejas aleatorias (a menos que los forcemos a tener valores específicos).
 
-    d. Invoca el método `show()` al objeto `w`. Esto logra que se muestre la ventana donde se desplegarán los resultados.
+d. Invoca el método `show()` al objeto `w`. Esto logra que se muestre la ventana donde se desplegarán los resultados.
 
-    e. En los programas que no tienen interfaz gráfica, la función `main()` usualmente termina con la instrucción `return 0;`. En este proyecto se utiliza la instrucción `return a.exec();` para que el objeto `a` se haga cargo de la aplicación a partir de ese momento.
+e. En los programas que no tienen interfaz gráfica, la función `main()` usualmente termina con la instrucción `return 0;`. En este proyecto se utiliza la instrucción `return a.exec();` para que el objeto `a` se haga cargo de la aplicación a partir de ese momento.
 
 4. Ejecuta el programa marcando la flecha verde en el menú de la izquierda de la ventana de Qt Creator. El programa debe mostrar una ventana blanca.
 
-###Ejercicio 2
+###Ejercicio 2: Crear objetos de clase `Bird` con ciertos atributos
 
-En este ejercicio crearás objetos del tipo `Bird` usando el constructor por defecto y usando constructores donde defines características específicas para el objeto. También practicarás el uso de "getters" y "setters" para obtener y asignar atributos a los objetos.
+En este ejercicio crearás objetos de clase `Bird` usando el constructor por defecto y usando constructores donde defines características específicas para el objeto. También practicarás el uso de "getters" y "setters" para obtener y asignar atributos a los objetos.
 
 **Instrucciones**
 
 
 3. Utiliza los "setters" `setSize(int size)`, `setFaceColor(Qstring color)`, `setEyeColor(Qstring color)`,  y `setEyebrow(EyeBrowType)` para que `abelardo` luzca como en la Figura 2  (su size es 200).
 
-    ---
+  
+  ---
 
-    ![figure2.png](images/figure2.png)
+  ![figure2.png](images/figure2.png)
 
-    **Figura 2.** Abelardo.
+  **Figura 2.** Abelardo.
 
-    ---
+  ---
 
-4. Crea otro objeto de la clase Bird llamado `piolin` que tenga cara azul, ojos verdes, y cejas UNI invocando el constructor `Bird(int size, EyeBrowType brow, QString faceColor, QString eyeColor, QWidget *parent = 0)`. Su tamaño debe ser la mitad que el de `abelardo`. Añádelo a la misma ventana donde se muestra a  `abelardo` usando `w.addBird(300, 100, piolin)` para obtener una imagen como la que se muestra en la Figura 3
 
-    ---
+4. Crea otro objeto de la clase Bird llamado `piolin` que tenga cara azul, ojos verdes, y cejas UNI invocando el constructor `Bird(int size, EyeBrowType brow, QString faceColor, QString eyeColor, QWidget *parent = 0)`. Su tamaño debe ser la mitad que el de `abelardo`. Añádelo a la misma ventana donde se muestra a  `abelardo` usando `w.addBird(300, 100, piolin)` para obtener una imagen como la que se muestra en la Figura 3.
 
-    ![figure3.png](images/figure3.png)
 
-    **Figura 3.** Abelardo y Piolin.
+   ---
+
+  ![figure3.png](images/figure3.png)
+
+  **Figura 3.** Abelardo y Piolin.
+
+  ---
 
-    ---
-    
 5. Crea otros dos objetos llamados `juana` y `alondra` que salgan dibujados en las coordenadas (100, 300) y (300,300) respectivamente. Crea a `juana` usando el constructor por defecto para que sus propiedades sean asignadas de forma aleatoria.
 Luego crea a `alondra` usando el otro constructor (el que recibe argumentos) para que puedas especificar sus propiedades durante su creación.  `alondra` debe ser  igual de grande que `juana`, tener el mismo tipo de cejas, y el mismo color de ojos.  Su cara debe ser blanca. Añade a `alondra` y a `juana` a la misma ventana de `abelardo` y `piolin`. La ventana debe ser similar a la de la Figura 4.
 
-    ---
+   ---
 
-    ![figure4.png](images/figure4.png)
+  ![figure4.png](images/figure4.png)
 
-    **Figura 4.** Abelardo, Piolín, Juana y Alondra.
+  **Figura 4.** Abelardo, Piolín, Juana y Alondra.
 
-    ---
+  ---
 
 6. Corre varias veces el programa para asegurarte que `alondra` y `juana` siguen pareciéndose en tamaño, cejas y ojos. 
 
 
 1. Reviewed the following concepts:
 
-    a. the creation of objects of a class.
+  a. the creation of objects of a class.
 
-    b. using the "getter" method functions to access the attributes of an object.
+  b. using the "getter" method functions to access the attributes of an object.
 
-    c. using the "setter" method functions to modify the attributes of an object.
+  c. using the "setter" method functions to modify the attributes of an object.
 
 2. Studied the documentation for the class `Bird` available in [this link.](http://ada.uprrp.edu/~ranazario/bird-html/class_bird.html)
 
 
 ###Classes
 
-A class is a piece of code that describes how objects will be. The variables or data's attributes that the object will contain are defined, and the methods that carry out a procedure on the object's data. To declare a class we should specify the types that the variables and the prototypes of the methods will have.
-
-If it isn't specified otherwise, the attributes and methods defined in a class will be private. This means that the variables can only be accessed and changed by the methods of the class (*constructors*, *setters*, and *getters*, among others).
+A class is a template for the creation of objects that establishes its attributes and behavior. If it isn't specified otherwise, the attributes and methods defined in a class will be private. This means that the variables can only be accessed and changed by the methods of the class (*constructors*, *setters*, and *getters*, among others).
 
 The following is the skeleton of the declaration of a class:
 
 ---
 
 ```cpp
+
   class ClassName
    {
     // Declarations
       type nameOfPublicMemFunc(type of the parameters);
    };
 ```
+
 ---
 
 You can see the declaration of the `Bird` class in the file `bird.h` included in this laboratory experience's program.
 
 
 ```cpp
+
 class Bird : public QWidget
 {
-.
-.
-.
+
+//...
+
     Bird(int , EyeBrowType , QString , QString, QWidget *parent = 0) ;
     
     int getSize() const;
     void setEyebrow(EyeBrowType) ;
     void setFaceColor(QString) ;
     void setEyeColor(QString) ;
-.
-.
-.
+
+//...
+
 };
 ```
 
 
 The class `Bird` that you will be using in today's session has two constructors (overloaded functions):
 
-```cpp
-Bird (QWidget *parent=0)
-```
+`Bird (QWidget *parent=0)`
 
-```cpp
-Bird (int, EyeBrowType, QString, QString, QWidget *parent=0)
-```
+`Bird (int, EyeBrowType, QString, QString, QWidget *parent=0)`
 
 You can see the declarations of the method prototypes in the declaration of the `Bird` class in the project's `bird.h` file. The documentation can be found in [this link.](http://ada.uprrp.edu/~ranazario/bird-html/class_bird.html) The first constructor, `Bird (QWidget *parent=0)`, is a method that can be invoked with one or no argument. If no argument is used, the function's parameter has a value of 0.
 
 A class' constructor that can be invoked without using an argument is the class' *default constructor*; that is, the constructor that is invoked when we create an object using an instruction  like:
 
-```cpp
-Bird pitirre;
-```
+`Bird pitirre;`
 
 You can see the implementations of the class `Bird` in the file `bird.cpp`. Note that the first constructor, `Bird (QWidget *parent=0)`, will assign random values to each of the object's attributes. Later on there is a brief explanation for the `randInt` function.
 
 Have a look at the documentation for the second constructor, `Bird (int, EyeBrowType, QString, QString, QWidget *parent=0)`. This function requires four arguments and has a fifth argument that is optional since it has a default value. One way to use this constructor is creating an object like this:
 
-```cpp
-Bird guaraguao(200, Bird::UPSET, "blue", "red");
-```
+`Bird guaraguao(200, Bird::UPSET, "blue", "red");`
+
 
 ####Setters (mutators)
 
 
 You can see the method's declarations in Figure 1 and in the `Bird` class declaration in `bird.h`, and the implementation of the some of the methods in `bird.cpp`. The code in the following example creates the object `bobo` of the `Bird` class and then changes its size to 333.
 
-```cpp
+```
 Bird bobo;
 bobo.setSize(333);
 ```
 
 You can see the declarations of the methods in Figure 1 and  in the `Bird` class declaration in `bird.h`, and the implementations of some of the methods in `bird.cpp`. The code in the following example creates the object `piolin` of the `Bird` class and prints its size:
 
-```cpp
+```
 Bird piolin;
 cout << piolin.getSize();
 ```
 
 **MainWindow:** The file `mainwindow.h` contains the declaration of a class called `MainWindow`. The objects that are instances of this class will be able to use the overloaded methods
 
-```cpp
-void MainWindow::addBird(int x, int y, Bird &b)
-```
+`void MainWindow::addBird(int x, int y, Bird &b)`  
 
-```cpp
-void MainWindow::addBird(Bird &b)
-```
+`void MainWindow::addBird(Bird &b)`  
 
 that will add to the screen a drawing of an object of the `Bird` class that is received as an argument. The code in the following example creates an object `w` of the `MainWindow` class, creates an object `zumbador` of the `Bird` class and adds it in the position (200,200) on the screen `w` using the first method.
 
 ```cpp
+
 MainWindow w;
 Bird zumbador;
 w.addBird(200,200,zumbador);
 
 **randInt:** The `Bird` class includes the method
 
-```cpp
-int Bird::randInt(int min, int max)
-```
-
+`int Bird::randInt(int min, int max)`
 
 to generate random numbers in the range [min, max]. The method `randInt` depends on another function to generate random numbers that require a first element or *seed* to be evaluated. In this project, that first element is generated with the function call `srand(time(NULL)) ;`.
 
 
-
-!INCLUDE "../../eip-diagnostic/birds-objects/en/diag-birds-objects-01.html"
-
-!INCLUDE "../../eip-diagnostic/birds-objects/en/diag-birds-objects-02.html"
-
-!INCLUDE "../../eip-diagnostic/birds-objects/en/diag-birds-objects-03.html"
-
-!INCLUDE "../../eip-diagnostic/birds-objects/en/diag-birds-objects-04.html"
-
-!INCLUDE "../../eip-diagnostic/birds-objects/en/diag-birds-objects-05.html"
-
 ---
 
 ---
 
 In today's laboratory experience you will use the `Bird` class to practice the creation of objects, accessing and changing its attributes.
 
-###Exercise 1
+###Exercise 1: Study the `Bird` class
 
 In this exercise you will familiarize yourself with the `Bird` class and with some methods associated with the `MainWindow` class that defines the window where the results are displayed.
 
 
 3. In the `main.cpp` file (in Sources) the `main` function does the following:
 
-    a. Creates a Qt object application, called `a`. The only thing you need to know is that thanks to this object we can create a graphical application in Qt and interact with it.
+a. Creates a Qt object application, called `a`. The only thing you need to know is that thanks to this object we can create a graphical application in Qt and interact with it.
 
-    b. Creates an object of the MainWindow class called `w`. This object corresponds to the window that you will see when you run the application.
+b. Creates an object of the MainWindow class called `w`. This object corresponds to the window that you will see when you run the application.
 
-    c. Initializes the seed of Qt's random number generator. As a result of this, the new birds will have random sizes, colors and eyebrows (unless we force them to have specific values).
+c. Initializes the seed of Qt's random number generator. As a result of this, the new birds will have random sizes, colors and eyebrows (unless we force them to have specific values).
 
-    d. Invokes the method `show()` on the object `w`. This shows the window where the results will be displayed.
+d. Invokes the method `show()` on the object `w`. This shows the window where the results will be displayed.
 
-    e. In programs that don't have a graphical interface, the `main()` function usually ends with the instruction `return 0;`. In this project, the `return a.exec();` instruction is used so that the object `a` takes charge of the application from that moment on.
+e. In programs that don't have a graphical interface, the `main()` function usually ends with the instruction `return 0;`. In this project, the `return a.exec();` instruction is used so that the object `a` takes charge of the application from that moment on.
 
 4. Execute the program by clicking on the green arrow in the left menu on the Qt Creator window. The program should display a blank window.
 
-###Exercise 2
+###Exercise 2: Create objects of the `Bird` class with certain attributes
 
-In this exercise you will create an object of type `Bird` using the default constructor and using constructors where you define specific characteristics for the object. You will also practice the use of getters and setters to obtain and assign attributes to the objects.
+In this exercise you will create objects of the  `Bird` class using the default constructor and using constructors where you define specific characteristics for the object. You will also practice the use of getters and setters to obtain and assign attributes to the objects.
 
 **Instructions**
 
 
 3. Use the setters `setSize(int size)`, `setFaceColor(Qstring color)`, `setEyeColor(Qstring color)`, and `setEyebrow(EyeBrowType)` so that `abelardo` looks as in Figure 2  (its size is 200).
 
-    ---
+  ---
 
-    ![figure2.png](images/figure2.png)
+  ![figure2.png](images/figure2.png)
 
-    **Figure 2.** Abelardo.
+  **Figure 2.** Abelardo.
 
-    ---
+  ---
 
 4. Create another object of class Bird called `piolin` that has a blue face, green eyes and UNI eyebrows invoking the constructor `Bird(int size, EyeBrowType brow, QString faceColor, QString eyeColor, QWidget *parent = 0)`. Its size should be half of `abelardo`'s. Add it to the same window where `abelardo` is being displayed by using `w.addBird(300, 100, piolin)`, to obtain an image like the one in Figure 3
 
-    ---
+  ---
 
-    ![figure3.png](images/figure3.png)
+  ![figure3.png](images/figure3.png)
 
-    **Figure 3.** Abelardo and Piolin.
+  **Figure 3.** Abelardo and Piolin.
 
-    ---
+  ---
 
 5. Create two other objects called `juana` and `alondra` that will appear drawn in the coordinates (100, 300) and (300,300) respectively. Create `juana` using the default constructor so that its properties are assigned randomly. Create `alondra` using the other constructor so that you may specify its properties during its creation.  `alondra` should have the same size as `juana`, have the same type of eyebrows, and the same eye color. Its face should be white. Add `alondra` and `juana` to the window where `abelardo` and `piolin` are. The window should look similar to the one in Figure 4.
 
-    ---
+  ---
 
-    ![figure4.png](images/figure4.png)
+  ![figure4.png](images/figure4.png)
 
-    **Figure 4.** Abelardo, Piolin, Juana and Alondra.
+  **Figure 4.** Abelardo, Piolin, Juana and Alondra.
 
-    ---
+  ---
 
 6. Run the program several times making sure that `alondra` and `juana` have the same size, eyebrows and eyes.
 
 ##References
 
 
-https://sites.google.com/a/wellesley.edu/wellesley-cs118-spring13/lectures-labs/lab-2
-
-
-
-
-
-
-
-
-
-
-
+https://sites.google.com/a/wellesley.edu/wellesley-cs118-spring13/lectures-labs/lab-2

bird.cpp

 
 #include "bird.h"
 
-/// \fn Bird::Bird(QWidget *parent)
-/// \~English
-/// \brief Default constructor. The properties of the bird are set as follows:
-/// size: set to random value of either 50, 100, 150 or 200
+///
+/// Default constructor. The properties of the bird are set as follows:
+/// * size: set to random value of either 50, 100, 150 or 200
 /// * eyeBrow: set randomly to one of the five possible values
 /// * color and eColor: set randomly to one of the five possible colors: 
 /// "green", "blue", "red", "yellow", "white"
-/// \~Spanish
-/// \brief Constructor por defecto. Las propiedades de el pajaron son ajustados como sigue:
-/// * eyeBrow: ajustado aleatoriamente a uno de los 5 posibles valores
-/// * color y eColor: ajustao aleatoriamente a uno de los 5 posibles colores:
-/// "verde", "azul", "rojo", "amarillo", "blanco"
 ///
 Bird::Bird(QWidget *parent) :
     QWidget(parent)
     setStyleSheet("background:transparent;");
 }
 
-/// \fn Bird::Bird(int s, EyeBrowType eb, QString col, QString eye, QWidget *parent)
-/// \~English
-/// \brief Constructor which accepts specification of the attributes of the bird
-/// \param s size
-/// \param eb eyeBrow
-/// \param col (faceColor)
-/// \param eye (eyeColor)
-/// \~Spanish
-/// \brief Constructor que acepta especificaciones de los atributos del pajaro
-/// \param s tamaño
-/// \param eb cejas
-/// \param col color de la cara
-/// \param eye color del ojo
+///
+/// Constructor which accepts specification for s (size), eb (eyeBrow),
+/// col (faceColor), eye (eyeColor)
+///
 Bird::Bird(int s, EyeBrowType eb, QString col, QString eye, QWidget *parent):
     QWidget(parent)
 {
     setStyleSheet("background:transparent;");
 }
 
-/// \fn QString  Bird::getEyeColor()
-/// \~English
-/// \brief Getter for the eyeColor.
-/// \~Spanish
-/// \brief Devuelve el color del ojo.
-QString  Bird::getEyeColor() const{
+///
+/// Getter for the eyeColor.
+///
+QString  Bird::getEyeColor(){
     return eColor ;
 }
 
-/// \fn QString  Bird::getFaceColor()
-/// \~English
-/// \brief Getter for the faceColor.
-/// \~Spanish
-/// \brief Devuelve el color de la cara.
-QString  Bird::getFaceColor() const{
+///
+/// Getter for the faceColor.
+///
+QString  Bird::getFaceColor(){
     return color ;
 }
 
-/// \fn void  Bird::setEyeColor(QString eye)
-/// \~English
-/// \brief Setter for the eyeColor.
-/// \param eye eyeColor
-/// \~Spanish
-/// \brief Ajusta el color del ojo
-/// \param eje color del ojo
+///
+/// Setter for the eyeColor.
+///
 void  Bird::setEyeColor(QString eye){
     eColor = eye ;
 }
 
-/// \fn void  Bird::setFaceColor(QString col)
-/// \~English
-/// \brief Setter for the face color.
-/// \param col face Color
-/// \~Spanish
-/// \brief Ajusta el color de la cara
-/// \param col color de la cara
+///
+/// Setter for the faceColor.
+///
 void  Bird::setFaceColor(QString col){
     color =   col;
 }
 
-/// \fn int Bird::getSize()
-/// \~English
-/// \brief Getter for the bird size.
-/// \~Spanish
-/// \brief Devuelve el tamano del pajaro.
-int Bird::getSize() const{
+///
+/// Getter for the size.
+///
+int Bird::getSize(){
     return size ;
 }
 
-/// \fn int Bird::getEyeBrow()
-/// \~English
-/// \brief Getter for the bird eyeBrow type
-/// \~Spanish
-/// \brief Devuelve el tipo de ceja
-Bird::EyeBrowType Bird::getEyebrow() const{
+///
+/// Getter for the Eyebrow.
+///
+Bird::EyeBrowType Bird::getEyebrow(){
     return eyeBrow ;
 }
 
-/// \fn void  Bird::setSize(int s)
-/// \~English
-/// \brief Setter for the bird size.
-/// \param s bird size
-/// \~Spanish
-/// \brief Ajusta el tamano del pajaro
-/// \param s tamano del pajaro
+///
+/// Setter for the size.
+///
 void Bird::setSize(int s){
-    if(s <= 100 || s > 300)
-        size = 100 ;
-    else size = s;
+  //  if(s <= 100 || s > 300)
+  //     size = 100 ;
+  //  else
+    size = s;
     resize(size + 2, size + 2) ;
 }
 
-/// \fn void  Bird::setEyebrow(QString eye)
-/// \~English
-/// \brief Setter for the eyebrow type.
-/// \param eb eyebrow type
-/// \~Spanish
-/// \brief Ajusta el tipo de cejas
-/// \param eb tipo de ceja
+///
+/// Setter for the Eyebrow.
+///
 void Bird::setEyebrow(EyeBrowType eb){
     if(eb < 0 || eb > 3)
         eyeBrow = UNI ;
     else eyeBrow = eb;
 }
 
-/// \fn Qt::GlobalColor Bird::getColor(QString color)
-/// \~English
-/// \brief Converts a color specified as string to a Qt::GlobalColor
-/// \param color string with a color
-/// \~Spanish
-/// \brief Convierte un color especificado como un string a un Qt::GlobalColor
-/// \param color cadena de caracteres de un color
-Qt::GlobalColor Bird::getColor(QString color) const{
+///
+/// Converts a color specified as string to a Qt::GlobalColor
+///
+Qt::GlobalColor Bird::getColor(QString color){
 
     if(color=="red")
         return Qt::red ;
 
 }
 
-/// \fn int Bird::randInt(int min, int max)
-/// \~English
-/// \brief Generates a random integer in the range [min, max]
-/// \param min minimum random value
-/// \param max maximum random value
-/// \~Spanish
-/// \brief Genera un entero aleatorio en el rango [min, max]
-/// \param min valor aleatorio minimo
-/// \param max valor aleatorio maximo
+///
+/// Generates a random integer in the range [min, max]
 ///
 int Bird::randInt(int min, int max){
     return qrand() % ((max +1 )- min) +  min ;
 }
 
+///
+/// Assignment operator
+///
+Bird & Bird::operator=(Bird &b) {
+    return *this;
+}
 
-/// \fn void Bird::paintEvent(QPaintEvent *event)
-/// \~English
-/// \brief This function is automatically invoked each time the widget or
+///
+/// This function is automatically invoked each time the widget or 
 /// its parent receives a repaint signal.
-/// \~Spanish
-/// \brief Esta funcion es invocada automaticamente cada ves que el widget
-/// o su padre recive una senal de repintar.
 ///
-void Bird::paintEvent(QPaintEvent *) {
+void Bird::paintEvent(QPaintEvent *event) {
     QPainter p(this);
 
     QPen outlinePen(Qt::black);

bird.h

         BUSHY   /**< enum value 3 */
     };
     
-    /// \fn Bird::Bird(QWidget *parent)
-    /// \~English
-    /// \brief Default constructor. The properties of the bird are set as follows:
-    /// size: set to random value of either 50, 100, 150 or 200
-    /// * eyeBrow: set randomly to one of the five possible values
-    /// * color and eColor: set randomly to one of the five possible colors:
-    /// "green", "blue", "red", "yellow", "white"
-    /// \~Spanish
-    /// \brief Constructor por defecto. Las propiedades de el pajaron son ajustados como sigue:
-    /// * eyeBrow: ajustado aleatoriamente a uno de los 5 posibles valores
-    /// * color y eColor: ajustao aleatoriamente a uno de los 5 posibles colores:
-    /// "verde", "azul", "rojo", "amarillo", "blanco"
-    ///
     explicit Bird(QWidget *parent = 0);
-
-    /// \fn Bird::Bird(int s, EyeBrowType eb, QString col, QString eye, QWidget *parent)
-    /// \~English
-    /// \brief Constructor which accepts specification of the attributes of the bird
-    /// \param s size
-    /// \param eb eyeBrow
-    /// \param col (faceColor)
-    /// \param eye (eyeColor)
-    /// \~Spanish
-    /// \brief Constructor que acepta especificaciones de los atributos del pajaro
-    /// \param s tamaño
-    /// \param eb cejas
-    /// \param col color de la cara
-    /// \param eye color del ojo
     Bird(int , EyeBrowType , QString , QString, QWidget *parent = 0) ;
-
-    /// \fn QString  Bird::getEyeColor()
-    /// \~English
-    /// \brief Getter for the eyeColor.
-    /// \~Spanish
-    /// \brief Devuelve el color del ojo.
-    QString  getEyeColor() const;
-
-    /// \fn QString  Bird::getFaceColor()
-    /// \~English
-    /// \brief Getter for the faceColor.
-    /// \~Spanish
-    /// \brief Devuelve el color de la cara.
-    QString  getFaceColor() const;
-
-    /// \fn void  Bird::setEyeColor(QString eye)
-    /// \~English
-    /// \brief Setter for the eyeColor.
-    /// \param eye eyeColor
-    /// \~Spanish
-    /// \brief Ajusta el color del ojo
-    /// \param eje color del ojo
-    ///
+    QString  getEyeColor() ;
+    QString  getFaceColor() ;
     void  setEyeColor(QString) ;
-
-    /// \fn void  Bird::setFaceColor(QString col)
-    /// \~English
-    /// \brief Setter for the face color.
-    /// \param col face Color
-    /// \~Spanish
-    /// \brief Ajusta el color de la cara
-    /// \param col color de la cara
     void  setFaceColor(QString) ;
-
-    /// \fn int Bird::getSize()
-    /// \~English
-    /// \brief Getter for the bird size.
-    /// \~Spanish
-    /// \brief Devuelve el tamano del pajaro.
-    int getSize() const ;
-
-    /// \fn int Bird::getEyeBrow()
-    /// \~English
-    /// \brief Getter for the bird eyeBrow type
-    /// \~Spanish
-    /// \brief Devuelve el tipo de ceja
-    EyeBrowType getEyebrow() const;
-
-    /// \fn void  Bird::setSize(int s)
-    /// \~English
-    /// \brief Setter for the bird size.
-    /// \param s bird size
-    /// \~Spanish
-    /// \brief Ajusta el tamano del pajaro
-    /// \param s tamano del pajaro
+    int getSize() ;
+    EyeBrowType getEyebrow() ;
     void setSize(int) ;
-
-    /// \fn void  Bird::setEyebrow(QString eye)
-    /// \~English
-    /// \brief Setter for the eyebrow type.
-    /// \param eb eyebrow type
-    /// \~Spanish
-    /// \brief Ajusta el tipo de cejas
-    /// \param eb tipo de ceja
     void setEyebrow(EyeBrowType) ;
+    Qt::GlobalColor getColor(QString) ;
 
-    /// \fn Qt::GlobalColor Bird::getColor(QString color)
-    /// \~English
-    /// \brief Converts a color specified as string to a Qt::GlobalColor
-    /// \param color string with a color
-    /// \~Spanish
-    /// \brief Convierte un color especificado como un string a un Qt::GlobalColor
-    /// \param color cadena de caracteres de un color
-    Qt::GlobalColor getColor(QString) const;
-
+    Bird & operator=(Bird &b);
 signals:
 
 public slots:
 
 protected:
-    /// \fn void Bird::paintEvent(QPaintEvent *event)
-    /// \~English
-    /// \brief This function is automatically invoked each time the widget or
-    /// its parent receives a repaint signal.
-    /// \~Spanish
-    /// \brief Esta funcion es invocada automaticamente cada ves que el widget
-    /// o su padre recive una senal de repintar.
-    void paintEvent(QPaintEvent *);
+    void paintEvent(QPaintEvent *event);
 
 private:
-    int size ; /**< size of the bird*/
-    EyeBrowType eyeBrow ; /**< eyebrow type (ceja)*/
-    QString color ; /**< face color  (cara)*/
-    QString eColor ; /**< eye color (ojos)*/
-
-    /// \fn int Bird::randInt(int min, int max)
-    /// \~English
-    /// \brief Generates a random integer in the range [min, max]
-    /// \param min minimum random value
-    /// \param max maximum random value
-    /// \~Spanish
-    /// \brief Genera un entero aleatorio en el rango [min, max]
-    /// \param min valor aleatorio minimo
-    /// \param max valor aleatorio maximo
-    ///
+    int size ;
+    EyeBrowType eyeBrow ;
+    QString color ;
+    QString eColor ;
     int randInt(int min, int max) ;
 };
 

filter.cpp

 #include "bird.h"
-
-/// \file
-
-/// \fn void FilterBirds(Bird birds[], int N)
-/// \~English
-/// \brief Funtion that receives an array with birds and only shows
-/// the birds that pass a filter.
-/// \param birds Array of birds.
-/// \param N number of birds.
-/// \~Spanish
-/// \brief Funcion que recibe un arreglo de pajaros (tipo Bird) y solo demuestra
-/// los pajaros que pasan el filtro.
-/// \param birds arreglo de pajaros (tipo Bird).
-/// \param N numero de pajaros.
 void FilterBirds(Bird birds[], int N){
 
     for(int i = 0; i < N; i++){

mainwindow.cpp

 #include "mainwindow.h"
 #include "ui_mainwindow.h"
 
-/// \fn MainWindow::MainWindow(QWidget *parent)
-/// \~English
-/// \brief Constructor
-/// \~Spanish
-/// \brief Constructor
 MainWindow::MainWindow(QWidget *parent) :
     QMainWindow(parent),
     ui(new Ui::MainWindow)
     ui->mainView->setAlignment((Qt::AlignLeft | Qt::AlignTop));
 }
 
-/// \fn MainWindow::~MainWindow(QWidget *parent)
-/// \~English
-/// \brief Destructor
-/// \~Spanish
-/// \brief Destructor
 MainWindow::~MainWindow()
 {
     delete ui;
     delete scene;
 }
 
-/// \fn void MainWindow::addBird(int x, int y, Bird &b)
-/// \~English
-/// \brief Paints a bird into the MainWindow
-/// \param x X coordinate of the Main Window
-/// \param y Y coordinate of the Main Window
-/// \param b Bird object to be painted
-/// \~Spanish
-/// \brief Pinta un pajaro en la pantalla principal
-/// \param x Coordenada X de la pantalla principal
-/// \param y Coordenada Y de la pantalla principal
-/// \param b Objecto Bird a ser pintado
 void MainWindow::addBird(int x, int y, Bird &b){
     scene->addWidget(&b) ;
     b.move(x,y) ;
 }
 
-/// \fn void MainWindow::addBird(Bird &b)
-/// \~English
-/// \brief Paints a bird into the MainWindow
-/// \param b Bird object to be painted
-/// \~Spanish
-/// \brief Pinta un pajaro en la pantalla principal
-/// \param b Objecto Bird a ser pintado
 void MainWindow::addBird(Bird &b){
     scene->addWidget(&b) ;
 }

mainwindow.h

     Q_OBJECT
 
 public:
-    /// \fn MainWindow::MainWindow(QWidget *parent)
-    /// \~English
-    /// \brief Constructor
-    /// \~Spanish
-    /// \brief Constructor
     explicit MainWindow(QWidget *parent = 0);
-
-    /// \fn MainWindow::~MainWindow(QWidget *parent)
-    /// \~English
-    /// \brief Destructor
-    /// \~Spanish
-    /// \brief Destructor
     ~MainWindow();
-
-    /// \fn void MainWindow::addBird(int x, int y, Bird &b)
-    /// \~English
-    /// \brief Paints a bird into the MainWindow
-    /// \param x X coordinate of the Main Window
-    /// \param y Y coordinate of the Main Window
-    /// \param b Bird object to be painted
-    /// \~Spanish
-    /// \brief Pinta un pajaro en la pantalla principal
-    /// \param x Coordenada X de la pantalla principal
-    /// \param y Coordenada Y de la pantalla principal
-    /// \param b Objecto Bird a ser pintado
     void addBird(int x, int y, Bird &b) ;
-
-    /// \fn void MainWindow::addBird(Bird &b)
-    /// \~English
-    /// \brief Paints a bird into the MainWindow
-    /// \param b Bird object to be painted
-    /// \~Spanish
-    /// \brief Pinta un pajaro en la pantalla principal
-    /// \param b Objecto Bird a ser pintado
     void addBird(Bird &b) ;
 
 private: