Soporte para bloques mas chicos que el registro.

[z.facultad/75.06/emufs.git] / emufs_gui / registros.c

diff --git a/emufs_gui/registros.c b/emufs_gui/registros.c
index 9f816a12273f0d9884206b0643d2bdfdac588d90..2dde456b1a7f12c4a65d18a82784444ea0c4f919 100644 (file)
--- a/emufs_gui/registros.c
+++ b/emufs_gui/registros.c
@@ -6,6 +6,7 @@
 /* Se encarga de reemplazar los \0 un caracter visual, y segurar un \0 al final */
 static char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
 static char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
 /* Se encarga de reemplazar los \0 un caracter visual, y segurar un \0 al final */
 static char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
 static char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);

+static int preguntar_id(WINDOW *win, EMUFS *fp);

 
 void mostrar_info(WINDOW *padre, int h, int offset_alto)
 {
 
 void mostrar_info(WINDOW *padre, int h, int offset_alto)
 {


@@ -32,6 +33,7 @@ void mostrar_info(WINDOW *padre, int h, int offset_alto)
        waddstr(padre, "E");
        wattroff(padre, A_BOLD);
        waddstr(padre, "liminar ");
        waddstr(padre, "E");
        wattroff(padre, A_BOLD);
        waddstr(padre, "liminar ");

+       mvwaddstr(padre, h-offset_alto+6, 8, "Buscar ID : B");

        
        /* Info de leyenda */
        wattron(padre, A_BOLD);
        
        /* Info de leyenda */
        wattron(padre, A_BOLD);


@@ -44,36 +46,51 @@ void mostrar_info(WINDOW *padre, int h, int offset_alto)
        mvwaddstr(padre, h-offset_alto+4, 48, "(XXX) = ID de registro");
        mvwaddstr(padre, h-offset_alto+5, 48, "{XXX} = Tam. de registro");
        mvwaddstr(padre, h-offset_alto+6, 48, "  .   = Esp. Libre");
        mvwaddstr(padre, h-offset_alto+4, 48, "(XXX) = ID de registro");
        mvwaddstr(padre, h-offset_alto+5, 48, "{XXX} = Tam. de registro");
        mvwaddstr(padre, h-offset_alto+6, 48, "  .   = Esp. Libre");

+       mvwaddstr(padre, h-offset_alto+7, 48, " < >  = Separador Bloques");

 }
        
 void ver_registros(WINDOW *padre, int w, int h)
 {
        /* Ventanas donde mostrar las cosas */
        char *(*procesar)(EMUFS*, char*, EMUFS_REG_SIZE*, int*, int*);
 }
        
 void ver_registros(WINDOW *padre, int w, int h)
 {
        /* Ventanas donde mostrar las cosas */
        char *(*procesar)(EMUFS*, char*, EMUFS_REG_SIZE*, int*, int*);

-       WINDOW *actual[2];
+       WINDOW *actual[2], *dlg;

        EMUFS_REG_SIZE size;
        int scroll, actual_ancho;
        int max_scroll, c, offset_alto;
        EMUFS_REG_SIZE size;
        int scroll, actual_ancho;
        int max_scroll, c, offset_alto;

-       EMUFS_REG_ID ant_indice, total_indice; /* Indice de registro que tengo en ANT */
+       /* Indices que hay validos en IDX */
+       EMUFS_REG_ID *indices, indices_total, indices_actual;

        char *data; /* Registros a mostrar en pantalla */
        char codigo[50]; /* Variable para guardar el codigo actual para mandar a modificar */
        EMUFS *fp;
        int pos_actual, ancho_registro, offset, pos;
        char *data; /* Registros a mostrar en pantalla */
        char codigo[50]; /* Variable para guardar el codigo actual para mandar a modificar */
        EMUFS *fp;
        int pos_actual, ancho_registro, offset, pos;

+       

        fp = emufs_abrir("articulos");
        fp = emufs_abrir("articulos");

+       wattron(padre, COLOR_PAIR(COLOR_BLUE));
+       mvwaddstr(padre, 0, 0, "Tipo de archivo : ");
+       wattroff(padre, COLOR_PAIR(COLOR_BLUE));

        switch (fp->tipo) {
                case T1:
        switch (fp->tipo) {
                case T1:

-               case T2:
+                       waddstr(padre, "Registro variable con bloque parametrizado.");

                        procesar = procesar_registro_articulo_tipo1;
                break;
                        procesar = procesar_registro_articulo_tipo1;
                break;

+               case T2:
+                       waddstr(padre, "Registro variable sin bloques.");
+               break;

                case T3:
                        procesar = procesar_registro_articulo_tipo3;
                case T3:
                        procesar = procesar_registro_articulo_tipo3;

+                       waddstr(padre, "Registro fijo con bloque parametrizado.");

        }
 
        }
 

-       total_indice = emufs_idx_get_count(fp);
+       indices = emufs_idx_get(fp, &indices_total);

 
 

-       ant_indice = 1;
-       data = (char *)fp->leer_registro_raw(fp, emufs_idx_get_id_at(fp, ant_indice), &size, &pos_actual);
-       data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
+       indices_actual = 0;
+       if (indices) {
+               fprintf(stderr, "LEO REGISTRO %lu\n", indices[indices_actual]);
+               data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
+               fprintf(stderr, "Data leida %p (%s)\n",data, data);
+               data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
+               fprintf(stderr, "Tamanio = %lu\n", size);
+       }

 
 
        offset_alto = 8;
 
 
        offset_alto = 8;


@@ -87,7 +104,7 @@ void ver_registros(WINDOW *padre, int w, int h)
 
        curs_set(0);
 
 
        curs_set(0);
 

-       mostrar_info(padre, h, actual_ancho);
+       mostrar_info(padre, h, offset_alto);

        
        mvwaddnstr(actual[1], 0, 0, data, pos_actual);
        wattron(actual[1], A_BOLD);
        
        mvwaddnstr(actual[1], 0, 0, data, pos_actual);
        wattron(actual[1], A_BOLD);


@@ -101,45 +118,58 @@ void ver_registros(WINDOW *padre, int w, int h)
        scroll = 0;
        while ((c=getch()) != 13) {
                switch (c) {
        scroll = 0;
        while ((c=getch()) != 13) {
                switch (c) {

+                       case 'b':
+                       case 'B':
+                               dlg = newwin(4, 50, h/2-2, w/2-25);
+                               box(dlg, 0, 0);
+                               preguntar_id(dlg, fp);
+                               werase(dlg);
+                               wrefresh(dlg);
+                               delwin(dlg);
+                               wrefresh(padre);
+                               curs_set(0);
+                       break;

                        case 'e':
                        case 'E':
                        case 'e':
                        case 'E':

-                               if (ant_indice != EMUFS_NOT_FOUND)
-                                       fp->borrar_registro(fp, emufs_idx_get_id_at(fp, ant_indice));
+                               if (indices_actual != EMUFS_NOT_FOUND)
+                                       fp->borrar_registro(fp, indices[indices_actual]);

        
        

-                               total_indice = emufs_idx_get_count(fp);
-                               if (ant_indice >= total_indice) {
-                                       ant_indice = total_indice - 1;
+                               free(indices);
+                               indices = emufs_idx_get(fp, &indices_total);
+                               if (indices_actual >= indices_total) {
+                                       indices_actual = indices_total - 1;

                                }
                                
                                }
                                

-                               data = (char *)fp->leer_registro_raw(fp, emufs_idx_get_id_at(fp, ant_indice), &size, &pos_actual);
+                               data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);

                                data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
                        break;
                        case 'g':
                        case 'G':
                                art_agregar(NULL);
                                free(data);
                                data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
                        break;
                        case 'g':
                        case 'G':
                                art_agregar(NULL);
                                free(data);

-                               data = (char *)fp->leer_registro_raw(fp, emufs_idx_get_id_at(fp, ant_indice), &size, &pos_actual);
+                               data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);

                                data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
        
                                data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
        

-                               total_indice = emufs_idx_get_count(fp);
+                               free(indices);
+                               indices = emufs_idx_get(fp, &indices_total);

 
                                /* Tengo que re-pintar algunas cosas */
 
                                /* Tengo que re-pintar algunas cosas */

-                               mostrar_info(padre, h, actual_ancho);
+                               mostrar_info(padre, h, offset_alto);

                                box(actual[0], 0, 0);
                                wrefresh(actual[0]);
                        break;                  
                        case 'M':
                        case 'm': /* Quiero editar !!! */
                                box(actual[0], 0, 0);
                                wrefresh(actual[0]);
                        break;                  
                        case 'M':
                        case 'm': /* Quiero editar !!! */

-                               sprintf(codigo, "%lu", emufs_idx_get_id_at(fp, ant_indice));
+                               sprintf(codigo, "%lu", indices[indices_actual]);

                                art_modificar(codigo);  
                                /* Vuelvo a cargar el articulo actual */
                                
                                free(data);
                                art_modificar(codigo);  
                                /* Vuelvo a cargar el articulo actual */
                                
                                free(data);

-                               data = (char *)fp->leer_registro_raw(fp, emufs_idx_get_id_at(fp, ant_indice), &size, &pos_actual);
+                               data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);

                                data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 
                                /* Tengo que re-pintar algunas cosas */
                                data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 
                                /* Tengo que re-pintar algunas cosas */

-                               mostrar_info(padre, h, actual_ancho);
+                               mostrar_info(padre, h, offset_alto);

                                box(actual[0], 0, 0);
                                wrefresh(actual[0]);
                        break;
                                box(actual[0], 0, 0);
                                wrefresh(actual[0]);
                        break;


@@ -152,20 +182,20 @@ void ver_registros(WINDOW *padre, int w, int h)
                                if (scroll > max_scroll) scroll = max_scroll;
                        break;
                        case 'l':
                                if (scroll > max_scroll) scroll = max_scroll;
                        break;
                        case 'l':

-                               if (ant_indice < total_indice) {
-                                       ant_indice++;
-                                       if (ant_indice >= total_indice) ant_indice = total_indice-1;
+                               if (indices_actual < indices_total) {
+                                       indices_actual++;
+                                       if (indices_actual >= indices_total) indices_actual = indices_total-1;

                                        if (data) free(data);
                                        if (data) free(data);

-                                       data = (char *)fp->leer_registro_raw(fp, emufs_idx_get_id_at(fp, ant_indice), &size, &pos_actual);
+                                       data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);

                                        data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
                                }
                        break;
                        case 'k':
                                        data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
                                }
                        break;
                        case 'k':

-                               if (ant_indice != EMUFS_NOT_FOUND) {
-                                       ant_indice--;
-                                       if (ant_indice == EMUFS_NOT_FOUND) ant_indice = 0;
+                               if (indices_actual != EMUFS_NOT_FOUND) {
+                                       indices_actual--;
+                                       if (indices_actual == EMUFS_NOT_FOUND) indices_actual = 0;

                                        if (data) free(data);
                                        if (data) free(data);

-                                       data = (char *)fp->leer_registro_raw(fp, emufs_idx_get_id_at(fp, ant_indice), &size, &pos_actual);
+                                       data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);

                                        data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
                                }
 
                                        data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
                                }
 


@@ -189,7 +219,9 @@ void ver_registros(WINDOW *padre, int w, int h)
                wrefresh(actual[1]);
                wrefresh(padre);
        }
                wrefresh(actual[1]);
                wrefresh(padre);
        }

