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