From 840e216ee1d0b23864f75f44ba549899669d9595 Mon Sep 17 00:00:00 2001 From: Ricardo Markiewicz Date: Fri, 16 Apr 2004 09:27:44 +0000 Subject: [PATCH] * Bugfix en idx_get para saltar los registros no utilizados * Bugfix en tipo 3 para mandar mensajes por stderr * Agrego "compactar" en EMUFS * Agrego en GUI menu mantenimiento, que implementa el compactar y cambio de organizacion en archivos. Este ultimo no esta andando bien, fallan los leer de todos los tipos de datos. Como se puede ver en los archivos temporales, los .idx suelen quedar vacios en algunos casos! ... hay que revisar bien esas cosas. --- emufs/emufs.h | 1 + emufs/idx.c | 10 ++- emufs/tipo3.c | 4 +- emufs_gui/articulos.c | 75 ++++++++++++++++ emufs_gui/articulos.h | 3 +- emufs_gui/facturas.c | 126 +++++++++++++++++++++++++-- emufs_gui/facturas.h | 3 + emufs_gui/gui.c | 197 +++++++++++++++++++++++++++++++++++++++++- 8 files changed, 405 insertions(+), 14 deletions(-) diff --git a/emufs/emufs.h b/emufs/emufs.h index 9d8b17c..c2dab18 100644 --- a/emufs/emufs.h +++ b/emufs/emufs.h @@ -123,6 +123,7 @@ typedef struct _emu_fs_t { EMUFS_REG_ID (*modificar_registro)(struct _emu_fs_t*, EMUFS_REG_ID, void*, EMUFS_REG_SIZE, int*); /**< Método para modificar un registro */ int (*borrar_registro)(struct _emu_fs_t*, EMUFS_REG_ID); /**< Método para borrar un registro */ EMUFS_Estadisticas (*leer_estadisticas)(struct _emu_fs_t *); + void (*compactar)(struct _emu_fs_t *); char *nombre; /**< Nombre del archivo */ } EMUFS; diff --git a/emufs/idx.c b/emufs/idx.c index 701ba25..8b4f969 100644 --- a/emufs/idx.c +++ b/emufs/idx.c @@ -214,14 +214,18 @@ EMUFS_REG_ID *emufs_idx_get(EMUFS *emu, EMUFS_REG_ID *cant) count = 0; while (!feof(f_idx)) { if (fread(®, sizeof(EMUFS_IDX), 1, f_idx) != 1) continue; - count++; /* TODO : Verificar errores :-D */ - tmp = realloc(tmp, count); - tmp[count-1] = reg.id_reg; + if (reg.location != EMUFS_NOT_FOUND) { + count++; + tmp = realloc(tmp, count); + tmp[count-1] = reg.id_reg; + fprintf(stderr, "Nuevo registro de id = %lu\n", reg.id_reg); + } } fclose(f_idx); (*cant) = count; + fprintf(stderr, "Mando %d registros\n", count); return tmp; } diff --git a/emufs/tipo3.c b/emufs/tipo3.c index 224c096..6375a7e 100644 --- a/emufs/tipo3.c +++ b/emufs/tipo3.c @@ -153,7 +153,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t resto = emu->tam_bloque - sizeof(EMUFS_REG_ID); /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/ num_bloque = emufs_fsc_buscar_lugar(emu, emu->tam_reg+sizeof(EMUFS_REG_ID), &fs); - printf("encontre lugar en %d\n", num_bloque); + fprintf(stderr, "encontre lugar en %d\n", num_bloque); /*si no hay bloques con suficiente espacio creo un bloque nuevo */ if (num_bloque == -1) { if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/ @@ -219,7 +219,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t /*grabo el id en el bloque*/ /*veo el espacio libre que queda*/ fs = emufs_fsc_get_fs(emu, num_bloque+i); - printf("el espacio libre del bloque %d es: %d\n", num_bloque+i, fs); + fprintf(stderr, "el espacio libre del bloque %d es: %d\n", num_bloque+i, fs); if (emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg) memcpy(bloque+sizeof(EMUFS_REG_ID),&ID_aux,sizeof(EMUFS_REG_ID)); else diff --git a/emufs_gui/articulos.c b/emufs_gui/articulos.c index af4536f..96f6b3d 100644 --- a/emufs_gui/articulos.c +++ b/emufs_gui/articulos.c @@ -14,6 +14,11 @@ static t_Reg_Articulo *crear_nodo_articulo(EMUFS_REG_ID reg, unsigned int num); static int agregar_nodo_articulo(t_LstArticulos *lst, t_Reg_Articulo *nodo); static int eliminar_nodo_articulo(t_LstArticulos *lst, t_Reg_Articulo *nodo); +t_LstArticulos *art_get_lst() +{ + return lst_articulos; +} + int eliminar_nodo_articulo(t_LstArticulos *lst, t_Reg_Articulo *nodo) { if (nodo == NULL) return 0; @@ -472,3 +477,73 @@ void *procesar_guardar_articulo(t_Articulo *src, EMUFS_REG_SIZE *size, t_LstArti return tmp; } +void art_reformatear(int tipo, int tam_bloque, int tam_reg) +{ + EMUFS *nuevo, *old; + EMUFS_REG_ID *indices, id; + EMUFS_REG_SIZE indices_total, i, size; + t_Articulo art; + t_LstArticulos *lst_nueva; + int error; + char *save; + + old = lst_articulos->fp; + + /* Si el tipo es el mismo, no tengo que hacer nada! */ + if (old->tipo == tipo) return; + + fprintf(stderr, "Me prepado para cambiar de archivo\n"); + + /* Creo el nuevo file */ + nuevo = emufs_crear("emufs_tmp", tipo, tam_bloque, sizeof(t_Articulo)); + if (nuevo == NULL) { + fprintf(stderr, "ARCHIVO NUEVO NO CREADO\n"); + return; + } + + /* Creo la nueva lista */ + lst_nueva = (t_LstArticulos *)malloc(sizeof(t_LstArticulos)); + lst_nueva->primero = NULL; + lst_nueva->fp = nuevo; + + /* Leo los indices del archivo viejo */ + indices = emufs_idx_get(old, &indices_total); + if (indices == NULL) { + fprintf(stderr, "NO HAY INDICES!\n"); + art_liberar(lst_nueva); + return; + } + + for(i=0; ileer_registro(old, indices[i], &size, &error); + fprintf(stderr, "Lei\n"); + if (procesar_leer_articulo(&art, save, size, lst_articulos) == 1) { + fprintf(stderr, "Procese\n"); + free(save); + /* Lei un registro Ok. Lo salvo en el archivo nuevo */ + save = procesar_guardar_articulo(&art, &size, lst_nueva); + fprintf(stderr, "Procese guardar\n"); + if (save) { + id = nuevo->grabar_registro(nuevo, save, size, &error); + fprintf(stderr, "Guarde\n"); + agregar_nodo_articulo(lst_nueva, crear_nodo_articulo(id, art.numero)); + free(save); + } + } + } + + art_liberar(lst_articulos); + lst_articulos = lst_nueva; + + fprintf(stderr, "Listo. Renombre y me voy\n"); + /* Muevo los archivos! */ + /* TODO : Poner en otro lugar mas generico! */ +/* rename("emufs_tmp.dat", "articulos.dat"); + rename("emufs_tmp.idx", "articulos.idx"); + rename("emufs_tmp.fsc", "articulos.fsc"); + rename("emufs_tmp.did", "articulos.did");*/ +} + diff --git a/emufs_gui/articulos.h b/emufs_gui/articulos.h index 8d7eced..432e85b 100644 --- a/emufs_gui/articulos.h +++ b/emufs_gui/articulos.h @@ -38,6 +38,7 @@ t_Articulo *art_obtener(t_LstArticulos *, const char *numero, EMUFS_REG_ID *id); void art_agregar(char *); void art_eliminar(char *); void art_modificar(char *); - +t_LstArticulos *art_get_lst(); +void art_reformatear(int tipo, int tam_bloque, int tam_reg); #endif diff --git a/emufs_gui/facturas.c b/emufs_gui/facturas.c index d0c0428..ec87770 100644 --- a/emufs_gui/facturas.c +++ b/emufs_gui/facturas.c @@ -12,6 +12,11 @@ int eliminar_nodo_factura(t_LstFacturas *lst, t_Reg_Factura *nodo); static t_Item *leer_items(xmlNode *, int *cant, int size); static char *leer_nota(xmlNode *); +t_LstFacturas *fact_get_lst() +{ + return lst_facturas; +} + /* Hack! ... Si no existe propiedad retorna "" */ char *xml_get_prop(xmlNode *node, char *nombre) { @@ -190,6 +195,8 @@ t_LstFacturas *fact_cargar(const char *filename, int tipo, int tam_bloque) id = tmp->fp->grabar_registro(tmp->fp, save, size, &error); id_texto = tmp->fp_texto->grabar_registro(tmp->fp_texto, fact.nota, 400, &error); agregar_nodo_factura(tmp, crear_nodo_factura(id, id_texto, fact.numero)); + if (fact.items) free(fact.items); + if (fact.nota) free(fact.nota); free(save); } } @@ -228,7 +235,7 @@ int fact_liberar(t_LstFacturas *l) return 0; } -t_Factura *fact_buscar(t_LstFacturas *lst, int numero) +t_Factura *fact_buscar(t_LstFacturas *lst, int numero, EMUFS_REG_ID *id, EMUFS_REG_ID *id_texto) { t_Factura *fact; t_Reg_Factura *reg; @@ -241,10 +248,16 @@ t_Factura *fact_buscar(t_LstFacturas *lst, int numero) reg = lst->primero; while (reg) { if (reg->numero == numero) { + size = 0; + fprintf(stderr, "Leer me dice que %lu\n", size); leo = lst->fp->leer_registro(lst->fp, reg->num_reg, &size, &error); + fprintf(stderr, "Leer me dice que %lu\n", size); if (leo != NULL) { fact = (t_Factura *)malloc(sizeof(t_Factura)); procesar_leer_factura(fact, leo, size, lst); + (*id) = reg->num_reg; + (*id_texto) = reg->texto_reg; + free(leo); } break; } @@ -253,7 +266,7 @@ t_Factura *fact_buscar(t_LstFacturas *lst, int numero) return fact; } -t_Factura *fact_form_buscar(WINDOW *win, EMUFS_REG_ID *id) +t_Factura *fact_form_buscar(WINDOW *win, EMUFS_REG_ID *id, EMUFS_REG_ID *id_texto) { t_Form *form; t_Factura *fact; @@ -261,19 +274,58 @@ t_Factura *fact_form_buscar(WINDOW *win, EMUFS_REG_ID *id) form = form_crear(win); form_agregar_widget(form, INPUT, "Numero de Factura", 8, ""); form_ejecutar(form, 1,1); - fact = fact_buscar(lst_facturas, form_obtener_valor_int(form, "Numero de Factura")); + fact = fact_buscar(lst_facturas, form_obtener_valor_int(form, "Numero de Factura"), id, id_texto); form_destruir(form); return fact; } +void fact_eliminar(char *s) +{ + WINDOW *win; + t_Factura *fact; + t_Reg_Factura *nodo; + EMUFS_REG_ID id; + + win = newwin(LINES-4, COLS-2, 2, 1); + box(win, 0, 0); + + fact = fact_form_buscar(win, &id, &id); + + if (fact == NULL) { + wattron(win, COLOR_PAIR(COLOR_YELLOW)); + mvwaddstr(win, 2, 1, "No existe artículo con ese código. Abortando!"); + wattroff(win, COLOR_PAIR(COLOR_YELLOW)); + wrefresh(win); + getch(); + werase(win); + wrefresh(win); + delwin(win); + 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; + } + + free(fact->items); + free(fact); +} + void fact_modificar(char *s) { WINDOW *win, *items; t_Form *form; t_Factura *fact; /*EMUFS_REG_SIZE size;*/ - EMUFS_REG_ID id; /*, id_texto;*/ + EMUFS_REG_ID id, id_texto; /* int y_actual, cant, error;*/ char tmp_str[10]; @@ -281,9 +333,14 @@ void fact_modificar(char *s) win = newwin(LINES-4, COLS-2, 2, 1); box(win, 0, 0); - fact = fact_form_buscar(win, &id); + fact = fact_form_buscar(win, &id, &id_texto); if (fact == NULL) { + wattron(win, COLOR_PAIR(COLOR_YELLOW)); + mvwaddstr(win, 2, 1, "No existe artículo con ese código. Abortando!"); + wattroff(win, COLOR_PAIR(COLOR_YELLOW)); + wrefresh(win); + getch(); werase(win); wrefresh(win); delwin(win); @@ -507,9 +564,68 @@ void *procesar_guardar_factura(t_Factura *f, t_LstFacturas *lst, EMUFS_REG_SIZE static int procesar_leer_factura(t_Factura *dst, void *src, EMUFS_REG_SIZE size, t_LstFacturas *lst) { + char *ini, *fin; + switch (lst->fp->tipo) { case T1: case T2: + ini = (char *)src; + /* Copio los campos numericos, muy facil:-) */ + memcpy(&dst->numero, ini, sizeof(int)); + ini+=sizeof(int); + + memcpy(&dst->procdoi, ini, sizeof(float)); + ini+=sizeof(float); + + memcpy(&dst->numero_remito, ini, sizeof(int)); + ini+=sizeof(int); + + memcpy(&dst->cant_items, ini, sizeof(int)); + ini+=sizeof(int); + + /* Ahora empieza el juego */ + /* Los \0 son los delimitadores de campo! */ + fin = ini; + while (*fin!='\0') fin++; + memcpy(dst->emision, ini, fin-ini+1); + + ini = fin+1; + fin = ini; + while (*fin!='\0') fin++; + memcpy(dst->vencimiento, ini, fin-ini+1); + + ini = fin+1; + fin = ini; + while (*fin!='\0') fin++; + memcpy(dst->estado, ini, fin-ini+1); + + ini = fin+1; + fin = ini; + while (*fin!='\0') fin++; + memcpy(dst->fp, ini, fin-ini+1); + + ini = fin+1; + fin = ini; + while (*fin!='\0') fin++; + memcpy(dst->ctacte, ini, fin-ini+1); + + ini = fin+1; + fin = ini; + while (*fin!='\0') fin++; + memcpy(dst->cheque, ini, fin-ini+1); + + if (dst->cant_items > 0) { + /* Ahora tengo que cargar los items */ + dst->items = (t_Item *)malloc(sizeof(t_Item)*dst->cant_items); + + ini = fin+1; + fprintf(stderr, "trabajo con 1 -> %lu\n", size); + fin = (char *)src+size; + memcpy(dst->items, ini, fin-ini); + } else { + dst->items = NULL; + } + return 0; case T3: /* Se que tengo 10 items */ diff --git a/emufs_gui/facturas.h b/emufs_gui/facturas.h index cdf92bc..c43a104 100644 --- a/emufs_gui/facturas.h +++ b/emufs_gui/facturas.h @@ -54,6 +54,9 @@ int fact_liberar(t_LstFacturas *l); void fact_agregar(char *s); void fact_modificar(char *s); +void fact_eliminar(char *s); + +t_LstFacturas *fact_get_lst(); #endif diff --git a/emufs_gui/gui.c b/emufs_gui/gui.c index 99418b8..5346b6c 100644 --- a/emufs_gui/gui.c +++ b/emufs_gui/gui.c @@ -19,6 +19,8 @@ static void finish(int sig); int main_menu(); void menu_articulos(); void menu_facturas(); +void menu_mantenimiento(); +void preguntar_nuevo_tipo(int *tipo, int *tam_bloque, int *tam_reg); /* cuadro de msg. w y h son de la ventana padre */ WINDOW *msg_box(WINDOW *win, int w, int h, const char *format, ...); @@ -136,7 +138,7 @@ int main(int argc, char *argv[]) dialog = msg_box(stdscr, COLS, LINES, "Generando archivos ..."); if (argc == 4) { art_cargar(argv[1], atoi(argv[2]), atoi(argv[3])); - if (!fact_cargar("facturas.xml", 3, 400)) + if (!fact_cargar("facturas.xml", 1, 400)) fprintf(stderr, "ERROR CARGANDO FACTURAS\n"); } else art_cargar(NULL, -1, -1); @@ -160,7 +162,9 @@ int main(int argc, char *argv[]) delwin(dialog); refresh(); break; - // case 3: + case 5: + menu_mantenimiento(); + break; case 6: fin = 1; break; @@ -194,7 +198,7 @@ void menu_facturas() items[0] = new_item(opciones[0], "Crear una nueva factura."); set_item_userptr(items[0], fact_agregar); items[1] = new_item(opciones[1], "Eliminar una factura existente."); -/* set_item_userptr(items[1], art_eliminar); */ + set_item_userptr(items[1], fact_eliminar); items[2] = new_item(opciones[2], "Modificar una factura existente."); set_item_userptr(items[2], fact_modificar); items[3] = new_item(opciones[3], "Volver al menu anterior."); @@ -261,6 +265,7 @@ void menu_facturas() free_item(items[2]); free_item(items[3]); free_menu(menu); + free(items); } void menu_articulos() { @@ -347,6 +352,7 @@ void menu_articulos() free_item(items[2]); free_item(items[3]); free_menu(menu); + free(items); } int main_menu() @@ -435,6 +441,7 @@ int main_menu() free_item(items[5]); free_item(items[6]); free_menu(menu); + free(items); return opcion; } @@ -477,3 +484,187 @@ void msg_box_free(WINDOW *padre, WINDOW *win) wrefresh(padre); } +void menu_mantenimiento() +{ + WINDOW *menu_win, *dlg; + MENU *menu; + ITEM **items; + int c, salir, nuevo_tipo, nuevo_tam_bloque, nuevo_tam_registro; + char *opciones[] = { + "Compactar Articulos", + "Compactar Facturas", + "Compactar Notas", + "Cambiar tipo Archivo Articulos", + "Cambiar tipo Archivo Facturas", + "Cambiar tipo Archivo Notas", + "Volver" + }; + + items = (ITEM **)calloc(8, sizeof(ITEM *)); + + items[0] = new_item(opciones[0], "Elimina espacio no utilizado."); + items[1] = new_item(opciones[1], "Elimina espacio no utilizado."); + items[2] = new_item(opciones[2], "Elimina espacio no utilizado."); + items[3] = new_item(opciones[3], "Permite cambiar el tipo del archivo."); + items[4] = new_item(opciones[4], "Permite cambiar el tipo del archivo."); + items[5] = new_item(opciones[5], "Permite cambiar el tipo del archivo."); + items[6] = new_item(opciones[6], "Volver al menu anterior."); + items[7] = NULL; + + menu = new_menu((ITEM **)items); + menu_win = newwin(12, COLS-2, 3, 1); + keypad(menu_win, TRUE); + set_menu_mark(menu, " > "); + set_menu_win(menu, menu_win); + set_menu_sub(menu, derwin(menu_win, 8, COLS-4, 3, 1)); + + box(menu_win, 0, 0); + mvwaddch(menu_win, 2, 0, ACS_LTEE); + mvwhline(menu_win, 2, 1, ACS_HLINE, COLS-3); + mvwaddch(menu_win, 2, COLS-3, ACS_RTEE); + wattron(menu_win, COLOR_PAIR(COLOR_RED)); + mvwaddstr(menu_win, 1, 1, "Menu Mantenimiento"); + wattroff(menu_win, COLOR_PAIR(COLOR_RED)); + post_menu(menu); + wrefresh(menu_win); + + curs_set(0); + salir = 0; + while((!salir) && (c = getch()) != KEY_F(3)) { + switch(c) { + case KEY_DOWN: + menu_driver(menu, REQ_DOWN_ITEM); + break; + case KEY_UP: + menu_driver(menu, REQ_UP_ITEM); + break; + case 13: + case 10: + { + ITEM *cur; + + cur = current_item(menu); + if (strcmp(item_name(cur), opciones[6]) == 0) { + salir = 1; + } else { + if (strcmp(item_name(cur), opciones[0]) == 0) { + art_get_lst()->fp->compactar(art_get_lst()->fp); + } + if (strcmp(item_name(cur), opciones[1]) == 0) { + fact_get_lst()->fp->compactar(fact_get_lst()->fp); + } + if (strcmp(item_name(cur), opciones[2]) == 0) { + fact_get_lst()->fp_texto->compactar(fact_get_lst()->fp_texto); + } + if (strcmp(item_name(cur), opciones[3]) == 0) { + unpost_menu(menu); + nuevo_tam_registro = -1; /* No permito cambiar el tamaño de registro */ + preguntar_nuevo_tipo(&nuevo_tipo, &nuevo_tam_bloque, &nuevo_tam_registro); + dlg = msg_box(stdscr, COLS, LINES, "Cambiando el formato de archivo .... Aguarde"); + art_reformatear(nuevo_tipo, nuevo_tam_bloque, nuevo_tam_registro); + msg_box_free(stdscr, dlg); + box(menu_win, 0, 0); + post_menu(menu); + } + if (strcmp(item_name(cur), opciones[4]) == 0) { + unpost_menu(menu); + nuevo_tam_registro = 0; + preguntar_nuevo_tipo(&nuevo_tipo, &nuevo_tam_bloque, &nuevo_tam_registro); + box(menu_win, 0, 0); + post_menu(menu); + } + if (strcmp(item_name(cur), opciones[5]) == 0) { + unpost_menu(menu); + nuevo_tam_registro = -2; + preguntar_nuevo_tipo(&nuevo_tipo, &nuevo_tam_bloque, &nuevo_tam_registro); + box(menu_win, 0, 0); + post_menu(menu); + } + } + } + } + wrefresh(menu_win); + } + curs_set(1); + + unpost_menu(menu); + delwin(menu_win); + free_item(items[0]); + free_item(items[1]); + free_item(items[2]); + free_item(items[3]); + free_menu(menu); + + free(items); +} + +void preguntar_nuevo_tipo(int *tipo, int *tam_bloque, int *tam_reg) +{ + WINDOW *win; + t_Form *form; + char *s; + int n, is_ok; + + win = newwin(LINES/2, COLS/2, LINES/4, COLS/4); + box(win, 0, 0); + + form = form_crear(win); + form_agregar_widget(form, RADIO, "Tipo de archivo", 3, "T1,T2,T3"); + form_ejecutar(form, 1,1); + + s = form_obtener_valor_char(form, "Tipo de archivo"); + if (strcmp(s, "T1") == 0) n = T1; + if (strcmp(s, "T2") == 0) n = T2; + if (strcmp(s, "T3") == 0) n = T3; + + form_destruir(form); + + werase(win); + box(win, 0, 0); + wrefresh(win); + + (*tipo) = n; + switch (n) { + case T1: + form = form_crear(win); + form_agregar_widget(form, INPUT, "Tamaño de bloque", 8, ""); + is_ok = 0; + do { + form_set_valor(form, "Tamaño de bloque", ""); + form_ejecutar(form, 1,1); + if (form_obtener_valor_int(form, "Tamaño de bloque") > 0) is_ok = 1; + } while (!is_ok); + (*tam_bloque) = form_obtener_valor_int(form, "Tamaño de bloque"); + form_destruir(form); + break; + case T2: + break; + case T3: + if (((*tam_reg) != -1) && ((*tam_reg) != -2)) { + mvwaddstr(win, LINES/2-3, 1, "Nota: El tamaño de registro puede"); + mvwaddstr(win, LINES/2-2, 1, "llegar a ser redondeado por el sistema."); + } + form = form_crear(win); + form_agregar_widget(form, INPUT, "Tamaño de bloque", 8, ""); + if ((*tam_reg) != -1) + form_agregar_widget(form, INPUT, "Tamaño de registro", 8, ""); + is_ok = 0; + do { + form_set_valor(form, "Tamaño de bloque", ""); + if ((*tam_reg) != -1) + form_set_valor(form, "Tamaño de registro", ""); + form_ejecutar(form, 1,1); + if (form_obtener_valor_int(form, "Tamaño de bloque") > 0) is_ok = 1; + if ((*tam_reg) != -1) { + if (form_obtener_valor_int(form, "Tamaño de registro") > 0) is_ok = 1; else is_ok = 0; + } + } while (!is_ok); + (*tam_bloque) = form_obtener_valor_int(form, "Tamaño de bloque"); + if ((*tam_reg) != -1) + (*tam_reg) = form_obtener_valor_int(form, "Tamaño de registro"); + form_destruir(form); + } + werase(win); + wrefresh(win); + delwin(win); +} -- 2.43.0