Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

Trabajo Prctico Final de Informtica II TEXTO PREDICTIVO El programa simula el ingreso de texto predictivo de un telfono celular. Posee un entorno grfico compuesto por un dibujo de un telfono con un visor donde se muestran las palabras que el usuario va ingresando desde teclado. Sobre el rengln inferior de la pantalla se ubica una lnea de ayuda de comandos indicando que hace cada una de las posibles teclas a pulsar, que son los dgitos numricos, el asterisco, el numeral y Escape.. El operador tiene la posibilidad de elegir entre cuatro posibles modos de operacin (Predictivo, Numrico, Normal y Diccionario). La seleccin de estos posibles modos lo hace pulsando la tecla # (numeral). Si el usuario opta por ingresar palabras en modo predictivo, deber ir pulsando las teclas que contienen las letras de la palabra que desea ingresar. A medida que se vaya pulsando dichas teclas, se ir filtrando palabras, visualizndose en pantalla solo la que contenga una combinacin de letras ingresadas. Las posibles palabras a mostrar son todas aquellas que se encuentran cargadas en un diccionario. Si la palabra visualizada no es la que uno desea ingresar, el usuario tiene la opcin de ver todas las palabras posibles conformadas con la combinacin de letras ingresadas hasta el momento, oprimiendo la tecla * (asterisco). De esta manera se recorrer y mostrar de a una palabra por vez, un arreglo con todas las posibles palabras a ingresar. Para confirmar una palabra e ingresar un espacio, se deber pulsar la tecla 0 . En el caso de que no se encuentre en el diccionario la palabra que uno desea ingresar, el usuario puede cargarla en el mismo cambiando el modo de operacin a modo diccionario. De esta forma, en la lnea inferior del visor, se mostrar la palabra que uno ingresa. Automticamente el programa pasa a trabajar como modo de operacin normal, es decir que la palabra se la va ingresando pulsando cada tecla la cantidad de veces de acuerdo a la ubicacin de la letra deseada en la tecla. Una letra es aceptada ya sea porque se ingres una letra de otra tecla distinta o porque no se ingres ninguna letra durante los tres segundos siguientes luego del pulsado de la ultima letra ingresada. Una vez que se ingres la palabra que desebamos agregar al diccionario, debemos aceptarla pulsando 0 . El modo de operacin numrico lo que hace es permitir ingresar el nmero asociado a cada tecla. Como ventaja el programa posee la opcin de agregar una palabra al diccionario y adems permite el ingreso de nmeros. Al estar muy restringido el uso de las teclas, presenta la desventaja de no poder borrar la palabra ingresada en caso de pulsar una tecla no deseada. La tecla Escape se utiliza para cancelar una palabra en modo Diccionario o para salir del programa en los otros modos. El programa consiste en dos grandes reas: un rea lgica, donde se encuentran las estructuras de datos y bsqueda, y otra rea de interfaz en donde se desarrolla todo lo relacionado con la pantalla y comandos. Se crearon las siguientes estructuras de datos: Tecla: Contiene letras y la cantidad de las misma que hay en cada tecla.

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

