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