-       delwin(actual[1]);
+       if (indices) free(indices);
+       if (data) free(data);
+

        delwin(actual[0]);
        wrefresh(padre);
        curs_set(1);
        delwin(actual[0]);
        wrefresh(padre);
        curs_set(1);


@@ -198,12 +230,18 @@ void ver_registros(WINDOW *padre, int w, int h)
 char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 {
        char *tmp, *salida, *tmp1, pos_actualizada, ant;
 char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 {
        char *tmp, *salida, *tmp1, pos_actualizada, ant;

-       int cant_header, i=0, j;
+       int cant_header, i=0, j, tam_data;

        if (ptr == NULL) return NULL;
 
        /* Calculo cuantos headers de registros va a haber en el archivo */
        if (ptr == NULL) return NULL;
 
        /* Calculo cuantos headers de registros va a haber en el archivo */

-       cant_header = emu->tam_bloque / (emu->tam_reg+sizeof(EMUFS_REG_ID));
-       if (cant_header == 0) cant_header++; /* Si tam_reg > tam_bloque, voy a tener solo 1 header */
+       if (emu->tam_bloque > emu->tam_reg) {
+               cant_header = emu->tam_bloque / (emu->tam_reg+sizeof(EMUFS_REG_ID));
+               if (cant_header == 0) cant_header++; /* Si tam_reg > tam_bloque, voy a tener solo 1 header */
+               tam_data = sizeof(t_Articulo)-sizeof(unsigned int);
+       } else {
+               cant_header = 1;
+               tam_data = *size - sizeof(EMUFS_REG_ID)-sizeof(unsigned int);
+       }

 
        /* El tamaño del nuevo array lo calculo asi :
         *   
 
        /* El tamaño del nuevo array lo calculo asi :
         *   


@@ -215,10 +253,15 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
         *   +1 == Por el \0
         */
        salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);
         *   +1 == Por el \0
         */
        salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);

