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