* Actualizo leer_registro_raw de tipo1

 * Actualizo GUI para Articulos (tanto bloques como registros)

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index 8e4011300e7a375c19a61cf143a8dedd2c91f118..51a5f525e85b09273aaa6933ddb2eae8857cc5ac 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -439,81 +439,38 @@ EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, EMUFS_REG_ID id, void *d
 
 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
 {
 
 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
 {

-       char* bloque, *tmp, *cur;
+       char* bloque;

        EMUFS_BLOCK_ID block;
        EMUFS_REG_ID ID_aux;
        EMUFS_BLOCK_SIZE iterador = 0;
        EMUFS_BLOCK_ID block;
        EMUFS_REG_ID ID_aux;
        EMUFS_BLOCK_SIZE iterador = 0;

-       int err, cant_bloques, i;
+       int err;

        
        bloque = NULL;
        
        bloque = NULL;

-       if (emu->tam_reg < emu->tam_bloque) {
-               /* Aca estoy en el caso de que 1 registro entra en 1 solo bloque */
-               block = emufs_idx_buscar_registro(emu,ID);
-               if ( block == EMUFS_NOT_FOUND ) {
-                       return NULL;
-               }
-               if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
-                       return NULL;
-               }
-               
-               ID_aux = -1;
-               iterador = 0;
-       
-               /* Busco el offset desde el comienzo desde donde arranca el registro
-                * buscado, para luego resaltarlo en al GUI
-                */
-               while ( iterador < emu->tam_bloque ) {
-                       memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
-                       if ( ID_aux == ID ){
-                               *pos = iterador; 
-                               *size = emu->tam_bloque;
-                               break;
-                       }
-                       iterador += sizeof(EMUFS_REG_ID);
-                       iterador += emu->tam_reg;
-               }
-       } else {
-               /* Junto todos los bloques que ocupa el registro y agrego un separador de bloques */

                
                

-               /* Busco el primer bloque */
-               block = emufs_idx_buscar_registro(emu,ID);
-               if ( block == EMUFS_NOT_FOUND ){
-                       return NULL;
-               }
-               cant_bloques = emu->tam_reg / (emu->tam_bloque - sizeof(EMUFS_REG_ID))+1;
-               *size = emu->tam_bloque*cant_bloques /*+ cant_bloques*2*/ - sizeof(EMUFS_REG_ID)*(cant_bloques-1);
-               bloque = (char *)malloc(*size);
-               cur = bloque;
-               *pos = 0; 
-
-               /* El bloque 0 va completo */
-               err = 0;
-               if ((tmp = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
-                       /* Oops! ... un bloque no existe, todo mal! */
-                       free(bloque);
-                       return NULL;
-               }
-               memcpy(cur, tmp, emu->tam_bloque);
-               cur += emu->tam_bloque;
-/*             memcpy(cur, "<>", 2);
-               cur += 2;*/
-               free(tmp);
+       /* Aca estoy en el caso de que 1 registro entra en 1 solo bloque */
+       block = emufs_idx_buscar_registro(emu,ID);
+       if ( block == EMUFS_NOT_FOUND ) {
+               return NULL;
+       }
+       if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
+               return NULL;
+       }

                
                

-               /* En resto de los bloques no pongo el ID porque ya esta en el primero */
-               for(i=1; i<cant_bloques; i++) {
-                       err = 0;
-                       if ((tmp = emufs_tipo3_leer_bloque(emu, block+i, &err)) == NULL) {
-                               /* Oops! ... un bloque no existe, todo mal! */
-                               free(bloque);
-                               return NULL;
-                       }
-                       memcpy(cur, tmp+sizeof(EMUFS_REG_ID), emu->tam_bloque-sizeof(EMUFS_REG_ID));
-                       cur += emu->tam_bloque - sizeof(EMUFS_REG_ID);
-/*                     memcpy(cur, "<>", 2);
-                       cur += 2;*/
-                       free(tmp);
+       ID_aux = -1;
+       iterador = 0;
+       
+       /* Busco el offset desde el comienzo desde donde arranca el registro
+        * buscado, para luego resaltarlo en al GUI
+        */
+       while ( iterador < emu->tam_bloque ) {
+               memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
+               if ( ID_aux == ID ){
+                       *pos = iterador; 
+                       *size = emu->tam_bloque;
+                       break;

                }
                }

-               (*cur) = '\0';
+               iterador += sizeof(EMUFS_REG_ID);
+               iterador += emu->tam_reg;

        }
        return bloque;
 }
        }
        return bloque;
 }