+       if (salida == NULL) {
+               fprintf(stderr, "Error de malloc en salida\n");
+               return NULL;
+       }

        tmp = ptr;
        tmp1 = salida;
        pos_actualizada = 0;
        while (i<cant_header) {
        tmp = ptr;
        tmp1 = salida;
        pos_actualizada = 0;
        while (i<cant_header) {

+               fprintf(stderr, "voy a hacer el %d de %d\n", i, cant_header);

                /* Verifico la pos_actual para el resaltado, asi queda coherente 
                 * en el cambio de formato
                 */
                /* Verifico la pos_actual para el resaltado, asi queda coherente 
                 * en el cambio de formato
                 */


@@ -227,15 +270,17 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                        pos_actualizada = 1;
                }
                /* Pongo el ID del registro */
                        pos_actualizada = 1;
                }
                /* Pongo el ID del registro */

-               sprintf(tmp1, "(%08d)", *((unsigned int *)tmp));
+               sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
+               fprintf(stderr, "ID=%lu\n",*((EMUFS_REG_ID *)tmp) );

                tmp1 += 10;
                tmp1 += 10;

-               tmp += sizeof(unsigned int);
+               tmp += sizeof(EMUFS_REG_ID);

                /* Pongo el campo numero del registro */
                sprintf(tmp1, "[%08d]", *((unsigned int *)tmp));
                /* Pongo el campo numero del registro */
                sprintf(tmp1, "[%08d]", *((unsigned int *)tmp));

