X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/087bc4de9c787d31ba4711af77af8620c4eae004..0e4db6997a0ac80650f3ec37ba58f7e9a8083147:/emufs_gui/registros.c diff --git a/emufs_gui/registros.c b/emufs_gui/registros.c index 0a9324f..325b3e2 100644 --- a/emufs_gui/registros.c +++ b/emufs_gui/registros.c @@ -1,86 +1,733 @@ #include "registros.h" +#include "idx.h" +#include "articulos.h" +#include "facturas.h" /* Se encarga de reemplazar los \0 un caracter visual, y segurar un \0 al final */ -static char *procesar_registro(char *ptr, size_t size); +static char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho); +static char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho); -void ver_registros(WINDOW *padre, int w, int h) +static char *procesar_registro_factura_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho); +static char *procesar_registro_factura_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho); + +static int preguntar_id(WINDOW *win, EMUFS *fp); + +void mostrar_info(WINDOW *padre, int h, int offset_alto) +{ + /* Info de teclas */ + wattron(padre, A_BOLD); + wattron(padre, COLOR_PAIR(COLOR_RED)); + mvwaddstr(padre, h-offset_alto+1, 5, "Teclas :"); + wattroff(padre, A_BOLD); + wattroff(padre, COLOR_PAIR(COLOR_RED)); + mvwaddstr(padre, h-offset_alto+2, 8, "Salir = ENTER"); + mvwaddstr(padre, h-offset_alto+3, 8, "Scroll = A/Z"); + mvwaddstr(padre, h-offset_alto+4, 8, "Seleccionar registros = K/L"); + mvwaddstr(padre, h-offset_alto+5, 8, "Acciones: "); + waddstr(padre, "A"); + wattron(padre, A_BOLD); + waddch(padre, 'g'); + wattroff(padre, A_BOLD); + waddstr(padre, "regar "); + wattron(padre, A_BOLD); + waddstr(padre, "M"); + wattroff(padre, A_BOLD); + waddstr(padre, "ofidicar "); + wattron(padre, A_BOLD); + waddstr(padre, "E"); + wattroff(padre, A_BOLD); + waddstr(padre, "liminar "); + mvwaddstr(padre, h-offset_alto+6, 8, "Buscar ID : B"); + + /* Info de leyenda */ + wattron(padre, A_BOLD); + wattron(padre, COLOR_PAIR(COLOR_RED)); + mvwaddstr(padre, h-offset_alto+1, 45, "Leyenda :"); + wattroff(padre, A_BOLD); + wattroff(padre, COLOR_PAIR(COLOR_RED)); + mvwaddstr(padre, h-offset_alto+2, 48, " | = Separador de campo"); + mvwaddstr(padre, h-offset_alto+3, 48, "[XXX] = Campo numerico"); + mvwaddstr(padre, h-offset_alto+4, 48, "(XXX) = ID de registro"); + mvwaddstr(padre, h-offset_alto+5, 48, "{XXX} = Tam. de registro"); + mvwaddstr(padre, h-offset_alto+6, 48, " . = Esp. Libre"); + mvwaddstr(padre, h-offset_alto+7, 48, " < > = Separador Bloques"); +} + +void ver_registros(WINDOW *padre, int w, int h, int cual) { /* Ventanas donde mostrar las cosas */ - WINDOW *actual[2], *ant[2], *sig[2]; - int c, scroll, actual_ancho; - char *data; + char *(*procesar)(EMUFS*, char*, EMUFS_REG_SIZE*, int*, int*); + WINDOW *actual[2], *dlg; + EMUFS_REG_SIZE size; + int scroll, actual_ancho; + int max_scroll, c, offset_alto; + /* Indices que hay validos en IDX */ + EMUFS_REG_ID *indices, indices_total, indices_actual; + char *data; /* Registros a mostrar en pantalla */ + char codigo[50]; /* Variable para guardar el codigo actual para mandar a modificar */ EMUFS *fp; - fp = emufs_abrir("articulos"); + int pos_actual, ancho_registro, offset, pos; - data = (char *)fp->leer_registro(fp, 0, &c, &scroll); + if (cual == 0) + fp = emufs_abrir("articulos"); + else + fp = emufs_abrir("facturas"); - data = procesar_registro(data, c); + wattron(padre, COLOR_PAIR(COLOR_BLUE)); + mvwaddstr(padre, 0, 0, "Tipo de archivo : "); + wattroff(padre, COLOR_PAIR(COLOR_BLUE)); + switch (fp->tipo) { + case T1: + waddstr(padre, "Registro variable con bloque parametrizado."); + if (cual == 0) + procesar = procesar_registro_articulo_tipo1; + else + procesar = procesar_registro_factura_tipo1; + break; + case T2: + waddstr(padre, "Registro variable sin bloques."); + break; + case T3: + if (cual == 0) + procesar = procesar_registro_articulo_tipo3; + else + procesar = procesar_registro_factura_tipo3; + waddstr(padre, "Registro fijo con bloque parametrizado."); + } - actual[0] = derwin(padre, h-2, w/3, 1, w/3); - actual_ancho = w/3-2; - actual[1] = derwin(actual[0], h-4, w/3-2, 1, 1); + indices = emufs_idx_get(fp, &indices_total); + + indices_actual = 0; + if (indices) { + data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual); + data = procesar(fp, data, &size, &pos_actual, &ancho_registro); + } + + + offset_alto = 8; + max_scroll = size / (w-4) - (h-offset_alto-2); + if (max_scroll < 0) max_scroll = 0; + + actual[0] = derwin(padre, h-offset_alto, w-2, 1, 1); + actual_ancho = w-4; + actual[1] = derwin(actual[0], h-offset_alto-2, w-4, 1, 1); box(actual[0], 0, 0); - ant[0] = derwin(padre, h-2, w/3, 1, 0); - box(ant[0], 0, 0); - sig[0] = derwin(padre, h-2, w/3, 1, w/3*2); - box(sig[0], 0, 0); + curs_set(0); + + mostrar_info(padre, h, offset_alto); + + mvwaddnstr(actual[1], 0, 0, data, pos_actual); wattron(actual[1], A_BOLD); - mvwaddstr(actual[1], 0, 0, data); + waddnstr(actual[1], data+pos_actual, ancho_registro); wattroff(actual[1], A_BOLD); + waddnstr(actual[1], data+pos_actual+ancho_registro, size-(pos_actual+ancho_registro)); - wrefresh(sig[0]); - wrefresh(ant[0]); - wrefresh(actual[0]); wrefresh(actual[1]); + wrefresh(actual[0]); wrefresh(padre); scroll = 0; while ((c=getch()) != 13) { switch (c) { - case 'a': + case 'b': + case 'B': + dlg = newwin(4, 50, h/2-2, w/2-25); + box(dlg, 0, 0); + preguntar_id(dlg, fp); + werase(dlg); + wrefresh(dlg); + delwin(dlg); + wrefresh(padre); + curs_set(0); + break; + case 'e': + case 'E': + if (indices_actual != EMUFS_NOT_FOUND) + fp->borrar_registro(fp, indices[indices_actual]); + + free(indices); + indices = emufs_idx_get(fp, &indices_total); + if (indices_actual >= indices_total) { + indices_actual = indices_total - 1; + } + + data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual); + data = procesar(fp, data, &size, &pos_actual, &ancho_registro); + break; + case 'g': + case 'G': + if (cual == 0) + art_agregar(NULL); + else + fact_agregar(NULL); + free(data); + data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual); + data = procesar(fp, data, &size, &pos_actual, &ancho_registro); + + free(indices); + indices = emufs_idx_get(fp, &indices_total); + + /* Tengo que re-pintar algunas cosas */ + mostrar_info(padre, h, offset_alto); + box(actual[0], 0, 0); + wrefresh(actual[0]); + break; + case 'M': + case 'm': /* Quiero editar !!! */ + sprintf(codigo, "%lu", indices[indices_actual]); + if (cual == 0) + art_modificar(codigo); + else + fact_modificar(codigo); + /* Vuelvo a cargar el articulo actual */ + + free(data); + data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual); + data = procesar(fp, data, &size, &pos_actual, &ancho_registro); + + /* Tengo que re-pintar algunas cosas */ + mostrar_info(padre, h, offset_alto); + box(actual[0], 0, 0); + wrefresh(actual[0]); + break; + case 'a': /* Scroll */ scroll--; if (scroll < 0) scroll = 0; break; - case 'z': + case 'z': /* Scroll */ scroll++; + if (scroll > max_scroll) scroll = max_scroll; + break; + case 'l': + if (indices_actual < indices_total) { + indices_actual++; + if (indices_actual >= indices_total) indices_actual = indices_total-1; + if (data) free(data); + data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual); + data = procesar(fp, data, &size, &pos_actual, &ancho_registro); + } + break; + case 'k': + if (indices_actual != EMUFS_NOT_FOUND) { + indices_actual--; + if (indices_actual == EMUFS_NOT_FOUND) indices_actual = 0; + if (data) free(data); + data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual); + data = procesar(fp, data, &size, &pos_actual, &ancho_registro); + } + } + /* Borro las ventanas */ werase(actual[1]); - wattron(actual[1], A_BOLD); - mvwaddstr(actual[1], 0, 0, data+actual_ancho*scroll); - wattroff(actual[1], A_BOLD); + + /* Imprimo los registros */ + if (data) { + offset = scroll*actual_ancho; + pos = pos_actual - offset; + mvwaddnstr(actual[1], 0, 0, data+offset, pos); + offset += pos; + wattron(actual[1], A_BOLD); + waddnstr(actual[1], data+offset, ancho_registro); + wattroff(actual[1], A_BOLD); + offset += ancho_registro; + waddnstr(actual[1], data+offset, size-offset); + } + wrefresh(actual[1]); - wrefresh(actual[0]); wrefresh(padre); } - werase(actual[1]); - delwin(actual[1]); - werase(actual[0]); + if (indices) free(indices); + if (data) free(data); + + emufs_destruir(fp); delwin(actual[0]); - werase(sig[0]); - delwin(sig[0]); - werase(ant[0]); - delwin(ant[0]); wrefresh(padre); + curs_set(1); +} + +char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho) +{ + char *tmp, *salida, *tmp1, pos_actualizada, ant; + int cant_header, i=0, j, tam_data; + if (ptr == NULL) return NULL; + + /* Calculo cuantos headers de registros va a haber en el archivo */ + if (emu->tam_bloque > emu->tam_reg) { + cant_header = emu->tam_bloque / (emu->tam_reg+sizeof(EMUFS_REG_ID)); + if (cant_header == 0) cant_header++; /* Si tam_reg > tam_bloque, voy a tener solo 1 header */ + tam_data = sizeof(t_Articulo)-sizeof(unsigned int); + } else { + cant_header = 1; + tam_data = *size - sizeof(EMUFS_REG_ID)-sizeof(unsigned int); + } + + /* El tamaño del nuevo array lo calculo asi : + * + * tamañoviejo - tamaño_headers_en_int - tamaño_ints_en_registro + * + 10*(cant_headers+cant_registros) +1 + * + * En tipo3, la cantidad de headers y cant de registros es la misma + * El 10 es por : (XXXXXXXX) + * +1 == Por el \0 + */ + salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1); + if (salida == NULL) { + return NULL; + } + tmp = ptr; + tmp1 = salida; + pos_actualizada = 0; + while (itam_bloque > emu->tam_reg) { + (*size) = (*size)-sizeof(unsigned int)*cant_header*2+2*cant_header*10+1; + (*ancho) = sizeof(t_Articulo)-sizeof(unsigned int)*2+20+1; + } else { + (*size) = (*size)-sizeof(EMUFS_REG_ID)-sizeof(unsigned int)+21; + (*ancho) = (*size); + } + memset(tmp1, '.', (*size)-(tmp1-salida)); + salida[*size-1] = '\0'; + + return salida; } -static char *procesar_registro(char *ptr, size_t size) +char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho) { - char *tmp, *salida, *tmp1; - salida = (char *)malloc(size-sizeof(unsigned int)+10+1); - sprintf(salida, "(%08d)", *((unsigned int *)ptr)); - tmp1 = salida+10; - tmp = ptr+sizeof(unsigned int); - while (tmp < (ptr+size)) { - if (*tmp == '\0') { - (*tmp1) = '|'; + EMUFS_REG_SIZE offset, curr_size; + char *tmp, *salida, *tmp1, pos_actualizada, ant; + int cant_header, i=0, j; + if (ptr == NULL) return NULL; + + /* Cuento la cantidad de registros en este bloque */ + cant_header = 0; + offset = 0; + do { + /* Me salto el ID, que no me interesa saber su valor */ + offset += sizeof(EMUFS_REG_ID); + /* Copio el tamaño del registro de la cabecera. */ + memcpy(&curr_size, ptr + offset, sizeof(EMUFS_REG_SIZE)); + offset += sizeof(EMUFS_REG_SIZE); + + /* Desplazo el offset */ + if (curr_size == 0) { + /* Si el tamaño de registro es 0, quiere decir que llegue a la + * parte que esta vacia */ + break; } else { - (*tmp1) = (*tmp); + cant_header++; + offset += curr_size; } - tmp++; + } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size)); + + /* Proceso */ + salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*3 + 3*cant_header*10+1); + tmp = ptr; + tmp1 = salida; + pos_actualizada = 0; + while (itam_bloque > emu->tam_reg) { + cant_header = emu->tam_bloque / (emu->tam_reg+sizeof(EMUFS_REG_ID)); + if (cant_header == 0) cant_header++; /* Si tam_reg > tam_bloque, voy a tener solo 1 header */ + tam_data = emu->tam_reg-sizeof(int)*3-sizeof(float)-sizeof(EMUFS_BLOCK_ID); + } else { + cant_header = 1; + tam_data = (*size) - sizeof(EMUFS_REG_ID)-sizeof(int)*3-sizeof(float)-sizeof(EMUFS_BLOCK_ID); + } + + /* El tamaño del nuevo array lo calculo asi : + * + */ + 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);*/ + if (salida == NULL) { + PERR("Error de malloc en salida"); + return NULL; + } + tmp = ptr; + pos_actualizada = 0; + (*ancho) = 0; + while (itam_bloque > emu->tam_reg) { + (*size) = tmp1-salida; + } else { + (*size) = tmp1-salida; + (*ancho) = tmp1-salida; + } + salida[*size-1] = '\0'; + + return salida; +} + +char *procesar_registro_factura_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho) +{ + char *tmp, *salida, *tmp1, pos_actualizada, ant; + EMUFS_REG_SIZE offset, curr_size; + char flotante[10]; + int cant_header, i=0, j, tam_data, k; + int cant_items; + if (ptr == NULL) return NULL; + + PERR("Empieza el baile"); + cant_header = 0; + offset = 0; + do { + /* Me salto el ID, que no me interesa saber su valor */ + offset += sizeof(EMUFS_REG_ID); + /* Copio el tamaño del registro de la cabecera. */ + memcpy(&curr_size, ptr + offset, sizeof(EMUFS_REG_SIZE)); + offset += sizeof(EMUFS_REG_SIZE); + + /* Desplazo el offset */ + if (curr_size == 0) { + /* Si el tamaño de registro es 0, quiere decir que llegue a la + * parte que esta vacia */ + break; + } else { + cant_header++; + offset += curr_size; + } + } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size)); + + /* El tamaño del nuevo array lo calculo asi : + * + */ + 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);*/ + if (salida == NULL) { + PERR("Error de malloc en salida"); + return NULL; + } + tmp = ptr; + pos_actualizada = 0; + (*ancho) = 0; + i = 0; + while (itam_bloque > emu->tam_reg) { + (*size) = tmp1-salida; + } else { + (*size) = tmp1-salida; + (*ancho) = tmp1-salida; + } + salida[*size-1] = '\0'; + return salida; }