diff --git a/emufs_gui/viewer.c b/emufs_gui/viewer.c
index c2b2e1dbe3a9df798aa8e89634dc061241b87bfd..5d325dabd357fcda9e847bfdea98ce7f18012c68 100644 (file)
--- a/emufs_gui/viewer.c
+++ b/emufs_gui/viewer.c
@@ -5,6 +5,7 @@
 #include "facturas.h"
 #include "gui.h"
 #include "common.h"
 #include "facturas.h"
 #include "gui.h"
 #include "common.h"

+#include <ctype.h>

 
 /* 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);
 
 /* 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);


@@ -16,6 +17,14 @@ static char *procesar_registro_factura_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SI
 
 static int preguntar_id(WINDOW *win, EMUFS *fp);
 
 
 static int preguntar_id(WINDOW *win, EMUFS *fp);
 

+void copy_char(char *dst, char *src)
+{
+       /* Todos los espacidores los pongo iguales */
+       if (isspace(*src)) *dst = ' ';
+       else if (iscntrl(*src)) *dst = '*';
+       else *dst = *src;
+}
+

 void mostrar_info(WINDOW *padre, int h, int offset_alto, int opt)
 {
        /* Info de teclas */
 void mostrar_info(WINDOW *padre, int h, int offset_alto, int opt)
 {
        /* Info de teclas */


@@ -466,25 +475,19 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
        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 */

-       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);
-       }
+       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);

 
 

-       /* El tamaño del nuevo array lo calculo asi :
-        *   
-        *   tamañoviejo - tamaño_headers_en_int - tamaño_ints_en_registro
-        *               + 10*(cant_headers+cant_registros) +1
-        *
-        *   En tipo3, la cantidad de headers y cant de registros es la misma
-        *   El 10 es por : (XXXXXXXX)
-        *   +1 == Por el \0
-        */
-       salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);
+       (*size) = (*size)-sizeof(EMUFS_REG_ID)*cant_header*2 + 2*cant_header*10+1;
+       (*ancho) = sizeof(t_Articulo)-sizeof(EMUFS_REG_ID)+10;
+       if ((*ancho) > (*size))
+               (*ancho) = (*size);
+       if ((tam_data) > ((*size)-sizeof(EMUFS_REG_ID))) {
+               tam_data = (*size) - sizeof(EMUFS_REG_ID);
+       }
+       salida = (char *)malloc(*size);
+       memset(salida, '.', *size);

        if (salida == NULL) {
                return NULL;
        }
        if (salida == NULL) {
                return NULL;
        }


@@ -503,10 +506,6 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
                tmp1 += 10;
                tmp += sizeof(EMUFS_REG_ID);
                sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
                tmp1 += 10;
                tmp += sizeof(EMUFS_REG_ID);

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

                j = 0;
                while (j < (tam_data)) {
                        if (*tmp == '\0') {
                j = 0;
                while (j < (tam_data)) {
                        if (*tmp == '\0') {


@@ -515,7 +514,7 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                                else
                                        (*tmp1) = '|';
                        } else {
                                else
                                        (*tmp1) = '|';
                        } else {

-                               (*tmp1) = (*tmp);
+                               copy_char(tmp1, tmp);

                        }
                        ant = (*tmp);
                        tmp++;
                        }
                        ant = (*tmp);
                        tmp++;


@@ -526,15 +525,7 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
        }
        free(ptr);
        
        }
        free(ptr);
        

-       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-2] = '\0';
+       salida[*size-1] = '\0';

 
        return salida;
 }
 
        return salida;
 }


@@ -549,6 +540,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;

+       PERR("Voy a contar la cantidad de headers");

        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);


@@ -557,6 +549,9 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                offset += sizeof(EMUFS_REG_SIZE);
 
                /* Desplazo el offset */
                offset += sizeof(EMUFS_REG_SIZE);
 
                /* Desplazo el offset */