Nodo de lista: Contiene dos apuntadores, uno al nodo siguiente de la lista y el otro a la palabra contenida en dicho nodo. Lista de palabras: Contiene un arreglo de bsqueda y apuntadores al inicio y fin del rango de bsqueda. Pgina: Contiene un arreglo dinmico de listas asociadas a una tecla. Cada lista contiene a su vez todas la palabras que comienzan con la misma letra. Se crearon tambin las siguientes constantes con el fin de simplificar y clarificar el cdigo del programa y hacer ms fcil la deteccin de errores dentro del mismo: const Tecla Teclado[10] : Es un arreglo constante con la descripcin de cada tecla. const char *nombreNodo[CANT_MODOS]: Es un arreglo constante con los nombres de los modos de operacin. const char *signo: Arreglo constante con los signos de puntuacin. Hay constantes para posicin y dimensin de elementos en Pantalla. Tambin hay constantes para coordenadas horizontales y verticales de cada tecla del teclado. El programa comienza cargando con palabras el archivo de diccionario, luego configura la pantalla y dibuja el telfono. Una vez hecho esto, se encuentra listo para comenzar a operar hasta que se pulse la tecla ESC haciendo que la funcin principal comience con el proceso de finalizacin del programa. En este proceso se libera la memoria ocupada por el diccionario y se reestablece la pantalla a su color original. La funcin pulsarTecla() es la responsable de recibir las entradas del operador, evaluarlas segn el carcter ingresado y el modo de operacin actual y llamar a las dems funciones que resuelven cada parte de la tarea. Funciona de un modo muy similar a una mquina de estados, ya que su comportamiento cambia segn cada situacin. Otra funcin que tambin es similar a una mquina de estados es escribirVisor(), que se ocupa de administrar la impresin de letras y palabras en el visor, as como los colores de texto y de fondo que se usan en cada modo de operacin. Cada una de estas funciones tiene una variable local esttica (modoOperacion) que recuerda y establece el modo de operacin actual. Se opt por usar dos variables locales estticas gemelas en lugar de una nica variable pblica porque estas dos funciones son las nicas que trabajan solidariamente segn el modo de operacin. Cdigo del programa texto predictivo: #include #include #include #include <stdio.h> <stdlib.h> <string.h> <dos.h>

Materia: Informtica II #include <conio.h> #define TAM_BUS 6 #define CANT_MODOS 4 /*********************************** Estructuras ***********************************/ typedef struct { char letra; char cant; } Tecla; typedef struct Nodo { char *pal; struct Nodo *sig; } Nodo; typedef struct { char bus [TAM_BUS]; Nodo *pri; Nodo *ini; Nodo *fin; } Lista; typedef struct { char tam; Lista *lis; } Pagina; /*********************************** Constantes ***********************************/ const char *nombreDic = "dic$.txt";

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

/* Arreglo constante con la descripcin de cada tecla */ const Tecla Teclado [10] = { /* Tecla */ { ' ', 0 }, /* 0 */ { '.', 1 }, /* 1 */ { 'a', 3 }, /* 2 */

Materia: Informtica II { { { { { { { 'd', 'g', 'j', 'm', 'p', 't', 'w', 3 3 3 3 4 3 4 }, }, }, }, }, }, }, /* /* /* /* /* /* /* 3 4 5 6 7 8 9 */ */ */ */ */ */ */

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

}; const char *nombreModo [CANT_MODOS] = { "Pred", "Num", "Norm", "Dicc" }; const char *Signo = "-:;!?,."; /* Constantes para posicin y dimensin de elementos en pantalla */ const char anchoTecla = 7; const char altoTecla = 2; const char yTelefono = 2; const char altoVisor = 7; const char anchoVisor = anchoTecla * 3 + 2; const char anchoTelefono = anchoVisor + 4; const char altoTelefono = altoVisor + altoTecla * 4 + 7; const char xTelefono = (80 - anchoTelefono) / 2 + 1; /* Coordenada horizontal de cada tecla */ const char xTecla [12] = { xTelefono + anchoTecla + 1 + 2, xTelefono + 2, xTelefono + anchoTecla + 1 + 2, xTelefono + (anchoTecla + 1) * 2 + 2, xTelefono + 2, xTelefono + anchoTecla + 1 + 2, xTelefono + (anchoTecla + 1) * 2 + 2, xTelefono + 2, xTelefono + anchoTecla + 1 + 2, xTelefono + (anchoTecla + 1) * 2 + 2, xTelefono + 2, xTelefono + (anchoTecla + 1) * 2 + 2 }; /* Coordenada vertical de cada tecla */ const char yTecla [12] = { yTelefono + altoVisor + (altoTecla + 1) * 3 + 2, yTelefono + altoVisor + 2,

Materia: Informtica II yTelefono yTelefono yTelefono yTelefono yTelefono yTelefono yTelefono yTelefono yTelefono yTelefono }; /*********************************** Macros ***********************************/ #define #define #define #define modoPredictivo modoNumerico modoNormal modoDiccionario 0 1 2 3 + + + + + + + + + + altoVisor altoVisor altoVisor altoVisor altoVisor altoVisor altoVisor altoVisor altoVisor altoVisor + + + + + + + + + + 2, 2, altoTecla + 1 + altoTecla + 1 + altoTecla + 1 + (altoTecla + 1) (altoTecla + 1) (altoTecla + 1) (altoTecla + 1) (altoTecla + 1)

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

