Interfaz.h

#ifndef INTERFAZ_H
#define INTERFAZ_H

#include <string.h>
#include <gtk/gtk.h>
#include <stdbool.h>
#include "Parser.h"

//G_MODULE_EXPORT gboolean;

bool interface_running = true;

GtkBuilder  *builder; 
GtkWidget   *window;

GtkWidget   *entry_nombre_problema;
GtkWidget   *entry_nombre_variables;
GtkWidget   *entry_funcion_objetivo;
GtkWidget   *radiobutton_max;

GtkWidget   *entry_var1;
GtkWidget   *entry_var2;
GtkWidget   *entry_var3;
GtkWidget   *entry_var4;
GtkWidget   *entry_var5;
GtkWidget   *entry_var6;
GtkWidget   *entry_var7;
GtkWidget   *entry_var8;
GtkWidget   *entry_rest1;
GtkWidget   *entry_rest2;
GtkWidget   *entry_rest3;
GtkWidget   *entry_rest4;
GtkWidget   *entry_rest5;
GtkWidget   *entry_rest6;
GtkWidget   *entry_rest7;
GtkWidget   *entry_rest8;
GtkWidget   *entry_rest9;
GtkWidget   *entry_rest10;
GtkWidget   *entry_eq1;
GtkWidget   *entry_eq2;
GtkWidget   *entry_eq3;
GtkWidget   *entry_eq4;
GtkWidget   *entry_eq5;
GtkWidget   *entry_eq6;
GtkWidget   *entry_eq7;
GtkWidget   *entry_eq8;
GtkWidget   *entry_eq9;
GtkWidget   *entry_eq10;
GtkWidget   *combobox1;
GtkWidget   *combobox2;
GtkWidget   *combobox3;
GtkWidget   *combobox4;
GtkWidget   *combobox5;
GtkWidget   *combobox6;
GtkWidget   *combobox7;
GtkWidget   *combobox8;
GtkWidget   *combobox9;
GtkWidget   *combobox10;

GtkWidget   *switch_tablas_intermedias;
GtkWidget   *button_ejecutar;

 GtkWidget *cover_image;
  

char s_constraints[10][40];
char s_equals[10][10];
char s_nombre_variables[8][40];
int  s_equalitor[10];

char texto_nombre_problema[100];
char texto_nombre_variables[100];
char texto_funcion_objetivo[100];

char texto_var1[100];
char texto_var2[100];
char texto_var3[100];
char texto_var4[100];
char texto_var5[100];
char texto_var6[100];
char texto_var7[100];
char texto_var8[100];
char texto_rest1[100];
char texto_rest2[100];
char texto_rest3[100];
char texto_rest4[100];
char texto_rest5[100];
char texto_rest6[100];
char texto_rest7[100];
char texto_rest8[100];
char texto_rest9[100];
char texto_rest10[100];
char texto_eq1[100];
char texto_eq2[100];
char texto_eq3[100];
char texto_eq4[100];
char texto_eq5[100];
char texto_eq6[100];
char texto_eq7[100];
char texto_eq8[100];
char texto_eq9[100];
char texto_eq10[100];
int id_radiobutton_max;
int id_switch_tablas_intermedias;

