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