2, 2, 2, * 2 * 2 * 2 * 3 * 3

+ + + + +

2, 2, 2, 2, 2

#define ventanaVisor window(xTelefono+2, \ yTelefono+2, \ xTelefono+anchoTelefono-3, \ yTelefono+altoVisor-1) #define #define #define #define #define #define #define #define #define esDigito(c) tieneLetra(c) esLetra(c) esEspacio(c) esAsterisco(c) esNumeral(c) esEscape(c) esComando(c) esValida(c) ((c)>='0'&&(c)<='9') ((c)>='2'&&(c)<='9') ((c)>='a'&&(c)<='z') ((c)==' ') ((c)=='*') ((c)=='#') ((c)==27) (esNumeral(c)||esAsterisco(c)) (esDigito(c)||esComando(c)||esEscape(c))

int esSigno (char c) { const char *p; for (p = Signo; *p && *p != c; p++); return *p; }

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

/*********************************** Funciones de manejo de listas de palabras ***********************************/ /* Crea un nuevo nodo de lista y le transfiere una palabra */ Nodo *nuevoNodo (const char *pal) { Nodo *nuevo; if (nuevo = (Nodo *) malloc (sizeof (Nodo))) if ((nuevo->pal = (char *) malloc (strlen (pal) + 1))) strlwr (strcpy (nuevo->pal, pal)); else { free (nuevo); return NULL; } return nuevo; } /*Agrega la palabra apuntada por pal a la lista apuntada por lis. Retorna 0 en caso de xito o 1 si no hay memoria dinamica. Si la palabra ya esta en la lista la ignora y retorna 0 */ int insertarNodo (Nodo **pri, const char *pal) Nodo *nuevo, *p; int dif; /* Si no hay primer nodo o la palabra a ingresar es menor que la primera */ if (!*pri || (dif = strcmp (pal, (*pri)->pal)) < 0) { if (!(nuevo = nuevoNodo (pal))) return 1; nuevo->sig = *pri; *pri = nuevo; return 0; }

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

if (dif) /* Si la primera palabra no { /* Hay que insertar en p = *pri; /* Mientras haya un insertar sea mayor */ while (p->sig && (dif p = p->sig;

esta repetida */ el interior de la lista */ siguiente de p y la palabra a

= strcmp (pal, p->sig->pal)) > 0)

if (dif) /* Si la palabra no esta repetida */ { if (!(nuevo = nuevoNodo (pal))) return 1; nuevo->sig = p->sig; p->sig = nuevo; } } return 0; } void crearPuntuacion (Nodo **pri) { char aux [2] = { 0, 0 }; const char *p; Nodo *nuevo; for (p = Signo, *pri = NULL; *p; *pri = nuevo, p++) { *aux = *p; nuevo = nuevoNodo (aux); nuevo->sig = *pri; } } void liberarLista (Nodo *pri) { Nodo *aux; while (pri) { free (pri->pal); aux = pri; pri = pri->sig; free (aux); }

Materia: Informtica II }

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