// IniciarInterfaz(argc, argv);
int IniciarInterfaz(int argc, char *argv[])
{
    gtk_init(&argc, &argv);
    builder = gtk_builder_new();

    if( gtk_builder_add_from_file (builder,"interface.glade" , NULL) == 0){
         printf("No se pudo cargar el archivo GLADE\n");
         return(0);
    } 
    
    // Traigo los objetos/widgets de la interfaz Glade
    window = GTK_WIDGET(gtk_builder_get_object(builder, "interface"));
    entry_nombre_problema  = GTK_WIDGET(gtk_builder_get_object(builder, "entry_nombre_problema"));
    entry_nombre_variables = GTK_WIDGET(gtk_builder_get_object(builder, "entry_nombre_variables"));
    entry_funcion_objetivo = GTK_WIDGET(gtk_builder_get_object(builder, "entry_funcion_objetivo"));
    entry_var1 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_var1"));
    entry_var2 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_var2"));
    entry_var3 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_var3"));
    entry_var4 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_var4"));
    entry_var5 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_var5"));
    entry_var6 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_var6"));
    entry_var7 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_var7"));
    entry_var8 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_var8"));
    entry_rest1 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_rest1"));
    entry_rest2 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_rest2"));
    entry_rest3 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_rest3"));
    entry_rest4 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_rest4"));
    entry_rest5 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_rest5"));
    entry_rest6 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_rest6"));
    entry_rest7 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_rest7"));
    entry_rest8 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_rest8"));
    entry_rest9 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_rest9"));
    entry_rest10= GTK_WIDGET(gtk_builder_get_object(builder, "entry_rest10"));
    entry_eq1 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_eq1"));
    entry_eq2 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_eq2"));
    entry_eq3 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_eq3"));
    entry_eq4 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_eq4"));
    entry_eq5 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_eq5"));
    entry_eq6 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_eq6"));
    entry_eq7 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_eq7"));
    entry_eq8 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_eq8"));
    entry_eq9 = GTK_WIDGET(gtk_builder_get_object(builder, "entry_eq9"));
    entry_eq10= GTK_WIDGET(gtk_builder_get_object(builder, "entry_eq10"));
    combobox1 = GTK_WIDGET(gtk_builder_get_object(builder, "combobox1"));
    combobox2 = GTK_WIDGET(gtk_builder_get_object(builder, "combobox2"));
    combobox3 = GTK_WIDGET(gtk_builder_get_object(builder, "combobox3"));
    combobox4 = GTK_WIDGET(gtk_builder_get_object(builder, "combobox4"));
    combobox5 = GTK_WIDGET(gtk_builder_get_object(builder, "combobox5"));
    combobox6 = GTK_WIDGET(gtk_builder_get_object(builder, "combobox6"));
    combobox7 = GTK_WIDGET(gtk_builder_get_object(builder, "combobox7"));
    combobox8 = GTK_WIDGET(gtk_builder_get_object(builder, "combobox8"));
    combobox9 = GTK_WIDGET(gtk_builder_get_object(builder, "combobox9"));
    combobox10= GTK_WIDGET(gtk_builder_get_object(builder, "combobox10"));
    radiobutton_max= GTK_WIDGET(gtk_builder_get_object(builder, "radiobutton_max"));
    switch_tablas_intermedias= GTK_WIDGET(gtk_builder_get_object(builder, "switch_tablas_intermedias"));
    cover_image = GTK_WIDGET(gtk_builder_get_object(builder, "cover_image"));
    cover_image = gtk_image_new_from_file ("cover_image.png");
    gtk_builder_connect_signals(builder, NULL);
 
    g_object_unref(builder);
    
//    g_signal_connect (window, "delete_event", G_CALLBACK (gtk_window_close), NULL);

 
    gtk_widget_show(window);                
    gtk_main();
 
    return 0;   
}
 

void on_window_main_destroy(){
    gtk_widget_hide(window);
}


bool FormatoCorrectoNombrePrograma(char *texto){
    printf("Nombre del programa: \"%s\" \n", texto);
    return true;
}

bool FormatoCorrectoNombreVariables(char *texto){
    printf("Nombres de las variables: \"%s\"  \n", texto);
    return true;
}
bool FormatoCorrectoFuncionObjetivo(char *texto){
    printf("Función objetivo: \"%s\" \n", texto);
    return true;
}

bool FormatoCorrectoRestriccion(char *texto_resticcion, char *texto_equal){
    printf("Restriccion: \"%s\" | Comparada a: \"%s\" \n", texto_resticcion ,texto_equal);
    return true;
}




