From 0e6e058c514e07878085512095d5be4f5b50e8d9 Mon Sep 17 00:00:00 2001 From: Ricardo Markiewicz Date: Sun, 18 Apr 2004 02:58:17 +0000 Subject: [PATCH] * Termino Ver bloques para : - Articulos - Facturas - Notas Si el tipo de archivo no tiene bloques. Avisa y no hace nada * Se agrega leer_bloque_raw que lee el bloque pedido, el anterior y el siguiente. Tanto para tipo1 como para tipo3. --- emufs/emufs.c | 2 + emufs/emufs.h | 1 + emufs/tipo1.c | 10 +++ emufs/tipo1.h | 2 + emufs/tipo3.c | 18 ++++ emufs/tipo3.h | 3 + emufs_gui/gui.c | 48 +++++++++- emufs_gui/registros.c | 202 ++++++++++++++++++++++++++++++++++++++++++ emufs_gui/registros.h | 1 + 9 files changed, 283 insertions(+), 4 deletions(-) diff --git a/emufs/emufs.c b/emufs/emufs.c index ebd4337..b946e48 100644 --- a/emufs/emufs.c +++ b/emufs/emufs.c @@ -171,6 +171,7 @@ EMUFS *emufs_crear(const char *filename, EMUFS_Tipo tipo, EMUFS_BLOCK_SIZE tam_b efs->leer_estadisticas = emufs_tipo3_leer_estadisticas; efs->modificar_registro = emufs_tipo3_modificar_registro; efs->compactar = emufs_tipo3_compactar; + efs->leer_bloque_raw = emufs_tipo3_leer_bloque_raw; /* Guarda cabeceras propias. */ fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp); fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp); @@ -251,6 +252,7 @@ EMUFS *emufs_abrir(const char *filename) efs->leer_estadisticas = emufs_tipo3_leer_estadisticas; efs->modificar_registro = emufs_tipo3_modificar_registro; efs->compactar = emufs_tipo3_compactar; + efs->leer_bloque_raw = emufs_tipo3_leer_bloque_raw; break; } diff --git a/emufs/emufs.h b/emufs/emufs.h index 85730d4..ac123ca 100644 --- a/emufs/emufs.h +++ b/emufs/emufs.h @@ -122,6 +122,7 @@ typedef struct _emu_fs_t { EMUFS_BLOCK_SIZE tam_bloque; /**< Tamaño de bloque. 0 Si no tiene bloques */ EMUFS_REG_SIZE tam_reg; /**< Tamaño de registro. 0 Si son registros variables */ void* (*leer_bloque)(struct _emu_fs_t*, EMUFS_BLOCK_ID, int*); /**< Método para leer un bloque */ + void (*leer_bloque_raw)(struct _emu_fs_t*, EMUFS_BLOCK_ID, char **, char **, char **, EMUFS_BLOCK_SIZE *, EMUFS_BLOCK_SIZE *, EMUFS_BLOCK_SIZE *); /**< Método para leer un bloque, el anterior y el siguiente */ void* (*leer_registro)(struct _emu_fs_t*, EMUFS_REG_ID, EMUFS_REG_SIZE*, int*); /**< Método para leer un registro */ void* (*leer_registro_raw)(struct _emu_fs_t*, EMUFS_REG_ID, EMUFS_REG_SIZE*, int *); /**< Método para leer un registro con todo su bloque asociado */ EMUFS_REG_ID (*grabar_registro)(struct _emu_fs_t*, void*, EMUFS_REG_SIZE, int*); /**< Método para grabar un registro */ diff --git a/emufs/tipo1.c b/emufs/tipo1.c index 5812bfe..0db0f3a 100644 --- a/emufs/tipo1.c +++ b/emufs/tipo1.c @@ -90,6 +90,7 @@ int emufs_tipo1_inicializar(EMUFS* efs) } /* Asigna punteros a funciones. */ efs->leer_bloque = emufs_tipo1_leer_bloque; + efs->leer_bloque_raw = emufs_tipo1_leer_bloque_raw; efs->grabar_registro = emufs_tipo1_grabar_registro; efs->borrar_registro = emufs_tipo1_borrar_registro; efs->leer_registro = emufs_tipo1_leer_registro; @@ -735,3 +736,12 @@ long emufs_tipo1_get_file_size(EMUFS* efs, int* err) return file_size; } +void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3) +{ + int err; + (*actual) = emufs_tipo1_leer_bloque(efs, id, &err); + (*anterior) = emufs_tipo1_leer_bloque(efs, id-1, &err); + (*siguiente) = emufs_tipo1_leer_bloque(efs, id+1, &err); + (*size1) = (*size2) = (*size3) = efs->tam_bloque; +} + diff --git a/emufs/tipo1.h b/emufs/tipo1.h index 7a7c21f..9297e86 100644 --- a/emufs/tipo1.h +++ b/emufs/tipo1.h @@ -64,4 +64,6 @@ EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS*); /** Método para compactar el archivo reorganizándolo físicamente */ void emufs_tipo1_compactar(EMUFS*); +void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3); + #endif /* _EMUFS_TIPO1_H_ */ diff --git a/emufs/tipo3.c b/emufs/tipo3.c index 97752e7..062a948 100644 --- a/emufs/tipo3.c +++ b/emufs/tipo3.c @@ -527,3 +527,21 @@ void emufs_tipo3_compactar(EMUFS *emu) if (emufs_fsc_truncate(emu, block_id)!= 0) PERR("NO TURNQUE EL FSC"); } + +void emufs_tipo3_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3) +{ + int err; + (*actual) = emufs_tipo3_leer_bloque(efs, id, &err); + (*anterior) = emufs_tipo3_leer_bloque(efs, id-1, &err); + (*siguiente) = emufs_tipo3_leer_bloque(efs, id+1, &err); + if (!(*anterior)) { + (*anterior) = (char *)malloc(efs->tam_bloque); + memset(*anterior, 0, efs->tam_bloque); + } + if (!(*siguiente)) { + (*siguiente) = (char *)malloc(efs->tam_bloque); + memset(*siguiente, 0, efs->tam_bloque); + } + (*size1) = (*size2) = (*size3) = efs->tam_bloque; +} + diff --git a/emufs/tipo3.h b/emufs/tipo3.h index 97de3fa..508f396 100644 --- a/emufs/tipo3.h +++ b/emufs/tipo3.h @@ -73,4 +73,7 @@ void* emufs_tipo3_leer_registro_raw(struct _emu_fs_t*, EMUFS_REG_ID, EMUFS_REG_S /** Elimina los espacios libres que hay en el archivo */ void emufs_tipo3_compactar(EMUFS *emu); + +void emufs_tipo3_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3); + #endif /* _EMUFS_TIPO3_H_ */ diff --git a/emufs_gui/gui.c b/emufs_gui/gui.c index ff7e68b..03b61a3 100644 --- a/emufs_gui/gui.c +++ b/emufs_gui/gui.c @@ -7,6 +7,7 @@ #include #include +#include "gui.h" #include "menu.h" #include "form.h" #include "articulos.h" @@ -24,14 +25,11 @@ void menu_facturas(); void menu_mantenimiento(); void menu_estadisticas(); void menu_ver_registros(); +void menu_ver_bloques(); void preguntar_nuevo_tipo(int *tipo, int *tam_bloque, int *tam_reg); void ver_estadisticas(EMUFS *fp); -/* cuadro de msg. w y h son de la ventana padre */ -WINDOW *msg_box(WINDOW *win, int w, int h, const char *format, ...); -void msg_box_free(WINDOW *padre, WINDOW *win); - typedef enum { PARAM_OK, /* Parametros estan ok */ NO_ART_FILE, /* No se especifico nombre de archivo Articulos */ @@ -235,6 +233,7 @@ int main(int argc, char *argv[]) menu_ver_registros(); break; case 3: + menu_ver_bloques(); break; case 4: menu_estadisticas(); @@ -363,6 +362,47 @@ void menu_ver_registros() } } } + +void menu_ver_bloques() +{ + MENU(mi_menu) { + MENU_OPCION("Articulos", "Ver bloques del archivo de Articulos."), + MENU_OPCION("Facturas", "Ver bloques del archivo de Facturas."), + MENU_OPCION("Notas", "Ver bloques del archivo de Notas."), + MENU_OPCION("Volver", "Ir al menu anterior.") + }; + int opt; + WINDOW *dialog; + + while ((opt = menu_ejecutar(mi_menu, 4, "Menu Ver Bloques")) != 3) { + switch (opt) { + case 0: + dialog = derwin(stdscr, LINES-4, COLS-2, 2, 1); + ver_bloques(dialog, COLS-2, LINES-4, 0); + werase(dialog); + wrefresh(dialog); + delwin(dialog); + refresh(); + break; + case 1: + dialog = derwin(stdscr, LINES-4, COLS-2, 2, 1); + ver_bloques(dialog, COLS-2, LINES-4, 1); + werase(dialog); + wrefresh(dialog); + delwin(dialog); + refresh(); + break; + case 2: + dialog = derwin(stdscr, LINES-4, COLS-2, 2, 1); + ver_bloques(dialog, COLS-2, LINES-4, 2); + werase(dialog); + wrefresh(dialog); + delwin(dialog); + refresh(); + } + } +} + int main_menu() { MENU(mi_menu) { diff --git a/emufs_gui/registros.c b/emufs_gui/registros.c index 325b3e2..7daf984 100644 --- a/emufs_gui/registros.c +++ b/emufs_gui/registros.c @@ -3,6 +3,7 @@ #include "idx.h" #include "articulos.h" #include "facturas.h" +#include "gui.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); @@ -53,7 +54,208 @@ void mostrar_info(WINDOW *padre, int h, int offset_alto) mvwaddstr(padre, h-offset_alto+6, 48, " . = Esp. Libre"); mvwaddstr(padre, h-offset_alto+7, 48, " < > = Separador Bloques"); } + +char *juntar_memoria(char *s1, char *s2, char *s3, int size1, int size2, int size3) +{ + char *salida; + int tam=0; + if (s1) tam += size1; + if (s2) tam += size2; + if (s3) tam += size3; + salida = (char *)malloc(tam); + if (salida == NULL) { + free(s1); + free(s2); + free(s3); + return NULL; + } + + if (s1) memcpy(salida, s1, size1); + if (s2) memcpy(salida+size2, s2, size2); + if (s3) memcpy(salida+size2+size3, s3, size3); + if (s1) free(s1); + if (s2) free(s2); + if (s3) free(s3); + return salida; +} + +void ver_bloques(WINDOW *padre, int w, int h, int cual) +{ + /* Ventanas donde mostrar las cosas */ + char *(*procesar)(EMUFS*, char*, EMUFS_REG_SIZE*, int*, int*); + WINDOW *actual[2], *dlg; + EMUFS_REG_SIZE size, size_actual, size_siguiete, size_anterior; + int scroll, actual_ancho; + int max_scroll, c, offset_alto; + /* Indices que hay validos en IDX */ + EMUFS_REG_ID indices_total, indices_actual; + char *bloque_actual, *bloque_anterior, *bloque_siguiente; + char *data; /* Registros a mostrar en pantalla */ + EMUFS *fp; + int pos_actual, ancho_registro, offset, pos; + EMUFS_Estadisticas stats; + + if (cual == 0) + fp = emufs_abrir("articulos"); + else if (cual == 1) + fp = emufs_abrir("facturas"); + else if (cual == 2) + fp = emufs_abrir("notas"); + + stats = fp->leer_estadisticas(fp); + + wattron(padre, COLOR_PAIR(COLOR_BLUE)); + mvwaddstr(padre, 0, 0, "Tipo de archivo : "); + wattroff(padre, COLOR_PAIR(COLOR_BLUE)); + switch (fp->tipo) { + case T1: + waddstr(padre, "Registro variable con bloque parametrizado."); + if (cual == 0) + procesar = procesar_registro_articulo_tipo1; + else + procesar = procesar_registro_factura_tipo1; + break; + case T2: + waddstr(padre, "Registro variable sin bloques."); + actual[0] = msg_box(padre, w, h, "El tipo de archivo no contiene bloques."); + getch(); + msg_box_free(padre, actual[0]); + return; + break; + case T3: + if (cual == 0) + procesar = procesar_registro_articulo_tipo3; + else + procesar = procesar_registro_factura_tipo3; + waddstr(padre, "Registro fijo con bloque parametrizado."); + } + + + indices_actual = 0; + indices_total = stats.cant_bloques; + /* Leo */ + fp->leer_bloque_raw(fp, indices_actual, &bloque_actual, &bloque_anterior, &bloque_siguiente, &size_actual, &size_anterior, &size_siguiete); + pos_actual = 0; + bloque_actual = procesar(fp, bloque_actual, &size_actual, &pos_actual, &ancho_registro); + pos_actual = 0; + bloque_siguiente = procesar(fp, bloque_siguiente, &size_siguiete, &pos_actual, &ancho_registro); + pos_actual = 0; + bloque_anterior = procesar(fp, bloque_anterior, &size_anterior, &pos_actual, &ancho_registro); + if (!bloque_siguiente) { + bloque_siguiente = (char *)malloc(size_siguiete); + memset(bloque_siguiente, 0, size_siguiete); + } + if (!bloque_anterior) { + bloque_anterior = (char *)malloc(size_anterior); + memset(bloque_anterior, 0, size_anterior); + } + pos_actual = size_anterior; /* Resalta desde el fin del bloque anterior */ + ancho_registro = size_actual; + data = juntar_memoria(bloque_anterior, bloque_actual, bloque_siguiente, size_anterior, size_actual, size_siguiete); + + PERR("HASTA ACA VOY BIEN"); + offset_alto = 8; + max_scroll = (size_actual+size_anterior+size_siguiete) / (w-4) - (h-offset_alto-2); + if (max_scroll < 0) max_scroll = 0; + + actual[0] = derwin(padre, h-offset_alto, w-2, 1, 1); + actual_ancho = w-4; + actual[1] = derwin(actual[0], h-offset_alto-2, w-4, 1, 1); + box(actual[0], 0, 0); + + curs_set(0); + + mostrar_info(padre, h, offset_alto); + + mvwaddnstr(actual[1], 0, 0, data, pos_actual); + wattron(actual[1], A_BOLD); + waddnstr(actual[1], data+pos_actual, ancho_registro); + wattroff(actual[1], A_BOLD); + waddnstr(actual[1], data+pos_actual+ancho_registro, size-(pos_actual+ancho_registro)); + wrefresh(actual[1]); + wrefresh(actual[0]); + wrefresh(padre); + 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 'a': /* Scroll */ + scroll--; + if (scroll < 0) scroll = 0; + break; + case 'z': /* Scroll */ + scroll++; + if (scroll > max_scroll) scroll = max_scroll; + break; + case 'l': + if (indices_actual < indices_total) { + indices_actual++; + if (indices_actual >= indices_total) indices_actual = indices_total-1; + if (data) free(data); + fp->leer_bloque_raw(fp, indices_actual, &bloque_actual, &bloque_anterior, &bloque_siguiente, &size_actual, &size_anterior, &size_siguiete); + bloque_actual = procesar(fp, bloque_actual, &size_actual, &pos_actual, &ancho_registro); + bloque_siguiente = procesar(fp, bloque_siguiente, &size_siguiete, &pos_actual, &ancho_registro); + bloque_anterior = procesar(fp, bloque_anterior, &size_anterior, &pos_actual, &ancho_registro); + pos_actual = size_anterior; /* Resalta desde el fin del bloque anterior */ + ancho_registro = size_actual; + data = juntar_memoria(bloque_anterior, bloque_actual, bloque_siguiente, size_anterior, size_actual, size_siguiete); + } + break; + case 'k': + if (indices_actual != EMUFS_NOT_FOUND) { + indices_actual--; + if (indices_actual == EMUFS_NOT_FOUND) indices_actual = 0; + if (data) free(data); + fp->leer_bloque_raw(fp, indices_actual, &bloque_actual, &bloque_anterior, &bloque_siguiente, &size_actual, &size_anterior, &size_siguiete); + bloque_actual = procesar(fp, bloque_actual, &size_actual, &pos_actual, &ancho_registro); + bloque_siguiente = procesar(fp, bloque_siguiente, &size_siguiete, &pos_actual, &ancho_registro); + bloque_anterior = procesar(fp, bloque_anterior, &size_anterior, &pos_actual, &ancho_registro); + pos_actual = size_anterior; /* Resalta desde el fin del bloque anterior */ + ancho_registro = size_actual; + data = juntar_memoria(bloque_anterior, bloque_actual, bloque_siguiente, size_anterior, size_actual, size_siguiete); + } + } + /* Borro las ventanas */ + werase(actual[1]); + + /* Imprimo los registros */ + if (data) { + offset = scroll*actual_ancho; /* Cantidad de caracteres que tengo que saltar */ + pos = pos_actual - offset; /* Cantidad de caracteres que hay antes de mi a imprimir */ + mvwaddnstr(actual[1], 0, 0, data+offset, pos); + if (pos > 0) + offset += pos; + else + offset -= pos; + wattron(actual[1], A_BOLD); + waddnstr(actual[1], data+offset, ancho_registro+((pos<0)?pos:0)); + wattroff(actual[1], A_BOLD); + offset += ancho_registro+((pos<0)?pos:0); + waddnstr(actual[1], data+offset, size-offset); + } + + wrefresh(actual[1]); + wrefresh(padre); + } + if (data) free(data); + + emufs_destruir(fp); + delwin(actual[0]); + wrefresh(padre); + curs_set(1); +} + void ver_registros(WINDOW *padre, int w, int h, int cual) { /* Ventanas donde mostrar las cosas */ diff --git a/emufs_gui/registros.h b/emufs_gui/registros.h index 03ba038..681c5f1 100644 --- a/emufs_gui/registros.h +++ b/emufs_gui/registros.h @@ -8,6 +8,7 @@ #include "emufs.h" void ver_registros(WINDOW *padre, int w, int h, int cual); +void ver_bloques(WINDOW *padre, int w, int h, int cual); #endif -- 2.43.0