emufs_gui/registros.c

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