void AccionEjecutar(){
    printf("Se presionó el botón de ejecutar \n");

    // Inicializar todas las variables
    const gchar *g_texto_nombre_problema;
    const gchar *g_texto_nombre_variables;
    const gchar *g_texto_funcion_objetivo;
    const gchar *g_texto_var1;
    const gchar *g_texto_var2;
    const gchar *g_texto_var3;
    const gchar *g_texto_var4;
    const gchar *g_texto_var5;
    const gchar *g_texto_var6;
    const gchar *g_texto_var7;
    const gchar *g_texto_var8;
    const gchar *g_texto_rest1;
    const gchar *g_texto_rest2;
    const gchar *g_texto_rest3;
    const gchar *g_texto_rest4;
    const gchar *g_texto_rest5;
    const gchar *g_texto_rest6;
    const gchar *g_texto_rest7;
    const gchar *g_texto_rest8;
    const gchar *g_texto_rest9;
    const gchar *g_texto_rest10;
    const gchar *g_texto_eq1;
    const gchar *g_texto_eq2;
    const gchar *g_texto_eq3;
    const gchar *g_texto_eq4;
    const gchar *g_texto_eq5;
    const gchar *g_texto_eq6;
    const gchar *g_texto_eq7;
    const gchar *g_texto_eq8;
    const gchar *g_texto_eq9;
    const gchar *g_texto_eq10;
    int g_combobox1;
    int g_combobox2;
    int g_combobox3;
    int g_combobox4;
    int g_combobox5;
    int g_combobox6;
    int g_combobox7;
    int g_combobox8;
    int g_combobox9;
    int g_combobox10;
    
    

    // Coger todos los datos de la interfaz y convertirlo a un formato manejable propio de C (ej.: gchar -> char)
    g_texto_nombre_problema = gtk_entry_get_text(GTK_ENTRY(entry_nombre_problema));
    g_texto_nombre_variables = gtk_entry_get_text(GTK_ENTRY(entry_nombre_variables));
    g_texto_funcion_objetivo = gtk_entry_get_text(GTK_ENTRY(entry_funcion_objetivo));
    g_texto_var1 = gtk_entry_get_text(GTK_ENTRY(entry_var1));
    g_texto_var2 = gtk_entry_get_text(GTK_ENTRY(entry_var2));
    g_texto_var3 = gtk_entry_get_text(GTK_ENTRY(entry_var3));
    g_texto_var4 = gtk_entry_get_text(GTK_ENTRY(entry_var4));
    g_texto_var5 = gtk_entry_get_text(GTK_ENTRY(entry_var5));
    g_texto_var6 = gtk_entry_get_text(GTK_ENTRY(entry_var6));
    g_texto_var7 = gtk_entry_get_text(GTK_ENTRY(entry_var7));
    g_texto_var8 = gtk_entry_get_text(GTK_ENTRY(entry_var8));
    g_texto_rest1 = gtk_entry_get_text(GTK_ENTRY(entry_rest1));
    g_texto_rest2 = gtk_entry_get_text(GTK_ENTRY(entry_rest2));
    g_texto_rest3 = gtk_entry_get_text(GTK_ENTRY(entry_rest3));
    g_texto_rest4 = gtk_entry_get_text(GTK_ENTRY(entry_rest4));
    g_texto_rest5 = gtk_entry_get_text(GTK_ENTRY(entry_rest5));
    g_texto_rest6 = gtk_entry_get_text(GTK_ENTRY(entry_rest6));
    g_texto_rest7 = gtk_entry_get_text(GTK_ENTRY(entry_rest7));
    g_texto_rest8 = gtk_entry_get_text(GTK_ENTRY(entry_rest8));
    g_texto_rest9 = gtk_entry_get_text(GTK_ENTRY(entry_rest9));
    g_texto_rest10 = gtk_entry_get_text(GTK_ENTRY(entry_rest10));
    g_texto_eq1 = gtk_entry_get_text(GTK_ENTRY(entry_eq1));
    g_texto_eq2 = gtk_entry_get_text(GTK_ENTRY(entry_eq2));
    g_texto_eq3 = gtk_entry_get_text(GTK_ENTRY(entry_eq3));
    g_texto_eq4 = gtk_entry_get_text(GTK_ENTRY(entry_eq4));
    g_texto_eq5 = gtk_entry_get_text(GTK_ENTRY(entry_eq5));
    g_texto_eq6 = gtk_entry_get_text(GTK_ENTRY(entry_eq6));
    g_texto_eq7 = gtk_entry_get_text(GTK_ENTRY(entry_eq7));
    g_texto_eq8 = gtk_entry_get_text(GTK_ENTRY(entry_eq8));
    g_texto_eq9 = gtk_entry_get_text(GTK_ENTRY(entry_eq9));
    g_texto_eq10 = gtk_entry_get_text(GTK_ENTRY(entry_eq10));
    g_combobox1 = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(combobox1));
    g_combobox2 = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(combobox2));
    g_combobox3 = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(combobox3));
    g_combobox4 = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(combobox4));
    g_combobox5 = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(combobox5));
    g_combobox6 = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(combobox6));
    g_combobox7 = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(combobox7));
    g_combobox8 = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(combobox8));
    g_combobox9 = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(combobox9));
    g_combobox10 = (int)gtk_combo_box_get_active(GTK_COMBO_BOX(combobox10));
    sprintf(texto_nombre_problema,  "%8s\n", g_texto_nombre_problema);
    sprintf(texto_nombre_variables, "%8s\n", g_texto_nombre_variables);
    sprintf(texto_funcion_objetivo, "%8s\n", g_texto_funcion_objetivo);
    sprintf(texto_var1, "%8s\n", g_texto_var1);
    sprintf(texto_var2, "%8s\n", g_texto_var2);
    sprintf(texto_var3, "%8s\n", g_texto_var3);
    sprintf(texto_var4, "%8s\n", g_texto_var4);
    sprintf(texto_var5, "%8s\n", g_texto_var5);
    sprintf(texto_var6, "%8s\n", g_texto_var6);
    sprintf(texto_var7, "%8s\n", g_texto_var7);
    sprintf(texto_var8, "%8s\n", g_texto_var8);
    sprintf(texto_rest1, "%8s\n", g_texto_rest1);
    sprintf(texto_rest2, "%8s\n", g_texto_rest2);
    sprintf(texto_rest3, "%8s\n", g_texto_rest3);
    sprintf(texto_rest4, "%8s\n", g_texto_rest4);
    sprintf(texto_rest5, "%8s\n", g_texto_rest5);
    sprintf(texto_rest6, "%8s\n", g_texto_rest6);
    sprintf(texto_rest7, "%8s\n", g_texto_rest7);
    sprintf(texto_rest8, "%8s\n", g_texto_rest8);
    sprintf(texto_rest9, "%8s\n", g_texto_rest9);
    sprintf(texto_rest10,"%8s\n", g_texto_rest10);
    sprintf(texto_eq1, "%8s\n", g_texto_eq1);
    sprintf(texto_eq2, "%8s\n", g_texto_eq2);
    sprintf(texto_eq3, "%8s\n", g_texto_eq3);
    sprintf(texto_eq4, "%8s\n", g_texto_eq4);
    sprintf(texto_eq5, "%8s\n", g_texto_eq5);
    sprintf(texto_eq6, "%8s\n", g_texto_eq6);
    sprintf(texto_eq7, "%8s\n", g_texto_eq7);
    sprintf(texto_eq8, "%8s\n", g_texto_eq8);
    sprintf(texto_eq9, "%8s\n", g_texto_eq9);
    sprintf(texto_eq10,"%8s\n", g_texto_eq10);
    