+               fprintf(stderr, "Numero=%d\n",*((unsigned int *)tmp) );

                tmp1 += 10;
                tmp += sizeof(unsigned int);
                j = 0;
                tmp1 += 10;
                tmp += sizeof(unsigned int);
                j = 0;

-               while (j < (sizeof(t_Articulo)-sizeof(unsigned int))) {
+               while (j < (tam_data)) {

                        if (*tmp == '\0') {
                                if (ant == (*tmp))
                                        (*tmp1) = '.';
                        if (*tmp == '\0') {
                                if (ant == (*tmp))
                                        (*tmp1) = '.';


@@ -252,9 +297,17 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                i++;
        }
        free(ptr);
                i++;
        }
        free(ptr);

-       (*tmp1) = '\0';
-       (*size) = (*size)-sizeof(unsigned int)*cant_header*2+2*cant_header*10+1;
-       (*ancho) = sizeof(t_Articulo)-sizeof(unsigned int)*2+20;
+       
+       if (emu->tam_bloque > emu->tam_reg) {
+               (*size) = (*size)-sizeof(unsigned int)*cant_header*2+2*cant_header*10+1;
+               (*ancho) = sizeof(t_Articulo)-sizeof(unsigned int)*2+20+1;
+       } else {
+               (*size) = (*size)-sizeof(EMUFS_REG_ID)-sizeof(unsigned int)+21;
+               (*ancho) = (*size);
+       }
+       memset(tmp1, '.', (*size)-(tmp1-salida)); 
+       salida[*size] = '\0';
+

        return salida;
 }
 
        return salida;
 }
 


@@ -268,6 +321,7 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
        /* Cuento la cantidad de registros en este bloque */
        cant_header = 0;
        offset = 0;
        /* Cuento la cantidad de registros en este bloque */
        cant_header = 0;
        offset = 0;

+       fprintf(stderr, "Tam = %lu\n", *size);

        do {
                /* Me salto el ID, que no me interesa saber su valor */
                offset += sizeof(EMUFS_REG_ID);
        do {
                /* Me salto el ID, que no me interesa saber su valor */
                offset += sizeof(EMUFS_REG_ID);


@@ -333,11 +387,41 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                }
                i++;
        }
                }
                i++;
        }

-       free(ptr);
-       (*tmp1) = '\0';
+       /* Tengo que trabajar sobre lo que me falte (seguro es espacio libre) */

        (*size) = (*size)-sizeof(unsigned int)*cant_header*3+3*cant_header*10+1;
        (*size) = (*size)-sizeof(unsigned int)*cant_header*3+3*cant_header*10+1;

+       memset(tmp1, '.', (*size)-(tmp1-salida)); 
+       free(ptr);
+       salida[*size] = '\0';

        
        return salida;
 }
 
        
        return salida;
 }
 

+int preguntar_id(WINDOW *win, EMUFS *fp)
+{
+       int n=-1, j=0;
+       t_Form *form = form_crear(win);
+       form_agregar_widget(form, INPUT, "ID a buscar", 8, "");
+
+       do {
+               if (j != 0) {
+                       curs_set(0);
+                       wattron(win, COLOR_PAIR(COLOR_YELLOW));
+                       wattron(win, A_BOLD);
+                       mvwaddstr(win, 2, 1, "Registro no encontrado!!");
+                       wattroff(win, A_BOLD);
+                       wattroff(win, COLOR_PAIR(COLOR_YELLOW));
+                       wrefresh(win);
+                       getch();
+                       werase(win);
+                       box(win, 0, 0);
+               }
+               form_ejecutar(form, 1,1);
+
+               n = form_obtener_valor_int(form, "ID a buscar");
+               j = 1;
+       } while (emufs_idx_existe_id(fp, n) != 0);
+
+       form_destruir(form);
+       return n;
+}