emufs_gui/emufs_view.c

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