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