tp5window.cpp

   1 /* vim: set et sts=4 sw=4 fdm=indent fdn=1 fo+=t tw=80 fileencoding=utf-8:
   2  *
   3  * Taller de Programación (75.42).
   4  *
   5  * Ejercicio Número 5:
   6  * Graficador de figuras.
   7  *
   8  * Copyleft 2003 - Leandro Lucarella <llucare@fi.uba.ar>
   9  * Puede copiar, modificar y distribuir este programa bajo los términos de
  10  * la licencia GPL (http://www.gnu.org/).
  11  *
  12  * Creado: mié oct  1 23:31:40 ART 2003
  13  *
  14  * $Id$
  15  */
  16
  17 #include "callbacks.h"
  18 #include "tp5window.h"
  19 #include "dibujo.h"
  20
  21 #include <cstring>
  22 #include <gtk/gtk.h>
  23
  24 const char* TP5Window::COLOR[] = {
  25     "Negro",
  26     "Azul Oscuro",
  27     "Verde Oscuro",
  28     "Cián Oscuro",
  29     "Rojo Oscuro",
  30     "Magenta Oscuro",
  31     "Amarillo Oscuro",
  32     "Gris Oscuro",
  33     "Gris",
  34     "Azul",
  35     "Verde",
  36     "Cián",
  37     "Rojo",
  38     "Magenta",
  39     "Amarillo",
  40     "Blanco"
  41 };
  42
  43 int TP5Window::get_color(void) const {
  44     // Obtiene el string del color elegido.
  45     const char* str = gtk_entry_get_text(
  46             GTK_ENTRY(GTK_COMBO(combo_color)->entry));
  47     for (int i = 0; i < CANT_COLORES; i++) {
  48         // Si el string con el color coincide, devuelvo el índice.
  49         if (!strcmp(str, COLOR[i])) {
  50             return i;
  51         }
  52     }
  53     // No debería pasar nunca.
  54     return -1;
  55 }
  56
  57 TP5Window::TP5Window(void) {
  58     // Widgets utilizados, de los cuales no voy a guardar un puntero de acceso
  59     // rápido en la clase porque no se usan más que para el funcionamiento
  60     // general de la interfaz gráfica.
  61     GtkWidget *vbox;
  62     GtkWidget *hbox_botones;
  63     GtkWidget *frame_dibujo;
  64     GtkWidget *label_dibujo;
  65     GtkWidget *vbuttonbox_botones;
  66     GtkWidget *hbox;
  67     GtkWidget *frame_figura;
  68     GtkWidget *vbox_figura;
  69     GSList    *radiobutton_group = NULL;
  70     GtkWidget *label_figura;
  71     GtkWidget *vbox_comun;
  72     GtkWidget *table_comun;
  73     GtkWidget *label_nombre;
  74     GtkWidget *label_color;
  75     GtkWidget *label_grosor;
  76     GtkWidget *combo_entry;
  77     GtkObject *spinbutton_grosor_adj;
  78     GtkWidget *vbox_otros;
  79     GtkWidget *table_puntos;
  80     GtkWidget *label_centro;
  81     GtkWidget *label_inicio;
  82     GtkWidget *label_fin;
  83     GtkWidget *label_puntos;
  84     GtkWidget *label_x;
  85     GtkWidget *label_y;
  86     GtkObject *spinbutton_centro_x_adj;
  87     GtkObject *spinbutton_centro_y_adj;
  88     GtkObject *spinbutton_inicio_x_adj;
  89     GtkObject *spinbutton_inicio_y_adj;
  90     GtkObject *spinbutton_fin_x_adj;
  91     GtkObject *spinbutton_fin_y_adj;
  92     GtkWidget *table_otros;
  93     GtkWidget *label_alto;
  94     GtkWidget *label_ancho;
  95     GtkWidget *label_radio;
  96     GtkObject *spinbutton_alto_adj;
  97     GtkObject *spinbutton_ancho_adj;
  98     GtkObject *spinbutton_radio_adj;
  99     combo_color_items = NULL;
 100
 101     // Creo ventana principal.
 102     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 103     // Asigna márgen a la ventana (se va a dibujar los controles 5 píxeles por
 104     // dentro de la ventana.
 105     gtk_container_set_border_width(GTK_CONTAINER(window), 5);
 106     // Asigno título a la ventana.
 107     gtk_window_set_title(GTK_WINDOW(window), "Trabajo Práctico V");
 108
 109     // Divide la ventana en 2 verticalmente. Abajo irán los controles para crear
 110     // figuras, arriba el área de dibujo y los controles de dibujo/salida.
 111     vbox = gtk_vbox_new(
 112             FALSE, // No se distribuye homogeneamente.
 113             0);    // Espaciado.
 114     gtk_container_add(GTK_CONTAINER(window), vbox);
 115
 116     // Divide en dos horizontalmente la porción de arriba. A la izquierda irá el
 117     // área de dibujo y a la derecha los botones de dibujo/salida.
 118     hbox_botones = gtk_hbox_new(FALSE, 5);
 119     gtk_box_pack_start(GTK_BOX(vbox), hbox_botones, TRUE, TRUE, 0);
 120     //                                              ^|^^  ^|^^  |
 121     // Indica si se expanda cuando se cambia el  <---'     |    |
 122     // tamaño de la ventana.                               |    |
 123     //                                                     |    |
 124     // Indica que se debe rellenar toda el área  <---------'    V
 125     // expandida con el widget que contiene.                 Espaciado
 126
 127     // Crea un marco con una leyenda para indicar que dentro está el área de
 128     // dibujo.
 129     frame_dibujo = gtk_frame_new(NULL);
 130     gtk_box_pack_start(GTK_BOX(hbox_botones), frame_dibujo, TRUE, TRUE, 0);
 131
 132     // Crea la leyenda y la agrega al marco.
 133     label_dibujo = gtk_label_new("Dibujo");
 134     gtk_frame_set_label_widget(GTK_FRAME(frame_dibujo), label_dibujo);
 135
 136     // Crea el área de dibujo y la agrega al marco.
 137     drawingarea = gtk_drawing_area_new();
 138     gtk_container_add(GTK_CONTAINER(frame_dibujo), drawingarea);
 139     // Sugiere un tamaño de 200x200, pero puede adaptarse si se cambia el tamaño
 140     // de la ventana.
 141     gtk_widget_set_size_request(drawingarea, 200, 200);
 142
 143     // Crea una barra vertical de tres botones relativos al dibujo (y
 144     // salida). Esto es agregado a la región de la derecha del dibujo.
 145     vbuttonbox_botones = gtk_vbutton_box_new();
 146     gtk_box_pack_start(GTK_BOX(hbox_botones), vbuttonbox_botones, FALSE,
 147             TRUE, 0);
 148     // Deja un márgen de 5 píxeles.
 149     gtk_container_set_border_width(GTK_CONTAINER(vbuttonbox_botones), 5);
 150     // Ajusta la distribución de los botones.
 151     gtk_button_box_set_layout(GTK_BUTTON_BOX(vbuttonbox_botones),
 152             GTK_BUTTONBOX_SPREAD);
 153
 154     // Agrega un botón predefinido para limpiar (con ícono y traducido a varios
 155     // idiomas).
 156     button_limpiar = gtk_button_new_from_stock("gtk-clear");
 157     gtk_container_add(GTK_CONTAINER(vbuttonbox_botones), button_limpiar);
 158
 159     // Agrega un botón predefinido para actualizar (con ícono y traducido a
 160     // varios idiomas).
 161     button_actualizar = gtk_button_new_from_stock("gtk-refresh");
 162     gtk_container_add(GTK_CONTAINER(vbuttonbox_botones), button_actualizar);
 163
 164     // Agrega un botón predefinido para salir (con ícono y traducido a varios
 165     // idiomas).
 166     button_salir = gtk_button_new_from_stock("gtk-quit");
 167     gtk_container_add(GTK_CONTAINER(vbuttonbox_botones), button_salir);
 168
 169     /////////////// FIN DE LA MITAD SUPERIOR DE LA PANTALLA ///////////////////
 170
 171     // Se divide la parte inferior en tres columnas.
 172     hbox = gtk_hbox_new(FALSE, 0);
 173     gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
 174
 175     //////////// PRIMERA COLUMNA //////////////
 176     // Crea un marco con una leyenda para poner los botones de selección de tipo
 177     // de figura.
 178     frame_figura = gtk_frame_new(NULL);
 179     gtk_box_pack_start(GTK_BOX(hbox), frame_figura, FALSE, FALSE, 0);
 180     // Crea la leyenda del marco.
 181     label_figura = gtk_label_new("Figura");
 182     gtk_frame_set_label_widget(GTK_FRAME(frame_figura), label_figura);
 183
 184     // Crea una división vertical para poner los botones de selección del tipo
 185     // de figura.
 186     vbox_figura = gtk_vbox_new(FALSE, 0);
 187     gtk_container_add(GTK_CONTAINER(frame_figura), vbox_figura);
 188
 189     // Agrega botón de selección (radio button) para Línea.
 190     radiobutton_linea = gtk_radio_button_new_with_mnemonic(NULL, "_Línea");
 191     gtk_box_pack_start(GTK_BOX(vbox_figura), radiobutton_linea,FALSE,FALSE,0);
 192     // Lo agrega a un grupo de botones para controlar que sólo uno esté activo.
 193     gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_linea),
 194             radiobutton_group);
 195     // Obtiene el puntero al grupo (ya que la función anterior también
 196     // inicializa el grupo que estaba en NULL.
 197     radiobutton_group = gtk_radio_button_get_group(
 198             GTK_RADIO_BUTTON(radiobutton_linea));
 199     // Activa el botón.
 200     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_linea), TRUE);
 201
 202     // Agrega botón de selección (radio button) para Cuadrado.
 203     radiobutton_cuadrado = gtk_radio_button_new_with_mnemonic(NULL, "_Cuadrado");
 204     gtk_box_pack_start(GTK_BOX(vbox_figura), radiobutton_cuadrado, FALSE, FALSE, 0);
 205     gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_cuadrado), radiobutton_group);
 206     radiobutton_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_cuadrado));
 207
 208     // Agrega botón de selección (radio button) para Rectángulo.
 209     radiobutton_rectangulo = gtk_radio_button_new_with_mnemonic(NULL, "_Rectángulo");
 210     gtk_box_pack_start(GTK_BOX(vbox_figura), radiobutton_rectangulo, FALSE, FALSE, 0);
 211     gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_rectangulo), radiobutton_group);
 212     radiobutton_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_rectangulo));
 213
 214     // Agrega botón de selección (radio button) para Círculo.
 215     radiobutton_circulo = gtk_radio_button_new_with_mnemonic(NULL, "Círc_ulo");
 216     gtk_box_pack_start(GTK_BOX(vbox_figura), radiobutton_circulo, FALSE, FALSE, 0);
 217     gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_circulo), radiobutton_group);
 218     radiobutton_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_circulo));
 219
 220     //////////// SEGUNDA COLUMNA //////////////
 221     // Crea una división vertical para poner los campos comunes a todas las
 222     // figuras y el botón de agregar.
 223     vbox_comun = gtk_vbox_new(FALSE, 0);
 224     gtk_box_pack_start(GTK_BOX(hbox), vbox_comun, TRUE, TRUE, 0);
 225
 226     // Crea una tabla de 3x2 para poner los campos de entrada con sus etiquetas.
 227     table_comun = gtk_table_new(3, 2, FALSE);
 228     gtk_box_pack_start(GTK_BOX(vbox_comun), table_comun, TRUE, TRUE, 0);
 229     gtk_container_set_border_width(GTK_CONTAINER(table_comun), 5);
 230     // Asigna el espaciado entre celdas.
 231     gtk_table_set_row_spacings(GTK_TABLE(table_comun), 3);
 232     gtk_table_set_col_spacings(GTK_TABLE(table_comun), 5);
 233
 234     // Crea la etiqueta de Nombre.
 235     label_nombre = gtk_label_new("Nombre");
 236     // La agrega a la tabla.
 237     gtk_table_attach(GTK_TABLE(table_comun), label_nombre, 0, 1, 0, 1,
 238            (GtkAttachOptions)(GTK_FILL),
 239            (GtkAttachOptions)(0), 0, 0);
 240
 241     // Crea y agrega la etiqueta de Color.
 242     label_color = gtk_label_new("Color");
 243     gtk_table_attach(GTK_TABLE(table_comun), label_color, 0, 1, 1, 2,
 244            (GtkAttachOptions)(GTK_FILL),
 245            (GtkAttachOptions)(0), 0, 0);
 246
 247     // Crea y agrega la etiqueta de Grosor.
 248     label_grosor = gtk_label_new("Grosor");
 249     gtk_table_attach(GTK_TABLE(table_comun), label_grosor, 0, 1, 2, 3,
 250            (GtkAttachOptions)(GTK_FILL),
 251            (GtkAttachOptions)(0), 0, 0);
 252
 253     // Crea y agrega una entrada texto para el Nombre.
 254     entry_nombre = gtk_entry_new();
 255     gtk_table_attach(GTK_TABLE(table_comun), entry_nombre, 1, 2, 0, 1,
 256            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 257            (GtkAttachOptions)(GTK_EXPAND), 0, 0);
 258     // Sugiere un tamaño en X de 100 píxeles.
 259     gtk_widget_set_size_request(entry_nombre, 100, -1);
 260
 261     // Agrega un combo para elegir el color.
 262     combo_color = gtk_combo_new();
 263     gtk_table_attach(GTK_TABLE(table_comun), combo_color, 1, 2, 1, 2,
 264            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 265            (GtkAttachOptions)(GTK_EXPAND), 0, 0);
 266     // Sugiere un tamaño en X de 150 píxeles.
 267     gtk_widget_set_size_request(combo_color, 150, -1);
 268     // Indica que sólo acepta valores que estén en la lista.
 269     gtk_combo_set_value_in_list(GTK_COMBO(combo_color),
 270             TRUE,   // Solo acepta valores en la lista.
 271             FALSE); // No puede estar vacío.
 272     // Llena la lista con los colores admitidos.
 273     for (int i = 0; i < CANT_COLORES; i++) {
 274         combo_color_items = g_list_append(combo_color_items,(gpointer) COLOR[i]);
 275     }
 276     // Copia la lista para usarla en el combo.
 277     gtk_combo_set_popdown_strings(GTK_COMBO(combo_color), combo_color_items);
 278     // Libera la memoria de la lista temporal.
 279     g_list_free(combo_color_items);
 280     // Obtiene el campo de entrada del combo.
 281     combo_entry = GTK_COMBO(combo_color)->entry;
 282     // Hace que no pueda editarse.
 283     gtk_editable_set_editable(GTK_EDITABLE(combo_entry), FALSE);
 284     // Setea el primer color por defecto.
 285     gtk_entry_set_text(GTK_ENTRY(combo_entry), COLOR[0]);
 286
 287     // Crea valores de ajuste para la entrada de Grosor.
 288     spinbutton_grosor_adj = gtk_adjustment_new(
 289             1,   // Valor inicial.
 290             1,   // Mínimo.
 291             10,  // Máximo.
 292             1,   // Tamaño del paso de incremento.
 293             10,  // Tamaño del paso de incremento de página. | no aplicable
 294             10); // Tamaño de página.                        | en este caso.
 295     // Crea la entrada de grosor con flechas de incremento y decremento.
 296     spinbutton_grosor = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_grosor_adj), 1, 0);
 297     // Agrega a la tabla.
 298     gtk_table_attach(GTK_TABLE(table_comun), spinbutton_grosor, 1, 2, 2, 3,
 299            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 300            (GtkAttachOptions)(GTK_EXPAND), 0, 0);
 301     // Sugiere el tamaño.
 302     gtk_widget_set_size_request(spinbutton_grosor, 48, -1);
 303
 304     // Agrega el botón de Agregar.
 305     button_agregar = gtk_button_new_from_stock("gtk-add");
 306     gtk_box_pack_start(GTK_BOX(vbox_comun), button_agregar, FALSE, FALSE, 0);
 307
 308     ///////////////// TERCERA COLUMNA /////////////////
 309     // Divide la comunma verticalmente en 2, arriba iran las entradas de puntos
 310     // y abajo el alto, ancho y radio.
 311     vbox_otros = gtk_vbox_new(FALSE, 5);
 312     gtk_box_pack_start(GTK_BOX(hbox), vbox_otros, FALSE, FALSE, 0);
 313     gtk_container_set_border_width(GTK_CONTAINER(vbox_otros), 5);
 314
 315     // Crea una tabla de 4x3 para poner las entradas de los puntos con
 316     // etiquetas de una forma como esta:
 317     //        | X | Y | \.
 318     // -------+---+---+ |
 319     // Centro |   |   | |
 320     // -------+---+---+ +--> 4
 321     // Inicio |   |   | |
 322     // -------+---+---+ |
 323     // Fin    |   |   | |
 324     // -------+---+---+/
 325     // \_______.______/
 326     //         |
 327     //         V
 328     //         3
 329     table_puntos = gtk_table_new(4, 3, FALSE);
 330     gtk_box_pack_start(GTK_BOX(vbox_otros), table_puntos, FALSE, FALSE, 0);
 331     gtk_table_set_col_spacings(GTK_TABLE(table_puntos), 2);
 332
 333     // Agrega una etiqueta vacía para la esquina superior izquierda.
 334     label_puntos = gtk_label_new("");
 335     gtk_table_attach(GTK_TABLE(table_puntos), label_puntos, 0, 1, 0, 1,
 336            (GtkAttachOptions)(GTK_FILL),
 337            (GtkAttachOptions)(0), 0, 0);
 338
 339     // Agrega etiqueta de Centro.
 340     label_centro = gtk_label_new("Centro");
 341     gtk_table_attach(GTK_TABLE(table_puntos), label_centro, 0, 1, 1, 2,
 342            (GtkAttachOptions)(GTK_FILL),
 343            (GtkAttachOptions)(0), 0, 0);
 344
 345     // Agrega etiqueta de Inicio.
 346     label_inicio = gtk_label_new("Inicio");
 347     gtk_table_attach(GTK_TABLE(table_puntos), label_inicio, 0, 1, 2, 3,
 348            (GtkAttachOptions)(GTK_FILL),
 349            (GtkAttachOptions)(0), 0, 0);
 350
 351     // Agrega etiqueta de Fin.
 352     label_fin = gtk_label_new("Fin");
 353     gtk_table_attach(GTK_TABLE(table_puntos), label_fin, 0, 1, 3, 4,
 354            (GtkAttachOptions)(GTK_FILL),
 355            (GtkAttachOptions)(0), 0, 0);
 356
 357     // Agrega etiqueta de X.
 358     label_x = gtk_label_new("X");
 359     gtk_table_attach(GTK_TABLE(table_puntos), label_x, 1, 2, 0, 1,
 360            (GtkAttachOptions)(0),
 361            (GtkAttachOptions)(0), 0, 0);
 362
 363     // Agrega etiqueta de Y.
 364     label_y = gtk_label_new("Y");
 365     gtk_table_attach(GTK_TABLE(table_puntos), label_y, 2, 3, 0, 1,
 366            (GtkAttachOptions)(GTK_EXPAND),
 367            (GtkAttachOptions)(0), 0, 0);
 368
 369     // Crea botón con ajuste para la coordenada X del Centro.
 370     spinbutton_centro_x_adj = gtk_adjustment_new(0, 0, 1000, 1, 10, 10);
 371     spinbutton_centro_x = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_centro_x_adj), 1, 0);
 372     gtk_table_attach(GTK_TABLE(table_puntos), spinbutton_centro_x, 1, 2, 1, 2,
 373            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 374            (GtkAttachOptions)(0), 0, 0);
 375
 376     // Crea botón con ajuste para la coordenada Y del Centro.
 377     spinbutton_centro_y_adj = gtk_adjustment_new(0, 0, 1000, 1, 10, 10);
 378     spinbutton_centro_y = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_centro_y_adj), 1, 0);
 379     gtk_table_attach(GTK_TABLE(table_puntos), spinbutton_centro_y, 2, 3, 1, 2,
 380            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 381            (GtkAttachOptions)(0), 0, 0);
 382
 383     // Crea botón con ajuste para la coordenada X del Inicio.
 384     spinbutton_inicio_x_adj = gtk_adjustment_new(0, 0, 1000, 1, 10, 10);
 385     spinbutton_inicio_x = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_inicio_x_adj), 1, 0);
 386     gtk_table_attach(GTK_TABLE(table_puntos), spinbutton_inicio_x, 1, 2, 2, 3,
 387            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 388            (GtkAttachOptions)(0), 0, 0);
 389
 390     // Crea botón con ajuste para la coordenada Y del Inicio.
 391     spinbutton_inicio_y_adj = gtk_adjustment_new(0, 0, 1000, 1, 10, 10);
 392     spinbutton_inicio_y = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_inicio_y_adj), 1, 0);
 393     gtk_table_attach(GTK_TABLE(table_puntos), spinbutton_inicio_y, 2, 3, 2, 3,
 394            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 395            (GtkAttachOptions)(0), 0, 0);
 396
 397     // Crea botón con ajuste para la coordenada X del Fin.
 398     spinbutton_fin_x_adj = gtk_adjustment_new(0, 0, 1000, 1, 10, 10);
 399     spinbutton_fin_x = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_fin_x_adj), 1, 0);
 400     gtk_table_attach(GTK_TABLE(table_puntos), spinbutton_fin_x, 1, 2, 3, 4,
 401            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 402            (GtkAttachOptions)(0), 0, 0);
 403
 404     // Crea botón con ajuste para la coordenada Y del Fin.
 405     spinbutton_fin_y_adj = gtk_adjustment_new(0, 0, 1000, 1, 10, 10);
 406     spinbutton_fin_y = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_fin_y_adj), 1, 0);
 407     gtk_table_attach(GTK_TABLE(table_puntos), spinbutton_fin_y, 2, 3, 3, 4,
 408            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 409            (GtkAttachOptions)(0), 0, 0);
 410
 411     // Se crea una tabla de 3x2 para poner las entradas que faltan (Alto, Ancho
 412     // y Radio) con sus etiquetas.
 413     table_otros = gtk_table_new(3, 2, FALSE);
 414     gtk_box_pack_start(GTK_BOX(vbox_otros), table_otros, FALSE, FALSE, 0);
 415     gtk_table_set_col_spacings(GTK_TABLE(table_otros), 2);
 416
 417     // Agrega etiqueta de Alto.
 418     label_alto = gtk_label_new("Alto");
 419     gtk_table_attach(GTK_TABLE(table_otros), label_alto, 0, 1, 0, 1,
 420            (GtkAttachOptions)(GTK_FILL),
 421            (GtkAttachOptions)(0), 0, 0);
 422
 423     // Agrega etiqueta de Ancho.
 424     label_ancho = gtk_label_new("Ancho");
 425     gtk_table_attach(GTK_TABLE(table_otros), label_ancho, 0, 1, 1, 2,
 426            (GtkAttachOptions)(GTK_FILL),
 427            (GtkAttachOptions)(0), 0, 0);
 428
 429     // Agrega etiqueta de Radio.
 430     label_radio = gtk_label_new("Radio");
 431     gtk_table_attach(GTK_TABLE(table_otros), label_radio, 0, 1, 2, 3,
 432            (GtkAttachOptions)(GTK_FILL),
 433            (GtkAttachOptions)(0), 0, 0);
 434
 435     // Agrega botón con ajuste para el Alto.
 436     spinbutton_alto_adj = gtk_adjustment_new(1, 1, 1000, 1, 10, 10);
 437     spinbutton_alto = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_alto_adj), 1, 0);
 438     gtk_table_attach(GTK_TABLE(table_otros), spinbutton_alto, 1, 2, 0, 1,
 439            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 440            (GtkAttachOptions)(0), 0, 0);
 441     // Lo desactiva ya que inicialmente está seleccionada la Línea.
 442     gtk_widget_set_sensitive(spinbutton_alto, FALSE);
 443
 444     // Agrega botón con ajuste para el Ancho.
 445     spinbutton_ancho_adj = gtk_adjustment_new(1, 1, 1000, 1, 10, 10);
 446     spinbutton_ancho = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_ancho_adj), 1, 0);
 447     gtk_table_attach(GTK_TABLE(table_otros), spinbutton_ancho, 1, 2, 1, 2,
 448            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 449            (GtkAttachOptions)(0), 0, 0);
 450     // Lo desactiva ya que inicialmente está seleccionada la Línea.
 451     gtk_widget_set_sensitive(spinbutton_ancho, FALSE);
 452
 453     // Agrega botón con ajuste para el Radio.
 454     spinbutton_radio_adj = gtk_adjustment_new(1, 1, 1000, 1, 10, 10);
 455     spinbutton_radio = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_radio_adj), 1, 0);
 456     gtk_table_attach(GTK_TABLE(table_otros), spinbutton_radio, 1, 2, 2, 3,
 457            (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 458            (GtkAttachOptions)(0), 0, 0);
 459     // Lo desactiva ya que inicialmente está seleccionada la Línea.
 460     gtk_widget_set_sensitive(spinbutton_radio, FALSE);
 461
 462     ////////////////// ASIGNACION DE FUNCIONES CALLBACK ///////////////////////
 463
 464     // Conecta el evento (señal) delete_event para la ventana principal.
 465     g_signal_connect((gpointer) window, "delete_event",
 466             G_CALLBACK(on_window_delete_event), NULL);
 467     // Conecta el evento (señal) expose para el área de dibujo.
 468     g_signal_connect((gpointer) drawingarea, "expose_event",
 469             G_CALLBACK(on_drawingarea_expose_event), &dibujo);
 470     // Conecta el evento (señal) clicked del botón Borrar.
 471     g_signal_connect((gpointer) button_limpiar, "clicked",
 472             G_CALLBACK(on_button_borrar_clicked), &dibujo);
 473     // Conecta el evento (señal) clicked del botón Actualizar.
 474     g_signal_connect((gpointer) button_actualizar, "clicked",
 475             G_CALLBACK(on_button_graficar_clicked), drawingarea);
 476     // Conecta el evento (señal) clicked del botón  Salir.
 477     g_signal_connect((gpointer) button_salir, "clicked",
 478             G_CALLBACK(on_button_salir_clicked), NULL);
 479     // Conecta el evento (señal) clicked del botón  Agregar.
 480     g_signal_connect((gpointer) button_agregar, "clicked",
 481             G_CALLBACK(on_button_agregar_clicked), this);
 482     // Conecta el evento (señal) toggled del botón de selección Línea.
 483     g_signal_connect((gpointer) radiobutton_linea, "toggled",
 484             G_CALLBACK(on_radiobutton_linea_toggled), this);
 485     // Conecta el evento (señal) toggled del botón de selección Cuadrado.
 486     g_signal_connect((gpointer) radiobutton_cuadrado, "toggled",
 487             G_CALLBACK(on_radiobutton_cuadrado_toggled), this);
 488     // Conecta el evento (señal) toggled del botón de selección Rectángulo.
 489     g_signal_connect((gpointer) radiobutton_rectangulo, "toggled",
 490             G_CALLBACK(on_radiobutton_rectangulo_toggled), this);
 491     // Conecta el evento (señal) toggled del botón de selección Círculo.
 492     g_signal_connect((gpointer) radiobutton_circulo, "toggled",
 493             G_CALLBACK(on_radiobutton_circulo_toggled), this);
 494
 495     // Muestrá la ventana principal y todos sus componentes.
 496     gtk_widget_show_all(window);
 497 }
 498
 499 TP5Window::~TP5Window(void) {
 500     dibujo.borrar_todo();
 501 }