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