//    strcpy (example, "TechOnTheNet.com knows strcpy!");

    
    
    
//    // Revisar formato de las variables
//    FormatoCorrectoNombrePrograma(texto_nombre_problema);
//    FormatoCorrectoNombreVariables(texto_nombre_variables);
//    FormatoCorrectoFuncionObjetivo(texto_funcion_objetivo);
//    FormatoCorrectoRestriccion(texto_rest1, texto_eq1);
//    FormatoCorrectoRestriccion(texto_rest2, texto_eq2);
//    FormatoCorrectoRestriccion(texto_rest3, texto_eq3);
//    FormatoCorrectoRestriccion(texto_rest4, texto_eq4);
//    FormatoCorrectoRestriccion(texto_rest5, texto_eq5);
//    FormatoCorrectoRestriccion(texto_rest6, texto_eq6);
//    FormatoCorrectoRestriccion(texto_rest7, texto_eq7);
//    FormatoCorrectoRestriccion(texto_rest8, texto_eq8);
//    FormatoCorrectoRestriccion(texto_rest9, texto_eq9);
    
//    printf("\n\n\n");
//    printf("AAAAAAAAAAAAAAA:%s:AAAAAAAAAAAAAAA",texto_var1);
//    printf("\n\n\n");
    
    if (texto_nombre_problema[7] == ' ') strcpy (texto_nombre_problema, "Problema sin nombre");
    
    if (texto_var1[7] == ' ') strcpy (s_nombre_variables[0], "x1");
    else                      strcpy (s_nombre_variables[0], texto_var1);
    
    if (texto_var2[7] == ' ') strcpy (s_nombre_variables[1], "x2");
    else                      strcpy (s_nombre_variables[1], texto_var2);
    
    if (texto_var3[7] == ' ') strcpy (s_nombre_variables[2], "x3");
    else                      strcpy (s_nombre_variables[2], texto_var3);
    
    if (texto_var4[7] == ' ') strcpy (s_nombre_variables[3], "x4");
    else                      strcpy (s_nombre_variables[3], texto_var4);
    
    if (texto_var5[7] == ' ') strcpy (s_nombre_variables[4], "x5");
    else                      strcpy (s_nombre_variables[4], texto_var5);
    
    if (texto_var6[7] == ' ') strcpy (s_nombre_variables[5], "x6");
    else                      strcpy (s_nombre_variables[5], texto_var6);
    
    if (texto_var7[7] == ' ') strcpy (s_nombre_variables[6], "x7");
    else                      strcpy (s_nombre_variables[6], texto_var7);
    
    if (texto_var8[7] == ' ') strcpy (s_nombre_variables[7], "x8");
    else                      strcpy (s_nombre_variables[7], texto_var8);
    
