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