emufs_gui/viewer.c

   1
   2 #include "viewer.h"
   3 #include "idx.h"
   4 #include "articulos.h"
   5 #include "facturas.h"
   6 #include "gui.h"
   7 #include "common.h"
   8 #include <ctype.h>
   9
  10 /* Se encarga de reemplazar los \0 un caracter visual, y segurar un \0 al final */
  11 static char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
  12 static char *procesar_registro_articulo_tipo2(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
  13 static char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
  14
  15 static char *procesar_registro_factura_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
  16 static char *procesar_registro_factura_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
  17
  18 static int preguntar_id(WINDOW *win, EMUFS *fp);
  19
  20 void copy_char(char *dst, char *src)
  21 {
  22         /* Todos los espacidores los pongo iguales */
  23         if (isspace(*src)) *dst = ' ';
  24         else if (iscntrl(*src)) *dst = '*';
  25         else *dst = *src;
  26 }
  27
  28 void mostrar_info(WINDOW *padre, int h, int offset_alto, int opt)
  29 {
  30         /* Info de teclas */
  31         wattron(padre, A_BOLD);
  32         wattron(padre, COLOR_PAIR(COLOR_RED));
  33         mvwaddstr(padre, h-offset_alto+1, 5, "Teclas :");
  34         wattroff(padre, A_BOLD);
  35         wattroff(padre, COLOR_PAIR(COLOR_RED));
  36         mvwaddstr(padre, h-offset_alto+2, 8, "Salir = ENTER");
  37         mvwaddstr(padre, h-offset_alto+3, 8, "Scroll = A/Z");
  38         mvwaddstr(padre, h-offset_alto+4, 8, "Seleccionar registros = K/L");
  39         if (opt) {
  40                 mvwaddstr(padre, h-offset_alto+5, 8, "Acciones: ");
  41                 waddstr(padre, "A");
  42                 wattron(padre, A_BOLD);
  43                 waddch(padre, 'g');
  44                 wattroff(padre, A_BOLD);
  45                 waddstr(padre, "regar ");
  46                 wattron(padre, A_BOLD);
  47                 waddstr(padre, "M");
  48                 wattroff(padre, A_BOLD);
  49                 waddstr(padre, "ofidicar ");
  50                 wattron(padre, A_BOLD);
  51                 waddstr(padre, "E");
  52                 wattroff(padre, A_BOLD);
  53                 waddstr(padre, "liminar ");
  54         }
  55         mvwaddstr(padre, h-offset_alto+6, 8, "Buscar ID : B");
  56
  57         /* Info de leyenda */
  58         wattron(padre, A_BOLD);
  59         wattron(padre, COLOR_PAIR(COLOR_RED));
  60         mvwaddstr(padre, h-offset_alto+1, 45, "Leyenda :");
  61         wattroff(padre, A_BOLD);
  62         wattroff(padre, COLOR_PAIR(COLOR_RED));
  63         mvwaddstr(padre, h-offset_alto+2, 48, "  |   = Separador de campo");
  64         mvwaddstr(padre, h-offset_alto+3, 48, "[XXX] = Campo numerico");
  65         mvwaddstr(padre, h-offset_alto+4, 48, "(XXX) = ID de registro");
  66         mvwaddstr(padre, h-offset_alto+5, 48, "{XXX} = Tam. de registro");
  67         mvwaddstr(padre, h-offset_alto+6, 48, "  .   = Esp. Libre");
  68 }
  69
  70 char *juntar_memoria(char *s1, char *s2, char *s3, int size1, int size2, int size3)
  71 {
  72         char *salida;
  73         int tam=0;
  74         if (s1) tam += size1;
  75         if (s2) tam += size2;
  76         if (s3) tam += size3;
  77         salida = (char *)malloc(tam);
  78         if (salida == NULL) {
  79                         free(s1);
  80                         free(s2);
  81                         free(s3);
  82                         return NULL;
  83         }
  84
  85         if (s1) memcpy(salida, s1, size1); else size1 = 0;
  86         if (s2) memcpy(salida+size1, s2, size2); else size2 = 0;
  87         if (s3) memcpy(salida+size1+size2, s3, size3);
  88         if (s1) free(s1);
  89         if (s2) free(s2);
  90         if (s3) free(s3);
  91         return salida;
  92 }
  93
  94 void ver_bloques(WINDOW *padre, int w, int h, int cual)
  95 {
  96         /* Ventanas donde mostrar las cosas */
  97         char *(*procesar)(EMUFS*, char*, EMUFS_REG_SIZE*, int*, int*);
  98         WINDOW *actual[2], *dlg;
  99         EMUFS_REG_SIZE size, size_actual, size_siguiete, size_anterior;
 100         int scroll, actual_ancho;
 101         int max_scroll, c, offset_alto;
 102         /* Indices que hay validos en IDX */
 103         EMUFS_REG_ID indices_total, indices_actual;
 104         char *bloque_actual, *bloque_anterior, *bloque_siguiente;
 105         char *data; /* Registros a mostrar en pantalla */
 106         EMUFS *fp;
 107         int pos_actual, ancho_registro, offset, pos;
 108         EMUFS_Estadisticas stats;
 109
 110         if (cual == 0)
 111                 fp = emufs_abrir("articulos");
 112         else if (cual == 1)
 113                 fp = emufs_abrir("facturas");
 114         else if (cual == 2)
 115                 fp = emufs_abrir("notas");
 116
 117         stats = fp->leer_estadisticas(fp);
 118
 119         wattron(padre, COLOR_PAIR(COLOR_BLUE));
 120         mvwaddstr(padre, 0, 0, "Tipo de archivo : ");
 121         wattroff(padre, COLOR_PAIR(COLOR_BLUE));
 122         switch (fp->tipo) {
 123                 case T1:
 124                         waddstr(padre, "Registro variable con bloque parametrizado.");
 125                         if (cual == 0)
 126                                 procesar = procesar_registro_articulo_tipo1;
 127                         else
 128                                 procesar = procesar_registro_factura_tipo1;
 129                 break;
 130                 case T2:
 131                         waddstr(padre, "Registro variable sin bloques.");
 132                         actual[0] = msg_box(padre, w, h, "El tipo de archivo no contiene bloques.");
 133                         getch();
 134                         msg_box_free(padre, actual[0]);
 135                         return;
 136                 break;
 137                 case T3:
 138                         if (cual == 0)
 139                                 procesar = procesar_registro_articulo_tipo3;
 140                         else
 141                                 procesar = procesar_registro_factura_tipo3;
 142                         waddstr(padre, "Registro fijo con bloque parametrizado.");
 143         }
 144
 145
 146         indices_actual = 0;
 147         indices_total = stats.cant_bloques;
 148         /* Leo */
 149         fp->leer_bloque_raw(fp, indices_actual, &bloque_actual, &bloque_anterior, &bloque_siguiente, &size_actual, &size_anterior, &size_siguiete);
 150         pos_actual = 0;
 151         bloque_actual = procesar(fp, bloque_actual, &size_actual, &pos_actual, &ancho_registro);
 152         pos_actual = 0;
 153         bloque_siguiente = procesar(fp, bloque_siguiente, &size_siguiete, &pos_actual, &ancho_registro);
 154         pos_actual = 0;
 155         bloque_anterior = procesar(fp, bloque_anterior, &size_anterior, &pos_actual, &ancho_registro);
 156         if (!bloque_siguiente) {
 157                 bloque_siguiente = (char *)malloc(size_siguiete);
 158                 memset(bloque_siguiente, 0, size_siguiete);
 159         }
 160         if (!bloque_anterior) {
 161                 bloque_anterior = (char *)malloc(size_anterior);
 162                 memset(bloque_anterior, 0, size_anterior);
 163         }
 164         pos_actual = size_anterior; /* Resalta desde el fin del bloque anterior */
 165         ancho_registro = size_actual;
 166         data = juntar_memoria(bloque_anterior, bloque_actual, bloque_siguiente, size_anterior, size_actual, size_siguiete);
 167
 168         PERR("HASTA ACA VOY BIEN");
 169         offset_alto = 8;
 170         max_scroll = (size_actual+size_anterior+size_siguiete) / (w-4) - (h-offset_alto-2);
 171         if (max_scroll < 0) max_scroll = 0;
 172
 173         actual[0] = derwin(padre, h-offset_alto, w-2, 1, 1);
 174         actual_ancho = w-4;
 175         actual[1] = derwin(actual[0], h-offset_alto-2, w-4, 1, 1);
 176         box(actual[0], 0, 0);
 177
 178         curs_set(0);
 179
 180         mostrar_info(padre, h, offset_alto, 0);
 181
 182         mvwaddnstr(actual[1], 0, 0, data, pos_actual);
 183         wattron(actual[1], A_BOLD);
 184         waddnstr(actual[1], data+pos_actual, ancho_registro);
 185         wattroff(actual[1], A_BOLD);
 186         waddnstr(actual[1], data+pos_actual+ancho_registro, size-(pos_actual+ancho_registro));
 187
 188         wrefresh(actual[1]);
 189         wrefresh(actual[0]);
 190         wrefresh(padre);
 191         scroll = 0;
 192         while ((c=getch()) != 13) {
 193                 switch (c) {
 194                         case 'b':
 195                         case 'B':
 196                                 dlg = newwin(4, 50, h/2-2, w/2-25);
 197                                 box(dlg, 0, 0);
 198                                 indices_actual = preguntar_id(dlg, fp);
 199                                 if (indices_actual < 0) indices_actual = 0;
 200                                 if (indices_actual > indices_total) indices_actual = indices_total-1;
 201                                 werase(dlg);
 202                                 wrefresh(dlg);
 203                                 delwin(dlg);
 204                                 wrefresh(padre);
 205                                 curs_set(0);
 206                         break;
 207                         case 'a': /* Scroll */
 208                                 scroll--;
 209                                 if (scroll < 0) scroll = 0;
 210                         break;
 211                         case 'z': /* Scroll */
 212                                 scroll++;
 213                                 if (scroll > max_scroll) scroll = max_scroll;
 214                         break;
 215                         case 'l':
 216                                 if (indices_actual < indices_total) {
 217                                         indices_actual++;
 218                                         if (indices_actual >= indices_total) indices_actual = indices_total-1;
 219                                         if (data) free(data);
 220                                         fp->leer_bloque_raw(fp, indices_actual, &bloque_actual, &bloque_anterior, &bloque_siguiente, &size_actual, &size_anterior, &size_siguiete);
 221                                         bloque_actual = procesar(fp, bloque_actual, &size_actual, &pos_actual, &ancho_registro);
 222                                         bloque_siguiente = procesar(fp, bloque_siguiente, &size_siguiete, &pos_actual, &ancho_registro);
 223                                         bloque_anterior = procesar(fp, bloque_anterior, &size_anterior, &pos_actual, &ancho_registro);
 224                                         pos_actual = size_anterior; /* Resalta desde el fin del bloque anterior */
 225                                         ancho_registro = size_actual;
 226                                         data = juntar_memoria(bloque_anterior, bloque_actual, bloque_siguiente, size_anterior, size_actual, size_siguiete);
 227                                 }
 228                         break;
 229                         case 'k':
 230                                 if (indices_actual != EMUFS_NOT_FOUND) {
 231                                         indices_actual--;
 232                                         if (indices_actual == EMUFS_NOT_FOUND) indices_actual = 0;
 233                                         if (data) free(data);
 234                                         fp->leer_bloque_raw(fp, indices_actual, &bloque_actual, &bloque_anterior, &bloque_siguiente, &size_actual, &size_anterior, &size_siguiete);
 235                                         bloque_actual = procesar(fp, bloque_actual, &size_actual, &pos_actual, &ancho_registro);
 236                                         bloque_siguiente = procesar(fp, bloque_siguiente, &size_siguiete, &pos_actual, &ancho_registro);
 237                                         bloque_anterior = procesar(fp, bloque_anterior, &size_anterior, &pos_actual, &ancho_registro);
 238                                         pos_actual = size_anterior; /* Resalta desde el fin del bloque anterior */
 239                                         ancho_registro = size_actual;
 240                                         data = juntar_memoria(bloque_anterior, bloque_actual, bloque_siguiente, size_anterior, size_actual, size_siguiete);
 241                                 }
 242                 }
 243                 /* Borro las ventanas */
 244                 werase(actual[1]);
 245
 246                 /* Imprimo los registros */
 247                 if (data) {
 248                         offset = scroll*actual_ancho; /* Cantidad de caracteres que tengo que saltar */
 249                         pos = pos_actual - offset; /* Cantidad de caracteres que hay antes de mi a imprimir */
 250                         mvwaddnstr(actual[1], 0, 0, data+offset, pos);
 251                         if (pos > 0)
 252                                 offset += pos;
 253                         else
 254                                 offset -= pos;
 255                         wattron(actual[1], A_BOLD);
 256                         waddnstr(actual[1], data+offset, ancho_registro+((pos<0)?pos:0));
 257                         wattroff(actual[1], A_BOLD);
 258                         offset += ancho_registro+((pos<0)?pos:0);
 259                         waddnstr(actual[1], data+offset, size-offset);
 260                 }
 261
 262                 wrefresh(actual[1]);
 263                 wrefresh(padre);
 264         }
 265         if (data) free(data);
 266
 267         emufs_destruir(fp);
 268         delwin(actual[0]);
 269         wrefresh(padre);
 270         curs_set(1);
 271 }
 272
 273 void ver_registros(WINDOW *padre, int w, int h, int cual)
 274 {
 275         /* Ventanas donde mostrar las cosas */
 276         char *(*procesar)(EMUFS*, char*, EMUFS_REG_SIZE*, int*, int*);
 277         WINDOW *actual[2], *dlg;
 278         EMUFS_REG_SIZE size;
 279         int scroll, actual_ancho;
 280         int max_scroll, c, offset_alto;
 281         /* Indices que hay validos en IDX */
 282         EMUFS_REG_ID *indices, indices_total, indices_actual;
 283         char *data; /* Registros a mostrar en pantalla */
 284         char codigo[50]; /* Variable para guardar el codigo actual para mandar a modificar */
 285         EMUFS *fp;
 286         int pos_actual, ancho_registro, offset, pos;
 287
 288         if (cual == 0)
 289                 fp = emufs_abrir("articulos");
 290         else
 291                 fp = emufs_abrir("facturas");
 292
 293         wattron(padre, COLOR_PAIR(COLOR_BLUE));
 294         mvwaddstr(padre, 0, 0, "Tipo de archivo : ");
 295         wattroff(padre, COLOR_PAIR(COLOR_BLUE));
 296         switch (fp->tipo) {
 297                 case T1:
 298                         waddstr(padre, "Registro variable con bloque parametrizado.");
 299                         if (cual == 0)
 300                                 procesar = procesar_registro_articulo_tipo1;
 301                         else
 302                                 procesar = procesar_registro_factura_tipo1;
 303                 break;
 304                 case T2:
 305                         waddstr(padre, "Registro variable con sin bloques.");
 306                         if (cual == 0)
 307                                 procesar = procesar_registro_articulo_tipo2;
 308                         else
 309                                 procesar = procesar_registro_factura_tipo1;
 310                 break;
 311                 case T3:
 312                         if (cual == 0)
 313                                 procesar = procesar_registro_articulo_tipo3;
 314                         else
 315                                 procesar = procesar_registro_factura_tipo3;
 316                         waddstr(padre, "Registro fijo con bloque parametrizado.");
 317         }
 318
 319         indices = emufs_idx_get(fp, &indices_total);
 320
 321         indices_actual = 0;
 322         if (indices) {
 323                 data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
 324                 data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 325         }
 326
 327
 328         offset_alto = 8;
 329         max_scroll = size / (w-4) - (h-offset_alto-2);
 330         if (max_scroll < 0) max_scroll = 0;
 331
 332         actual[0] = derwin(padre, h-offset_alto, w-2, 1, 1);
 333         actual_ancho = w-4;
 334         actual[1] = derwin(actual[0], h-offset_alto-2, w-4, 1, 1);
 335         box(actual[0], 0, 0);
 336
 337         curs_set(0);
 338
 339         mostrar_info(padre, h, offset_alto, 1);
 340
 341         if (data) {
 342                 mvwaddnstr(actual[1], 0, 0, data, pos_actual);
 343                 wattron(actual[1], A_BOLD);
 344                 waddnstr(actual[1], data+pos_actual, ancho_registro);
 345                 wattroff(actual[1], A_BOLD);
 346                 waddnstr(actual[1], data+pos_actual+ancho_registro, size-(pos_actual+ancho_registro));
 347         }
 348
 349         wrefresh(actual[1]);
 350         wrefresh(actual[0]);
 351         wrefresh(padre);
 352         scroll = 0;
 353         while ((c=getch()) != 13) {
 354                 switch (c) {
 355                         case 'b':
 356                         case 'B':
 357                                 dlg = newwin(4, 50, h/2-2, w/2-25);
 358                                 box(dlg, 0, 0);
 359                                 preguntar_id(dlg, fp);
 360                                 werase(dlg);
 361                                 wrefresh(dlg);
 362                                 delwin(dlg);
 363                                 wrefresh(padre);
 364                                 curs_set(0);
 365                         break;
 366                         case 'e':
 367                         case 'E':
 368                                 if (indices_actual != EMUFS_NOT_FOUND)
 369                                         fp->borrar_registro(fp, indices[indices_actual]);
 370
 371                                 free(indices);
 372                                 indices = emufs_idx_get(fp, &indices_total);
 373                                 if (indices_actual >= indices_total) {
 374                                         indices_actual = indices_total - 1;
 375                                 }
 376
 377                                 data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
 378                                 data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 379                         break;
 380                         case 'g':
 381                         case 'G':
 382                                 if (cual == 0)
 383                                         art_agregar(NULL);
 384                                 else
 385                                         fact_agregar(NULL);
 386                                 free(data);
 387                                 data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
 388                                 data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 389
 390                                 free(indices);
 391                                 indices = emufs_idx_get(fp, &indices_total);
 392
 393                                 /* Tengo que re-pintar algunas cosas */
 394                                 mostrar_info(padre, h, offset_alto, 1);
 395                                 box(actual[0], 0, 0);
 396                                 wrefresh(actual[0]);
 397                         break;
 398                         case 'M':
 399                         case 'm': /* Quiero editar !!! */
 400                                 sprintf(codigo, "%lu", indices[indices_actual]);
 401                                 if (cual == 0)
 402                                         art_modificar(codigo);
 403                                 else
 404                                         fact_modificar(codigo);
 405                                 /* Vuelvo a cargar el articulo actual */
 406
 407                                 free(data);
 408                                 data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
 409                                 data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 410
 411                                 /* Tengo que re-pintar algunas cosas */
 412                                 mostrar_info(padre, h, offset_alto, 1);
 413                                 box(actual[0], 0, 0);
 414                                 wrefresh(actual[0]);
 415                         break;
 416                         case 'a': /* Scroll */
 417                                 scroll--;
 418                                 if (scroll < 0) scroll = 0;
 419                         break;
 420                         case 'z': /* Scroll */
 421                                 scroll++;
 422                                 if (scroll > max_scroll) scroll = max_scroll;
 423                         break;
 424                         case 'l':
 425                                 if (indices_actual < indices_total) {
 426                                         indices_actual++;
 427                                         if (indices_actual >= indices_total) indices_actual = indices_total-1;
 428                                         if (data) free(data);
 429                                         data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
 430                                         data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 431                                 }
 432                         break;
 433                         case 'k':
 434                                 if (indices_actual != EMUFS_NOT_FOUND) {
 435                                         indices_actual--;
 436                                         if (indices_actual == EMUFS_NOT_FOUND) indices_actual = 0;
 437                                         if (data) free(data);
 438                                         data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
 439                                         data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 440                                 }
 441
 442                 }
 443                 /* Borro las ventanas */
 444                 werase(actual[1]);
 445
 446                 /* Imprimo los registros */
 447                 if (data) {
 448                         offset = scroll*actual_ancho;
 449                         pos = pos_actual - offset;
 450                         mvwaddnstr(actual[1], 0, 0, data+offset, pos);
 451                         offset += pos;
 452                         wattron(actual[1], A_BOLD);
 453                         waddnstr(actual[1], data+offset, ancho_registro);
 454                         wattroff(actual[1], A_BOLD);
 455                         offset += ancho_registro;
 456                         waddnstr(actual[1], data+offset, size-offset);
 457                 }
 458
 459                 wrefresh(actual[1]);
 460                 wrefresh(padre);
 461         }
 462         if (indices) free(indices);
 463         if (data) free(data);
 464
 465         emufs_destruir(fp);
 466         delwin(actual[0]);
 467         wrefresh(padre);
 468         curs_set(1);
 469 }
 470
 471 char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 472 {
 473         char *tmp, *salida, *tmp1, pos_actualizada, ant;
 474         int cant_header, i=0, j, tam_data;
 475         if (ptr == NULL) return NULL;
 476
 477         /* Calculo cuantos headers de registros va a haber en el archivo */
 478         cant_header = emu->tam_bloque / (emu->tam_reg+sizeof(EMUFS_REG_ID));
 479         if (cant_header == 0) cant_header++; /* Si tam_reg > tam_bloque, voy a tener solo 1 header */
 480         tam_data = sizeof(t_Articulo);
 481
 482         (*size) = (*size)-sizeof(EMUFS_REG_ID)*cant_header*2 + 2*cant_header*10+1;
 483         (*ancho) = sizeof(t_Articulo)-sizeof(EMUFS_REG_ID)+10;
 484         if ((*ancho) > (*size))
 485                 (*ancho) = (*size);
 486         if ((tam_data) > ((*size)-sizeof(EMUFS_REG_ID))) {
 487                 tam_data = (*size) - sizeof(EMUFS_REG_ID);
 488         }
 489         salida = (char *)malloc(*size);
 490         memset(salida, '.', *size);
 491         if (salida == NULL) {
 492                 return NULL;
 493         }
 494         tmp = ptr;
 495         tmp1 = salida;
 496         pos_actualizada = 0;
 497         while (i<cant_header) {
 498                 /* Verifico la pos_actual para el resaltado, asi queda coherente
 499                  * en el cambio de formato
 500                  */
 501                 if (((tmp - ptr) == *pos_actual) && (!pos_actualizada)) {
 502                         (*pos_actual) = tmp1-salida;
 503                         pos_actualizada = 1;
 504                 }
 505                 /* Pongo el ID del registro */
 506                 sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
 507                 tmp1 += 10;
 508                 tmp += sizeof(EMUFS_REG_ID);
 509                 j = 0;
 510                 while (j < (tam_data)) {
 511                         if (*tmp == '\0') {
 512                                 if (ant == (*tmp))
 513                                         (*tmp1) = '.';
 514                                 else
 515                                         (*tmp1) = '|';
 516                         } else {
 517                                 copy_char(tmp1, tmp);
 518                         }
 519                         ant = (*tmp);
 520                         tmp++;
 521                         tmp1++;
 522                         j++;
 523                 }
 524                 i++;
 525         }
 526         free(ptr);
 527
 528         salida[*size-1] = '\0';
 529
 530         return salida;
 531 }
 532
 533 char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 534 {
 535         EMUFS_REG_SIZE offset, curr_size;
 536         char *tmp, *salida, *tmp1, pos_actualizada, ant;
 537         int cant_header, i=0, j;
 538         if (ptr == NULL) return NULL;
 539
 540         /* Cuento la cantidad de registros en este bloque */
 541         cant_header = 0;
 542         offset = 0;
 543         PERR("Voy a contar la cantidad de headers");
 544         do {
 545                 /* Me salto el ID, que no me interesa saber su valor */
 546                 offset += sizeof(EMUFS_REG_ID);
 547                 /* Copio el tamaño del registro de la cabecera. */
 548                 memcpy(&curr_size, ptr + offset, sizeof(EMUFS_REG_SIZE));
 549                 offset += sizeof(EMUFS_REG_SIZE);
 550
 551                 /* Desplazo el offset */
 552 #ifdef DEBUG
 553                 fprintf(stderr, "Tamaño Registro = %lu\n", curr_size);
 554 #endif
 555                 if (curr_size == 0) {
 556                         /* Si el tamaño de registro es 0, quiere decir que llegue a la
 557                          * parte que esta vacia */
 558                         break;
 559                 } else {
 560                         cant_header++;
 561                         offset += curr_size;
 562                 }
 563         } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size));
 564
 565         /* Proceso */
 566         salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);
 567         memset(salida, '.',(*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);
 568         tmp = ptr;
 569         tmp1 = salida;
 570         pos_actualizada = 0;
 571         while (i<cant_header) {
 572                 /* Verifico la pos_actual para el resaltado, asi queda coherente
 573                  * en el cambio de formato
 574                  */
 575                 if (((tmp - ptr) == *pos_actual) && (!pos_actualizada)) {
 576                         (*pos_actual) = tmp1-salida;
 577                         pos_actualizada = 1;
 578                 }
 579                 /* Pongo el ID del registro */
 580                 sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
 581                 tmp1 += 10;
 582                 tmp += sizeof(EMUFS_REG_ID);
 583                 /* Pongo el tamaño del registro */
 584                 sprintf(tmp1, "{%08lu}", *((EMUFS_REG_SIZE *)tmp));
 585                 curr_size = *((EMUFS_REG_SIZE *)tmp);
 586                 if (pos_actualizada == 1) {
 587                         (*ancho) = curr_size+20;
 588                         pos_actualizada = 2;
 589                 }
 590                 tmp1 += 10;
 591                 tmp += sizeof(EMUFS_REG_SIZE);
 592                 PERR("Voy aca");
 593                 j = 0;
 594                 while (j < curr_size) {
 595                         if (*tmp == '\0') {
 596                                 if (ant == (*tmp))
 597                                         (*tmp1) = '.';
 598                                 else
 599                                         (*tmp1) = '|';
 600                         } else {
 601                                 copy_char(tmp1, tmp);
 602                         }
 603                         ant = (*tmp);
 604                         tmp++;
 605                         tmp1++;
 606                         j++;
 607                 }
 608                 PERR("Y hasta todo bien");
 609                 i++;
 610         }
 611         /* Tengo que trabajar sobre lo que me falte (seguro es espacio libre) */
 612         (*size) = (*size)-sizeof(unsigned int)*cant_header*2+2*cant_header*10+1;
 613         free(ptr);
 614         salida[*size-1] = '\0';
 615
 616         return salida;
 617 }
 618
 619 int preguntar_id(WINDOW *win, EMUFS *fp)
 620 {
 621         int n=-1;
 622         t_Form *form = form_crear(win);
 623         form_agregar_widget(form, INPUT, "ID a buscar", 8, "");
 624
 625         do {
 626                 form_set_valor(form, "ID a buscar", "");
 627                 form_ejecutar(form, 1,1);
 628
 629                 n = form_obtener_valor_int(form, "ID a buscar");
 630         } while (n>0);
 631
 632         form_destruir(form);
 633         return n;
 634 }
 635
 636 char *procesar_registro_factura_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 637 {
 638         char *tmp, *salida, *tmp1, pos_actualizada, ant;
 639         char flotante[10];
 640         int cant_header, i=0, j, tam_data;
 641         if (ptr == NULL) return NULL;
 642
 643         PERR("Empieza el baile");
 644
 645         /* Calculo cuantos headers de registros va a haber en el archivo */
 646         cant_header = emu->tam_bloque / (emu->tam_reg+sizeof(EMUFS_REG_ID));
 647         if (cant_header == 0) cant_header++; /* Si tam_reg > tam_bloque, voy a tener solo 1 header */
 648         tam_data = emu->tam_reg;
 649
 650         (*size) = (*size) - cant_header*sizeof(EMUFS_REG_ID)+cant_header*10+1;
 651         tmp1 = salida = (char *)malloc(*size);
 652         memset(salida, '.', *size);
 653         if (salida == NULL) {
 654                 PERR("Error de malloc en salida");
 655                 return NULL;
 656         }
 657         tmp = ptr;
 658         pos_actualizada = 0;
 659         (*ancho) = 0;
 660         while (i<cant_header) {
 661                 /* Verifico la pos_actual para el resaltado, asi queda coherente
 662                  * en el cambio de formato
 663                  */
 664                 if (((tmp - ptr) == *pos_actual) && (!pos_actualizada)) {
 665                         (*pos_actual) = tmp1-salida;
 666                         pos_actualizada = 1;
 667                 }
 668                 /* Pongo el ID del registro */
 669                 sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
 670                 tmp1 += 10;
 671                 tmp += sizeof(EMUFS_REG_ID);
 672
 673                 if (pos_actualizada == 1) {
 674                         (*ancho) = 10;
 675                 }
 676                 j = 0;
 677                 while (j < (tam_data)) {
 678                         if (*tmp == '\0') {
 679                                 if (ant == (*tmp)){
 680                                         (*tmp1) = '.';
 681                                 } else {
 682                                         (*tmp1) = '|';
 683                                 }
 684                         } else {
 685                                 copy_char(tmp1, tmp);
 686                         }
 687                         ant = (*tmp);
 688                         tmp++;
 689                         tmp1++;
 690                         if (pos_actualizada == 1)
 691                                 (*ancho)++;
 692                         j++;
 693                 }
 694                 if (pos_actualizada == 1)
 695                         pos_actualizada = 2;
 696                 i++;
 697         }
 698         free(ptr);
 699
 700         PERR("Termine");
 701         salida[*size-1] = '\0';
 702
 703         return salida;
 704 }
 705
 706 char *procesar_registro_factura_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 707 {
 708         char *tmp, *salida, *tmp1, pos_actualizada, ant;
 709         EMUFS_REG_SIZE offset, curr_size;
 710         char flotante[10];
 711         int cant_header, i=0, j, tam_data, k;
 712         int cant_items;
 713         if (ptr == NULL) return NULL;
 714
 715         PERR("Empieza el baile");
 716         cant_header = 0;
 717         offset = 0;
 718         do {
 719                 /* Me salto el ID, que no me interesa saber su valor */
 720                 offset += sizeof(EMUFS_REG_ID);
 721                 /* Copio el tamaño del registro de la cabecera. */
 722                 memcpy(&curr_size, ptr + offset, sizeof(EMUFS_REG_SIZE));
 723                 offset += sizeof(EMUFS_REG_SIZE);
 724
 725                 /* Desplazo el offset */
 726                 if (curr_size == 0) {
 727                         /* Si el tamaño de registro es 0, quiere decir que llegue a la
 728                          * parte que esta vacia */
 729                         break;
 730                 } else {
 731                         cant_header++;
 732                         offset += curr_size;
 733                 }
 734         } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size));
 735
 736         /* El tamaño del nuevo array lo calculo asi :
 737          *
 738          */
 739         tmp1 = salida = (char *)malloc(1000000); /*(*size)-(sizeof(char *)+sizeof(t_Item *)+sizeof(EMUFS_REG_ID)+sizeof(int)*3+sizeof(float)+sizeof(EMUFS_BLOCK_ID))*cant_header + 5*cant_header*10+1);*/
 740         if (salida == NULL) {
 741                 PERR("Error de malloc en salida");
 742                 return NULL;
 743         }
 744         tmp = ptr;
 745         pos_actualizada = 0;
 746         (*ancho) = 0;
 747         i = 0;
 748         while (i<cant_header) {
 749                 /* Verifico la pos_actual para el resaltado, asi queda coherente
 750                  * en el cambio de formato
 751                  */
 752                 if (((tmp - ptr) == *pos_actual) && (!pos_actualizada)) {
 753                         (*pos_actual) = tmp1-salida;
 754                         pos_actualizada = 1;
 755                 }
 756                 /* Pongo el ID del registro */
 757                 sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
 758                 tmp1 += 10;
 759                 tmp += sizeof(EMUFS_REG_ID);
 760                 /* Cantidad de espacio que ocupa la data */
 761                 sprintf(tmp1, "{%08lu}", *((EMUFS_REG_SIZE *)tmp));
 762                 tam_data = *((EMUFS_REG_SIZE *)tmp) - sizeof(int)*3 - sizeof(float) - sizeof(EMUFS_BLOCK_ID);
 763                 tmp1 += 10;
 764                 tmp += sizeof(EMUFS_REG_SIZE);
 765                 /* Pongo el campo numero */
 766                 sprintf(tmp1, "[%08d]", *((int *)tmp));
 767                 tmp1 += 10;
 768                 tmp += sizeof(int);
 769                 /* Pongo campo procdoi */
 770                 sprintf(flotante, "[%5.2f]", *((float *)tmp));
 771                 memcpy(tmp1, flotante, strlen(flotante));
 772                 tmp1 += strlen(flotante);
 773                 tmp += sizeof(float);
 774                 /* Pongo campo numero_remito */
 775                 sprintf(tmp1, "[%08d]", *((int *)tmp));
 776                 tmp1 += 10;
 777                 tmp += sizeof(int);
 778                 /* Pongo numero de items */
 779                 sprintf(tmp1, "[%08d]", *((int *)tmp));
 780                 cant_items = *((int *)tmp);
 781                 tmp1 += 10;
 782                 tmp += sizeof(int);
 783                 /* Pongo reg_nota */
 784                 sprintf(tmp1, "(%08lu)", *((EMUFS_BLOCK_ID*)tmp));
 785                 tmp1 += 10;
 786                 tmp += sizeof(EMUFS_BLOCK_ID);
 787
 788                 if (pos_actualizada == 1) {
 789                         (*ancho) = 60+strlen(flotante);
 790                 }
 791                 j = 0;
 792                 PERR("Voy por la data");
 793                 while (j < (tam_data-cant_items*sizeof(t_Item))) {
 794                         if (*tmp == '\0') {
 795                                 if (ant == (*tmp)){
 796                                         (*tmp1) = '.';
 797                                 } else {
 798                                         (*tmp1) = '|';
 799                                 }
 800                         } else {
 801                                 (*tmp1) = (*tmp);
 802                         }
 803                         ant = (*tmp);
 804                         tmp++;
 805                         tmp1++;
 806                         if (pos_actualizada == 1)
 807                                 (*ancho)++;
 808                         j++;
 809                 }
 810                 /* Ahora proceso los items */
 811                 k = 0;
 812                 while (k < cant_items) {
 813                         sprintf(tmp1, "[%08d]", *((int *)tmp));
 814                         tmp1 += 10;
 815                         tmp += sizeof(int);
 816                         if (pos_actualizada == 1)
 817                                 (*ancho)+=10;
 818                         j = 0;
 819                         while (j < (sizeof(t_Item)-sizeof(int))) {
 820                                 if (*tmp == '\0') {
 821                                         if (ant == (*tmp)){
 822                                                 (*tmp1) = '.';
 823                                         } else {
 824                                                 (*tmp1) = '|';
 825                                         }
 826                                 } else {
 827                                         (*tmp1) = (*tmp);
 828                                 }
 829                                 ant = (*tmp);
 830                                 tmp++;
 831                                 tmp1++;
 832                                 if (pos_actualizada == 1)
 833                                         (*ancho)++;
 834                                 j++;
 835                         }
 836                         k++;
 837                 }
 838                 if (pos_actualizada == 1)
 839                         pos_actualizada = 2;
 840                 PERR(salida);
 841                 i++;
 842         }
 843         /* llego no . hasta el final */
 844         while (tmp < (ptr+(*size))) {
 845                 (*tmp1) = '.';
 846                 tmp1++;
 847                 tmp++;
 848         }
 849         free(ptr);
 850
 851         PERR("Termine");
 852         if (emu->tam_bloque > emu->tam_reg) {
 853                 (*size) = tmp1-salida;
 854         } else {
 855                 (*size) = tmp1-salida;
 856                 (*ancho) = tmp1-salida;
 857         }
 858         salida[*size-1] = '\0';
 859
 860         return salida;
 861 }
 862
 863 char *procesar_registro_articulo_tipo2(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 864 {
 865         char *salida, *tmp;
 866         char *in;
 867         int i;
 868         EMUFS_REG_SIZE tam_data;
 869         if (ptr == NULL) return NULL;
 870
 871         (*size) = *size - sizeof(EMUFS_REG_SIZE) - sizeof(EMUFS_REG_ID) + 21;
 872         (*ancho) = *size-101;
 873         salida = (char *)malloc(*size);
 874         memset(salida, '.', *size);
 875
 876         PERR("Voy por el espacio antes");
 877         for(i=0; i < *pos_actual; i++) {
 878                 /* Los datos que tengo por ahora los pongo enmascarados! */
 879                 copy_char(&salida[i], in);
 880                 in++;
 881         }
 882         tmp = salida + *pos_actual;
 883         in = ptr + *pos_actual;
 884
 885         PERR("Voy por el header");
 886         /* ID de registro */
 887         sprintf(tmp, "(%08lu)", *((EMUFS_REG_ID *)in));
 888         tmp += 10;
 889         in += sizeof(EMUFS_REG_ID);
 890         /* Tamaño de registro */
 891         sprintf(tmp, "{%08lu}", *((EMUFS_REG_SIZE *)in));
 892         tam_data = *((EMUFS_REG_SIZE *)in);
 893         tmp += 10;
 894         in += sizeof(EMUFS_REG_SIZE);
 895         PERR("Voy por la data");
 896         i = 0;
 897         while (i < tam_data) {
 898                 copy_char(tmp, in);
 899                 tmp++;
 900                 in++;
 901                 i++;
 902         }
 903         PERR("Voy por el espacio despues");
 904         for(i=0; i < 100-*pos_actual; i++) {
 905                 copy_char(tmp, in);
 906                 tmp++;
 907                 in++;
 908         }
 909
 910         free(ptr);
 911         PERR("LISTO");
 912         salida[*size-1] = '\0';
 913         return salida;
 914 }
 915