/*********************************** Funciones de manejo del diccionario ***********************************/ /*Crea e inicializa las listas de cada pagina del diccionario */ void crearDiccionario (Pagina *dic) { Pagina *pag; Lista *lis; int i, j; /* En la tecla 0 no hay listas */ dic->lis = NULL; /* En la tecla 1 hay una lista de signos de puntuacion */ pag = dic + 1; pag->tam = 1; pag->lis = (Lista *) malloc (sizeof (Lista)); crearPuntuacion (&pag->lis->pri); pag->lis->ini = pag->lis->pri; pag->lis->fin = NULL; /* Crea una pagina para cada una de las 8 teclas con letras */ for (pag = dic + 2, i = 2; i < 10; i++, pag++) { /* Cantidad de letras asociadas a la pagina */ j = pag->tam = Teclado [i].cant; /* Memoria para el vector de listas de palabras */ pag->lis = (Lista *) malloc (sizeof (Lista) * j); /* Inicializa cada lista de palabras */ for (lis = pag->lis; j--; lis++) lis->pri = lis->ini = lis->fin = NULL; } } void liberarDiccionario (Pagina *dic) { Pagina *p; int i, j; for (p = dic + 2, i = 2; i < 10; i++, p++) { j = Teclado [i].cant; while (j--) liberarLista (p->lis [j].pri); free (p->lis); } }

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

int agregarPalabra (Pagina *dic, char *pal) { char p; char dif; /*Calcula la diferencia entre la primera letra de la palabra a insertar y la 'a' y avanza por el teclado acortando la diferencia hasta que se hace menor que la cantidad de letras asociadas a una tecla */ for (dif = *pal - 'a', p = 2; dif >= Teclado [p].cant; dif -= Teclado [p++].cant); return insertarNodo (&dic [p].lis [dif].pri, pal); } int cargarDiccionario (Pagina *dic, const char *nomarch) { FILE *arch; char pal [80]; /* Intenta abrir el archivo para lectura de texto */ if (!(arch = fopen (nomarch, "rt"))) return 1; fscanf (arch, "%s", pal); /* Lee la primera palabra del archivo */ while (!feof (arch)) { /* Si la primera letra esta en el rango 'a' - 'z' */ if (esLetra(*pal)) if (agregarPalabra (dic, pal)) { fclose (arch); return 2; } fscanf (arch, "%s", pal); } fclose (arch); return 0; }

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

/*********************************** Funciones de entrada ***********************************/ char unaTecla () { char c; do c = getch (); while (!esValida (c)); return c; } /*Espera la pulsacion de una tecla valida durante 3 segundos. Si esta ocurre retorna el caracter ingresado, en caso contrario retorna 0 */ char unaTecla3Seg () { char c = 0; long t = time (NULL) + 3; do if (kbhit ()) { c = getch (); if (!esValida (c)) c = 0; } while (time (NULL) <= t && !c); return c; } char unaLetra (char *sig, int fondo) { char tecla, letra, tam; int x, y; int i = 0; if (*sig != 0) tecla = *sig; else tecla = unaTecla (); if (!tieneLetra (tecla)) return tecla; letra = Teclado [tecla - '0'].letra;

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

tam = Teclado [tecla - '0'].cant; textbackground (CYAN); /* Muestra las letras sobre fondo de busqueda */ x = wherex (); /* Registra la posicion actual del cursor */ y = wherey (); i = tam - 1; /* Inicializa i para conteo circular */ do /* Repite mientras no se demore o cambie de tecla */ { i = (i + 1) % tam; gotoxy (x, y); putch (letra + i); } while ((*sig = unaTecla3Seg ()) == tecla);

gotoxy (x, y); textbackground (fondo); /* Vuelve a mostrar la letra aceptada */ putch (letra + i); return letra + i; } char unaPalabra (char *pal, int tam, int fondo) { int i = tam - 1; char *p = pal; char c, s = 0; memset (pal, 0, tam); do { c = unaLetra (&s, fondo); if (!esLetra (c)) return c; } } *(p++) = c; while (--i && tieneLetra (s));

return s;

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

/*********************************** Funciones de dibujo en pantalla ***********************************/ void lineaTeclado (char izq, char sep, char der, char esp) { int i; putch (izq); for (i = anchoTecla; i--; putch (esp)); putch (sep); for (i = anchoTecla; i--; putch (esp)); putch (sep); for (i = anchoTecla; i--; putch (esp)); putch (der); } void dibujarMarco (int x0, int y0, int x1, int y1) { int i; gotoxy (x0, y0); putch (218); for (i = x0+1; i < x1; i++) putch (196); putch (191); for (i = y0+1; i < y1; i++) { gotoxy (x0, i); putch (179); } for (i = y0+1; i < y1; i++) { gotoxy (x1, i); putch (179); } gotoxy (x0, y1); putch (192); for (i = x0+1; i < x1; i++) putch (196); putch (217); }

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

