]> git.llucax.com Git - z.facultad/75.06/emufs.git/commitdiff
* Termino Ver bloques para :
authorRicardo Markiewicz <gazer.arg@gmail.com>
Sun, 18 Apr 2004 02:58:17 +0000 (02:58 +0000)
committerRicardo Markiewicz <gazer.arg@gmail.com>
Sun, 18 Apr 2004 02:58:17 +0000 (02:58 +0000)
     - 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
emufs/emufs.h
emufs/tipo1.c
emufs/tipo1.h
emufs/tipo3.c
emufs/tipo3.h
emufs_gui/gui.c
emufs_gui/registros.c
emufs_gui/registros.h

index ebd43371950763cf1a5a61f5c358c5dbbf09dbc6..b946e482334a0b8b1204503c2fde59725d67bd78 100644 (file)
@@ -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_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);                        
                        /* 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_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;
        }
 
                        break;
        }
 
index 85730d496859020817d0cfd49c18dcfb6ca2594c..ac123ca3c76e783d9e3c0ad055b15644b00dc692 100644 (file)
@@ -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 */
        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 */
        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 */
index 5812bfe69302dbef5262bab6d1011492f89e7f70..0db0f3a3c85ccbd695d65dcc931d646072c22744 100644 (file)
@@ -90,6 +90,7 @@ int emufs_tipo1_inicializar(EMUFS* efs)
        }
        /* Asigna punteros a funciones. */
        efs->leer_bloque       = emufs_tipo1_leer_bloque;
        }
        /* 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;
        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;
 }
 
        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;
+}
+
index 7a7c21f8d2b30482404acaa2249bcc15f21a3d2f..9297e86a0edaa2697a826b27ccaf8eba24739fc2 100644 (file)
@@ -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*);
 
 /** 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_ */
 #endif /* _EMUFS_TIPO1_H_ */
index 97752e75ad4b8340a0208a48f5561babeb1d6215..062a94863545e42e2fea7c5113c699063487dcd9 100644 (file)
@@ -527,3 +527,21 @@ void emufs_tipo3_compactar(EMUFS *emu)
        if (emufs_fsc_truncate(emu, block_id)!= 0)
                PERR("NO TURNQUE EL FSC");
 }
        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;
+}
+
index 97de3fab026e39e7535d4a28cbeb8b3d5cc178f2..508f3963fbea9aa31b96b5d8365671717b8bf5e6 100644 (file)
@@ -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);
 
 /** 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_ */
 #endif /* _EMUFS_TIPO3_H_ */
index ff7e68b7bb7d8c39381d1ae0b5b714f9624c363d..03b61a3b5eea84ee29426e43fa4eafb5a00aa6d9 100644 (file)
@@ -7,6 +7,7 @@
 #include <string.h>
 #include <stdarg.h>
 
 #include <string.h>
 #include <stdarg.h>
 
+#include "gui.h"
 #include "menu.h"
 #include "form.h"
 #include "articulos.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_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);
 
 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 */
 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_registros();
                        break;
                        case 3:
+                               menu_ver_bloques();
                        break;
                        case 4:
                                menu_estadisticas();
                        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) {
 int main_menu()
 {
        MENU(mi_menu) {
index 325b3e26d800d64c23fa3546399ee508d9ebad9e..7daf984f983f3e8d513fdafcb80d2f81e9dfb3fa 100644 (file)
@@ -3,6 +3,7 @@
 #include "idx.h"
 #include "articulos.h"
 #include "facturas.h"
 #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);
 
 /* 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");
 }
        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 */
 void ver_registros(WINDOW *padre, int w, int h, int cual)
 {
        /* Ventanas donde mostrar las cosas */
index 03ba038c13dafda8d03d82831fca660647925603..681c5f12492dea639aa71917c9a93933b4474f5e 100644 (file)
@@ -8,6 +8,7 @@
 #include "emufs.h"
 
 void ver_registros(WINDOW *padre, int w, int h, int cual);
 #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
 
 
 #endif