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