void mostrarTecla (int tecla) { int i; window (xTecla [tecla], yTecla [tecla], xTecla [tecla] + anchoTecla - 1, yTecla [tecla] + altoTecla - 1); clrscr (); textcolor (DARKGRAY); if (tecla < 10) { gotoxy (anchoTecla / 2 + 1, 1); putch ('0' + tecla); textcolor (BLUE); if (tecla > 1) { gotoxy (5 - Teclado [tecla].cant, altoTecla); cprintf ("%c", Teclado [tecla].letra); for (i = 1; i < Teclado [tecla].cant; i++) cprintf (" %c", Teclado [tecla].letra i); } else if (tecla) { gotoxy (anchoTecla / 2 + 1, altoTecla); putch ('.'); } else { gotoxy (anchoTecla / 2, altoTecla); cprintf ("[ ]"); } textcolor (BLACK); } else if (tecla == 10) { gotoxy (anchoTecla / 2 + 1, 1); putch ('*'); } else { gotoxy (anchoTecla / 2 + 1, 1); putch ('#'); } }

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

/* Muestra el modo de operacion actual al pie del visor */ void mostrarModo (int mod) { textbackground (GREEN); textcolor (BLACK); gotoxy (1, altoVisor - 2); clreol (); gotoxy (anchoVisor - 3, altoVisor - 2); cprintf (nombreModo [mod]); } /*Escribe pal en la posicion actual del visor segun el modo de operacion m */ void escribirVisor (char *pal, int m) { static int modoOperacion = -1; /* Modo de operacion actual */ static int x = 1; /* Coordenadas estaticas de fin del */ static int y = 1; /* texto confirmado */ /* Variables estaticas usadas solamente en modo predictivo */ static int xu = 1; /* Coordenadas estaticas de principio */ static int yu = 1; /* de texto predictivo */ static char ult [anchoVisor]; /* Ultima palabra ingresada */ ventanaVisor; if (m != modoOperacion) mostrarModo (modoOperacion = m); switch (modoOperacion) { case modoDiccionario: textbackground (GREEN); textcolor (BLUE); gotoxy (1, altoVisor - 2); break; case modoNormal: case modoNumerico: textbackground (LIGHTGRAY); if (x + strlen (pal) >= anchoVisor) gotoxy (1, y + 1); else gotoxy (x, y); cprintf (pal); x = wherex (); visor */ y = wherey (); break; /* para la proxima entrada */ /* Escribe pal y confirma */ /* Actualiza la posicion en el

Materia: Informtica II case modoPredictivo: textbackground (LIGHTGRAY); textcolor (BLACK); gotoxy (xu, yu); clreol (); if (!pal) { *ult = 0; return; }

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

if (!esLetra (*pal) && !esSigno (*pal)) { gotoxy (xu, yu); cprintf (ult); /* Confirma ultima palabra ingresada */ xu = x = wherex (); yu = y = wherey (); *ult = 0; } if (esEspacio (*pal) || esDigito (*pal)) { cprintf (pal); xu = x = wherex (); yu = y = wherey (); } else { if (x + strlen (pal) > anchoVisor) { xu = 1; yu = y + 1; } else { xu = x; yu = y; } gotoxy (xu, yu); textbackground (CYAN); cprintf (pal); strcpy (ult, pal); } } }

la