//    strcpy (s_nombre_variables[0], texto_var1);
//    strcpy (s_nombre_variables[1], texto_var2);
//    strcpy (s_nombre_variables[2], texto_var3);
//    strcpy (s_nombre_variables[3], texto_var4);
//    strcpy (s_nombre_variables[4], texto_var5);
//    strcpy (s_nombre_variables[5], texto_var6);
//    strcpy (s_nombre_variables[6], texto_var7);
//    strcpy (s_nombre_variables[7], texto_var8);
    
    strcpy (s_constraints[0], texto_rest1);
    strcpy (s_constraints[1], texto_rest2);
    strcpy (s_constraints[2], texto_rest3);
    strcpy (s_constraints[3], texto_rest4);
    strcpy (s_constraints[4], texto_rest5);
    strcpy (s_constraints[5], texto_rest6);
    strcpy (s_constraints[6], texto_rest7);
    strcpy (s_constraints[7], texto_rest8);
    strcpy (s_constraints[8], texto_rest9);
    strcpy (s_constraints[9], texto_rest10);
    
    strcpy (s_equals[0], texto_eq1);
    strcpy (s_equals[1], texto_eq2);
    strcpy (s_equals[2], texto_eq3);
    strcpy (s_equals[3], texto_eq4);
    strcpy (s_equals[4], texto_eq5);
    strcpy (s_equals[5], texto_eq6);
    strcpy (s_equals[6], texto_eq7);
    strcpy (s_equals[7], texto_eq8);
    strcpy (s_equals[8], texto_eq9);
    strcpy (s_equals[9], texto_eq10);
    
    s_equalitor[0] = g_combobox1;
    s_equalitor[1] = g_combobox2;
    s_equalitor[2] = g_combobox3;
    s_equalitor[3] = g_combobox4;
    s_equalitor[4] = g_combobox5;
    s_equalitor[5] = g_combobox6;
    s_equalitor[6] = g_combobox7;
    s_equalitor[7] = g_combobox8;
    s_equalitor[8] = g_combobox9;
    s_equalitor[9] = g_combobox10;
    
    
            
    GSList *tmp_list;
    tmp_list = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_max));
    GtkToggleButton *tmp_button = NULL;
    id_radiobutton_max = -1;
    while (tmp_list){
        id_radiobutton_max ++;
        tmp_button = tmp_list->data;
        tmp_list = tmp_list->next;
        if (gtk_toggle_button_get_active(tmp_button))
            break;
        tmp_button = NULL;
    }
