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