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