//    printf("\n\n\n\n RADIOBUTTON %i \n\n\n\n", id_radiobutton_max);
    
    gboolean g_tablas_intermedias;
    g_tablas_intermedias = gtk_switch_get_active(GTK_SWITCH(switch_tablas_intermedias));
    if (g_tablas_intermedias){
        id_switch_tablas_intermedias = 1;
    }else{
        id_switch_tablas_intermedias = 0;
    }
    // 0: MIN | 1: MAX ; 
    
//    printf("\n\n\n g_combobox1:%d \n\n\n", g_combobox1);
//    printf("\n\n\n g_combobox2:%d \n\n\n", g_combobox2);

//    texto_rest_list[0] = texto_rest1;
//    texto_rest_list[1] = texto_rest2;
//    texto_rest_list[2] = texto_rest3;
//    printf("\n\n %s \n\n", texto_rest_list[0]);
//    CrearMatriz();
//    printf("\n rest 1: %s\n", g_texto_rest1);
//    printf("\n rest 2: %s\n", g_texto_rest2);
//    ParserByRow();
    
    
    
//    if(texto_rest1 == " \n") 
//    else printf("\n\nEeeees NOOO vacia %i,%i,%i,%i,%i,%i  \n\n", (int)texto_rest1[0], (int)texto_rest1[1], (int)texto_rest1[2], (int)texto_rest1[3], (int)texto_rest1[4], (int)texto_rest1[5]);

    gtk_main_quit();
//  gtk_widget_hide(window);  
//    sleep(1);
    
//    interface_running = false;
    
//    exit();
//    on_window_main_destroy();
    
//    gtk_widget_set_size_request(GTK_WIDGET(GTK_ENTRY(entry_rest1)),3,5);
    // delete_entry();
    // Convertir al formato adecuado para el ALGORITMO SIMPLEX
    
    // gtk_widget_hide(GTK_ENTRY(texto_eq9));
    // gtk_widget_hide(GTK_ENTRY(texto_rest9));
    // Llamar la función del ALGORITMO SIMPLEX

}

void CrearMatriz(){
    
}

gboolean delete_entry() {
    gtk_widget_hide(entry_eq1);
    gtk_widget_hide(entry_eq2);
    gtk_widget_hide(entry_eq3);
    gtk_widget_hide(entry_eq4);
    gtk_widget_hide(entry_eq5);
    gtk_widget_hide(entry_eq6);
    gtk_widget_hide(entry_eq7);
    gtk_widget_hide(entry_eq8);
    gtk_widget_hide(entry_eq9);
    gtk_widget_hide(entry_eq10);
    // gtk_widget_show_all(GTK_WIDGET(u));
    return TRUE;
}


#endif /* INTERFAZ_H */