Materia: Informtica II void dibujarTelefono () { int i, y, x; textcolor (BLACK); x = xTelefono + anchoTelefono;

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

for (y = yTelefono + altoTelefono - 1; y > yTelefono; y--) { gotoxy (x, y); putch (219); } gotoxy (x, y); putch (220); y = yTelefono + altoTelefono; while (x > xTelefono) { gotoxy (x--, y); putch (223); } x = xTelefono + 1; textbackground (LIGHTGRAY); textcolor (DARKGRAY); /* Borde del telefono */ dibujarMarco (xTelefono, yTelefono, xTelefono + anchoTelefono - 1, yTelefono + altoTelefono - 1); /* Borde del visor */ dibujarMarco (xTelefono + 1, yTelefono + 1, xTelefono + anchoTelefono - 2, yTelefono + altoVisor); /* Teclado */ y = yTelefono + altoVisor + 1; gotoxy (x, y++); lineaTeclado (218, 194, 191, 196); gotoxy (x, y++); for (i = altoTecla; i--; ) { lineaTeclado (179, 179, 179, 32); gotoxy (x, y++); } lineaTeclado (195, 197, 180, 196); gotoxy (x, y++); for (i = altoTecla; i--; ) { lineaTeclado (179, 179, 179, 32);

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

gotoxy (x, y++); } lineaTeclado (195, 197, 180, gotoxy (x, y++); for (i = altoTecla; i--; ) { lineaTeclado (179, 179, gotoxy (x, y++); } lineaTeclado (195, 197, 180, gotoxy (x, y++); for (i = altoTecla; i--; ) { lineaTeclado (179, 179, gotoxy (x, y++); } lineaTeclado (192, 193, 217, /* Teclas */ for (i = 0; i < 12; i++) mostrarTecla (i); /* Interior del visor */ ventanaVisor; clrscr (); /* El programa se inicia en modo predictivo */ escribirVisor (NULL, modoPredictivo); } void resaltarTecla (char tecla) { int num = esDigito (tecla)? tecla - '0': 10 + esNumeral (tecla); _setcursortype (_NOCURSOR); textbackground (GREEN); mostrarTecla (num); delay (50); /* Pausa de media decima de segundo para efecto destello */ textbackground (LIGHTGRAY); mostrarTecla (num); _setcursortype (_NORMALCURSOR); } 196);

179, 32); 196);

179, 32); 196);

Materia: Informtica II /*********************************** Funciones de evaluacion y busqueda ***********************************/

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

/*Establece los apuntadores inicial y final del rango de una lista segun la secuencia de numeros que van ingresando. lis apunta a la lista, num es el ultimo numero ingresado y tam es su numero de orden, a partir de 1. Retorna 1 si hay un rango definido en la lista o 0 en caso contrario */ int definirRango (Lista *lis, int num, int tam) { Nodo *n; if (tam > 1) { n = lis->ini; /* Amplia el arreglo de busqueda */ lis->bus [tam - 1] = Teclado [num].letra; while (n && memcmp (n->pal, lis->bus, tam) < 0) n = n->sig; lis->ini = n; lis->bus [tam - 1] += Teclado [num].cant; while (n && memcmp (n->pal, lis->bus, tam) < 0) n = n->sig; lis->fin = n; } else { } /* Si hay rango definido */ if (lis->ini != lis->fin) /* Deja en el arreglo de busqueda la letra */ { lis->bus [tam - 1] = lis->ini->pal [tam - 1]; return 1; } return 0; } /* Busca la siguiente palabra en el rango definido en la pagina apuntada por pag (que es el apuntador retornado por la ultima llamada a evaluarNumero). Si pag es NULL anula la pagina de busqueda y retorna NULL. /* la lista (que tiene la misma inicial) */ lis->ini = lis->pri; lis->fin = NULL;

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0 retorna un

