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, k;
 641         int cant_items;
 642         if (ptr == NULL) return NULL;
 643
 644         PERR("Empieza el baile");
 645
 646         /* Calculo cuantos headers de registros va a haber en el archivo */
 647         if (emu->tam_bloque > emu->tam_reg) {
 648                 cant_header = emu->tam_bloque / (emu->tam_reg+sizeof(EMUFS_REG_ID));
 649                 if (cant_header == 0) cant_header++; /* Si tam_reg > tam_bloque, voy a tener solo 1 header */
 650                 tam_data = emu->tam_reg-sizeof(int)*3-sizeof(float)-sizeof(EMUFS_BLOCK_ID);
 651         } else {
 652                 cant_header = 1;
 653                 tam_data = (*size) - sizeof(EMUFS_REG_ID)-sizeof(int)*3-sizeof(float)-sizeof(EMUFS_BLOCK_ID);
 654         }
 655
 656         /* El tamaño del nuevo array lo calculo asi :
 657          *
 658          */
 659         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);*/
 660         if (salida == NULL) {
 661                 PERR("Error de malloc en salida");
 662                 return NULL;
 663         }
 664         tmp = ptr;
 665         pos_actualizada = 0;
 666         (*ancho) = 0;
 667         while (i<cant_header) {
 668                 /* Verifico la pos_actual para el resaltado, asi queda coherente
 669                  * en el cambio de formato
 670                  */
 671                 if (((tmp - ptr) == *pos_actual) && (!pos_actualizada)) {
 672                         (*pos_actual) = tmp1-salida;
 673                         pos_actualizada = 1;
 674                 }
 675                 /* Pongo el ID del registro */
 676                 sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
 677                 tmp1 += 10;
 678                 tmp += sizeof(EMUFS_REG_ID);
 679                 /* Pongo el campo numero */
 680                 sprintf(tmp1, "[%08d]", *((int *)tmp));
 681                 tmp1 += 10;
 682                 tmp += sizeof(int);
 683                 /* Pongo campo procdoi */
 684                 sprintf(flotante, "[%5.2f]", *((float *)tmp));
 685                 memcpy(tmp1, flotante, strlen(flotante));
 686                 tmp1 += strlen(flotante);
 687                 tmp += sizeof(float);
 688                 /* Pongo campo numero_remito */
 689                 sprintf(tmp1, "[%08d]", *((int *)tmp));
 690                 tmp1 += 10;
 691                 tmp += sizeof(int);
 692                 /* Pongo numero de items */
 693                 sprintf(tmp1, "[%08d]", *((int *)tmp));
 694                 cant_items = *((int *)tmp);
 695                 tmp1 += 10;
 696                 tmp += sizeof(int);
 697                 /* Pongo reg_nota */
 698                 sprintf(tmp1, "(%08lu)", *((EMUFS_BLOCK_ID*)tmp));
 699                 tmp1 += 10;
 700                 tmp += sizeof(EMUFS_BLOCK_ID);
 701
 702                 if (pos_actualizada == 1) {
 703                         (*ancho) = 50+strlen(flotante);
 704                 }
 705                 j = 0;
 706                 while (j < (tam_data-10*sizeof(t_Item))) {
 707                         if (*tmp == '\0') {
 708                                 if (ant == (*tmp)){
 709                                         (*tmp1) = '.';
 710                                 } else {
 711                                         (*tmp1) = '|';
 712                                 }
 713                         } else {
 714                                 (*tmp1) = (*tmp);
 715                         }
 716                         ant = (*tmp);
 717                         tmp++;
 718                         tmp1++;
 719                         if (pos_actualizada == 1)
 720                                 (*ancho)++;
 721                         j++;
 722                 }
 723                 /* Ahora proceso los items */
 724                 k = 0;
 725                 while (k < 10) {
 726                         sprintf(tmp1, "[%08d]", *((int *)tmp));
 727                         tmp1 += 10;
 728                         tmp += sizeof(int);
 729                         if (pos_actualizada == 1)
 730                                 (*ancho)+=10;
 731                         j = 0;
 732                         while (j < (sizeof(t_Item)-sizeof(int))) {
 733                                 if (*tmp == '\0') {
 734                                         if (ant == (*tmp)){
 735                                                 (*tmp1) = '.';
 736                                         } else {
 737                                                 (*tmp1) = '|';
 738                                         }
 739                                 } else {
 740                                         (*tmp1) = (*tmp);
 741                                 }
 742                                 ant = (*tmp);
 743                                 tmp++;
 744                                 tmp1++;
 745                                 if (pos_actualizada == 1)
 746                                         (*ancho)++;
 747                                 j++;
 748                         }
 749                         k++;
 750                 }
 751                 if (pos_actualizada == 1)
 752                         pos_actualizada = 2;
 753                 i++;
 754         }
 755         free(ptr);
 756
 757         PERR("Termine");
 758         if (emu->tam_bloque > emu->tam_reg) {
 759                 (*size) = tmp1-salida;
 760         } else {
 761                 (*size) = tmp1-salida;
 762                 (*ancho) = tmp1-salida;
 763         }
 764         salida[*size-1] = '\0';
 765
 766         return salida;
 767 }
 768
 769 char *procesar_registro_factura_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 770 {
 771         char *tmp, *salida, *tmp1, pos_actualizada, ant;
 772         EMUFS_REG_SIZE offset, curr_size;
 773         char flotante[10];
 774         int cant_header, i=0, j, tam_data, k;
 775         int cant_items;
 776         if (ptr == NULL) return NULL;
 777
 778         PERR("Empieza el baile");
 779         cant_header = 0;
 780         offset = 0;
 781         do {
 782                 /* Me salto el ID, que no me interesa saber su valor */
 783                 offset += sizeof(EMUFS_REG_ID);
 784                 /* Copio el tamaño del registro de la cabecera. */
 785                 memcpy(&curr_size, ptr + offset, sizeof(EMUFS_REG_SIZE));
 786                 offset += sizeof(EMUFS_REG_SIZE);
 787
 788                 /* Desplazo el offset */
 789                 if (curr_size == 0) {
 790                         /* Si el tamaño de registro es 0, quiere decir que llegue a la
 791                          * parte que esta vacia */
 792                         break;
 793                 } else {
 794                         cant_header++;
 795                         offset += curr_size;
 796                 }
 797         } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size));
 798
 799         /* El tamaño del nuevo array lo calculo asi :
 800          *
 801          */
 802         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);*/
 803         if (salida == NULL) {
 804                 PERR("Error de malloc en salida");
 805                 return NULL;
 806         }
 807         tmp = ptr;
 808         pos_actualizada = 0;
 809         (*ancho) = 0;
 810         i = 0;
 811         while (i<cant_header) {
 812                 /* Verifico la pos_actual para el resaltado, asi queda coherente
 813                  * en el cambio de formato
 814                  */
 815                 if (((tmp - ptr) == *pos_actual) && (!pos_actualizada)) {
 816                         (*pos_actual) = tmp1-salida;
 817                         pos_actualizada = 1;
 818                 }
 819                 /* Pongo el ID del registro */
 820                 sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
 821                 tmp1 += 10;
 822                 tmp += sizeof(EMUFS_REG_ID);
 823                 /* Cantidad de espacio que ocupa la data */
 824                 sprintf(tmp1, "{%08lu}", *((EMUFS_REG_SIZE *)tmp));
 825                 tam_data = *((EMUFS_REG_SIZE *)tmp) - sizeof(int)*3 - sizeof(float) - sizeof(EMUFS_BLOCK_ID);
 826                 tmp1 += 10;
 827                 tmp += sizeof(EMUFS_REG_SIZE);
 828                 /* Pongo el campo numero */
 829                 sprintf(tmp1, "[%08d]", *((int *)tmp));
 830                 tmp1 += 10;
 831                 tmp += sizeof(int);
 832                 /* Pongo campo procdoi */
 833                 sprintf(flotante, "[%5.2f]", *((float *)tmp));
 834                 memcpy(tmp1, flotante, strlen(flotante));
 835                 tmp1 += strlen(flotante);
 836                 tmp += sizeof(float);
 837                 /* Pongo campo numero_remito */
 838                 sprintf(tmp1, "[%08d]", *((int *)tmp));
 839                 tmp1 += 10;
 840                 tmp += sizeof(int);
 841                 /* Pongo numero de items */
 842                 sprintf(tmp1, "[%08d]", *((int *)tmp));
 843                 cant_items = *((int *)tmp);
 844                 tmp1 += 10;
 845                 tmp += sizeof(int);
 846                 /* Pongo reg_nota */
 847                 sprintf(tmp1, "(%08lu)", *((EMUFS_BLOCK_ID*)tmp));
 848                 tmp1 += 10;
 849                 tmp += sizeof(EMUFS_BLOCK_ID);
 850
 851                 if (pos_actualizada == 1) {
 852                         (*ancho) = 60+strlen(flotante);
 853                 }
 854                 j = 0;
 855                 PERR("Voy por la data");
 856                 while (j < (tam_data-cant_items*sizeof(t_Item))) {
 857                         if (*tmp == '\0') {
 858                                 if (ant == (*tmp)){
 859                                         (*tmp1) = '.';
 860                                 } else {
 861                                         (*tmp1) = '|';
 862                                 }
 863                         } else {
 864                                 (*tmp1) = (*tmp);
 865                         }
 866                         ant = (*tmp);
 867                         tmp++;
 868                         tmp1++;
 869                         if (pos_actualizada == 1)
 870                                 (*ancho)++;
 871                         j++;
 872                 }
 873                 /* Ahora proceso los items */
 874                 k = 0;
 875                 while (k < cant_items) {
 876                         sprintf(tmp1, "[%08d]", *((int *)tmp));
 877                         tmp1 += 10;
 878                         tmp += sizeof(int);
 879                         if (pos_actualizada == 1)
 880                                 (*ancho)+=10;
 881                         j = 0;
 882                         while (j < (sizeof(t_Item)-sizeof(int))) {
 883                                 if (*tmp == '\0') {
 884                                         if (ant == (*tmp)){
 885                                                 (*tmp1) = '.';
 886                                         } else {
 887                                                 (*tmp1) = '|';
 888                                         }
 889                                 } else {
 890                                         (*tmp1) = (*tmp);
 891                                 }
 892                                 ant = (*tmp);
 893                                 tmp++;
 894                                 tmp1++;
 895                                 if (pos_actualizada == 1)
 896                                         (*ancho)++;
 897                                 j++;
 898                         }
 899                         k++;
 900                 }
 901                 if (pos_actualizada == 1)
 902                         pos_actualizada = 2;
 903                 PERR(salida);
 904                 i++;
 905         }
 906         /* llego no . hasta el final */
 907         while (tmp < (ptr+(*size))) {
 908                 (*tmp1) = '.';
 909                 tmp1++;
 910                 tmp++;
 911         }
 912         free(ptr);
 913
 914         PERR("Termine");
 915         if (emu->tam_bloque > emu->tam_reg) {
 916                 (*size) = tmp1-salida;
 917         } else {
 918                 (*size) = tmp1-salida;
 919                 (*ancho) = tmp1-salida;
 920         }
 921         salida[*size-1] = '\0';
 922
 923         return salida;
 924 }
 925
 926 char *procesar_registro_articulo_tipo2(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 927 {
 928         char *salida, *tmp;
 929         char *in;
 930         int i;
 931         EMUFS_REG_SIZE tam_data;
 932         if (ptr == NULL) return NULL;
 933
 934         (*size) = *size - sizeof(EMUFS_REG_SIZE) - sizeof(EMUFS_REG_ID) + 21;
 935         (*ancho) = *size-101;
 936         salida = (char *)malloc(*size);
 937         memset(salida, '.', *size);
 938
 939         PERR("Voy por el espacio antes");
 940         for(i=0; i < *pos_actual; i++) {
 941                 /* Los datos que tengo por ahora los pongo enmascarados! */
 942                 copy_char(&salida[i], in);
 943                 in++;
 944         }
 945         tmp = salida + *pos_actual;
 946         in = ptr + *pos_actual;
 947
 948         PERR("Voy por el header");
 949         /* ID de registro */
 950         sprintf(tmp, "(%08lu)", *((EMUFS_REG_ID *)in));
 951         tmp += 10;
 952         in += sizeof(EMUFS_REG_ID);
 953         /* Tamaño de registro */
 954         sprintf(tmp, "{%08lu}", *((EMUFS_REG_SIZE *)in));
 955         tam_data = *((EMUFS_REG_SIZE *)in);
 956         tmp += 10;
 957         in += sizeof(EMUFS_REG_SIZE);
 958         PERR("Voy por la data");
 959         i = 0;
 960         while (i < tam_data) {
 961                 copy_char(tmp, in);
 962                 tmp++;
 963                 in++;
 964                 i++;
 965         }
 966         PERR("Voy por el espacio despues");
 967         for(i=0; i < 100-*pos_actual; i++) {
 968                 copy_char(tmp, in);
 969                 tmp++;
 970                 in++;
 971         }
 972
 973         free(ptr);
 974         PERR("LISTO");
 975         salida[*size-1] = '\0';
 976         return salida;
 977 }
 978