emufs_gui/gui.c

   1
   2
   3 #include <stdlib.h>
   4 #include <curses.h>
   5 #include <menu.h>
   6 #include <signal.h>
   7 #include <string.h>
   8 #include <stdarg.h>
   9
  10 #include "gui.h"
  11 #include "menu.h"
  12 #include "form.h"
  13 #include "articulos.h"
  14 #include "facturas.h"
  15 #include "emufs.h"
  16 #include "registros.h"
  17
  18 #define CTRLD 4
  19
  20 static void finish(int sig);
  21
  22 int main_menu();
  23 void menu_articulos();
  24 void menu_facturas();
  25 void menu_mantenimiento();
  26 void menu_estadisticas();
  27 void menu_ver_registros();
  28 void menu_ver_bloques();
  29 void preguntar_nuevo_tipo(int *tipo, int *tam_bloque, int *tam_reg);
  30
  31 void ver_estadisticas(EMUFS *fp);
  32
  33 typedef enum {
  34                 PARAM_OK, /* Parametros estan ok */
  35                 NO_ART_FILE,  /* No se especifico nombre de archivo Articulos */
  36                 NO_FACT_FILE, /* No se especifico nombre de archivo Facturas */
  37                 SHOW_HELP,    /* Mostrar ayuda encontrado */
  38                 TIPO_NO_DEFINIDO, /* No se definio tipo de archivo */
  39                 TIPO_INVALIDO,    /* El valor de tipo de archivo no es valido */
  40                 BLOQUE_NO_DEFINIDO, /* No se especifico tamaño de bloque */
  41                 NULL_BLOCK_FOUND    /* Tamaño de bloque <= 0!!! */
  42 } t_Param;
  43
  44 struct _mis_param_ {
  45         int xml_fact; /* Pos en argv  del archivo XML a usar para facturas */
  46         int xml_art; /* Pos en argv del archivo XML a usar para articulos */
  47         char tipo_arch_fact; /* Tipo de archivo para Facturas */
  48         char tipo_arch_art; /* Tipo de archivo para Articulos */
  49         EMUFS_BLOCK_SIZE tam_bloque_fact;
  50         EMUFS_BLOCK_SIZE tam_bloque_art;
  51 } parametros;
  52
  53 /* Verifica Argumentos */
  54 t_Param param_ok(int argc, char *argv[])
  55 {
  56         int n,i;
  57         for(i=1; i<argc; i++) {
  58                 if ((strcmp(argv[i], "-h")==0) || (strcmp(argv[i], "--help")==0)) return SHOW_HELP;
  59
  60                 if (strcmp(argv[i], "-a") == 0) { /* Articulos! */
  61                         i++;
  62                         if (i >= argc) return SHOW_HELP;
  63                         if (strcmp(argv[i]+strlen(argv[i])-3, "xml") == 0) {
  64                                 /* Luego del archivo XML debe seguir el tipo */
  65                                 if ((i+1)<argc) {
  66                                         n = atoi(argv[i+1]);
  67                                         if ((n < 1) || (n > 3)) return TIPO_INVALIDO;
  68                                         if (((n == 1) || (n == 3)) && ((i+2)>=argc))
  69                                                 return BLOQUE_NO_DEFINIDO;
  70                                         parametros.tipo_arch_art = n;
  71                                         parametros.tam_bloque_art = atoi(argv[i+2]);
  72                                         if (parametros.tam_bloque_art <= 0) return NULL_BLOCK_FOUND;
  73                                         parametros.xml_art = i;
  74                                 } else {
  75                                         /* Ops, no hay mas parametros */
  76                                         return TIPO_NO_DEFINIDO;
  77                                 }
  78                         } else {
  79                                 return NO_ART_FILE;
  80                         }
  81                 } /* Articulos */
  82
  83                 if (strcmp(argv[i], "-f") == 0) { /* Facturas! */
  84                         i++;
  85                         if (i >= argc) return SHOW_HELP;
  86                         if (strcmp(argv[i]+strlen(argv[i])-3, "xml") == 0) {
  87                                 /* Luego del archivo XML debe seguir el tipo */
  88                                 if ((i+1)<argc) {
  89                                         n = atoi(argv[i+1]);
  90                                         if ((n < 1) || (n > 3)) return TIPO_INVALIDO;
  91                                         if (((n == 1) || (n == 3)) && ((i+2)>=argc))
  92                                                 return BLOQUE_NO_DEFINIDO;
  93                                         parametros.tipo_arch_fact = n;
  94                                         parametros.tam_bloque_fact = atoi(argv[i+2]);
  95                                         if (parametros.tam_bloque_fact <= 0) return NULL_BLOCK_FOUND;
  96                                         parametros.xml_fact = i;
  97                                 } else {
  98                                         /* Ops, no hay mas parametros */
  99                                         return TIPO_NO_DEFINIDO;
 100                                 }
 101                         } else {
 102                                 return NO_FACT_FILE;
 103                         }
 104                 } /* Facturas */
 105
 106         }
 107         return PARAM_OK;
 108 }
 109
 110 void print_help(char *s)
 111 {
 112         printf("EMUFS - 1v0\n");
 113         printf("Modo de uso : %s [-[f|a] <archivo articulos XML> tipo [tamaño bloque]] \n", s);
 114         printf("  -f indica que lo que está a continuación seran los datos para generar el archivo de facturas.\n");
 115         printf("  -a indica que lo que está a continuación seran los datos para generar el archivo de articulos.\n");
 116         printf("  'tipo' es el modo de archivo. Siendo :\n");
 117         printf("     1 - Registros long. variables con bloque parametrizado\n");
 118         printf("     2 - Registros long. variables sin bloque\n");
 119         printf("     3 - Registros long fija con bloque parametrizado\n");
 120         printf("  tamaño bloque debe ser especificado solo en aquellos tipos que lo requiera.\n");
 121 }
 122
 123 int main(int argc, char *argv[])
 124 {
 125         int c, fin=0;
 126         WINDOW *dialog;
 127
 128         parametros.xml_art = parametros.xml_fact = -1;
 129         switch (param_ok(argc, argv)) {
 130                 case SHOW_HELP:
 131                         print_help(argv[0]);
 132                         return 0;
 133                 case TIPO_NO_DEFINIDO:
 134                         printf("Falta parámetro requerido.\nLuego del nombre del archivo debe especificar el tipo de archivo\n");
 135                         return 1;
 136                 case BLOQUE_NO_DEFINIDO:
 137                         printf("Falta parámetro requerido.\nLuego del tipo de archivo debe especificar el tamaño del bloque a utilizar\n");
 138                         return 1;
 139                 case TIPO_INVALIDO:
 140                         printf("Tipo de archivo no valido. Los valores posibles para el tipo de archivo son:\n");
 141                         printf("\t1 - Archivo de bloque parametrizado y registro de long. variable.\n");
 142                         printf("\t2 - Archivo de registros variables sin bloques.\n");
 143                         printf("\t3 - Archivos de bloque parametrizado y registro de long. parametrizada.\n");
 144                         return 2;
 145                 case NO_ART_FILE:
 146                         printf("Falta parámetro requerido.\nHa utilizado el modificador -a para crear los articulos a partir de un XML pero no ha especificado ningún archivo XML.\n");
 147                         return 3;
 148                 case NO_FACT_FILE:
 149                         printf("Falta parámetro requerido.\nHa utilizado el modificador -f para crear las facturas a partir de un XML pero no ha especificado ningún archivo XML.\n");
 150                         return 3;
 151                 case NULL_BLOCK_FOUND:
 152                         printf("Error de parámerto.\nHa ingresado un valor nulo como tamaño de bloque.\n");
 153                         return 4;
 154                 case PARAM_OK:
 155                         fin = 0;
 156         }
 157
 158 #ifdef DEBUG
 159         printf("CUIDADO! - Uds esta a punto de ejecutar EMUFS Gui compilado con mensajes de debug (-DDEBUG). ");
 160         printf("Esto puede causar que ante un error alguna función trate de emitir un mensaje por pantalla ");
 161         printf("haciendo que el aspecto visual se vea desvirtuado.\n\n");
 162         printf("Todos los mensajes de error se envian por stderr, por lo que es conveniente que vuelva a ejecutar ");
 163         printf("el programa de la siguiente manera :\n");
 164         printf("\t#> %s <parametros> 2> error.log\n\n", argv[0]);
 165         printf("De esta forma el SO se encargaga de redirigir stderr al archivo error.log y evitar algun problema en ");
 166         printf("visualizacion de la aplicacion.\n");
 167         printf("Para continuar **bajo su propio riesgo** presione una tecla. Puede cancelar la ejecucion en este punto con CTRL+C\n");
 168         fgetc(stdin);
 169 #endif
 170
 171         /* Inicio Curses */
 172         signal(SIGINT, finish);
 173         initscr();
 174         keypad(stdscr, TRUE);
 175         nonl();
 176         cbreak();
 177         noecho();
 178         /* Si se soporta color, los inicializo */
 179         if (has_colors()) {
 180                 start_color();
 181                 /* Simple color assignment, often all we need. */
 182                 init_pair(COLOR_BLACK, COLOR_BLACK, COLOR_BLACK); /* COLOR_PAIR(1) */
 183                 init_pair(COLOR_GREEN, COLOR_GREEN, COLOR_BLACK);
 184                 init_pair(COLOR_RED, COLOR_RED, COLOR_BLACK);
 185                 init_pair(COLOR_CYAN, COLOR_CYAN, COLOR_BLACK);
 186                 init_pair(COLOR_WHITE, COLOR_WHITE, COLOR_BLACK);
 187                 init_pair(COLOR_MAGENTA, COLOR_MAGENTA, COLOR_BLACK);
 188                 init_pair(COLOR_BLUE, COLOR_BLUE, COLOR_BLACK);
 189                 init_pair(COLOR_YELLOW, COLOR_YELLOW, COLOR_BLACK);
 190         }
 191
 192         /* Verifico un tamaño minimo de consola */
 193         if ((LINES < 25) || (COLS < 80)) {
 194                 endwin();
 195                 printf("El tamaño de la consola debe ser de por lo menos 80x25!\n");
 196                 return 1;
 197         }
 198
 199         /* Ventana, caracter para linea vertical, caracter para linea horizontal*/
 200         box(stdscr, ACS_VLINE, ACS_HLINE);
 201         /* Ventana, Y, X, Texto */
 202         mvwaddstr(stdscr, 1, 1, "EMUFS");
 203         attron(COLOR_PAIR(2));
 204         mvwaddstr(stdscr, LINES-2, 1, "EMUFS (c) The EMUFS Team - Bajo Licencia GNU/GPL");
 205         attroff(COLOR_PAIR(2));
 206         wrefresh(stdscr);
 207
 208         dialog = msg_box(stdscr, COLS, LINES, "Generando archivos ...");
 209
 210         if (parametros.xml_art != -1) {
 211                 art_cargar(argv[parametros.xml_art], parametros.tipo_arch_art, parametros.tam_bloque_art);
 212         } else {
 213                 art_cargar(NULL, -1, -1);
 214         }
 215         if (parametros.xml_fact != -1) {
 216                 fact_cargar(argv[parametros.xml_fact], parametros.tipo_arch_fact, parametros.tam_bloque_fact);
 217         } else {
 218                 fact_cargar(NULL, -1, -1);
 219         }
 220
 221         msg_box_free(stdscr, dialog);
 222
 223         /* CICLO PRINCIPAL DE LA APLICACION */
 224         while ((c = main_menu()) != -1) {
 225                 switch (c) {
 226                         case 0:
 227                                 menu_articulos();
 228                         break;
 229                         case 1:
 230                                 menu_facturas();
 231                         break;
 232                         case 2:
 233                                 menu_ver_registros();
 234                         break;
 235                         case 3:
 236                                 menu_ver_bloques();
 237                         break;
 238                         case 4:
 239                                 menu_estadisticas();
 240                         break;
 241                         case 5:
 242                                 menu_mantenimiento();
 243                         break;
 244                         case 6:
 245                                 fin = 1;
 246                         break;
 247                 }
 248                 if (fin == 1) break;
 249         }
 250
 251         endwin();
 252
 253         art_liberar(NULL);
 254         fact_liberar(NULL);
 255
 256         return 0;
 257 }
 258
 259 void menu_facturas()
 260 {
 261         MENU(mi_menu) {
 262                 MENU_OPCION("Alta", "Crear una nueva factura."),
 263                 MENU_OPCION("Baja", "Elimina una factura existente."),
 264                 MENU_OPCION("Modificacion", "Modifica una factura existente."),
 265                 MENU_OPCION("Volver", "Volver al menu anterior.")
 266         };
 267         int opt;
 268
 269         while ((opt = menu_ejecutar(mi_menu, 4, "Menu Articulos")) != 3) {
 270                 switch (opt) {
 271                         case 0:
 272                                 fact_agregar(NULL);
 273                         break;
 274                         case 1:
 275                                 fact_eliminar(NULL);
 276                         break;
 277                         case 2:
 278                                 fact_modificar(NULL);
 279                 }
 280         }
 281 }
 282
 283 void menu_articulos()
 284 {
 285         MENU(mi_menu) {
 286                 MENU_OPCION("Alta", "Crear un nuevo articulo."),
 287                 MENU_OPCION("Baja", "Elimina un articulo existente."),
 288                 MENU_OPCION("Modificacion", "Modifica un articulo existente."),
 289                 MENU_OPCION("Volver", "Volver al menu anterior.")
 290         };
 291         int opt;
 292
 293         while ((opt = menu_ejecutar(mi_menu, 4, "Menu Articulos")) != 3) {
 294                 switch (opt) {
 295                         case 0:
 296                                 art_agregar(NULL);
 297                         break;
 298                         case 1:
 299                                 art_eliminar(NULL);
 300                         break;
 301                         case 2:
 302                                 art_modificar(NULL);
 303                 }
 304         }
 305
 306 }
 307
 308 void menu_estadisticas()
 309 {
 310         MENU(mi_menu) {
 311                 MENU_OPCION("Articulos", "Ver datos del archivo de Articulos."),
 312                 MENU_OPCION("Facturas", "Ver datos del archivo de Facturas."),
 313                 MENU_OPCION("Notas", "Ver datos del archivo de Notas."),
 314                 MENU_OPCION("Volver", "Ir al menu anterior.")
 315         };
 316         int opt;
 317
 318         while ((opt = menu_ejecutar(mi_menu, 4, "Menu Estadisticas")) != 3) {
 319                 switch (opt) {
 320                         case 0:
 321                                 ver_estadisticas( art_get_lst()->fp );
 322                         break;
 323                         case 1:
 324                                 ver_estadisticas( fact_get_lst()->fp );
 325                         break;
 326                         case 2:
 327                                 ver_estadisticas( fact_get_lst()->fp_texto );
 328                 }
 329         }
 330 }
 331
 332 void menu_ver_registros()
 333 {
 334         MENU(mi_menu) {
 335                 MENU_OPCION("Articulos", "Ver registros del archivo de Articulos."),
 336                 MENU_OPCION("Facturas", "Ver registros del archivo de Facturas."),
 337                 MENU_OPCION("Notas", "Ver registros del archivo de Notas."),
 338                 MENU_OPCION("Volver", "Ir al menu anterior.")
 339         };
 340         int opt;
 341         WINDOW *dialog;
 342
 343         while ((opt = menu_ejecutar(mi_menu, 4, "Menu Ver Registros")) != 3) {
 344                 switch (opt) {
 345                         case 0:
 346                                 dialog = derwin(stdscr, LINES-4, COLS-2, 2, 1);
 347                                 ver_registros(dialog, COLS-2, LINES-4, 0);
 348                                 werase(dialog);
 349                                 wrefresh(dialog);
 350                                 delwin(dialog);
 351                                 refresh();
 352                         break;
 353                         case 1:
 354                                 dialog = derwin(stdscr, LINES-4, COLS-2, 2, 1);
 355                                 ver_registros(dialog, COLS-2, LINES-4, 1);
 356                                 werase(dialog);
 357                                 wrefresh(dialog);
 358                                 delwin(dialog);
 359                                 refresh();
 360  /*                     break; */
 361         /*              case 2: */
 362                 }
 363         }
 364 }
 365
 366 void menu_ver_bloques()
 367 {
 368         MENU(mi_menu) {
 369                 MENU_OPCION("Articulos", "Ver bloques del archivo de Articulos."),
 370                 MENU_OPCION("Facturas", "Ver bloques del archivo de Facturas."),
 371                 MENU_OPCION("Notas", "Ver bloques del archivo de Notas."),
 372                 MENU_OPCION("Volver", "Ir al menu anterior.")
 373         };
 374         int opt;
 375         WINDOW *dialog;
 376
 377         while ((opt = menu_ejecutar(mi_menu, 4, "Menu Ver Bloques")) != 3) {
 378                 switch (opt) {
 379                         case 0:
 380                                 dialog = derwin(stdscr, LINES-4, COLS-2, 2, 1);
 381                                 ver_bloques(dialog, COLS-2, LINES-4, 0);
 382                                 werase(dialog);
 383                                 wrefresh(dialog);
 384                                 delwin(dialog);
 385                                 refresh();
 386                         break;
 387                         case 1:
 388                                 dialog = derwin(stdscr, LINES-4, COLS-2, 2, 1);
 389                                 ver_bloques(dialog, COLS-2, LINES-4, 1);
 390                                 werase(dialog);
 391                                 wrefresh(dialog);
 392                                 delwin(dialog);
 393                                 refresh();
 394                         break;
 395                 case 2:
 396                                 dialog = derwin(stdscr, LINES-4, COLS-2, 2, 1);
 397                                 ver_bloques(dialog, COLS-2, LINES-4, 2);
 398                                 werase(dialog);
 399                                 wrefresh(dialog);
 400                                 delwin(dialog);
 401                                 refresh();
 402                 }
 403         }
 404 }
 405
 406 int main_menu()
 407 {
 408         MENU(mi_menu) {
 409                 MENU_OPCION("Articulos","Alta,baja,consulta y modificacion de articulos."),
 410                 MENU_OPCION("Facturas","Alta,baja,consulta y modificacion de facturas."),
 411                 MENU_OPCION("Ver Registros","Ver registros (en su contexto) de los archivos ."),
 412                 MENU_OPCION("Ver Bloques","Ver bloques (en su contexto) de los archivos."),
 413                 MENU_OPCION("Estadisticas","Ver estadisticas de ocupacion de archivos."),
 414                 MENU_OPCION("Mantenimiento","Tareas de mantenimiento de los archivos."),
 415                 MENU_OPCION("Salir", "Salir del sistema.")
 416         };
 417
 418         return menu_ejecutar(mi_menu, 7, "Menu Principal");
 419 }
 420
 421
 422 static void finish(int sig)
 423 {
 424         endwin();
 425
 426         /* do your non-curses wrapup here */
 427         exit(0);
 428 }
 429
 430 WINDOW *msg_box(WINDOW *win, int w, int h, const char *format, ...)
 431 {
 432         va_list ap;
 433         char txt[255];
 434         int mw, mh;
 435         WINDOW *dialog;
 436         va_start(ap, format);
 437         vsprintf(txt, format, ap);
 438         va_end(ap);
 439
 440         mw = strlen(txt)+2;
 441         mh = 3;
 442         dialog = derwin(win, mh, mw, h/2-mh/2, w/2-mw/2);
 443         box(dialog, 0 ,0);
 444         mvwaddstr(dialog, 1, 1, txt);
 445         wrefresh(dialog);
 446         curs_set(0);
 447         return dialog;
 448 }
 449
 450 void msg_box_free(WINDOW *padre, WINDOW *win)
 451 {
 452         werase(win);
 453         wrefresh(win);
 454         delwin(win);
 455         curs_set(1);
 456         wrefresh(padre);
 457 }
 458
 459 void menu_mantenimiento()
 460 {
 461         MENU(mi_menu) {
 462                 MENU_OPCION("Compactar Articulos","Elimina espacio no utilizado."),
 463                 MENU_OPCION("Compactar Facturas","Elimina espacio no utilizado."),
 464                 MENU_OPCION("Compactar Notas","Elimina espacio no utilizado."),
 465                 MENU_OPCION("Cambiar tipo Archivo Articulos","Permite cambiar el tipo del archivo."),
 466                 MENU_OPCION("Cambiar tipo Archivo Facturas","Permite cambiar el tipo del archivo."),
 467                 MENU_OPCION("Cambiar tipo Archivo Notas","Permite cambiar el tipo del archivo."),
 468                 MENU_OPCION("Volver", "Volver al menu anterior.")
 469         };
 470
 471         int opt;
 472         int nuevo_tam_registro, nuevo_tam_bloque;
 473         int nuevo_tipo;
 474         WINDOW *dlg;
 475
 476         while ((opt = menu_ejecutar(mi_menu, 7, "Menu Mantenimiento")) != 6) {
 477                 switch (opt) {
 478                         case 0:
 479                                 dlg = msg_box(stdscr, COLS, LINES, "Compactando archivo.... Aguarde");
 480                                 art_get_lst()->fp->compactar(art_get_lst()->fp);
 481                                 msg_box_free(stdscr, dlg);
 482                         break;
 483                         case 1:
 484                                 dlg = msg_box(stdscr, COLS, LINES, "Compactando archivo.... Aguarde");
 485                                 fact_get_lst()->fp->compactar(fact_get_lst()->fp);
 486                                 msg_box_free(stdscr, dlg);
 487                         break;
 488                         case 2:
 489                                 dlg = msg_box(stdscr, COLS, LINES, "Compactando archivo.... Aguarde");
 490                                 fact_get_lst()->fp_texto->compactar(fact_get_lst()->fp_texto);
 491                                 msg_box_free(stdscr, dlg);
 492                         break;
 493                         case 3:
 494                                 nuevo_tam_registro = -1; /* No permito cambiar el tamaño de registro */
 495                                 preguntar_nuevo_tipo(&nuevo_tipo, &nuevo_tam_bloque, &nuevo_tam_registro);
 496                                 dlg = msg_box(stdscr, COLS, LINES, "Cambiando el formato de archivo .... Aguarde");
 497                                 art_reformatear(nuevo_tipo, nuevo_tam_bloque, nuevo_tam_registro);
 498                                 msg_box_free(stdscr, dlg);
 499                         break;
 500                         case 4:
 501                                 nuevo_tam_registro = 0;
 502                                 preguntar_nuevo_tipo(&nuevo_tipo, &nuevo_tam_bloque, &nuevo_tam_registro);
 503                         break;
 504                         case 5:
 505                                 nuevo_tam_registro = -2;
 506                                 preguntar_nuevo_tipo(&nuevo_tipo, &nuevo_tam_bloque, &nuevo_tam_registro);
 507                 }
 508         }
 509 }
 510
 511 void preguntar_nuevo_tipo(int *tipo, int *tam_bloque, int *tam_reg)
 512 {
 513         WINDOW *win;
 514         t_Form *form;
 515         char *s;
 516         int n, is_ok;
 517
 518         win = newwin(LINES/2, COLS/2, LINES/4, COLS/4);
 519         box(win, 0, 0);
 520
 521         form = form_crear(win);
 522         form_agregar_widget(form, RADIO, "Tipo de archivo", 3, "T1,T2,T3");
 523         form_ejecutar(form, 1,1);
 524
 525         s = form_obtener_valor_char(form, "Tipo de archivo");
 526         if (strcmp(s, "T1") == 0) n = T1;
 527         if (strcmp(s, "T2") == 0) n = T2;
 528         if (strcmp(s, "T3") == 0) n = T3;
 529
 530         form_destruir(form);
 531
 532         werase(win);
 533         box(win, 0, 0);
 534         wrefresh(win);
 535
 536         (*tipo) = n;
 537         switch (n) {
 538                 case T1:
 539                         form = form_crear(win);
 540                         form_agregar_widget(form, INPUT, "Tamaño de bloque", 8, "");
 541                         is_ok = 0;
 542                         do {
 543                                 form_set_valor(form, "Tamaño de bloque", "");
 544                                 form_ejecutar(form, 1,1);
 545                                 if (form_obtener_valor_int(form, "Tamaño de bloque") > 0) is_ok = 1;
 546                         } while (!is_ok);
 547                         (*tam_bloque) = form_obtener_valor_int(form, "Tamaño de bloque");
 548                         form_destruir(form);
 549                 break;
 550                 case T2:
 551                         break;
 552                 case T3:
 553                         if (((*tam_reg) != -1) && ((*tam_reg) != -2)) {
 554                                 mvwaddstr(win, LINES/2-3, 1, "Nota: El tamaño de registro puede");
 555                                 mvwaddstr(win, LINES/2-2, 1, "llegar a ser redondeado por el sistema.");
 556                         }
 557                         form = form_crear(win);
 558                         form_agregar_widget(form, INPUT, "Tamaño de bloque", 8, "");
 559                         if ((*tam_reg) != -1)
 560                                 form_agregar_widget(form, INPUT, "Tamaño de registro", 8, "");
 561                         is_ok = 0;
 562                         do {
 563                                 form_set_valor(form, "Tamaño de bloque", "");
 564                                 if ((*tam_reg) != -1)
 565                                         form_set_valor(form, "Tamaño de registro", "");
 566                                 form_ejecutar(form, 1,1);
 567                                 if (form_obtener_valor_int(form, "Tamaño de bloque") > 0) is_ok = 1;
 568                                 if ((*tam_reg) != -1) {
 569                                         if (form_obtener_valor_int(form, "Tamaño de registro") > 0) is_ok = 1; else is_ok = 0;
 570                                 }
 571                         } while (!is_ok);
 572                         (*tam_bloque) = form_obtener_valor_int(form, "Tamaño de bloque");
 573                         if ((*tam_reg) != -1)
 574                                 (*tam_reg) = form_obtener_valor_int(form, "Tamaño de registro");
 575                         form_destruir(form);
 576         }
 577         werase(win);
 578         wrefresh(win);
 579         delwin(win);
 580 }
 581
 582 void ver_estadisticas(EMUFS *fp)
 583 {
 584         WINDOW *win;
 585         EMUFS_Estadisticas stats;
 586         char s[40];
 587         int i=3;
 588
 589         stats = fp->leer_estadisticas(fp);
 590
 591         win = newwin(LINES-4, COLS-2, 2, 1);
 592         curs_set(0);
 593
 594         wattron(win, COLOR_PAIR(COLOR_YELLOW));
 595         wattron(win, A_BOLD);
 596         mvwaddstr(win, 1, 1, "Tipo de Archivo : ");
 597         wattroff(win, A_BOLD);
 598         wattroff(win, COLOR_PAIR(COLOR_YELLOW));
 599         switch (fp->tipo) {
 600                 case T1:
 601                         waddstr(win, "Registro long. variable con bloque parametrizado");
 602                         wattron(win, A_BOLD);
 603                         mvwaddstr(win, i++, 1, "Tamaño de bloque : ");
 604                         wattroff(win, A_BOLD);
 605                         sprintf(s, "%lu bytes", fp->tam_bloque);
 606                         waddstr(win, s);
 607                 break;
 608                 case T2:
 609                         waddstr(win, "Registro long. variable sin bloques");
 610                 break;
 611                 case T3:
 612                         waddstr(win, "Registro long. fija con bloque parametrizado");
 613                         wattron(win, A_BOLD);
 614                         mvwaddstr(win, i++, 1, "Tamaño de bloque : ");
 615                         wattroff(win, A_BOLD);
 616                         sprintf(s, "%lu bytes", fp->tam_bloque);
 617                         waddstr(win, s);
 618                         wattron(win, A_BOLD);
 619                         mvwaddstr(win, i++, 1, "Tamaño de registro : ");
 620                         wattroff(win, A_BOLD);
 621                         sprintf(s, "%lu bytes", fp->tam_reg);
 622                         waddstr(win, s);
 623         }
 624
 625         wattron(win, A_BOLD);
 626         mvwaddstr(win, i++, 1, "Cant. Registros : ");
 627         wattroff(win, A_BOLD);
 628         sprintf(s, "%lu", stats.tam_archivo);
 629         waddstr(win, s);
 630
 631         wattron(win, A_BOLD);
 632         mvwaddstr(win, i++, 1, "Tamaño de Archivo : ");
 633         wattroff(win, A_BOLD);
 634         sprintf(s, "%lu bytes", stats.tam_archivo_bytes);
 635         waddstr(win, s);
 636
 637         wattron(win, A_BOLD);
 638         mvwaddstr(win, i++, 1, "Tamaño de Info de Control : ");
 639         wattroff(win, A_BOLD);
 640         sprintf(s, "%lu bytes", stats.info_control);
 641         waddstr(win, s);
 642
 643         wattron(win, A_BOLD);
 644         mvwaddstr(win, i++, 1, "Media de espacio libre : ");
 645         wattroff(win, A_BOLD);
 646         sprintf(s, "%lu bytes/bloque", stats.media_fs);
 647         waddstr(win, s);
 648
 649         wattron(win, A_BOLD);
 650         mvwaddstr(win, i++, 1, "Espacio Libre : ");
 651         wattroff(win, A_BOLD);
 652         sprintf(s, "%lu bytes", stats.total_fs);
 653         waddstr(win, s);
 654
 655         wattron(win, A_BOLD);
 656         mvwaddstr(win, i++, 1, "Maximo de Espacio libre : ");
 657         wattroff(win, A_BOLD);
 658         sprintf(s, "%lu bytes", stats.max_fs);
 659         waddstr(win, s);
 660
 661         wattron(win, A_BOLD);
 662         mvwaddstr(win, i++, 1, "Minimo de Espacio libre : ");
 663         wattroff(win, A_BOLD);
 664         sprintf(s, "%lu bytes", stats.min_fs);
 665         waddstr(win, s);
 666
 667         wattron(win, A_BOLD);
 668         mvwaddstr(win, i++, 1, "Cantidad de bloques : ");
 669         wattroff(win, A_BOLD);
 670         sprintf(s, "%lu", stats.cant_bloques);
 671         waddstr(win, s);
 672
 673         wattron(win, A_BLINK);
 674         mvwaddstr(win, i+2, 1, "Presione una tecla para continuar.");
 675         wattroff(win, A_BLINK);
 676
 677         wrefresh(win);
 678
 679         getch();
 680         werase(win);
 681         wrefresh(win);
 682         delwin(win);
 683 }
 684