+#ifdef DEBUG
+               fprintf(stderr, "Tamaño Registro = %lu\n", curr_size);
+#endif

                if (curr_size == 0) {
                        /* Si el tamaño de registro es 0, quiere decir que llegue a la
                         * parte que esta vacia */
                if (curr_size == 0) {
                        /* Si el tamaño de registro es 0, quiere decir que llegue a la
                         * parte que esta vacia */


@@ -568,7 +563,8 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
        } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size));
 
        /* Proceso */
        } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size));
 
        /* Proceso */

-       salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*3 + 3*cant_header*10+1);
+       salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);
+       memset(salida, '.',(*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);

        tmp = ptr;
        tmp1 = salida;
        pos_actualizada = 0;
        tmp = ptr;
        tmp1 = salida;
        pos_actualizada = 0;


@@ -588,17 +584,13 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                sprintf(tmp1, "{%08lu}", *((EMUFS_REG_SIZE *)tmp));
                curr_size = *((EMUFS_REG_SIZE *)tmp);
                if (pos_actualizada == 1) {
                sprintf(tmp1, "{%08lu}", *((EMUFS_REG_SIZE *)tmp));
                curr_size = *((EMUFS_REG_SIZE *)tmp);
                if (pos_actualizada == 1) {

-                       (*ancho) = curr_size-sizeof(unsigned int)+30;
+                       (*ancho) = curr_size+20;

                        pos_actualizada = 2;
                }
                tmp1 += 10;
                tmp += sizeof(EMUFS_REG_SIZE);
                        pos_actualizada = 2;
                }
                tmp1 += 10;
                tmp += sizeof(EMUFS_REG_SIZE);

-               /* Pongo el campo numero del registro */
-               sprintf(tmp1, "[%08d]", *((unsigned int *)tmp));
-               tmp1 += 10;
-               tmp += sizeof(unsigned int);
-               j = sizeof(unsigned int);

                PERR("Voy aca");
                PERR("Voy aca");

+               j = 0;

                while (j < curr_size) {
                        if (*tmp == '\0') {
                                if (ant == (*tmp))
                while (j < curr_size) {
                        if (*tmp == '\0') {
                                if (ant == (*tmp))


@@ -606,7 +598,7 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                                else
                                        (*tmp1) = '|';
                        } else {
                                else
                                        (*tmp1) = '|';
                        } else {

-                               (*tmp1) = (*tmp);
+                               copy_char(tmp1, tmp);

                        }
                        ant = (*tmp);
                        tmp++;
                        }
                        ant = (*tmp);
                        tmp++;


@@ -617,10 +609,9 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                i++;
        }
        /* Tengo que trabajar sobre lo que me falte (seguro es espacio libre) */
                i++;
        }
        /* 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;
-       memset(tmp1, '.', (*size)-(tmp1-salida)); 
+       (*size) = (*size)-sizeof(unsigned int)*cant_header*2+2*cant_header*10+1;

        free(ptr);
        free(ptr);

-       salida[*size-2] = '\0';
+       salida[*size-1] = '\0';

        
        return salida;
 }
        
        return salida;
 }


@@ -948,7 +939,7 @@ char *procesar_registro_articulo_tipo2(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
        PERR("Voy por el espacio antes");
        for(i=0; i < *pos_actual; i++) {
                /* Los datos que tengo por ahora los pongo enmascarados! */
        PERR("Voy por el espacio antes");
        for(i=0; i < *pos_actual; i++) {
                /* Los datos que tengo por ahora los pongo enmascarados! */

-               salida[i] = ((*in)=='\0')?'*':(*in);
+               copy_char(&salida[i], in);

                in++;
        }
        tmp = salida + *pos_actual;
                in++;
        }
        tmp = salida + *pos_actual;


@@ -967,14 +958,14 @@ char *procesar_registro_articulo_tipo2(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
        PERR("Voy por la data");
        i = 0;
        while (i < tam_data) {
        PERR("Voy por la data");
        i = 0;
        while (i < tam_data) {

-               (*tmp) = ((*in)=='\0')?'*':(*in);
+               copy_char(tmp, in);

                tmp++;
                in++;
                i++;
        }
        PERR("Voy por el espacio despues");
        for(i=0; i < 100-*pos_actual; i++) {
                tmp++;
                in++;
                i++;
        }
        PERR("Voy por el espacio despues");
        for(i=0; i < 100-*pos_actual; i++) {

-               (*tmp) = ((*in)=='\0')?'*':(*in);
+               copy_char(tmp, in);

                tmp++;
                in++;
        }
                tmp++;
                in++;
        }