emufs_gui/viewer.c

   1
   2 #include "viewer.h"
   3 #include "idx.h"
   4 #include "articulos.h"
   5 #include "facturas.h"
   6 #include "gui.h"
   7 #include "common.h"
   8 #include <ctype.h>
   9
  10 /* Se encarga de reemplazar los \0 un caracter visual, y segurar un \0 al final */
  11 static char *procesar_registro_tipo2(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
  12 static char *procesar_registro_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
  13 static char *procesar_registro_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 copy_char(char *dst, char *src)
  18 {
  19         /* Todos los espacidores los pongo iguales */
  20         if (isspace(*src)) *dst = ' ';
  21         else if (iscntrl(*src)) *dst = '*';
  22         else *dst = *src;
  23 }
  24
  25 void mostrar_info(WINDOW *padre, int h, int offset_alto, int opt)
  26 {
  27         /* Info de teclas */
  28         wattron(padre, A_BOLD);
  29         wattron(padre, COLOR_PAIR(COLOR_RED));
  30         mvwaddstr(padre, h-offset_alto+1, 5, "Teclas :");
  31         wattroff(padre, A_BOLD);
  32         wattroff(padre, COLOR_PAIR(COLOR_RED));
  33         mvwaddstr(padre, h-offset_alto+2, 8, "Salir = ENTER");
  34         mvwaddstr(padre, h-offset_alto+3, 8, "Scroll = A/Z");
  35         mvwaddstr(padre, h-offset_alto+4, 8, "Seleccionar registros = K/L");
  36         if (opt) {
  37                 mvwaddstr(padre, h-offset_alto+5, 8, "Acciones: ");
  38                 waddstr(padre, "A");
  39                 wattron(padre, A_BOLD);
  40                 waddch(padre, 'g');
  41                 wattroff(padre, A_BOLD);
  42                 waddstr(padre, "regar ");
  43                 wattron(padre, A_BOLD);
  44                 waddstr(padre, "M");
  45                 wattroff(padre, A_BOLD);
  46                 waddstr(padre, "ofidicar ");
  47                 wattron(padre, A_BOLD);
  48                 waddstr(padre, "E");
  49                 wattroff(padre, A_BOLD);
  50                 waddstr(padre, "liminar ");
  51         }
  52         mvwaddstr(padre, h-offset_alto+6, 8, "Buscar ID : B");
  53
  54         /* Info de leyenda */
  55         wattron(padre, A_BOLD);
  56         wattron(padre, COLOR_PAIR(COLOR_RED));
  57         mvwaddstr(padre, h-offset_alto+1, 45, "Leyenda :");
  58         wattroff(padre, A_BOLD);
  59         wattroff(padre, COLOR_PAIR(COLOR_RED));
  60         mvwaddstr(padre, h-offset_alto+2, 48, "  |   = Separador de campo");
  61         mvwaddstr(padre, h-offset_alto+3, 48, "[XXX] = Campo numerico");
  62         mvwaddstr(padre, h-offset_alto+4, 48, "(XXX) = ID de registro");
  63         mvwaddstr(padre, h-offset_alto+5, 48, "{XXX} = Tam. de registro");
  64         mvwaddstr(padre, h-offset_alto+6, 48, "  .   = Esp. Libre");
  65 }
  66
  67 char *juntar_memoria(char *s1, char *s2, char *s3, int size1, int size2, int size3)
  68 {
  69         char *salida;
  70         int tam=0;
  71         if (s1) tam += size1;
  72         if (s2) tam += size2;
  73         if (s3) tam += size3;
  74         salida = (char *)malloc(tam);
  75         if (salida == NULL) {
  76                         free(s1);
  77                         free(s2);
  78                         free(s3);
  79                         return NULL;
  80         }
  81
  82         if (s1) memcpy(salida, s1, size1); else size1 = 0;
  83         if (s2) memcpy(salida+size1, s2, size2); else size2 = 0;
  84         if (s3) memcpy(salida+size1+size2, s3, size3);
  85         if (s1) free(s1);
  86         if (s2) free(s2);
  87         if (s3) free(s3);
  88         return salida;
  89 }
  90
  91 void ver_bloques(WINDOW *padre, int w, int h, int cual)
  92 {
  93         /* Ventanas donde mostrar las cosas */
  94         char *(*procesar)(EMUFS*, char*, EMUFS_REG_SIZE*, int*, int*);
  95         WINDOW *actual[2], *dlg;
  96         EMUFS_REG_SIZE size, size_actual, size_siguiete, size_anterior;
  97         int scroll, actual_ancho;
  98         int max_scroll, c, offset_alto;
  99         /* Indices que hay validos en IDX */
 100         EMUFS_REG_ID indices_total, indices_actual;
 101         char *bloque_actual, *bloque_anterior, *bloque_siguiente;
 102         char *data; /* Registros a mostrar en pantalla */
 103         EMUFS *fp;
 104         int pos_actual, ancho_registro, offset, pos;
 105         EMUFS_Estadisticas stats;
 106
 107         if (cual == 0)
 108                 fp = emufs_abrir("articulos");
 109         else if (cual == 1)
 110                 fp = emufs_abrir("facturas");
 111         else if (cual == 2)
 112                 fp = emufs_abrir("notas");
 113
 114         stats = fp->leer_estadisticas(fp);
 115
 116         wattron(padre, COLOR_PAIR(COLOR_BLUE));
 117         mvwaddstr(padre, 0, 0, "Tipo de archivo : ");
 118         wattroff(padre, COLOR_PAIR(COLOR_BLUE));
 119         switch (fp->tipo) {
 120                 case T1:
 121                         waddstr(padre, "Registro variable con bloque parametrizado.");
 122                         procesar = procesar_registro_tipo1;
 123                 break;
 124                 case T2:
 125                         waddstr(padre, "Registro variable sin bloques.");
 126                         actual[0] = msg_box(padre, w, h, "El tipo de archivo no contiene bloques.");
 127                         getch();
 128                         msg_box_free(padre, actual[0]);
 129                         return;
 130                 break;
 131                 case T3:
 132                         procesar = procesar_registro_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                         procesar = procesar_registro_tipo1;
 291                 break;
 292                 case T2:
 293                         waddstr(padre, "Registro variable con sin bloques.");
 294                         procesar = procesar_registro_tipo2;
 295                 break;
 296                 case T3:
 297                         procesar = procesar_registro_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, 1);
 322
 323         if (data) {
 324                 mvwaddnstr(actual[1], 0, 0, data, pos_actual);
 325                 wattron(actual[1], A_BOLD);
 326                 waddnstr(actual[1], data+pos_actual, ancho_registro);
 327                 wattroff(actual[1], A_BOLD);
 328                 waddnstr(actual[1], data+pos_actual+ancho_registro, size-(pos_actual+ancho_registro));
 329         }
 330
 331         wrefresh(actual[1]);
 332         wrefresh(actual[0]);
 333         wrefresh(padre);
 334         scroll = 0;
 335         while ((c=getch()) != 13) {
 336                 switch (c) {
 337                         case 'b':
 338                         case 'B':
 339                                 dlg = newwin(4, 50, h/2-2, w/2-25);
 340                                 box(dlg, 0, 0);
 341                                 preguntar_id(dlg, fp);
 342                                 werase(dlg);
 343                                 wrefresh(dlg);
 344                                 delwin(dlg);
 345                                 wrefresh(padre);
 346                                 curs_set(0);
 347                         break;
 348                         case 'e':
 349                         case 'E':
 350                                 if (indices_actual != EMUFS_NOT_FOUND)
 351                                         fp->borrar_registro(fp, indices[indices_actual]);
 352
 353                                 free(indices);
 354                                 indices = emufs_idx_get(fp, &indices_total);
 355                                 if (indices_actual >= indices_total) {
 356                                         indices_actual = indices_total - 1;
 357                                 }
 358
 359                                 data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
 360                                 data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 361                         break;
 362                         case 'g':
 363                         case 'G':
 364                                 if (cual == 0)
 365                                         art_agregar(NULL);
 366                                 else
 367                                         fact_agregar(NULL);
 368                                 free(data);
 369                                 data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
 370                                 data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 371
 372                                 free(indices);
 373                                 indices = emufs_idx_get(fp, &indices_total);
 374
 375                                 /* Tengo que re-pintar algunas cosas */
 376                                 mostrar_info(padre, h, offset_alto, 1);
 377                                 box(actual[0], 0, 0);
 378                                 wrefresh(actual[0]);
 379                         break;
 380                         case 'M':
 381                         case 'm': /* Quiero editar !!! */
 382                                 sprintf(codigo, "%lu", indices[indices_actual]);
 383                                 if (cual == 0)
 384                                         art_modificar(codigo);
 385                                 else
 386                                         fact_modificar(codigo);
 387                                 /* Vuelvo a cargar el articulo actual */
 388
 389                                 free(data);
 390                                 data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
 391                                 data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 392
 393                                 /* Tengo que re-pintar algunas cosas */
 394                                 mostrar_info(padre, h, offset_alto, 1);
 395                                 box(actual[0], 0, 0);
 396                                 wrefresh(actual[0]);
 397                         break;
 398                         case 'a': /* Scroll */
 399                                 scroll--;
 400                                 if (scroll < 0) scroll = 0;
 401                         break;
 402                         case 'z': /* Scroll */
 403                                 scroll++;
 404                                 if (scroll > max_scroll) scroll = max_scroll;
 405                         break;
 406                         case 'l':
 407                                 if (indices_actual < indices_total) {
 408                                         indices_actual++;
 409                                         if (indices_actual >= indices_total) indices_actual = indices_total-1;
 410                                         if (data) free(data);
 411                                         data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
 412                                         data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
 413                                 }
 414                         break;
 415                         case 'k':
 416                                 if (indices_actual != EMUFS_NOT_FOUND) {
 417                                         indices_actual--;
 418                                         if (indices_actual == EMUFS_NOT_FOUND) indices_actual = 0;
 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
 424                 }
 425                 /* Borro las ventanas */
 426                 werase(actual[1]);
 427
 428                 /* Imprimo los registros */
 429                 if (data) {
 430                         offset = scroll*actual_ancho;
 431                         pos = pos_actual - offset;
 432                         mvwaddnstr(actual[1], 0, 0, data+offset, pos);
 433                         offset += pos;
 434                         wattron(actual[1], A_BOLD);
 435                         waddnstr(actual[1], data+offset, ancho_registro);
 436                         wattroff(actual[1], A_BOLD);
 437                         offset += ancho_registro;
 438                         waddnstr(actual[1], data+offset, size-offset);
 439                 }
 440
 441                 wrefresh(actual[1]);
 442                 wrefresh(padre);
 443         }
 444         if (indices) free(indices);
 445         if (data) free(data);
 446
 447         emufs_destruir(fp);
 448         delwin(actual[0]);
 449         wrefresh(padre);
 450         curs_set(1);
 451 }
 452
 453 int preguntar_id(WINDOW *win, EMUFS *fp)
 454 {
 455         int n=-1;
 456         t_Form *form = form_crear(win);
 457         form_agregar_widget(form, INPUT, "ID a buscar", 8, "");
 458
 459         do {
 460                 form_set_valor(form, "ID a buscar", "");
 461                 form_ejecutar(form, 1,1);
 462
 463                 n = form_obtener_valor_int(form, "ID a buscar");
 464         } while (n>0);
 465
 466         form_destruir(form);
 467         return n;
 468 }
 469
 470 char *procesar_registro_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 471 {
 472         char *tmp, *salida, *tmp1, pos_actualizada, ant;
 473         int cant_header, i=0, j, tam_data;
 474         if (ptr == NULL) return NULL;
 475
 476         PERR("Empieza el baile");
 477
 478         /* Calculo cuantos headers de registros va a haber en el archivo */
 479         cant_header = emu->tam_bloque / (emu->tam_reg+sizeof(EMUFS_REG_ID));
 480         if (cant_header == 0) cant_header++; /* Si tam_reg > tam_bloque, voy a tener solo 1 header */
 481         tam_data = emu->tam_reg;
 482         if (tam_data > (*size -  sizeof(EMUFS_REG_ID)))
 483                 tam_data = *size - sizeof(EMUFS_REG_ID);
 484
 485         (*size) = (*size) - cant_header*sizeof(EMUFS_REG_ID)+cant_header*10+1;
 486         tmp1 = salida = (char *)malloc(*size);
 487         memset(salida, '.', *size);
 488         if (salida == NULL) {
 489                 PERR("Error de malloc en salida");
 490                 return NULL;
 491         }
 492         tmp = ptr;
 493         pos_actualizada = 0;
 494         (*ancho) = 0;
 495         while (i<cant_header) {
 496                 /* Verifico la pos_actual para el resaltado, asi queda coherente
 497                  * en el cambio de formato
 498                  */
 499                 if (((tmp - ptr) == *pos_actual) && (!pos_actualizada)) {
 500                         (*pos_actual) = tmp1-salida;
 501                         pos_actualizada = 1;
 502                 }
 503                 /* Pongo el ID del registro */
 504                 sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
 505                 tmp1 += 10;
 506                 tmp += sizeof(EMUFS_REG_ID);
 507
 508                 if (pos_actualizada == 1) {
 509                         (*ancho) = 10;
 510                 }
 511                 j = 0;
 512                 while (j < (tam_data)) {
 513                         if (*tmp == '\0') {
 514                                 if (ant == (*tmp)){
 515                                         (*tmp1) = '.';
 516                                 } else {
 517                                         (*tmp1) = '|';
 518                                 }
 519                         } else {
 520                                 copy_char(tmp1, tmp);
 521                         }
 522                         ant = (*tmp);
 523                         tmp++;
 524                         tmp1++;
 525                         if (pos_actualizada == 1)
 526                                 (*ancho)++;
 527                         j++;
 528                 }
 529                 if (pos_actualizada == 1)
 530                         pos_actualizada = 2;
 531                 i++;
 532         }
 533         free(ptr);
 534
 535         PERR("Termine");
 536         salida[*size-1] = '\0';
 537
 538         return salida;
 539 }
 540
 541 char *procesar_registro_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 542 {
 543         char *tmp, *salida, *tmp1, pos_actualizada, ant;
 544         EMUFS_REG_SIZE offset, curr_size, size_acumulado, old_size;
 545         int cant_header, i=0, j, tam_data;
 546         if (ptr == NULL) return NULL;
 547
 548         PERR("Empieza el baile");
 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 #ifdef DEBUG
 560                 fprintf(stderr, "Tam = %lu\n", curr_size);
 561 #endif
 562                 if (curr_size == 0) {
 563                         /* Si el tamaño de registro es 0, quiere decir que llegue a la
 564                          * parte que esta vacia */
 565                         break;
 566                 } else {
 567                         cant_header++;
 568                         offset += curr_size;
 569                 }
 570         } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size));
 571
 572         if (cant_header == 0) {
 573                 PERR("NO TENGO ITEMS");
 574                 memset(ptr, '.', *size);
 575                 (*ancho) = (*size);
 576                 (*pos_actual) = 0;
 577                 return ptr;
 578         }
 579
 580         /* El tamaño del nuevo array lo calculo asi :
 581          *
 582          */
 583         old_size = (*size);
 584         (*size) = (*size) - sizeof(EMUFS_REG_ID)*cant_header - sizeof(EMUFS_REG_SIZE)*cant_header + cant_header*20+1;
 585         tmp1 = salida = (char *)malloc(*size);
 586         if (salida == NULL) {
 587                 PERR("Error de malloc en salida");
 588                 return NULL;
 589         }
 590         memset(salida, '.', *size);
 591         tmp = ptr;
 592         pos_actualizada = 0;
 593         (*ancho) = 0;
 594         i = 0;
 595         size_acumulado = 0;
 596         while (i<cant_header) {
 597                 /* Verifico la pos_actual para el resaltado, asi queda coherente
 598                  * en el cambio de formato
 599                  */
 600                 if (((tmp - ptr) == *pos_actual) && (!pos_actualizada)) {
 601                         (*pos_actual) = tmp1-salida;
 602                         pos_actualizada = 1;
 603                 }
 604                 /* Pongo el ID del registro */
 605                 sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
 606                 tmp1 += 10;
 607                 tmp += sizeof(EMUFS_REG_ID);
 608                 /* Cantidad de espacio que ocupa la data */
 609                 sprintf(tmp1, "{%08lu}", *((EMUFS_REG_SIZE *)tmp));
 610                 tam_data = *((EMUFS_REG_SIZE *)tmp);
 611                 if ((size_acumulado+tam_data) > old_size) {
 612                         tam_data = old_size - size_acumulado;
 613                 }
 614                 tmp1 += 10;
 615                 tmp += sizeof(EMUFS_REG_SIZE);
 616
 617                 if (pos_actualizada == 1) {
 618                         (*ancho) = 20;
 619                 }
 620                 j = 0;
 621                 PERR("Voy por la data");
 622                 ant = -1;
 623                 while (j < tam_data) {
 624                         if (*tmp == '\0') {
 625                                 if (ant == (*tmp)){
 626                                         (*tmp1) = '.';
 627                                 } else {
 628                                         (*tmp1) = '|';
 629                                 }
 630                         } else {
 631                                 copy_char(tmp1, tmp);
 632                         }
 633                         ant = (*tmp);
 634                         tmp++;
 635                         tmp1++;
 636                         if (pos_actualizada == 1)
 637                                 (*ancho)++;
 638                         j++;
 639                 }
 640                 size_acumulado += tam_data;
 641                 if (pos_actualizada == 1)
 642                         pos_actualizada = 2;
 643                 i++;
 644         }
 645         free(ptr);
 646
 647         PERR("Termine");
 648         salida[*size-1] = '\0';
 649
 650         return salida;
 651 }
 652
 653 char *procesar_registro_tipo2(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 654 {
 655         char *salida, *tmp;
 656         char *in;
 657         int i;
 658         EMUFS_REG_SIZE tam_data;
 659         if (ptr == NULL) return NULL;
 660
 661         (*size) = *size - sizeof(EMUFS_REG_SIZE) - sizeof(EMUFS_REG_ID) + 21;
 662         (*ancho) = *size-101;
 663         salida = (char *)malloc(*size);
 664         memset(salida, '.', *size);
 665
 666         PERR("Voy por el espacio antes");
 667         for(i=0; i < *pos_actual; i++) {
 668                 /* Los datos que tengo por ahora los pongo enmascarados! */
 669                 copy_char(&salida[i], in);
 670                 in++;
 671         }
 672         tmp = salida + *pos_actual;
 673         in = ptr + *pos_actual;
 674
 675         PERR("Voy por el header");
 676         /* ID de registro */
 677         sprintf(tmp, "(%08lu)", *((EMUFS_REG_ID *)in));
 678         tmp += 10;
 679         in += sizeof(EMUFS_REG_ID);
 680         /* Tamaño de registro */
 681         sprintf(tmp, "{%08lu}", *((EMUFS_REG_SIZE *)in));
 682         tam_data = *((EMUFS_REG_SIZE *)in);
 683         tmp += 10;
 684         in += sizeof(EMUFS_REG_SIZE);
 685         PERR("Voy por la data");
 686         i = 0;
 687         while (i < tam_data) {
 688                 copy_char(tmp, in);
 689                 tmp++;
 690                 in++;
 691                 i++;
 692         }
 693         PERR("Voy por el espacio despues");
 694
 695         free(ptr);
 696         PERR("LISTO");
 697         salida[*size-1] = '\0';
 698         return salida;
 699 }
 700