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