* BUGFIX : Modifico abreviaturas para soportar claves string que empiecen con

 numeros.
 * Agrego indices a las facturas

diff --git a/emufs/indice_b.c b/emufs/indice_b.c
index 9f3e4114e3c15160d88c663d09e99eda626f18cb..df096183359c6a03096021cf6c8d48fca81e319c 100644 (file)
--- a/emufs/indice_b.c
+++ b/emufs/indice_b.c
@@ -145,6 +145,10 @@ int emufs_indice_b_insertar(INDICE *idx, CLAVE clave, INDICE_DATO dato)
                 */
                dummy.id = -1;
                dato.id = b_insertar_dup_en_pos(idx, dummy, dato);
                 */
                dummy.id = -1;
                dato.id = b_insertar_dup_en_pos(idx, dummy, dato);

+               if (dato.id != -1)
+                       PERR("NODO INSERTADO EN POS GENERADA NUEVA");
+       PERR("Ahora inserto");
+       fprintf(stderr, "Nombre del coso = %s\n", idx->nombre);

        }
 
        b_insertar_en_nodo(idx, clave, dato, nodo_id, nodo, -1, -1);
        }
 
        b_insertar_en_nodo(idx, clave, dato, nodo_id, nodo, -1, -1);


@@ -169,7 +173,6 @@ INDICE_DATO emufs_indice_b_buscar(INDICE *idx, CLAVE clave)
                if ((i<header.cant) && (emufs_indice_es_igual(idx, claves[i].clave, clave))) {
                                ret = claves[i].dato;
                                free(nodo);
                if ((i<header.cant) && (emufs_indice_es_igual(idx, claves[i].clave, clave))) {
                                ret = claves[i].dato;
                                free(nodo);

-                               PERR("CLAVE ENCONTRADA");

                                return ret;
                } else {
                        tmp = nodo;
                                return ret;
                } else {
                        tmp = nodo;


@@ -377,7 +380,8 @@ static void b_insertar_en_nodo(INDICE *idx, CLAVE clave, INDICE_DATO dato, int n
                        tmp_claves[i].clave = clave;
                        tmp_claves[i].dato = dato;
                        tmp_claves[i].hijo_derecho = hijo1;
                        tmp_claves[i].clave = clave;
                        tmp_claves[i].dato = dato;
                        tmp_claves[i].hijo_derecho = hijo1;

-                       tmp_claves[i+1].hijo_derecho = hijo2;
+                       if (i<nodo_header.cant)
+                               tmp_claves[i+1].hijo_derecho = hijo2;

                        while (i < nodo_header.cant) {
                                tmp_claves[i+1] = claves[i];
                                i++;
                        while (i < nodo_header.cant) {
                                tmp_claves[i+1] = claves[i];
                                i++;


@@ -554,7 +558,6 @@ INDICE_DATO *emufs_indice_b_buscar_muchos(INDICE *idx, CLAVE clave, int *cant)
        }
 
        /* Busco la clave en el arbol */
        }
 
        /* Busco la clave en el arbol */

-       PERR("Buscando clave");

        dato = emufs_indice_b_buscar(idx, clave);
 
        if (dato.id == -1) {
        dato = emufs_indice_b_buscar(idx, clave);
 
        if (dato.id == -1) {


@@ -841,20 +844,21 @@ static EMUFS_REG_ID b_insertar_dup_en_pos(INDICE *idx, INDICE_DATO pos, INDICE_D
                error = 0;
                PERR("GRABADO REGISTRO NUEVO");
                k.i_clave = idx->emu_mult->grabar_registro(idx->emu_mult,
                error = 0;
                PERR("GRABADO REGISTRO NUEVO");
                k.i_clave = idx->emu_mult->grabar_registro(idx->emu_mult,

-                                                                       leido,
-                                                                       cant*sizeof(INDICE_DATO)+sizeof(int),
-                                                                       &error
-                                                               );
+                       leido,
+                       cant*sizeof(INDICE_DATO)+sizeof(int),
+                       &error
+               );
+               if (k.i_clave == -1) PERR("ALGO NO GRABO BIEN!!");

        } else {
                /* Modifico el que ya existia! */
                PERR("MODIFICANDO REGISTRO EXISTENTE");
                error = 0;
                idx->emu_mult->modificar_registro(idx->emu_mult,
        } else {
                /* Modifico el que ya existia! */
                PERR("MODIFICANDO REGISTRO EXISTENTE");
                error = 0;
                idx->emu_mult->modificar_registro(idx->emu_mult,

-                                                                       k.i_clave,
-                                                                       leido,
-                                                                       cant*sizeof(INDICE_DATO)+sizeof(int),
-                                                                       &error
-                                                               );
+                       k.i_clave,
+                       leido,
+                       cant*sizeof(INDICE_DATO)+sizeof(int),
+                       &error
+               );

        }
        /* Clean up! */
        free(leido);
        }
        /* Clean up! */
        free(leido);


@@ -894,7 +898,7 @@ static void abreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *heade
                 * mas de 2 letras iguales, si no no gano nada y complica las cosas
                 */
                if (iguales > 1) {
                 * mas de 2 letras iguales, si no no gano nada y complica las cosas
                 */
                if (iguales > 1) {

-                       sprintf(salvar, "%d%s", iguales, resto);
+                       sprintf(salvar, "%d|%s", iguales, resto);

                        free(actual);
                        error = 0;
                        idx->emu_string->modificar_registro(idx->emu_string, array[i].clave.i_clave, salvar, strlen(salvar)+1, &error);
                        free(actual);
                        error = 0;
                        idx->emu_string->modificar_registro(idx->emu_string, array[i].clave.i_clave, salvar, strlen(salvar)+1, &error);


@@ -919,10 +923,11 @@ static void desabreviar_claves(INDICE *idx, B_NodoEntry *array, B_NodoHeader *he
        for(i=1; i<header->cant; i++) {
                actual = (char *)idx->emu_string->leer_registro(idx->emu_string, array[i].clave, &size, &error);
                iguales = strtol(actual, &resto, 10);
        for(i=1; i<header->cant; i++) {
                actual = (char *)idx->emu_string->leer_registro(idx->emu_string, array[i].clave, &size, &error);
                iguales = strtol(actual, &resto, 10);

-               if (iguales > 0) {
+               if ((iguales > 0) && (*resto == '|')) {
+                       fprintf(stderr, "%s %s %d\n", primera, actual, iguales); 

                        strncpy(salvar, primera, iguales);
                        salvar[iguales] = '\0';
                        strncpy(salvar, primera, iguales);
                        salvar[iguales] = '\0';

-                       strcat(salvar, resto);
+                       strcat(salvar, resto+1); /* +1 para saltar el separador */

                        idx->emu_string->modificar_registro(idx->emu_string, array[i].clave.i_clave, salvar, strlen(salvar)+1, &error);
                        free(actual);
                } else {
                        idx->emu_string->modificar_registro(idx->emu_string, array[i].clave.i_clave, salvar, strlen(salvar)+1, &error);
                        free(actual);
                } else {

diff --git a/emufs/indices.c b/emufs/indices.c
index 895fb1fd6c11f57338425a60698925f91cc41417..c7235d9cb07401941cf9e5fbc9ea21bc5e54349f 100644 (file)
--- a/emufs/indices.c
+++ b/emufs/indices.c
@@ -86,7 +86,6 @@ void emufs_indice_agregar(INDICE *primero, char *data, INDICE_DATO dato)
        INDICE *iter = primero;
 
        while (iter) {
        INDICE *iter = primero;
 
        while (iter) {

-               fprintf(stderr, "AGREGANDO A INDICE %s\n", iter->nombre);

                iter->agregar_entrada(iter, emufs_indice_generar_clave(iter, data), dato);
                iter = iter->sig;
        }
                iter->agregar_entrada(iter, emufs_indice_generar_clave(iter, data), dato);
                iter = iter->sig;
        }


@@ -166,7 +165,6 @@ int emufs_indice_es_menor(INDICE *idx, CLAVE c1, CLAVE c2)
                        sc1 = idx->emu_string->leer_registro(idx->emu_string, c1, &dummy, &error);
                        sc2 = idx->emu_string->leer_registro(idx->emu_string, c2, &dummy, &error);
                        error = (strcmp(sc1, sc2) < 0);
                        sc1 = idx->emu_string->leer_registro(idx->emu_string, c1, &dummy, &error);
                        sc2 = idx->emu_string->leer_registro(idx->emu_string, c2, &dummy, &error);
                        error = (strcmp(sc1, sc2) < 0);

-                       fprintf(stderr, "COMPARANDO (%s) < (%s)\n", sc1, sc2);

                        free(sc1);
                        free(sc2);
                        return error;
                        free(sc1);
                        free(sc2);
                        return error;


@@ -191,12 +189,6 @@ int emufs_indice_es_igual(INDICE *idx, CLAVE c1, CLAVE c2)
                        error = 0;
                        sc2 = idx->emu_string->leer_registro(idx->emu_string, c2, &dummy, &error);
                        error = (strcmp(sc1, sc2) == 0);
                        error = 0;
                        sc2 = idx->emu_string->leer_registro(idx->emu_string, c2, &dummy, &error);
                        error = (strcmp(sc1, sc2) == 0);

-                       if ((sc1) && (sc2))
-                               fprintf(stderr, "COMPARANDO (%s) == (%s)\n", sc1, sc2);
-                       else {
-                               if (!sc1) fprintf(stderr, "CLAVE %d no esta en el file\n", c1.i_clave);
-                               if (!sc2) fprintf(stderr, "CLAVE %d no esta en el file\n", c2.i_clave);
-                       }

                        if (sc1) free(sc1);
                        if (sc2) free(sc2);
                        return error;
                        if (sc1) free(sc1);
                        if (sc2) free(sc2);
                        return error;

diff --git a/emufs_gui/emufs_view.c b/emufs_gui/emufs_view.c
index be3a6a67ab5ecd730288a281a162c57f7b9d08b1..067eaf06f8dea9f95e4235ade3b80127e5e136d2 100644 (file)
--- a/emufs_gui/emufs_view.c
+++ b/emufs_gui/emufs_view.c
@@ -283,11 +283,12 @@ void menu_facturas()
                MENU_OPCION("Alta", "Crear una nueva factura."),
                MENU_OPCION("Baja", "Elimina una factura existente."),
                MENU_OPCION("Modificacion", "Modifica una factura existente."),
                MENU_OPCION("Alta", "Crear una nueva factura."),
                MENU_OPCION("Baja", "Elimina una factura existente."),
                MENU_OPCION("Modificacion", "Modifica una factura existente."),

+               MENU_OPCION("Consultas", "Consulta varias de articulo."),

                MENU_OPCION("Volver", "Volver al menu anterior.")
        };
        int opt;
                
                MENU_OPCION("Volver", "Volver al menu anterior.")
        };
        int opt;
                

-       while ((opt = menu_ejecutar(mi_menu, 4, "Menu Articulos")) != 3) {
+       while ((opt = menu_ejecutar(mi_menu, 5, "Menu Articulos")) != 4) {

                switch (opt) {
                        case 0:
                                fact_agregar(NULL);
                switch (opt) {
                        case 0:
                                fact_agregar(NULL);


@@ -297,6 +298,8 @@ void menu_facturas()
                        break;
                        case 2:
                                fact_modificar(NULL);
                        break;
                        case 2:
                                fact_modificar(NULL);

+                       case 3:
+                               fact_consultas(NULL);

                }
        }
 }
                }
        }
 }

diff --git a/emufs_gui/facturas.c b/emufs_gui/facturas.c
index b713ba660e128c45cf7f83dd678d8179985ffbd7..f5bde1d538b357765acd6268fd453001faccaa2a 100644 (file)
--- a/emufs_gui/facturas.c
+++ b/emufs_gui/facturas.c
@@ -2,6 +2,8 @@
 #include "facturas.h"
 #include "idx.h"
 #include "common.h"
 #include "facturas.h"
 #include "idx.h"
 #include "common.h"

+#include "menu.h"
+#include "lista.h"

 
 static t_LstFacturas *lst_facturas;
 
 
 static t_LstFacturas *lst_facturas;
 


@@ -182,6 +184,7 @@ t_LstFacturas *fact_cargar(const char *filename, int tipo, int tam_bloque, int t
        char *prop;
        EMUFS_REG_SIZE size;
        t_LstFacturas *tmp;
        char *prop;
        EMUFS_REG_SIZE size;
        t_LstFacturas *tmp;

+       t_Factura *factura;

        EMUFS_REG_ID id;
        
        lst_facturas = NULL;
        EMUFS_REG_ID id;
        
        lst_facturas = NULL;


@@ -224,10 +227,8 @@ t_LstFacturas *fact_cargar(const char *filename, int tipo, int tam_bloque, int t
                        cant_items = 0;
                }
                tmp->fp = emufs_crear("facturas", tipo-1, tam_bloque, sizeof(t_Factura)-sizeof(char *)-sizeof(t_Item*)+cant_items*sizeof(t_Item));
                        cant_items = 0;
                }
                tmp->fp = emufs_crear("facturas", tipo-1, tam_bloque, sizeof(t_Factura)-sizeof(char *)-sizeof(t_Item*)+cant_items*sizeof(t_Item));

-#ifdef DEBUG
-               fprintf(stderr, "Facturas : Tipo=%d  Tam Bloque = %d\n", tipo-1, tam_bloque);
-               fprintf(stderr, "Notas : Tipo=%d  Tam Bloque = %d\n", tipo_nota-1, bloque_nota);
-#endif
+               emufs_agregar_indice(tmp->fp, "emision", IND_EXAHUSTIVO, IND_B, IDX_STRING, STRUCT_OFFSET(factura, emision), 512);
+               emufs_agregar_indice(tmp->fp, "numero", IND_PRIMARIO, IND_B, IDX_INT, 0, 512);

                tmp->fp_texto = emufs_crear("notas", tipo_nota-1, bloque_nota, 100);
                for (node=inicio ; node ; node = node->next) {
                        if (node->type == XML_ELEMENT_NODE) {
                tmp->fp_texto = emufs_crear("notas", tipo_nota-1, bloque_nota, 100);
                for (node=inicio ; node ; node = node->next) {
                        if (node->type == XML_ELEMENT_NODE) {


@@ -264,7 +265,6 @@ t_LstFacturas *fact_cargar(const char *filename, int tipo, int tam_bloque, int t
                                        if (save != NULL) {
                                                error = 0;
                                                id = tmp->fp->grabar_registro(tmp->fp, save, size, &error);
                                        if (save != NULL) {
                                                error = 0;
                                                id = tmp->fp->grabar_registro(tmp->fp, save, size, &error);

-                                               agregar_nodo_factura(tmp, crear_nodo_factura(id, fact.reg_nota, fact.numero));

                                                if (fact.items) free(fact.items);
                                                if (fact.nota) free(fact.nota);
                                                free(save);
                                                if (fact.items) free(fact.items);
                                                if (fact.nota) free(fact.nota);
                                                free(save);


@@ -276,6 +276,7 @@ t_LstFacturas *fact_cargar(const char *filename, int tipo, int tam_bloque, int t
                xmlCleanupParser();
        } else {
 #ifdef NO_SE_USA_MAS
                xmlCleanupParser();
        } else {
 #ifdef NO_SE_USA_MAS

+               /* TODO RECUPERAR INDICES DESDE EL ARCHIVO */

                PERR("Voy a recuperar desde un archivo");
                tmp->fp = emufs_abrir("facturas");
                if (tmp->fp == NULL) {
                PERR("Voy a recuperar desde un archivo");
                tmp->fp = emufs_abrir("facturas");
                if (tmp->fp == NULL) {


@@ -338,11 +339,12 @@ t_Factura *fact_buscar(t_LstFacturas *lst, int numero, EMUFS_REG_ID *id, EMUFS_R
        char *leo;
        EMUFS_REG_SIZE size;
        int error;
        char *leo;
        EMUFS_REG_SIZE size;
        int error;

+       CLAVE k;

        if (lst == NULL) return NULL;
 
        fact = NULL;
        if (lst == NULL) return NULL;
 
        fact = NULL;

-       leo = lst->fp->leer_registro(lst->fp, 
-                                       emufs_indice_generar_clave_desde_valor(lst->fp->indices, (char*)&numero), &size, &error);
+       k = emufs_indice_generar_clave_desde_valor(lst->fp->indices, (char*)&numero);
+       leo = lst->fp->leer_registro(lst->fp, k, &size, &error);

        if (leo != NULL) {
                fact = (t_Factura *)malloc(sizeof(t_Factura));
                if (fact == NULL) {
        if (leo != NULL) {
                fact = (t_Factura *)malloc(sizeof(t_Factura));
                if (fact == NULL) {


@@ -355,7 +357,8 @@ t_Factura *fact_buscar(t_LstFacturas *lst, int numero, EMUFS_REG_ID *id, EMUFS_R
                (*id_texto) = reg->texto_reg;
                */
                free(leo);
                (*id_texto) = reg->texto_reg;
                */
                free(leo);

-               //fact->nota = lst->fp_texto->leer_registro(lst->fp_texto, reg->texto_reg, &size, &error);
+               k.i_clave = fact->reg_nota;
+               fact->nota = lst->fp_texto->leer_registro(lst->fp_texto, k, &size, &error);

        }
        
        return fact;
        }
        
        return fact;


@@ -379,8 +382,8 @@ void fact_eliminar(char *s)
 {
        WINDOW *win;
        t_Factura *fact;
 {
        WINDOW *win;
        t_Factura *fact;

-       t_Reg_Factura *nodo;

        EMUFS_REG_ID id;
        EMUFS_REG_ID id;

+       CLAVE k;

                                                                        
        win = newwin(LINES-4, COLS-2, 2, 1);
        box(win, 0, 0);
                                                                        
        win = newwin(LINES-4, COLS-2, 2, 1);
        box(win, 0, 0);


@@ -399,16 +402,10 @@ void fact_eliminar(char *s)
                return;
        }
 
                return;
        }
 

-       nodo = lst_facturas->primero;
-       while (nodo) {
-               if (nodo->numero == fact->numero) {
-                       /*lst_facturas->fp->borrar_registro(lst_facturas->fp, nodo->num_reg);*/
-                       /*lst_facturas->fp_texto->borrar_registro(lst_facturas->fp_texto, nodo->texto_reg);*/
-                       eliminar_nodo_factura(lst_facturas, nodo);
-                       break;
-               }
-               nodo = nodo->sig;
-       }
+       k = emufs_indice_generar_clave_desde_valor(lst_facturas->fp->indices, (char *)(&fact->numero));
+       lst_facturas->fp->borrar_registro(lst_facturas->fp, k);
+       k.i_clave = fact->reg_nota;
+       lst_facturas->fp_texto->borrar_registro(lst_facturas->fp_texto, k);

 
        free(fact->items);
        free(fact);
 
        free(fact->items);
        free(fact);


@@ -426,7 +423,9 @@ void fact_modificar(char *s)
        char tmp_str[10];
        void *entrada;
 
        char tmp_str[10];
        void *entrada;
 

-                                                                       
+       /* XXX XXX XXX TODO */
+       return;
+       

        win = newwin(LINES-4, COLS-2, 2, 1);
        box(win, 0, 0);
        
        win = newwin(LINES-4, COLS-2, 2, 1);
        box(win, 0, 0);
        


@@ -434,15 +433,7 @@ void fact_modificar(char *s)
                fact = fact_form_buscar(win, &id, &id_texto);
        } else {
                id = atoi(s);
                fact = fact_form_buscar(win, &id, &id_texto);
        } else {
                id = atoi(s);

-               fact = NULL;
-               nodo = lst_facturas->primero;
-               while (nodo) {
-                       if (nodo->num_reg == id) {
-                               fact = fact_buscar(lst_facturas, nodo->numero, &id, &id_texto);
-                               break;
-                       }
-                       nodo = nodo->sig;
-               }
+               fact = fact_buscar(lst_facturas, nodo->numero, &id, &id_texto);

        }
 
        if (fact == NULL) {
        }
 
        if (fact == NULL) {


@@ -639,11 +630,13 @@ void fact_agregar(char *s)
        fact.cant_items = cant;
        fact.nota = form_obtener_valor_char(form_nota, "");
 
        fact.cant_items = cant;
        fact.nota = form_obtener_valor_char(form_nota, "");
 

+       id_texto = lst_facturas->fp_texto->grabar_registro(lst_facturas->fp_texto, fact.nota, strlen(fact.nota)+1, &error);
+       fact.reg_nota = id_texto;
+

        entrada = procesar_guardar_factura(&fact,lst_facturas, &size);
        if (entrada) {
                error = 0;
        entrada = procesar_guardar_factura(&fact,lst_facturas, &size);
        if (entrada) {
                error = 0;

-               id = lst_facturas->fp->grabar_registro(lst_facturas->fp, entrada, size, &error);
-               id_texto = lst_facturas->fp_texto->grabar_registro(lst_facturas->fp_texto, fact.nota, strlen(fact.nota)+1, &error);
+               lst_facturas->fp->grabar_registro(lst_facturas->fp, entrada, size, &error);

                agregar_nodo_factura(lst_facturas, crear_nodo_factura(id, id_texto, fact.numero));
                free(entrada);
        }
                agregar_nodo_factura(lst_facturas, crear_nodo_factura(id, id_texto, fact.numero));
                free(entrada);
        }


@@ -945,3 +938,169 @@ int fact_exportar_xml(const char *filename)
        return 1;
 }
 
        return 1;
 }
 

+void fact_consultas_codigos(char *s)
+{
+       EMUFS_REG_ID dummy;
+       int desde_codigo, hasta_codigo;
+       int i;
+       t_Factura *factura;
+       t_Lista *lista;
+       t_Form *form;
+       WINDOW *win, *win1;
+
+       win = newwin(LINES-4, COLS-2, 2, 1);
+       win1 = derwin(win, LINES-6, COLS-4, 1, 1);
+       werase(win);
+       box(win, 0, 0);
+       wrefresh(win);
+       
+       /* El usuario ingresa rango a listar */
+       form = form_crear(win1);
+       form_agregar_widget(form, INPUT, "Desde Codigo", 8, "0");
+       form_agregar_widget(form, INPUT, "Hasta Codigo", 8, "99999999");
+
+       form_ejecutar(form, 2, 2);
+
+       desde_codigo = form_obtener_valor_int(form, "Desde Codigo");
+       hasta_codigo = form_obtener_valor_int(form, "Hasta Codigo");
+
+       form_destruir(form);
+       werase(win1);
+       wrefresh(win1);
+
+       /* Creo la lista donde mostrar la consulta*/
+       /* Muestro solo info relevante */
+       lista = lista_crear(4, win1, COLS-4, LINES-6);
+
+       /* Creo las columnas */
+       lista_agregar_columna(lista, DATO_INT, 0, 8);    /* numero     */
+       lista_agregar_columna(lista, DATO_STR, 10, 9);   /* emision    */
+       lista_agregar_columna(lista, DATO_STR, 20, 3);   /* estado     */
+       lista_agregar_columna(lista, DATO_STR, 25, 3);   /* fp         */
+
+       /* Leo los datos desde el archivo */
+       for(i=desde_codigo; i<=hasta_codigo; i++) {
+               factura = fact_buscar(lst_facturas, i, &dummy, &dummy);
+               if (factura != NULL) {
+                       lista_agregar_fila(lista,
+                               factura->numero,
+                               factura->emision,
+                               factura->estado,
+                               factura->fp
+                       );
+               }
+       }
+
+       curs_set(0);
+       lista_ejecutar(lista);
+       curs_set(1);
+       
+       wrefresh(win1);
+       wrefresh(win);
+       werase(win1);
+       werase(win);
+       wrefresh(win);
+       delwin(win);
+}
+
+void fact_consultas_varias(char *nombre_indice, char *titulo)
+{
+       int i, cant, error;
+       char *desc, *tmp;
+       t_Factura factura;
+       t_Lista *lista;
+       t_Form *form;
+       INDICE_DATO *datos;
+       WINDOW *win, *win1;
+       CLAVE k;
+       EMUFS *fs;
+       EMUFS_REG_SIZE size;
+
+       fs = lst_facturas->fp;
+
+       win = newwin(LINES-4, COLS-2, 2, 1);
+       win1 = derwin(win, LINES-6, COLS-4, 1, 1);
+       werase(win);
+       box(win, 0, 0);
+       wrefresh(win);
+       
+       /* El usuario ingresa rango a listar */
+       form = form_crear(win1);
+       form_agregar_widget(form, INPUT, titulo, 50, "");
+
+       form_ejecutar(form, 2, 2);
+
+       tmp = form_obtener_valor_char(form, titulo);
+       desc = malloc(sizeof(char)*(strlen(tmp)+1));
+       strcpy(desc, tmp);
+
+       form_destruir(form);
+       werase(win1);
+       wrefresh(win1);
+
+       /* Creo la lista donde mostrar la consulta*/
+       /* Muestro solo info relevante */
+       lista = lista_crear(4, win1, COLS-4, LINES-6);
+
+       /* Creo las columnas */
+       lista_agregar_columna(lista, DATO_INT, 0, 8);    /* numero     */
+       lista_agregar_columna(lista, DATO_STR, 10, 9);   /* emision    */
+       lista_agregar_columna(lista, DATO_STR, 20, 3);   /* estado     */
+       lista_agregar_columna(lista, DATO_STR, 25, 3);   /* fp         */
+
+       /* Leo los datos desde el archivo */
+       datos = emufs_buscar_registros(fs, nombre_indice, desc, &cant);
+       for(i=0; i<cant; i++) {
+               k.i_clave = datos[i].id;
+               error = 1;
+               tmp = (char *)fs->leer_registro(fs, k, &size, &error);
+               if (tmp != NULL) {
+                       procesar_leer_factura(&factura, tmp, size, lst_facturas);
+                       lista_agregar_fila(lista,
+                                                       factura.numero,
+                                                       factura.emision,
+                                                       factura.estado,
+                                                       factura.fp
+                                       );
+                       free(tmp);
+               } else {
+                       PERR("NO SE PUDO RECUPERAR EL REGISTRO DE DATOS");
+               }
+       }
+
+       curs_set(0);
+       lista_ejecutar(lista);
+       curs_set(1);
+       
+       wrefresh(win1);
+       wrefresh(win);
+       werase(win1);
+       werase(win);
+       wrefresh(win);
+       delwin(win);
+}
+
+void fact_consultas(char *s)
+{
+       MENU(mi_menu) {
+               MENU_OPCION("por Codigos", "Consulta de Articulos por rango de codigo."),
+               MENU_OPCION("por Fecha de Emision", "Consulta por fecha unica"),
+               MENU_OPCION("por Presentacion", "Consulta por Presentacion"),
+               MENU_OPCION("Volver", "Volver al menu anterior.")
+       };
+       int opt;
+       
+       while ((opt = menu_ejecutar(mi_menu, 4, "Consulta de Articulos")) != 3) {
+               switch (opt) {
+                       case 0:
+                               fact_consultas_codigos(s);
+                       break;
+                       case 1:
+                               fact_consultas_varias("emision", "Fecha");
+                       break;
+                       case 2:
+                               fact_consultas_varias("presentacion", "Presentacion");
+               }
+       }
+}
+

diff --git a/emufs_gui/facturas.h b/emufs_gui/facturas.h
index 56f67bc1ea660f6f057f42b39f5452779391ebc0..b417b2817a7d0d4f5a1940213c8c14df17105839 100644 (file)
--- a/emufs_gui/facturas.h
+++ b/emufs_gui/facturas.h
@@ -73,6 +73,8 @@ t_LstFacturas *fact_get_lst();
 
 void fact_reformatear(int tipo, int tam_bloque, int tam_reg, int nota_tipo, int nota_tam_bloque, int nota_tam_registro);
 
 
 void fact_reformatear(int tipo, int tam_bloque, int tam_reg, int nota_tipo, int nota_tam_bloque, int nota_tam_registro);
 

+void fact_consultas(char *s);
+

 int fact_exportar_xml(const char *filename);
 
 #endif
 int fact_exportar_xml(const char *filename);
 
 #endif

diff --git a/emufs_gui/lista.h b/emufs_gui/lista.h
index c350b62b6554a7fa32e55e54d473cd42121a4d32..cbc0ead6061d493f0d3625c9952991f95fe529b1 100644 (file)
--- a/emufs_gui/lista.h
+++ b/emufs_gui/lista.h
@@ -7,33 +7,44 @@
 #include <curses.h>
 #include <stdarg.h>
 
 #include <curses.h>
 #include <stdarg.h>
 

-typedef enum {DATO_INT, DATO_STR, DATO_FLOAT} t_TipoDato;
+/** Tipos de dato aceptados para las columnas */
+typedef enum {
+       DATO_INT,    /**< Entero */
+       DATO_STR,    /**< String */
+       DATO_FLOAT   /**< Punto flotante */
+} t_TipoDato;

 
 

+/** Tipo de dato para la columna */

 typedef union _dato_ {
        int i_dato;
        float f_dato;
        char s_dato[51];
 } t_Dato;
 
 typedef union _dato_ {
        int i_dato;
        float f_dato;
        char s_dato[51];
 } t_Dato;
 

+/** Columna */

 typedef struct _columna_ {
 typedef struct _columna_ {

-       t_TipoDato tipo;
-       int offset;
-       int width;
-       struct _columna_ *sig;
+       t_TipoDato tipo;          /**< Tipo de dato de la columna      */
+       int offset;               /**< Offset en X de la posicion      */
+       int width;                /**< Ancho de la columna             */
+       struct _columna_ *sig;    /**< Puntero a la siguiente columnas */

 } t_Columna;
 
 } t_Columna;
 

+/** Fila */

 typedef struct _fila_ {
 typedef struct _fila_ {

-       t_Dato *datos; /* 1 por columna! */
-       struct _fila_ *sig, *ant;
+       t_Dato *datos;       /**< Array de datos. Debe tener tantos items como columnas existan. */
+       struct _fila_ *sig;  /**< Puntero a la siguiente fila */
+       struct _file_ *ant;  /**< Puntero a la fila anterior */

 } t_Fila;
 
 } t_Fila;
 

+/** Lista */

 typedef struct _lista_ {
 typedef struct _lista_ {

-       int cant_columnas;
-       WINDOW *win;
-       int w,h;
+       int cant_columnas;     /**< Cantidad de columnas */
+       WINDOW *win;           /**< Ventana donde dibujar */
+       int w;                 /**< Ancho de la ventana */
+       int h;                 /**< Alto de la ventana */

 
 

-       t_Columna *columnas;
-       t_Fila *primera;
+       t_Columna *columnas;   /**< Puntero a la primer columna */
+       t_Fila *primera;       /**< Puntero a la primer fila */

 } t_Lista;
 
 /** Crea una nueva lista
 } t_Lista;
 
 /** Crea una nueva lista


@@ -61,6 +72,10 @@ void lista_agregar_columna(t_Lista *lst, t_TipoDato tipo, int offset, int width)
  */
 void lista_agregar_fila(t_Lista *lst, ...);
 
  */
 void lista_agregar_fila(t_Lista *lst, ...);
 

+/** Muestra la lista en pantalla
+ *
+ *  \param lst
+ */

 void lista_ejecutar(t_Lista *lst);
 
 #endif
 void lista_ejecutar(t_Lista *lst);
 
 #endif