Si pag no es NULL tiene un rango definido y apuntador a la siguiente palabra en el */ char *siguientePalabra (Pagina *pag) { static Pagina *act = NULL; static Nodo *nod; static char ind; char *pal; if (!pag) { act = NULL; return NULL; }

if (!act || pag != act) { act = pag; ind = 0; nod = act->lis [ind].ini; } /*Avanza a traves de los nodos de las listas de la pagina, que tiene al menos una lista con un rango definido (de lo contrario pag hubiera sido NULL)*/ while (!nod || nod == act->lis [ind].fin) { ind = (ind + 1) % act->tam; /* Avanza forma circular */ nod = act->lis [ind].ini; } pal = nod->pal; nod = nod->sig; return pal; } Pagina *evaluarNumero (Pagina *dic, int num) { static Pagina *act; static int tam = 0; Lista *lis; int i; int hayRango; /* Cancela la secuencia de busqueda anterior porque al ingresar un nuevo numero hay que volver a definir los rangos de busqueda */ /* Retorna la palabra hallada */

el

indice

en

Materia: Informtica II siguientePalabra (NULL); if (num < 2) tam = 0;

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

/* Si la tecla num no contiene letras */ /* Reinicia entrada predictiva */ /* Si num es 0 */ /* No hay pagina de busqueda */ /* Si tam es 0, es la primera entrada /* Establece la pagina actual */

if (!num) return act = NULL; if (!tam++) predictiva */ act = dic + num;

/* Reajusta el rango de cada lista */ for (hayRango = 0, lis = act->lis, i = act->tam; i--; lis++) hayRango |= definirRango (lis, num, tam); if (!hayRango) { tam = 0; act = NULL; } return act; } void guardarPalabra (char *pal) { FILE *arch; arch = fopen (nombreDic, "at"); fprintf (arch, "\n%s", pal); fclose (arch); } /*Permite la entrada desde el teclado y distribuye las acciones segn el caracter ingresado y el modo de operacin actual*/ char pulsarTecla (Pagina *dic) { static int modoOperacion = modoPredictivo; static Pagina *act; static char sig = 0; char pal [anchoVisor]; char ent; /* Caracter ingresado */ switch (modoOperacion) { case modoDiccionario: ent = unaPalabra (pal, anchoVisor, GREEN); while (!esEscape (ent) && !esNumeral (ent)) { agregarPalabra (dic, pal);

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

guardarPalabra (pal); mostrarModo (modoDiccionario); ent = unaPalabra (pal, anchoVisor, GREEN); } if (esEscape (ent)) ent = 0; break; case modoNormal: ent = unaLetra (&sig, LIGHTGRAY); if (ent == '0') escribirVisor (" ", modoOperacion); else if (!esEscape (ent) && !esNumeral (ent)) { sprintf (pal, "%c", ent); escribirVisor (pal, modoOperacion); } break; case modoNumerico: ent = unaTecla (); if (esDigito (ent)) { sprintf (pal, "%c", ent); escribirVisor (pal, modoOperacion); } break; case modoPredictivo: ent = unaTecla (); if (esDigito (ent)) { act = evaluarNumero (dic, ent - '0'); if (ent > '0') escribirVisor modoOperacion); else escribirVisor (" ", modoOperacion); } else if (esAsterisco (ent)) { escribirVisor (siguientePalabra (act), modoOperacion); } } if (esNumeral (ent)) { modoOperacion = (modoOperacion + 1) % CANT_MODOS; act = evaluarNumero (dic, 0); escribirVisor ("", modoOperacion); } (siguientePalabra (act),

Materia: Informtica II

Alumno: Sequeira Pedro Ignacio N Registro: 02-040239-0

return ent; } int main () { Pagina dic [10]; crearDiccionario (dic); cargarDiccionario (dic, nombreDic); /* Establece pantalla de texto color de 80 x 25 */ textmode (C80); /* Deshabilita el scroll de pantalla */ _wscroll = 0; /* Establece pantalla de fondo */ textbackground (BLUE); clrscr (); /* Escribe linea de ayuda de comandos */ textbackground (CYAN); gotoxy (1, 25); clreol (); textcolor (BLACK); cprintf (" <0-9> Texto %c <*> Elige %c <#> Modo %c <Esc> Salir ", 179, 179, 179); /* Dibuja el telefono */ textbackground (BLUE); dibujarTelefono (); /* Opera hasta que se pulsa Escape */ while (pulsarTecla (dic) != 27); /* Libera memoria */ liberarDiccionario (dic); /* Restablece pantalla */ textbackground (BLACK); textcolor (LIGHTGRAY); window (1, 1, 80, 25); _wscroll = 1; clrscr (); return 0; }