•☺Código Software y Más☻•

Cambio de la aplicación “Novia” a “Esposa”:

2010-09-04T10:57:00.000-07:00

El año pasado un amigo mío actualizó la NOVIA-6.0 a ESPOSA-1.0 y encontró que es una mala operación, porque deja muy escasos recursos del sistema para otras aplicaciones. Solamente ahora se ha dado cuenta de que ESPOSA-1.0 es también Procesadora-de-Niños, los cuales son adicionales consumidores de recursos valiosos.

No había mención de este particular fenómeno ni en la garantía ni en la documentación del producto, aunque otros usuarios le habían informado que esto sería de esperar debido a la naturaleza de la aplicación.

No solamente eso, sino que además se instala ella misma de forma que siempre se lanza en la inicialización del sistema, desde donde puede monitorizar todo el resto de la actividad del sistema. Se está encontrando con que algunas aplicaciones como TIEMPO-DE-POKER-10.3 JUERGA-DE-CERVEZA-2.5 y NOCHE-DE-BILLAR-7.0 no se pueden ejecutar nunca más, porque ESPOSA-1.0 detiene el sistema cuando son seleccionadas (incluso aunque siempre funcionaron bien antes).

En su instalación ESPOSA-1.0 agrega automáticamente aditamentos indeseados como SUEGRA- 55.8 y CUÑADO versión Demo. Como consecuencia, las funciones del sistema parecen disminuir con cada día que pasa.

Hay algunas caracterísiticas que serían deseables en la próxima versión de la aplicación (ESPOSA- 2.0), y son:
- Un par de botones grandes.
- Función de apagado.
- Control de volumen.
- Boton de minimizar
- Tener instalada una característica para que ESPOSA-2.0 pueda ser instalada con la opción de desinstalarla en cualquier momento sin la pérdida del caché y otros recursos del sistema.
- Una opción para correr el controlador de red en modo promiscuo que permita a los miembros del sistema probar las características del resto de ESPOSAS.*.

Yo he decidido evitar todos los dolores de cabeza asociados con ESPOSA-1.0 continuando con NOVIA-2.0. Incluso así, no obstante, he encontrado numerosos problemas. Aparéntemente no puedes instalar NOVIA-2.0 por encima de NOVIA-1.0. Debes desinstalar NOVIA-1.0 primero. Otros usuarios dicen que este es un virus de larga permanencia que debería vigilar. Aparentemente las versiones de NOVIA tiene conflictos para compartir el uso de la puerta de I/O (Entrada/Salida).

Para empeorar las cosas, el programa para desinstalar NOVIA-1.0 no funciona muy bien, dejando trazas indeseables de la aplicación en el sistema. Otro problema: todas las versiones de NOVIA.* lanzan continuos y molestos mensajes acerca de las ventajas de cambiar a ESPOSA-1.0.

* AVISO DE VIRUS: ESPOSA-1.0 tiene un virus no documentado. Si tratas de instalar AMANTE-1.1 antes de desinstalar ESPOSA-1.0, esta borrará los archivos de MS-Money antes de ejecutar una auto-desinstalación. Entonces AMANTE-1.1 rehusará instalarse, alengando insuficientes recursos del sistema.

* ANTIVIRUS: Para evitar el virus anterior, intenta instalar AMANTE-1.1 en un entorno diferente y nunca ejecutes una aplicación de transferencia de archivos como por ejemplo PINTURA-DE LABIOS-6.0. También evita similares aplicaciones de alquiler, porque se sabe que pueden transmitir virus que pueden afectar a ESPOSA-1.0. Otra solución podría ser correr AMANTE-1.1 vía proveedor de Internet bajo un nombre anónimo. De nuevo, evita los virus que pueden accidentalmente ser cargados desde la red.

* BUGs CONOCIDOS: Otra cosa repugnante en todas las versiones de Novia que existen es que están totalmente orientadas a objetos y sólo soportan hardware con contactos dorados (además de oro puro, nada de ‘goldfield’). También pudo comprobarse que los contactos son mejores cuantos más quilates poseen. Hay otro detalle, apuntado por técnicos especialistas de Microsoft, especialmente curioso: tras la instalación de Novia 1.0 se suele producir, transcurrido un breve espacio de tiempo y sin intervención externa, una reasignación de recursos desde el directorio local \MiDinero a un directorío compartido \NuestraCuenta\Vivienda sin que haya podido detectarse hasta la fecha la razón de dicho reajuste. Este fenómeno hace reducir sensiblemente la capacidad de respuesta del sistema.

* VERSION SHAREWARE: La versión shareware de NOVIA-6.0 es más fácil de desinstalar, hasta el extremo de que a veces se desinstala por sí misma sin motivo aparente. En estos casos una búsqueda en ordenadores de la misma red puede dar resultado, encontrando la aplicación instalada en uno o más ordenadores vecinos.

* RECOMENDACIONES ADICIONALES: Al elegir la versión de ESPOSA.* que se instalará, es conveniente comprobar antes que soporta el estandar PLUG&PLAY. También se recomienda configurar el hardware en modo master ANTES de proceder a la instalación. No es posible cambiar de modo slave a master si el programa se encuentra ya en el directorio principal.

Office - Seriales

2009-07-11T13:07:00.000-07:00

Claves para OFFICE

—————————————————————— ———————————

Microsoft Office Basic 2007 (preinstalados, ya deben tener la clave)
—————————————————————— ———————————

DGYC9-426Y3-DYGH2-3WC68-4Y6KQ
XHG6Q-DMJWD-97PYB-Y4CMG-MQ2CG

—————————————————————— ———————————

Microsoft Office Home and Student 2007

—————————————————————— ———————————

B4MKP-KP9YP-7TBQ4-7T4XF-MTGWY
TXF6Y-H24H8-H8YHX-46DY2-HCPCD
RBRT6-KV6YX-687MH-34HKG-97HR3
P7FXC-C4XJJ-6224W-6WMX3-J8VVB

—————————————————————— ———————————

Microsoft Office Standard 2007

—————————————————————— ———————————

CTKXX-M97FT-89PW2-DHKD3-74MYJ
KD3RD-TKY7Y-6QDP8-WXKX6-24BF3
B7MTR-PBJVD-47GWX-RJXTG-268PJ
JY46M-9BV6V-JJ2YH-JM6T8-2TR2D
QX8VX-QVF3W-MJ49F-6436K-PJ6WQ

—————————————————————— ———————————

Microsoft Office Small Business 2007

—————————————————————— ———————————

CKMPB-6B4QT-MG4C6-2VH4C-RDD43
HTPWX-FR6J8-2WBCQ-T63JR-3M8PD

—————————————————————— ———————————

Microsoft Office Professional 2007

—————————————————————— ———————————

RQ7XB-WB9TB-DYHMY-XGK9Y-4KWPD
WRWWX-G9MMD-X4B8X-7JQP3-CMD93
M2QKF-KDQ4R-YHQKD-M4YYK-GPWVD
KGFVY-7733B-8WCK9-KTG64-BC7D8
HGJH4-9W9FY-8C7B6-P2H6X-9DQ9T
R8JH9-Q3JDV-H7CFG-FVY8Y-P6R2D
TT3M8-H3469-V89G6-8FWK7-D3Q9Q

—————————————————————— ———————————

Microsoft Office Professional Plus 2007

—————————————————————— ———————————

V9MTG-3GX8P-D3Y4R-68BQ8-4Q8VD
DBXYD-TF477-46YM6-W74MH-6YDO8
CTKXX-M97FT-89PW2-DHKD3-74MYJ
RYC22-PRMXB-8HP8W-384PD-GXHX3
WHV8B-6FB6R-MY36T-2F8P7-VQQ9T
WFDWY-XQXJF-RHRYG-BG7RQ-BBDHM
TT3M8-H3469-V89G6-8FWK7-D3Q9Q
KT7WY-RHPHH-WWPT6-CX2H3-7HJ7W
XBGKY-8VY28-4C4J9-Y4MKC-RK87W
QBX6B-8MDWH-GYYFP-Y8KJQ-CFTHW
MTP6Q-D868F-448FG-B6MG7-3DBKT
KGFVY-7733B-8WCK9-KTG64-BC7D8
WRWWX-G9MMD-X4B8X-7JQP3-CMD93

—————————————————————— ———————————

Microsoft Office Enterprise 2007

—————————————————————— ———————————

KGFVY-7733B-8WCK9-KTG64-BC7D8
DBXYD-TF477-46YM4-W74MH-6YDQ8

—————————————————————— ———————————

Microsoft Office Ultimate 2007

—————————————————————— ———————————

J67F8-BB7GM-8VPH2-8YMXP-K49QQ
WRWWX-G9MMD-X4B8X-7JQP3-CMD93
RYC22-PRMXB-8HP8W-384PD-GXHX3
VM98J-C9X4C-MM7YX-93G64-BJMK3
VK626-MQWCC-FXXWY-W2H6F-KVKQQ
PGHBF-6K7PC-J9989-BGGJD-TKT3Q

Sockets en Java

2009-01-06T07:18:00.000-08:00

Los sockets son un sistema de comunicación entre procesos de diferentes máquinas de una red.

Es un punto de comunicación por el cual un proceso puede emitir o recibir información.

Fueron popularizados por Berckley Software Distribution, de la universidad norteamericana de Berkley.

Son capaces de utilizar el protocolo de streams TCP (Transfer Contro Protocol) y el de datagramas UDP (User Datagram Protocol).

Utilizan una serie de primitivas para establecer el punto de comunicación, para conectarse a una máquina remota en un determinado puerto que esté disponible, para escuchar en él, para leer o escribir y publicar información en él, y finalmente para desconectarse.

Con todas primitivas se puede crear un sistema de diálogo muy completo.

El Servidor

Abre el canal de comunicación.

Publica en la red la dirección del canal de comunicación.

Espera a recibir las solicitudes o peticiones, incluso, pues crear un proceso hijo.

Una vez que ya ha establecido la conexión, hace el envío y recepción de datos.

Finalmente cierra el canal de comunicación.

El Cliente

Abre el canal de comunicación.

Establece la conexión con el servidor.

Una vez hecha la conexión con el servidor hace el envío y recepción de datos o mensajes.

Finalmente cierra el canal de comunicacíón.

Java y Sockets

El paquete java.net de la plataforma Java proporciona una clase Socket, la cual implementa una de las partes de la comunicación bidireccional entre un programa Java y otro programa en la red.

La clase Socket se sitúa en la parte más alta de una implementación dependiente de la plataforma, ocultando los detalles de cualquier sistema particular al programa Java. Usando la clase java.net.Socket en lugar de utilizar código nativo de la plataforma, los programas Java pueden comunicarse a través de la red de una forma totalmente independiente de la plataforma.

De forma adicional, java.net incluye la clase ServerSocket, la cual implementa un socket el cual los servidores pueden utilizar para escuchar y aceptar peticiones de conexión de clientes.

Si se intenta conectar a través de la Web, la clase URL y clases relacionadas (URLConnection, URLEncoder) son probablemente más apropiadas que las clases de sockets. Pero de hecho, las clases URL no son más que una conexión a un nivel más alto a la Web y utlilizan como parte de su implementación interna los sockets.

Modelo de comunicaciones con Java

El servidor establece un puerto y espera durante un cierto tiempo (timeout segundos), a que el cliente establezca la conexión. Cuando el cliente solicite una conexión, el servidor abrirá la conexión socket con el método accept().

El cliente establece una conexión con la máquina host a través del puerto que se designe en puerto#

El cliente y el servidor se comunican con manejadores InputStream y OutputStream

Apertura de Sockets

Si estamos programando un CLIENTE, el socket se abre de la forma:

Socket miCliente;
try {
miCliente = new Socket( "maquina",numeroPuerto );
} catch( IOException e ) {
System.out.println( e );
}

Si estamos programando un SERVIDOR, el socket se abre de la forma:

Socket miServicio;
try {
miServicio = new ServerSocket( numeroPuerto );
} catch( IOException e ) {
System.out.println( e );
}

Fuente:

Linus Torvalds

2008-11-23T11:33:00.000-08:00

Sus padres tomaron su nombre de Linus Pauling. Comenzó sus andanzas informáticas a la edad de 11 años cuando su abuelo, un matemático y estadístico de la Universidad, compró uno de los primeros microordenadores Commodore en 1980 y le pidió ayuda para usarlo.

En 1988 Linus es admitido en la Universidad de Helsinki donde se gradúa con el grado de maestría en Ciencias de la Computación. Ese mismo año el profesor Andrew S. Tannenbaum saca a la luz el S.O. Minix con propósitos didácticos. Dos años después, en 1990, Torvalds empieza a aprender el lenguaje de programación C en su universidad.

A la edad de 21 años, con 5 años de experiencia programando (en C), ya conocía lo bastante del sistema operativo (S.O.) Minix como para tomarle algunas ideas prestadas y empezar un proyecto personal. Basándose en Design of the Unix Operating System, publicado por Maurice J. Bach en 1986, crearía una implementación que ejecutará cualquier tipo de programa, pero sobre una arquitectura de ordenadores compatibles, IBM/PC.

Este proyecto personal desembocó el 5 de octubre de 1991 con el anuncio de la primera versión de Linux capaz de ejecutar BASH (Bourne Again Shell) y el compilador conocido como GCC (GNU Compiler Collection).

En enero de 1992 se adoptó la Licencia Pública General (GPL) para Linux. Ésta añade libertades de uso a Linux totalmente opuestas a las del software privativo, permitiendo su modificación, redistribución, copia y uso ilimitado. Este modelo de licenciamiento facilita lo que es conocido como el modelo de desarrollo de bazar, que ha dado estabilidad y funcionalidad sin precedentes a éste.

En 1997 Linus Torvalds recibe los premios 1997 Nokia Foundation Award de Nokia y Lifetime Achievement Award at Uniforum Pictures. Ese mismo año finaliza los estudios superiores (198 - 1997) tras una década como estudiante e investigador en la Universidad de Helsinki, coordinando el desarrollo del núcleo del S.O. desde 1992.

Torvalds trabajó en Transmeta de febrero de 1997 a Junio de 2003 pero actualmente trabaja para el Open Source Development Labs en Beaverton, Oregón.

Solo el 2% del código del Linux actual está escrito por él, pero en su persona sigue descansando la paternidad de este núcleo del sistema operativo.

Torvalds posee la marca registrada "Linux" y supervisa el uso o en su defecto el abuso de la marca a través de la organización sin ánimo de lucro Linux International.

Fuente:

Free minix-like kernel sources for 386-AT, de Linus Benedict Torvalds (5 de octubre, 1991)

Linus Explains Linux Trademark Issues de CmdrTaco, Slashdot (en inglés)

Como nace Linux.

2008-11-23T11:25:00.000-08:00

¿Cómo creó Linus Torvalds a Linux?

En Finlandia, Linus Torvalds, entonces estudiante de informática de la universidad de Helsinki, decidió realizar la cuantiosa inversión de US$3500 de la época para adquirir un nuevo PC 386 (33 Mhz,4MB de RAM; una de las más avanzadas de su época). El pago lo realizaría a plazos pues no disponía de tal cantidad de dinero en efectivo.
Habituamente lo utilizaba para acceder a la red de su universidad, pero por desgracia no le gustaba nada el sistema operativo con el cual trabajaba, Minix, así que decidió crear uno él mismo. Como realmente le interesaba aprender el funcionamiento de su nuevo 386, decidió aprovechar esta oportunidad para realizar un programa a bajo nivel prescindiendo de este Minix.
En los primeros intentos consiguió arrancar el ordenador y ejecutar dos procesos que mostraban “AAAAABBBBB ”. Uno lo utilizaría para leer desde el módem y escribir en la pantalla, mientras que el otro leería desde el teclado y escribiría en el módem. Con el tiempo acabó el programa y lo utilizaba frecuentemente arrancando desde un disquete. La siguiente necesidad que tuvo fue la de poder descargar y subir archivos de su universidad, pero para implementar eso en su emulador era necesario crear un controlador de disco. Así que después de un trabajo continuo y duro creó un controlador compatible con el sistema de ficheros de Minix. En ese momento se percató que estaba creando algo más que un simple emulador de terminal, así que, descontento con su sistema Minix, emprendió la aventura de crear un sistema operativo partiendo de cero.
De forma privada, Linus nombraba “Linux” a su nuevo sistema, pero cuando decidió hacer una presentación pública (pues ya era capaz de mostrar una shell y ejecutar el compilador gcc) pensó que era demasiado egocéntrico llamarlo así y propuso llamarlo Freax. (aunque después se le siguió conociendo como linux). Después de anunciar en 25 Agosto de 1991 su intención de seguir desarrollando su sistema para construir un reemplazo de Minix, el 17 de septiembre de 1991 sube al servidor de FTP proporcionado por su universidad la versión 0.01 de Linux con 10.000 líneas de código (en la actualidad tiene más de 10 Millones). A partir de ese momento Linux empezó a evolucionar rápidamente.

Fuente:

Free minix-like kernel sources for 386-AT, de Linus Benedict Torvalds (5 de octubre, 1991)
Linus Explains Linux Trademark Issues de CmdrTaco, Slashdot (en inglés)

BECAS TELMEX

2008-10-20T14:54:00.000-07:00

Hola EMIR, como no sabia a que correo enviarte la información, así que te la puse aquí.

Para la consulta Formatos : No se si estos son los formatos reales, pero si es muy cierto que este toda esta información tendrías que presentar. Te dejo la liga para que bajes los archivos y veas todo lo que necesitas.

http://www.escom.ipn.mx/contenidos/telmex.jsp

Para mayor informe sobre beca telmex, revisa la pagina de la Fundación Telmex. También te dejo la liga para la cheques desde aquí.

http://www.fundaciontelmex.org/index.html

Por ahora es todo lo que tengo, pero aun sigo buscando un contacto directo. Te recomiendo revises constantemente esta pagina, porque aquí te pondré toda la informacion que te pueda servir, para esto, Espero poder seguirte ayudando..Besos..Bye

EMIR..Nuevo dato..

Entra a este sitio.

http://becanetsuperior.sep.gob.mx/

Se trata de una solicitud de beca que otorga el gobierno federal para alumnos de educación superior. Espero te pueda ayudar en algo.Como ya te habia explicado es un un unico apoyo de $9000.00 que no te caerian nada mal. En ese sitio podras ver los requisitos y alli mismo podras llenar la solicitud para que la mandes lo antes posible. La convocatoria se cierra el 25 de noviembre de 2008

Convertir documentos en diversos formatos

2008-10-03T09:34:00.000-07:00

Varias de las veces queremos convertir nuestro archivos en otros formatos, para quienes tenemos en nuestro equipo un convertidor pues la tarea realmente cómoda, pero el problema empieza cuando estamos en un ciber y queremos hacer esto.

Bueno pues la solución esta en la red, desde tu navegador entra a la siguiente página:

http://www.zamzar.com/

Al entrar a la página ubica la siguiente seccion (ver la siguiente imagen):

Desde allí, en botón Examinar que aparece en la sección Step 1, podemos seleccionar el archivo que queremos convertir. El archivo que queremos convertir, no debe superar los 100 MB.

En el menú desplegable que aparece en la seccion Step 2, podemos elegir a que formato lo queremos convertir.

En la sección Step 3 debemos escribir nuestro correo, que es a donde nos enviaran el archivo con el nuevo formato.

Finalmente, para completar el proceso de conversión hacer clic sobre el botón Convert que esta en la seccion Setp 4.

Telefonía celular.

2008-09-25T09:52:00.000-07:00

Para el envio gratuito e ilimitado de mensajes de texto a telefonos celulares de compañías como:

Movistar.

Iusacell.

Nextel.

Unefon.

Visita la siguiente página:

http://www.cxrex.com/index.aspx

En la página rellena los siguientes campos:

Número: "A quien le quieres enviar el mensaje"
Compañía: "Seleccionas la compañía a la que pertenece el número que escribiste en el campo anterior"
De: "Quien envia el mensaje, quieres que la otra persona responda a tu número y no lo tiene, pues en lugar de tu nombre puedes poner tu numero"
Mensaje: "Escribes el mensaje. Solo tienes 140 caracteres, pero no te preocupes, pues puedes enviar N mensajes."
Enviar el mensaje:
Notarás que en la página, enseguida de la imagen que te muestro aquí, aparecerá un botón que dice enviar, basta con presionarlo y tu mensaje será enviado. En breve tiempo te aparecerá un mensaje abajo, donde te indica el estado del envio.

Liberar NOKIA 3220b

2008-02-22T20:49:00.000-08:00

Para los que andan buscando como liberar su nokia..

les tengo la solucion. busqué solo unos minutos en la red y me encontré esto:

http://nfader.z-host.ru/

la verdad es muy efectivo me funciona casi en todos los telefonos nokia...Suerte

Conexion a una Base de datos MySQL

2008-02-15T17:10:00.000-08:00

$host="localhost";/*aqui se pone el host de red*/
$usuario="root";/*Usuario*/
$password="root";/*Contraseña del usuario*/
$conexion=mysql_connect($host,$usuario,$password); /*Se establece la conexion*/
mysql_select_db("base_datos",$conexion);/*Aqui se selecciona la base de datos*/
$result=mysql_query("SELECT * FROM tabla");/*Aqui hacemos la consulta a la tabla*/

/*Sacamos el contenido de la consulta en un arreglo*/
while($reg=mysql_fetch_array($result))
{
$dato1=$reg["campo1"];
$dato2=$reg["campo2"];
.
.
$daton=$reg["campoN"];
}

Clase Nodo

2007-09-12T09:51:00.000-07:00

Clase Lista

2007-09-12T09:50:00.000-07:00

/**
ESTE PROGRAMA ANALIZA UN ATRCHIVO DE TEXTO Y VERIFICA CUANTAS VECES SE REPITEN LAS PALABRAS ALMACENANDOLAS EN UNA LISTA SIMPLE, SE ALMACENA EL NUMERO DE VECES QUE SE REPITE LA PALABRA Y ENSEGUIDA LA PALABRA.

* Universidad del MAR, campus Puerto Esdondido

*Autor: Darwin Sosa Gómez.

* * */
public class Lista {
Nodo Inicio;
Nodo Final;

Lista(){
Inicio = Final=null;
}

boolean Vacio(){
return (Inicio==null);
}

void InsertarPrincipal(Object o,String palabra,int i){
if(Vacio()){
Inicio = new Nodo(palabra,i);
Final = Inicio;
}
else
Inicio = new Nodo(o,Inicio,palabra,i);
}

void imprimir(){

if(!Vacio()){
Nodo ElementosDeLista = Inicio;
System.out.println("REPETICIONES "+"\t"+" PALABRAS");
while(ElementosDeLista!=null){
System.out.println(" "+ElementosDeLista.VecesRepetidas+"\t\t\t"+ElementosDeLista.WORD);
ElementosDeLista=ElementosDeLista.siguiente;
}
System.out.print("Fin de Diccionario");
}
}

Object NumeroDePalabrasRepetidas(String PalabrasRepetidas){
Object X = null;
boolean Encontrado = false;
Nodo Siguiente = Inicio;

if(!Vacio()){
while(Siguiente!=null&&(!Encontrado)){
if(Siguiente.WORD.compareTo(PalabrasRepetidas)==0){
Siguiente.VecesRepetidas++;
Encontrado=true;
}
else
if(!Encontrado)
Siguiente = Siguiente.siguiente;
}
}
return (X);
}

boolean EsPalabraRepetida(String PalabrasRepetidas){
Nodo Siguiente = Inicio;
boolean Encontrado = false;
if(!Vacio()){
while(Siguiente!=null&&(!Encontrado)){
if(Siguiente.WORD.compareTo(PalabrasRepetidas)==0)
Encontrado=true;
else
if(!Encontrado)
Siguiente = Siguiente.siguiente;
}
}
return Encontrado;
}
}

Clase DiccionarioDePalabras

2007-09-12T09:45:00.002-07:00

/**
ESTE PROGRAMA ANALIZA UN ATRCHIVO DE TEXTO Y VERIFICA CUANTAS VECES SE REPITEN LAS PALABRAS ALMACENANDOLAS EN UNA LISTA SIMPLE, SE ALMACENA EL NUMERO DE VECES QUE SE REPITE LA PALABRA Y ENSEGUIDA LA PALABRA.

* Universidad del MAR, campus Puerto Esdondido

*Autor: Darwin Sosa Gómez.

* * */

import java.io.*;

public class DiccionarioDePalabras {
public static void main(String[] args) {
Lista Diccionario = new Lista();
String s1 = "", s, Auxiliar = "", palabras = "";
char Checar[] = { '.', ';', ',', ':', '(', ')', '[', ']', '{', '}',
'*', '"', '=', '!', '+', '-', '/', '\n', '\t', '\r', '\f', '¿',
'?', ' ' };
int contador = 0, i;
boolean bandera = true;

try {
BufferedReader entrada = new BufferedReader(new FileReader("cuenta.txt"));
while ((s = entrada.readLine()) != null) {
s = s + "\n";
while (s.charAt(contador) != '\n') {
bandera = false;
for (i = 0; i < Checar.length; i++) {
if (s.toString().charAt(contador) == Checar[i]) {
Auxiliar += " ";
bandera = true;
}
}
if (!bandera)
Auxiliar += s.toString().charAt(contador);
contador++;
}
if (s.charAt(contador) == '\n')
Auxiliar += ' ';
s1 += s;
contador = 0;
}/** CERRANDO WHILE*/

entrada.close();
contador = i = 0;
Auxiliar += "\n";
while (Auxiliar.charAt(i) != '\n') {
if (Auxiliar.toString().charAt(i) != ' ') {
palabras += Auxiliar.toString().charAt(i++);
}
else{
if (Auxiliar.toString().charAt(i) == ' ') {
while (Auxiliar.toString().charAt(i) == ' ')i++;
contador++;
if (!Diccionario.EsPalabraRepetida(palabras))
Diccionario.InsertarPrincipal(null, palabras, 1);
else
Diccionario.NumeroDePalabrasRepetidas(palabras);
palabras = "";
}
}/** CERRANDO ELSE*/
}/** CERRANDO WHILE*/

Diccionario.imprimir();/** Imprimiendo la Lista o el Diccionario de palabras encontradas*/
}
catch (IOException e) {System.out.print("Error al leer el archivo");}
}
}

Clase DiccionarioElementos

2007-09-12T09:45:00.001-07:00

/**
ESTE PROGRAMA CUENTA EL NUMERO DE PALABRAS QUE TIENE UN ARCHIVO DE TEXTO

Universidad del MAR, Campus Puerto Escondido.

Autor: Darwin Sosa Gómez
*/

public class DiccionarioElementos {
String token="";
int id=0;
public DiccionarioElementos(String token,int id) {
super();
this.token=token;
this.id=id;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getToken() {
return token;
}

public void setToken(String token) {
this.token = token;
}

}

Clase Diccionario

2007-09-12T09:44:00.001-07:00

/**
ESTE PROGRAMA CUENTA EL NUMERO DE PALABRAS QUE TIENE UN ARCHIVO DE TEXTO

Universidad del MAR, Campus Puerto Escondido.

Autor: Darwin Sosa Gómez
*/

import java.io.*;
import java.util.*;

public class Diccionario {
public static void main(String[] args) {
String s="",s1="";
char checar[]={'.','!',';',':','(',')','[',']','#','$','<','>','%','&','*','+','-','/','{','}','\n','=',',','\t','"'};
String checar2="";
int NUMERO_PALABRAS=0;
Vector diccionario=new Vector();
Vector diccionario1=new Vector();

try{
for(int x=0;x
BufferedReader entrada1=new BufferedReader(new FileReader("cuenta.txt"));
while((s=entrada1.readLine())!=null)
s1+=s;
entrada1.close();
System.out.println(s1);

StringTokenizer tokens=new StringTokenizer(s1);

//Separando por tokens

tokens=new StringTokenizer(s1);
while(tokens.hasMoreTokens()){
diccionario.addElement(tokens.nextToken(checar2));
NUMERO_PALABRAS++;
}

int repeticiones=1;
DiccionarioElementos d;

for(int i=0;i for(int j=0;j
if(diccionario.elementAt(i)==diccionario.elementAt(j)){
repeticiones++;
d =new DiccionarioElementos((String)(diccionario.elementAt(i)),repeticiones);
diccionario1.add(i,d);
}
else{
d =new DiccionarioElementos((String)(diccionario.elementAt(i)),repeticiones);
diccionario1.addElement(d);
}
}
}
System.out.println();

System.out.println("El archivo tiene: "+NUMERO_PALABRAS+" Palabras");
}
catch (IOException e)
{System.out.println("Fin del arreglo de Bytes");}
}

}

Clase ContarPalabras

2007-09-12T09:42:00.000-07:00

/**
ESTE PROGRAMA CUENTA EL NUMERO DE PALABRAS QUE TIENE UN ARCHIVO DE TEXTO

Universidad del MAR, Campus Puerto Escondido.

Autor: Darwin Sosa Gómez
*/

import java.io.*;
import java.util.*;

public class ContarPalabras {
public static void main(String[] args) {
String s = "", s1 = "",checar2 = "";;
char checar[] = { '.', ';', ',', ':', '(', ')', '[', ']', '{', '}',
'*', '"', '=', '!', '+', '-', '/', '\n', '\t', '\r', '\f', '¿',
'?', ' ' };

int NUMERO_PALABRAS = 0;
try {
for (int x = 0; x < checar.length; x++)
checar2 += checar[x];

BufferedReader entrada1 = new BufferedReader(new FileReader(
"cuenta.txt"));//Nombre del archivo a analizar.
while ((s = entrada1.readLine()) != null)
s1 += s;
entrada1.close();
System.out.println(s1);

StringTokenizer tokens = new StringTokenizer(s1);

tokens = new StringTokenizer(s1);
while (tokens.hasMoreTokens()) {
tokens.nextToken(checar2);
NUMERO_PALABRAS++;
}
System.out.println("El archivo tiene: " + NUMERO_PALABRAS
+ " Palabras");
} catch (IOException e) {
System.out.println("Fin del arreglo de Bytes");
}
}
}

Compresor De Archivos

2007-09-12T09:39:00.001-07:00

/*
ESTE PROGRAMA COMPRIME SOLO LOS ARCHIVOS QUE SE ENCUENTRAN EN UN DIRECTORIO DADO

Universidad del MAR, campus Puerto Escondido

Autor: Darwin Sosa Gómez
*/

import java.io.*;
import java.util.zip.*;
import javax.swing.JOptionPane;

public class CompresorDeArchivos {
public static boolean ChecaArchivos(String Archivo)
{
if(!Archivo.matches("[a-z]([0-9][a-z]_.)*"))
return(false);
else
return(true);
}

public static void main(String[] args) {
//Ingresando la ruta del archivo
File ruta = new File ("E:\\POO\\POO II\\Proyectos\\TareaCompresor\\");

String lista[]=ruta.list();

try{
FileOutputStream f = new FileOutputStream ("Carpeta Comprimida.zip");
ZipOutputStream salida = new ZipOutputStream (new BufferedOutputStream(f));

int c;
for(int i=0;i if(!ChecaArchivos(lista[i])){
BufferedReader entrada = new BufferedReader( new FileReader(lista[i]));
salida.putNextEntry(new ZipEntry (lista[i]));

while ((c=entrada.read())!= -1) {
salida.write(c);
entrada.close();
}
}
salida.close();
JOptionPane.showMessageDialog(null, "Los Archivos han sido comprimidos satisfactoriamente", "Exito en Operacion",JOptionPane.INFORMATION_MESSAGE);
}
catch(IOException e)
{
JOptionPane.showMessageDialog(null, "Error al Comprimir los Archivos", "Error en la Compresion",JOptionPane.ERROR_MESSAGE);
}
}
}

Clase Ventana

2007-09-12T09:35:00.000-07:00

/*

Universidad del MAR, campus Puerto Escondido

Autores:

*Eli Rafael Galguera Bautista.

*Darwin Sosa Gómez.

Proyecto: Simulador de supermercado.

*/
import java.awt.*;
import javax.swing.*;

public class Ventana extends JPanel {
Cuadros tienda;

Ventana() {
setSize(Configuracion.COLUMNAS * Configuracion.ANCHO_BTN,
Configuracion.FILAS * (Configuracion.ALTO_BTN + 8));
setVisible(true);
//setLayout(null);
agregarBotones();
}

private void agregarBotones() {
int numCuadros = Configuracion.FILAS * Configuracion.COLUMNAS;
tienda = new Cuadros(numCuadros);
for (int i = 0; i < numCuadros; i++) {
add(tienda.obtenerBoton(i));
}
}
}

Clase SuperMarket

2007-09-12T09:34:00.001-07:00

/*

Universidad del MAR, campus Puerto Escondido

Autores:

*Eli Rafael Galguera Bautista.

*Darwin Sosa Gómez.

Proyecto: Simulador de supermercado.

*/
import javax.swing.*;
import javax.swing.JButton;

import java.awt.event.*;
import java.awt.*;

public class SuperMarket extends JFrame implements ActionListener {
private JButton formarClientes, nuevoCliente, liberarTienda, cliente1,
cliente2, cliente3, cliente4, cliente5, cliente6, cliente7,
cliente8, cliente9, cliente10;

private JLabel etiqueta, caja;

private JPanel panel1, panel2;

private JPanel panel3;

private JTextField txtClientesTotales;

private int cliente = 0, j = 0, k = 0, l = 0, contador = 0;

private int arregloClientes[] = new int[Configuracion.HORA_DE_SALIDA + 1];

boolean salir = false;

Cuadros tienda;

Cola temp = new Cola();

private void agregarBotones() {
tienda = new Cuadros(Configuracion.MAX_CLIENTES);
for (int i = 0; i < Configuracion.MAX_CLIENTES; i++) {
panel3.add(tienda.obtenerBoton(i));
}
tienda.ocultarTodos();
}

public SuperMarket() {
super("Darel SuperMercado");
arregloClientes[0] = 0;
setSize(710, 600);
setResizable(false);
setLocationRelativeTo(null);
Container contenedor = getContentPane();
contenedor.setLayout(null);

panel2 = new JPanel();
panel2.setBounds(5, 450, 750, 120);
panel2.setLayout(null);
contenedor.add(panel2);

panel3 = new JPanel();
panel3.setBounds(20, 200, Configuracion.COLUMNAS
* Configuracion.ANCHO_BTN, Configuracion.FILAS
* (Configuracion.ALTO_BTN + 8));
panel3.setLayout(null);
agregarBotones();
contenedor.add(panel3);

panel1 = new JPanel();
panel1.setBounds(5, 50, 750, 100);
panel1.setLayout(null);
contenedor.add(panel1);

caja = new JLabel("CAJA");
caja.setIcon(new ImageIcon("caja.png"));
caja.setBounds(10, 5, 190, 50);
panel1.add(caja);

cliente1 = new JButton();
cliente1.setBounds(10, 50, 50, Configuracion.ALTO_BTN);
cliente1.setEnabled(false);
cliente1.setVisible(false);
panel1.add(cliente1);

cliente2 = new JButton();
cliente2.setBounds(70, 50, 50, Configuracion.ALTO_BTN);
cliente2.setEnabled(false);
cliente2.setVisible(false);
panel1.add(cliente2);

cliente3 = new JButton();
cliente3.setBounds(130, 50, 50, Configuracion.ALTO_BTN);
cliente3.setEnabled(false);
cliente3.setVisible(false);
panel1.add(cliente3);

cliente4 = new JButton();
cliente4.setBounds(190, 50, 50, Configuracion.ALTO_BTN);
cliente4.setEnabled(false);
cliente4.setVisible(false);
panel1.add(cliente4);

cliente5 = new JButton();
cliente5.setBounds(250, 50, 50, Configuracion.ALTO_BTN);
cliente5.setEnabled(false);
cliente5.setVisible(false);
panel1.add(cliente5);

cliente6 = new JButton();
cliente6.setBounds(310, 50, 50, Configuracion.ALTO_BTN);
cliente6.setEnabled(false);
cliente6.setVisible(false);
panel1.add(cliente6);

cliente7 = new JButton();
cliente7.setBounds(370, 50, 50, Configuracion.ALTO_BTN);
cliente7.setEnabled(false);
cliente7.setVisible(false);
panel1.add(cliente7);

cliente8 = new JButton();
cliente8.setBounds(430, 50, 50, Configuracion.ALTO_BTN);
cliente8.setEnabled(false);
cliente8.setVisible(false);
panel1.add(cliente8);

cliente9 = new JButton();
cliente9.setBounds(490, 50, 50, Configuracion.ALTO_BTN);
cliente9.setEnabled(false);
cliente9.setVisible(false);
panel1.add(cliente9);

cliente10 = new JButton();
cliente10.setBounds(550, 50, 50, Configuracion.ALTO_BTN);
cliente10.setEnabled(false);
cliente10.setVisible(false);
panel1.add(cliente10);

etiqueta = new JLabel("Total de Clientes");
etiqueta.setBounds(50, 10, 150, 25);
panel2.add(etiqueta);

txtClientesTotales = new JTextField(10);
txtClientesTotales.setBounds(150, 10, 50, 25);
txtClientesTotales.setEnabled(false);
panel2.add(txtClientesTotales);

nuevoCliente = new JButton("Agregar Cliente",
new ImageIcon("nuevo.png"));
nuevoCliente.setToolTipText("Agrega un Nuevo Cliente al SuperMercado");
nuevoCliente.setBounds(10, 40, 190, 50);
nuevoCliente.addActionListener(this);
panel2.add(nuevoCliente);

formarClientes = new JButton("Formar Clientes", new ImageIcon(
"formar.png"));
formarClientes
.setToolTipText("Forma los Clientes que estan en el SuperMercado");
formarClientes.setBounds(255, 40, 190, 50);
formarClientes.setEnabled(false);
formarClientes.addActionListener(this);
panel2.add(formarClientes);

liberarTienda = new JButton("Liberar Clientes", new ImageIcon(
"liberar.png"));
liberarTienda.setToolTipText("Saca los clientes de la caja");
liberarTienda.setBounds(480, 40, 190, 50);
liberarTienda.setEnabled(false);
liberarTienda.addActionListener(this);
panel2.add(liberarTienda);

setVisible(true);
}

public void actionPerformed(ActionEvent e) {

if (e.getSource().equals(nuevoCliente)) {
int num = 1;
if (temp.buscar(num)) {
num = temp.autogenerar();
}
temp.Insertar(new Integer(num), tienda.meterCliente(num));
cliente++;

txtClientesTotales.setText(String.valueOf(cliente));

arregloClientes[j++] = num;
formarClientes.setEnabled(true);
liberarTienda.setEnabled(false);
if (cliente == Configuracion.MAX_CLIENTES) {
JOptionPane.showMessageDialog(null,
"El SuperMercado ha llegado a su limite de Clientes",
"Super Mercado Lleno", JOptionPane.WARNING_MESSAGE);
nuevoCliente.setEnabled(false);
}
if (j > Configuracion.HORA_DE_SALIDA) {
JOptionPane
.showMessageDialog(
null,
"Es hora de Cerrar la Tienda, Libere todos los clientes",
"Fin de Operaciones", JOptionPane.ERROR_MESSAGE);
nuevoCliente.setEnabled(false);
salir = true;
}
}
if (e.getSource().equals(formarClientes)) {
for (int i = 0; i < Integer.parseInt(txtClientesTotales.getText()); i++) {
if (k == 0) {
cliente1.setVisible(true);
cliente1.setText(String.valueOf(arregloClientes[l++]));
contador++;
}
if (k == 1) {
cliente2.setVisible(true);
cliente2.setText(String.valueOf(arregloClientes[l++]));
contador++;
}
if (k == 2) {
cliente3.setVisible(true);
cliente3.setText(String.valueOf(arregloClientes[l++]));
contador++;
}
if (k == 3) {
cliente4.setVisible(true);
cliente4.setText(String.valueOf(arregloClientes[l++]));
contador++;
}
if (k == 4) {
cliente5.setVisible(true);
cliente5.setText(String.valueOf(arregloClientes[l++]));
contador++;
}
if (k == 5) {
cliente6.setVisible(true);
cliente6.setText(String.valueOf(arregloClientes[l++]));
contador++;
}
if (k == 6) {
cliente7.setVisible(true);
cliente7.setText(String.valueOf(arregloClientes[l++]));
contador++;
}
if (k == 7) {
cliente8.setVisible(true);
cliente8.setText(String.valueOf(arregloClientes[l++]));
contador++;
}
if (k == 8) {
cliente9.setVisible(true);
cliente9.setText(String.valueOf(arregloClientes[l++]));
contador++;
}
if (k == 9) {
cliente10.setVisible(true);
cliente10.setText(String.valueOf(arregloClientes[l++]));
contador++;
}

formarClientes.setEnabled(false);
if (!salir)
nuevoCliente.setEnabled(false);
liberarTienda.setEnabled(true);

if (k == Configuracion.MAX_COLA) {
k = 0;
break;
} else
k++;
}

Nodo nodoTemp = temp.Inicio;
for (int i = 0; i < contador; i++) {
tienda.ocultar(nodoTemp.indice);
nodoTemp = nodoTemp.siguiente;
}

}
if (e.getSource().equals(liberarTienda)) {
cliente = Integer.parseInt(txtClientesTotales.getText()) - contador;
txtClientesTotales.setText(String.valueOf(Integer
.parseInt(txtClientesTotales.getText())
- contador));
k = 0;
if (!temp.Vacio()) {
for (int i = 0; i < contador; i++) {
temp.EliminarPrincipio();
}
cliente1.setVisible(false);
cliente2.setVisible(false);
cliente3.setVisible(false);
cliente4.setVisible(false);
cliente5.setVisible(false);
cliente6.setVisible(false);
cliente7.setVisible(false);
cliente8.setVisible(false);
cliente9.setVisible(false);
cliente10.setVisible(false);
}
liberarTienda.setEnabled(false);
if (!salir)
nuevoCliente.setEnabled(true);
if (Integer.parseInt(txtClientesTotales.getText()) == 0)
formarClientes.setEnabled(false);
else
formarClientes.setEnabled(true);
contador = 0;
}
}
}

Clase Nodo

2007-09-12T09:33:00.002-07:00

/*

Universidad del MAR, campus Puerto Escondido

Autores:

*Eli Rafael Galguera Bautista.

*Darwin Sosa Gómez.

Proyecto: Simulador de supermercado.

*/
public class Nodo {
Object Datos;
int indice;
Nodo siguiente;

Nodo(Object o, int index) {
Datos = o;
indice = index;
siguiente = null;
}

Object getDatos() {
return Datos;
}

Object getSiguiente() {
return siguiente;
}
}

Clase Lista

2007-09-12T09:33:00.001-07:00

/*

Universidad del MAR, campus Puerto Escondido

Autores:

*Eli Rafael Galguera Bautista.

*Darwin Sosa Gómez.

Proyecto: Simulador de supermercado.

*/
public class Lista {
Nodo Inicio;

Nodo Final;

Lista() {
Inicio = Final = null;
}

boolean Vacio() {
return (Inicio == null);
}

void InsertarFinal(Object o, int indice) {
if (Vacio()) {
Inicio = new Nodo(o, indice);
Final = Inicio;
} else {
Nodo T = Final;
Final = new Nodo(o, indice);
T.siguiente = Final;
}
}

void ImprimirPila() {
if (Vacio())
System.out.print("La Pila está vacia...");
else {
Nodo ElementoLista = Inicio;
while (ElementoLista != null) {
System.out.println(ElementoLista.Datos.toString());
ElementoLista = ElementoLista.siguiente;
}
}
}

Object EliminarPrincipio() {
Object T = null;
if (Vacio())
System.out.print("La Pila esta vacia, no se puede eliminar");
else {
T = Inicio.Datos;
if (Inicio == Final)
Inicio = Final = null;
else
Inicio = Inicio.siguiente;
}
return T;
}

public boolean busqueda(int numero) {
Nodo R = Inicio;
boolean bEncontrado = false;
if (R == null) {
return bEncontrado;
}
do {
if (Integer.parseInt(R.Datos.toString()) == numero)
bEncontrado = true;
else
R = R.siguiente;
} while (R != null && !bEncontrado);
return bEncontrado;
}
}

Clase Cuadros

2007-09-12T09:32:00.002-07:00

/*

Universidad del MAR, campus Puerto Escondido

Autores:

*Eli Rafael Galguera Bautista.

*Darwin Sosa Gómez.

Proyecto: Simulador de supermercado.

*/
import java.util.*;
import javax.swing.*;

public class Cuadros {
private Vector botones;

Cuadros(int num) {
botones = new Vector();
int contColumna, contFila;
contColumna = contFila = 0;
for (int i = 0; i < num; i++) {
botones.add(new JButton(String
.valueOf(Configuracion.MAX_CLIENTES + 1)));
obtenerBoton(i).setSize(Configuracion.ANCHO_BTN,
Configuracion.ALTO_BTN);
obtenerBoton(i).setLocation(Configuracion.ANCHO_BTN * contColumna,
Configuracion.ALTO_BTN * contFila);
obtenerBoton(i).setEnabled(false);
if (contColumna + 1 == Configuracion.COLUMNAS) {
contColumna = 0;
contFila++;
} else
contColumna++;
}
}

public void ocultar(int indice) {
obtenerBoton(indice).setVisible(false);
obtenerBoton(indice).setText(null);
}

private void mostrar(int indice, int numCliente) {
obtenerBoton(indice).setVisible(true);
obtenerBoton(indice).setText(String.valueOf(numCliente));
}

public void ocultarTodos() {
for (int i = 0; i < getSize(); i++) {
obtenerBoton(i).setVisible(false);
obtenerBoton(i).setText(null);
}

}

public boolean vacio(int indice) {
if (obtenerBoton(indice).isVisible())
return false;
else
return true;
}

public int getSize() {
return botones.size();
}

public JButton obtenerBoton(int indice) {
return (JButton) botones.elementAt(indice);
}

public int meterCliente(int numCliente) {
int n;
boolean salir = false;
do {
n = (int) (Math.random() * Configuracion.MAX_CLIENTES);
if (vacio(n))
salir = true;
} while (!salir);
mostrar(n, numCliente);
return n;
}
}

Claso Configuracion

2007-09-12T09:32:00.001-07:00

/*

Universidad del MAR, campus Puerto Escondido

Autores:

*Eli Rafael Galguera Bautista.

*Darwin Sosa Gómez.

Proyecto: Simulador de supermercado.

*/
public class Configuracion {
static final int ANCHO_BTN = 65;
static final int ALTO_BTN = 50;
static final int COLUMNAS = 10;
static final int FILAS = 4;
static final int MAX_CLIENTES = COLUMNAS * FILAS;
static final int MAX_COLA = MAX_CLIENTES;
static final int HORA_DE_SALIDA = 10000;
}

Clase Cola

2007-09-12T09:31:00.000-07:00

/*

Universidad del MAR, campus Puerto Escondido

Autores:

*Eli Rafael Galguera Bautista.

*Darwin Sosa Gómez.

Proyecto: Simulador de supermercado.

*/
public class Cola extends Lista {
Cola() {
super();
}

void Insertar(Object o, int indice) {
InsertarFinal(o, indice);
}

boolean buscar(int n) {
return busqueda(n);
}

public int autogenerar() {
int n = 2;
boolean salir = false;
do {
if (buscar(n)) {
n++;
if (n == Configuracion.MAX_CLIENTES + 1)
n = 1;
} else {
salir = true;
}
} while (!salir);
return n;
}

Object Eliminar(Object o) {
return EliminarPrincipio();
}

void imprimir() {
super.ImprimirPila();
}

boolean Vacio() {
return (super.Vacio());
}
}

Clase Aplicacion

2007-09-12T09:27:00.000-07:00

/*

Universidad del MAR, campus Puerto Escondido

Autores:

*Eli Rafael Galguera Bautista.

*Darwin Sosa Gómez.

Proyecto: Simulador de supermercado.

*/
import javax.swing.JFrame;
import javax.swing.*;

public class Aplicacion {
public static void main(String[] args) {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception e) {
}
SuperMarket superMercado = new SuperMarket();
superMercado.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

Clase Ventana

2007-09-12T09:03:00.001-07:00

/*
UNIVERSIDAD DEL MAR

PROYECTO: CREAR UN SISTEMA QUE REPRODUZCA UNA MELODIA (USANDO LAS NOTAS BASICAS)
CREADA POR EL USUARIO.
AUTORES:

* Eli rafael Galguera Bautista
* Darwin Sosa Gómez
*/

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.table.*;
import javax.swing.event.*;
import javax.sound.midi.*;
import java.util.Vector;
import java.io.File;
import java.io.IOException;

public class VentanaSonido extends JFrame implements ActionListener{
final int PROGRAM = 192;
final int NOTEON = 144;
final int NOTEOFF = 128;
final int SUSTAIN = 64;
final int REVERB = 91;
final int numNotas = 7;
final int numPosiciones = 20;
final int ON = 0, OFF = 1;
final Color jfcBlue = new Color(204, 204, 255);
final Color pink = new Color(255, 175, 175);
Sequencer sequencer;
Sequence sequence;
Synthesizer synthesizer;
Instrument instruments[];
ChannelData channels[];
ChannelData channelData;
Vector keys = new Vector();
Vector whiteKeys = new Vector();
JTable table;
boolean record;
int xPos;
Track track;
long startTime;
RecordFrame recordFrame;
JButton btnDo, btnRe, btnMi, btnFa, btnSol, btnLa, btnSi, recordB ;

JButton btnAnt, btnSig,btnFin, btnInicio, btnBorrar, btnStop, btnPlay, btnRec;
JButton btnPointer;
JPanel panelNotas;
Cuadros cuadros;
Container contenedor;
public VentanaSonido() {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception e) {
}
super.setTitle("Sistema de archivos Midi");
pack();
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
int w = 530;
int h = 270;
setLocation(screenSize.width/2 - w/2, screenSize.height/2 - h/2);
setSize(w, h);
setResizable(false);

contenedor = getContentPane();
contenedor.setLayout(new BorderLayout());

xPos = 0;

recordB = createButton("Record...");
btnRec = createButton("Grabar");
btnDo = createButton("Do");
btnRe = createButton("Re");
btnMi = createButton("Mi");
btnFa = createButton("Fa");
btnSol = createButton("Sol");
btnLa = createButton("La");
btnSi = createButton("Si");
btnAnt=createButton("<<");
btnSig=createButton(">>");
btnFin=createButton(">|");
btnInicio=createButton("|<");
btnBorrar=createButton("X");
btnStop=createButton("O");
btnPlay=createButton(">");
btnPointer = new JButton();
btnPointer.setIcon(new ImageIcon("icono.png"));
btnPointer.setSize(20,20);
btnPointer.setLocation(0,145);

JPanel p1 = new JPanel(new GridLayout(2,8));
p1.add(btnInicio);
p1.add(btnAnt);
p1.add(btnStop);
p1.add(btnBorrar);
p1.add(btnPlay);
p1.add(btnSig);
p1.add(btnFin);
p1.add(recordB);
p1.add(btnSi);
p1.add(btnLa);
p1.add(btnSol);
p1.add(btnFa);
p1.add(btnMi);
p1.add(btnRe);
p1.add(btnDo);

cuadros = new Cuadros(182);
panelNotas=new JPanel(null);
for (int i=0; i<182; i++)
panelNotas.add(cuadros.obtenerBoton(i));
panelNotas.add(btnPointer);
contenedor.add(panelNotas,BorderLayout.CENTER);
contenedor.add(p1,BorderLayout.SOUTH);
setVisible(true);

btnSig.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
btnPointer.setLocation(xPos*20,145);
xPos++;
if(xPos==Configuracion.COLUMNAS){
btnSig.setEnabled(false);
habilitarNotas(false);
}
}
});

}

public void habilitarNotas(boolean habilitar){
btnDo.setEnabled(habilitar);
btnRe.setEnabled(habilitar);
btnMi.setEnabled(habilitar);
btnFa.setEnabled(habilitar);
btnSol.setEnabled(habilitar);
btnLa.setEnabled(habilitar);
btnSi.setEnabled(habilitar);
}

public void actionPerformed(ActionEvent e) {

if(e.getSource().equals(btnDo)){
channelData.channel.noteOn(Notas.DO, channelData.velocity);
if (record) {
creaEventoCorto(NOTEON, Notas.DO);
}
cuadros.mostrar(xPos,Notas._do);
btnSig.doClick();

} else if (e.getSource().equals(btnRe)){
channelData.channel.noteOn(Notas.RE, channelData.velocity);
if (record) {
creaEventoCorto(NOTEON, Notas.RE);
}
cuadros.mostrar(xPos,Notas._re);
btnSig.doClick();
}else if (e.getSource().equals(btnMi)){
channelData.channel.noteOn(Notas.MI, channelData.velocity);
if (record) {
creaEventoCorto(NOTEON, Notas.MI);
}
cuadros.mostrar(xPos,Notas._mi);
btnSig.doClick();
}else if (e.getSource().equals(btnFa)){
channelData.channel.noteOn(Notas.FA, channelData.velocity);
if (record) {
creaEventoCorto(NOTEON, Notas.FA);
}
cuadros.mostrar(xPos,Notas._fa);
btnSig.doClick();
}else if (e.getSource().equals(btnSol)){
channelData.channel.noteOn(Notas.SOL, channelData.velocity);
if (record) {
creaEventoCorto(NOTEON, Notas.SOL);
}
cuadros.mostrar(xPos,Notas._sol);
btnSig.doClick();
}else if (e.getSource().equals(btnLa)){
channelData.channel.noteOn(Notas.LA, channelData.velocity);
if (record) {
creaEventoCorto(NOTEON, Notas.LA);
}
cuadros.mostrar(xPos,Notas._la);
btnSig.doClick();
}else if (e.getSource().equals(btnSi)){
channelData.channel.noteOn(Notas.SI, channelData.velocity);
if (record) {
creaEventoCorto(NOTEON, Notas.SI);
}
cuadros.mostrar(xPos,Notas._si);
btnSig.doClick();
}

JButton button = (JButton) e.getSource();
if (button.getText().startsWith("Record")) {
if (recordFrame != null) {
recordFrame.toFront();
} else {
recordFrame = new RecordFrame();
}
}
}
public JButton createButton(String name) {
JButton b = new JButton(name);
b.addActionListener(this);
contenedor.add(b);
return b;
}
public void open() {
try {
if (synthesizer == null) {
if ((synthesizer = MidiSystem.getSynthesizer()) == null) {
System.out.println("getSynthesizer() failed!");
return;
}
}
synthesizer.open();
sequencer = MidiSystem.getSequencer();
sequence = new Sequence(Sequence.PPQ, 10);
} catch (Exception ex) { ex.printStackTrace(); return; }

Soundbank sb = synthesizer.getDefaultSoundbank();
if (sb != null) {
instruments = synthesizer.getDefaultSoundbank().getInstruments();
synthesizer.loadInstrument(instruments[0]);
}
MidiChannel midiChannels[] = synthesizer.getChannels();
channels = new ChannelData[midiChannels.length];
for (int i = 0; i < channels.length; i++) {
channels[i] = new ChannelData(midiChannels[i], i);
}
channelData = channels[0];
}

public void close() {
if (synthesizer != null) {
synthesizer.close();
}
if (sequencer != null) {
sequencer.close();
}
sequencer = null;
synthesizer = null;
instruments = null;
channels = null;
if (recordFrame != null) {
recordFrame.dispose();
recordFrame = null;
}
}

public void creaEventoCorto(int type, int num) {
ShortMessage mensajeCorto = new ShortMessage();
try {
long millis = System.currentTimeMillis() - startTime;
long tick = millis * sequence.getResolution() / 500;
mensajeCorto.setMessage(type+channelData.num, num, channelData.velocity);
MidiEvent event = new MidiEvent(mensajeCorto, tick);
track.add(event);
} catch (Exception ex) { ex.printStackTrace(); }
}

/*************************************************************************************************/
class ChannelData {

MidiChannel channel;
boolean solo, mono, mute, sustain;
int velocity = 127;
int pressure = 127;
int bend = 16383;
int reverb = 127;
int row, col, num;

public ChannelData(MidiChannel channel, int num) {
this.channel = channel;
this.num = num;
}

public void setComponentStates() {
table.setRowSelectionInterval(row, row);
table.setColumnSelectionInterval(col, col);
}
}

class RecordFrame extends JFrame implements ActionListener, MetaEventListener {
public JButton recB, playB, saveB;
Vector tracks = new Vector();
DefaultListModel listModel = new DefaultListModel();
TableModel dataModel;

public RecordFrame() {
super("Grabando Archivo Midi");
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {recordFrame = null;}
});

sequencer.addMetaEventListener(this);
try {
sequence = new Sequence(Sequence.PPQ, 10);
} catch (Exception ex) { ex.printStackTrace(); }

JPanel p1 = new JPanel(new BorderLayout());

JPanel p2 = new JPanel();
p2.setBorder(new EmptyBorder(5,5,5,5));
p2.setLayout(new BoxLayout(p2, BoxLayout.X_AXIS));

recB = createButton("Record", p2, true);
playB = createButton("Play", p2, false);
saveB = createButton("Save...", p2, false);
getContentPane().add("North", p2);

pack();
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
int w = 220;
int h = 80;
setLocation(d.width/2 - w/2, d.height/2 - h/2);
setSize(w, h);
setResizable(false);
setVisible(true);
}

public JButton createButton(String name, JPanel p, boolean state) {
JButton b = new JButton(name);
b.setFont(new Font("serif", Font.PLAIN, 10));
b.setEnabled(state);
b.addActionListener(this);
p.add(b);
return b;
}

public void actionPerformed(ActionEvent e) {
JButton button = (JButton) e.getSource();
if (button.equals(recB)) {
record = recB.getText().startsWith("Record");
if (record) {
track = sequence.createTrack();
startTime = System.currentTimeMillis();
creaEventoCorto(PROGRAM,channelData.col*8+channelData.row);

recB.setText("Stop");
playB.setEnabled(false);
saveB.setEnabled(false);
} else {
String name = null;
if (instruments != null) {
name = instruments[channelData.col*8+channelData.row].getName();
} else {
name = Integer.toString(channelData.col*8+channelData.row);
}
tracks.add(new TrackData(channelData.num+1, name, track));
recB.setText("Record");
playB.setEnabled(true);
saveB.setEnabled(true);
}
} else if (button.equals(playB)) {
if (playB.getText().startsWith("Play")) {
try {
sequencer.open();
sequencer.setSequence(sequence);
} catch (Exception ex) { ex.printStackTrace(); }
sequencer.start();
playB.setText("Stop");
recB.setEnabled(false);
} else {
sequencer.stop();
playB.setText("Play");
recB.setEnabled(true);
}
} else if (button.equals(saveB)) {
try {
File file = new File(System.getProperty("user.dir"));
JFileChooser fc = new JFileChooser(file);
fc.setFileFilter(new javax.swing.filechooser.FileFilter() {
public boolean accept(File f) {
if (f.isDirectory()) {
return true;
}
return false;
}
public String getDescription() {
return "Guardar como archivo .mid";
}
});
if (fc.showSaveDialog(null) == JFileChooser.APPROVE_OPTION) {
saveMidiFile(fc.getSelectedFile());
}
} catch (SecurityException ex) {
ex.printStackTrace();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
public void meta(MetaMessage message) {
if (message.getType() == 47) {
playB.setText("Play");
recB.setEnabled(true);
}
}

public void saveMidiFile(File file) {
try {
int[] fileTypes = MidiSystem.getMidiFileTypes(sequence);
if (fileTypes.length == 0) {
System.out.println("No se puede guardar la secuencia");
} else {
if (MidiSystem.write(sequence, fileTypes[0], file) == -1) {
throw new IOException("Error: No se puede guardar el archivo");
}
}
} catch (SecurityException ex) {
} catch (Exception ex) {
ex.printStackTrace();
}
}

class TrackData extends Object {
Integer chanNum; String name; Track track;
public TrackData(int chanNum, String name, Track track) {
this.chanNum = new Integer(chanNum);
this.name = name;
this.track = track;
}
}
}
/***********************************************************************************/

public static void main(String args[]) {
VentanaSonido ventana = new VentanaSonido();
ventana.open();
ventana.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {

System.exit(0);}
});
}
}

Clase Notas

2007-09-12T09:01:00.000-07:00

/*
UNIVERSIDAD DEL MAR

PROYECTO: CREAR UN SISTEMA QUE REPRODUZCA UNA MELODIA (USANDO LAS NOTAS BASICAS)
CREADA POR EL USUARIO.
AUTORES:

* Eli rafael Galguera Bautista
* Darwin Sosa Gómez
*/

import java.util.*;
import javax.swing.*;
public class Notas {
public static final int DO = 50;
public static final int RE = 60;
public static final int MI = 70;
public static final int FA = 80;
public static final int SOL =90;
public static final int LA =100;
public static final int SI =110;

public static final int _do = 6;
public static final int _re = 5;
public static final int _mi = 4;
public static final int _fa = 3;
public static final int _sol =2;
public static final int _la = 1;
public static final int _si = 0;

}

/*Vector vNotas;
Notas(int elements){
vNotas = new Vector();
for(int i=0;i vNotas.add(new Punto(new JButton(),i));
}
public void agregarNota(int pos, int nota){
getPunto(pos).setPosNota(nota);
getPunto(pos).boton.setVisible(true);
}
private Punto getPunto(int pos){
return (Punto)(vNotas.elementAt(pos));
}
public void limpiarNota(int pos){
getPunto(pos).boton.setVisible(false);
}
}
class Punto{
JButton boton;
int posicion;
int posX;
Punto(JButton btn, int pos){
boton = btn;
boton.setSize(10,10);
boton.setEnabled(false);
boton.setVisible(false);
posX = pos*10;
}
public void setPosNota(int nota){
posicion = nota;
switch(nota){
case Notas._do:
boton.setLocation(posX,Notas.DO);
break;
case Notas._re:
boton.setLocation(posX,Notas.RE);
break;
case Notas._mi:
boton.setLocation(posX,Notas.MI);
break;
case Notas._fa:
boton.setLocation(posX,Notas.FA);
break;
case Notas._sol:
boton.setLocation(posX,Notas.SOL);
break;
case Notas._la:
boton.setLocation(posX,Notas.LA);
break;
case Notas._si:
boton.setLocation(posX,Notas.SI);
break;
}
}*/

Clase Cuadros

2007-09-12T09:00:00.001-07:00

/*
UNIVERSIDAD DEL MAR

PROYECTO: CREAR UN SISTEMA QUE REPRODUZCA UNA MELODIA (USANDO LAS NOTAS BASICAS)
CREADA POR EL USUARIO.
AUTORES:

* Eli rafael Galguera Bautista
* Darwin Sosa Gómez
*/

import java.util.*;
import javax.swing.*;

public class Cuadros {
private Vector botones;

Cuadros(int num) {
botones = new Vector();
int contColumna, contFila;
contColumna = contFila = 0;
for (int i = 0; i < num; i++) {
botones.add(new JButton(/*String.valueOf(Configuracion.MAX_CLIENTES + 1)*/));
obtenerBoton(i).setSize(Configuracion.ANCHO_BTN,
Configuracion.ALTO_BTN);
obtenerBoton(i).setLocation(Configuracion.ANCHO_BTN * contColumna,
Configuracion.ALTO_BTN * contFila);
obtenerBoton(i).setEnabled(false);
if (contColumna + 1 == Configuracion.COLUMNAS) {
contColumna = 0;
contFila++;
} else
contColumna++;
}
}

public void ocultar(int indice) {
obtenerBoton(indice).setVisible(false);
obtenerBoton(indice).setText(null);
}

public void mostrar (int x, int y){
int indice = y*Configuracion.COLUMNAS+x;
obtenerBoton(indice).setEnabled(true);
}
public void ocultarTodos() {
for (int i = 0; i < getSize(); i++) {
obtenerBoton(i).setVisible(false);
obtenerBoton(i).setText(null);
}

}

public boolean vacio(int indice) {
if (obtenerBoton(indice).isVisible())
return false;
else
return true;
}

public int getSize() {
return botones.size();
}

public JButton obtenerBoton(int indice) {
return (JButton) botones.elementAt(indice);
}

public int meterCliente(int numCliente) {
int n;
boolean salir = false;
do {
n = (int) (Math.random() * Configuracion.MAX_CLIENTES);
if (vacio(n))
salir = true;
} while (!salir);
mostrar(n, numCliente);
return n;
}
public int getNota(int x){
int y;
for(y=0;y int indice = y*Configuracion.COLUMNAS+x;
if(obtenerBoton(indice).isEnabled())
break;
}
return getFrecuencia(y);
}
private int getFrecuencia(int posNota){
switch(posNota){
case Notas._do:
return Notas.DO;
case Notas._re:
return Notas.RE;
case Notas._mi:
return Notas.MI;
case Notas._fa:
return Notas.FA;
case Notas._sol:
return Notas.SOL;
case Notas._la:
return Notas.LA;
case Notas._si:
return Notas.SI;
}
return 0;
}
}

Clase de configuracion

2007-09-12T08:56:00.000-07:00

/*
UNIVERSIDAD DEL MAR

PROYECTO: CREAR UN SISTEMA QUE REPRODUZCA UNA MELODIA (USANDO LAS NOTAS BASICAS)
CREADA POR EL USUARIO.
AUTORES:

* Eli rafael Galguera Bautista
* Darwin Sosa Gómez
*/
public class Configuracion {
static final int ANCHO_BTN = 20;
static final int ALTO_BTN = 20;
static final int COLUMNAS = 26;
static final int FILAS = 7;
static final int MAX_CLIENTES = COLUMNAS * FILAS;
static final int MAX_COLA = MAX_CLIENTES;
static final int HORA_DE_SALIDA = 10000;
}

Editor de Texto

2007-09-10T10:43:00.000-07:00

/*
-----------------------------------------------------------------------------
-------------------- --------------------
-------------------- E D I T O R D E T E X T O --------------------
-------------------- --------------------
-----------------------------------------------------------------------------

UNIVERSIDAD DEL MAR. CAMPUS PUERTO ESCONDIDO..

MATERIA : Estructura de Datos.

CARRERA : Lic. Inform tica.

PROFESOR : Freddy Juarez P‚rez.

EQUIPO: # 2
Alma Alheli Pedro P‚rez.
Zulima Silva Santos.
Jasiel Hassan Toscano Mart¡nez.
Emilio Nicolas Lavariega.
Darwin Sosa G¢mez.

*/

#include
#include
#include
#include

#define constcodeAscii 1
#define constcodeExtended 0

/* DECLARANDO LA LISTA */
typedef struct Lista{
char *linea;
struct Lista *Siguiente;
struct Lista *Anterior;
}LISTA;

LISTA *BUSCAR;
LISTA *ROOT=NULL;

/* Funciones Usadas */
int editar(LISTA *R,int ncol, int nlin);
void Cre_archivo_NVO();
void Abre_archivo_NVO();
void fondo();
void crea_recuadr_();
void nombres();
void error();
void encabezado();
void analizar();
void limpiar(char);
void meterlista(char);
void imprimelista(void);
void fondo_blanco();
void fondo_Nombres();
void main1();

/* Vectores auxiliares */
char todo_el_archivo[3000];
char auxiliar[80];
char Archivo_name[10];
char unidad[1];
char nombre1[10];
char opcion;

/* Banderas auxiliar en los textos de las pantallas */
int c=0,m=0,a=0,An=0,contador=0;
int bandera=0;
void fondo_blanco(int color)
{
textmode(C4350);
window(1,1,80,50);
textbackground(color);
clrscr();
textcolor(BLACK);
}

/*--------------------------------------------------------------------------------
------------ ---------------------------------
------------ LLENANDO LA LISTA CON EL ARCHIVO ---------------------------------
------------ --------------------------------
--------------------------------------------------------------------------------*/
void meterlista()
{
int len=80;
LISTA *NUEVO=new(LISTA);

if(ROOT==NULL)
{
ROOT=NUEVO;
NUEVO->Siguiente=NULL;
NUEVO->Anterior=NULL;
NUEVO->linea=(char*)malloc(sizeof(char)*len);
strcpy(NUEVO->linea,auxiliar);
}
else
{
LISTA *R=ROOT;
while(R->Siguiente!=NULL)R=R->Siguiente;
R->Siguiente=NUEVO;
NUEVO->Siguiente=NULL;
NUEVO->Anterior=R;
NUEVO->linea=(char*)malloc(sizeof(char)*len);
strcpy(NUEVO->linea,auxiliar);
}
}

/*----------------------------------------------------------------------------------
------------ ---------------
------------ LIMPIANDO EL VECTOR AUXILIAR QUE GUARDA EN LA LISTA ---------------
------------ ---------------
----------------------------------------------------------------------------------*/
void limpiar()
{
for(int g=0;g<=79;g++)
{
auxiliar[g]=NULL;
}
}

/*----------------------------------------------------------------------------------
------------ ------------------------------
------------ IMPRIMIENDO LA LISTA Y GUARDANDO ------------------------------
------------ ------------------------------
----------------------------------------------------------------------------------*/
void imprimelista(void)
{
fondo_blanco(1);
_setcursortype(_NORMALCURSOR);
int ncontrol=80;
int naccion=0;
int x=3,y=6;

LISTA *R=ROOT;
clrscr();
fondo();

/* ENCABEZADO Y PIE DE LA PANTALLA ACTUAL */
textcolor(10);gotoxy(5,1);cprintf(" EDITANDO ARCHIVO ");textcolor(15);
for(int i=46;i<79;i++){gotoxy(i,4);cprintf("-");}
textcolor(12);gotoxy(50,3);cprintf("%s",unidad);textcolor(15);
for(i=2;i<80;i++){gotoxy(i,46);cprintf("_");}
textcolor(12);gotoxy(20,48);cprintf(" Para Guardar y Volver Presione 'ESC'");textcolor(15);

/* Imprimiendo en pantalla la lista (esta contiene el archivo) */

do{
if(bandera==1)
return;//main1();
else
{
textcolor(YELLOW);
gotoxy(3,y++);
cprintf("%s", R->linea);
}
R=R->Siguiente;
}while(R!=NULL);

R=ROOT;
x=3;y=6;

/* Segun la tecla presionada, se llama a la funcion que edita archivo */
while(naccion!=27)
{
switch(ncontrol)
{
case 80:
R=R->Siguiente;
if(y<=43)y++;
naccion=editar(R,x,y);
break;
case 72:
R=R->Anterior;
if(y>=8)y--;
naccion=editar(R,x,y);
break;
}
switch(naccion)
{
case 80:ncontrol=80;break;
case 72:ncontrol=72;break;
}
}

}

/*----------------------------------------------------------------------------------
------------ ------------------------------
------------ EDITANDO LA LISTA CON EL ARCHIVO ------------------------------
------------ ------------------------------
----------------------------------------------------------------------------------*/
int editar( LISTA *R,int ncol, int nlin)
{
int ntypecode=0;
int x=ncol;
int y=nlin;
FILE *fp;

char *lineas;
lineas=R->linea;/* Guardando toda la linea en un vector */

int nmaxcol=79;/* Ancho de la pantalla */
int w=strlen(lineas)+1;/* Calculando el tama¤o de la linea */

/* Limpiando los espacion no usados del vector linea (Evita imprimir basura)*/
for(int w1=w+1;w1<=nmaxcol;w1++)
lineas[w1]='\x0';

int acharacter=0;
int bexit=0;

gotoxy(ncol,nlin);
while(acharacter!=27 && !bexit)
{
acharacter=getch();
ntypecode=constcodeAscii;

if(acharacter==0)
{
acharacter=getch();
ntypecode=constcodeExtended;
}
if(ntypecode==constcodeAscii && acharacter!=27)
{
cprintf("%c",acharacter);
*(lineas+(x-ncol))=acharacter;
acharacter=77;
}

switch(acharacter)
{
case 80:bexit=1;break;
case 72:bexit=1;break;
case 75:if(x>ncol)x--;break;
case 77:if(x }
gotoxy(x,y);
}/* Cerrando While */
if (acharacter==27)
{
R=ROOT;
fp=fopen(unidad,"w");
if(fp==NULL)/*En caso que no se pueda crear el archivo*/
{
error();
getch();
}
_setcursortype(_NORMALCURSOR);/*Cursor Nomral*/
while(R!=NULL)/*Insertando Datos en el archivo*/
{
for(int b=0;b<=strlen(R->linea);b++)
{
fputc(R->linea[b],fp);
}
R=R->Siguiente;
}
fclose(fp);
} /* Cerrando IF */
return(acharacter);/*Rotornando el Caracter que se oprimi¢*/
}
/*------------------------------------------------------------------------------------
------------- --------------
------------- IMPRIMIENDO ENCABEZADO DE PORTADA (pantalla inicial) --------------
------------- --------------
-------------------------------------------------------------------------------------*/
void encabezado()
{
textcolor(10);
gotoxy(28,9);cprintf(" EDITOR DE TEXTO ");
gotoxy(22,11);cprintf(" SISTEMA MANEJADOR DE ARCHIVOS ");
for(int i=18;i<59;i++){textcolor(14);gotoxy(i,13);cprintf("Ü");}
textcolor(15);
}
/*------------------------------------------------------------------------------------
------------- --------------
------------- CAPTURANDO NOMBRE DEL ARCHIVO, crear, apertura o analisis --------------
------------- --------------
-------------------------------------------------------------------------------------*/
void nombres()
{
int i;
textcolor(14);
_setcursortype(_NOCURSOR);/*Imprimir sin ver el Cursor*/
for(i=21;i<35;i++)
{
gotoxy(15,i);cprintf("º");
gotoxy(55,i);cprintf("º");
}
for(i=16;i<55;i++)
{
gotoxy(i,20);cprintf("Í");
gotoxy(i,35);cprintf("Í");
}

gotoxy(15,20);cprintf("É");gotoxy(55,20);cprintf("»");
gotoxy(15,35);cprintf("È");gotoxy(55,35);cprintf("¼");

/* ENCABEZADO DE LAS VENTANAS QUE CAPTURAN NOMBRE Y UNIDAD DEL ARCHIVO */
do
{
textcolor(10);
if(c==1&&m==0&&a==0&&An==0){gotoxy(18,20);cprintf(" NOMBRAR ARCHIVO ");}
if(c==0&&m==0&&a==1&&An==0){gotoxy(18,20);cprintf(" EDITAR ARCHIVO ");}
if(c==0&&m==0&&a==0&&An==1){gotoxy(18,20);cprintf(" EDITAR ARCHIVO ");}
textcolor(15);

textcolor(12);gotoxy(17,24);cprintf("Maximo 10 caracteres");textcolor(15);
gotoxy(17,29);cprintf("Nombre del Archivo: ");gets(Archivo_name);
gotoxy(17,33);cprintf("Unidad De DISCO: ");gets(unidad);
clrscr();fondo();
if(strlen(Archivo_name)>10){clrscr();fondo();nombres();}

}while(strlen(Archivo_name)>10);
}
/*------------------------------------------------------------------------------------
------------------- ---------------------------------------
------------------- ENVIANDO MENSAJES DE ERROR ---------------------------------------
------------------- ---------------------------------------
------------------------------------------------------------------------------------*/
void error()
{
int i;
textcolor(14);
_setcursortype(_NOCURSOR);/*Desaparece Cursor*/
for(i=19;i<24;i++)
{
gotoxy(23,i);cprintf("º");
gotoxy(70,i);cprintf("º");
}
for(i=24;i<70;i++)
{
gotoxy(i,18);cprintf("Í");
gotoxy(i,24);cprintf("Í");
}
gotoxy(23,18);cprintf("É");gotoxy(70,18);cprintf("»");
gotoxy(23,24);cprintf("È");gotoxy(70,24);cprintf("¼");

/* MENSAJE DE ERROR, POR SI NO SE CREA O CARGA BIEN EL ARCHIVO */

textcolor(10);gotoxy(26,18);cprintf(" UPPSS..ERROR... ");textcolor(15);
textcolor(12);

if(c==1&&m==0&&a==0&&An==0){gotoxy(27,22);cprintf(" ERROR, NO SE CREO EL ARCHIVO");}
if(c==0&&m==1&&a==0&&An==0){gotoxy(27,22);cprintf(" ERROR, NO SE PUEDE CARGAR EL ARCHIVO");}
if(c==0&&m==0&&a==1&&An==0){gotoxy(27,22);cprintf(" ERROR, NO SE PUEDE CARGAR EL ARCHIVO");}
if(c==0&&m==0&&a==0&&An==1){gotoxy(27,22);cprintf(" ERROR, NO SE PUEDE EDITAR EL ARCHIVO ");}

textcolor(15);
}

/* CREANDO MARGEN DE CAPTURA DE OPCION EN PANTALLA INICIAL */
void crea_recuadro_()
{
textcolor(12);
gotoxy(37,35);cprintf("É");gotoxy(59,35);cprintf("»");
gotoxy(37,41);cprintf("È");gotoxy(59,41);cprintf("¼");

for(int i=38;i<59;i++)
{
gotoxy(i,35);cprintf("Í");
gotoxy(i,41);cprintf("Í");
}
textcolor(15);
}
/*----------------------------------------------------------------------------------
------------------- --------------------------------
------------------- FUNCION MAIN, menu de opciones --------------------------------
------------------- --------------------------------
----------------------------------------------------------------------------------*/
void main()
{
textmode(C4350);/* Definiendo tama¤o de ventana */

main1();
getch();
}

void main1()
{
do{
_setcursortype(_NORMALCURSOR);/*Cursor normal*/
clrscr();
fondo_blanco(0);
fondo();
encabezado();

/* MENU DE ACCIONES */
textcolor(11);
gotoxy(24,20);cprintf(" F9 ÍÍ%c Nombrar Archivo.",16);
gotoxy(24,24);cprintf(" F3 ÍÍ%c Editar Archivo.",16);
gotoxy(24,28);cprintf("Esc ÍÍ%c SALIR\n",16);

crea_recuadro_();

textcolor(10);
gotoxy(40,38);cprintf("ELIJA OPCION : ");opcion=getche();
textcolor(15);

switch(opcion)
{
case 67:Cre_archivo_NVO();break; /* F9 */
case 61:analizar();break; /* F3 */
case 27:exit(1);break; /* ESC */
}
}while(opcion!=27);
}

/*---------------------------------------------------------------------------------
------------- ----------------------------------
------------- CREANDO UN ARCHIVO NUEVO ----------------------------------
------------- ----------------------------------
---------------------------------------------------------------------------------*/
void Cre_archivo_NVO()
{
c=1;m=a=An=0;
int ren=5,col=5;

FILE *fp;/* Puntero para maniobrar Archivos */

char caracter;
char Extension_de_archivo[]=".txt";
char diagonal[]=":\\";
int columna;
int renglon;
clrscr();
fondo();
nombres();
clrscr();
fondo();

fflush(stdin);

/* CONCATENANDO RUTA PARA GUARDAR EL ARCHIVO */
strncat(unidad,diagonal,3);
strncat(unidad,Archivo_name,strlen(Archivo_name));
strncat(unidad,Extension_de_archivo,4);/*Concatenando Extension*/

/* Se esta creando el archivo */
fp=fopen(unidad,"w+t");

/*En caso que no se pueda crear el archivo*/
if(fp==NULL)
{
error();
getch();
return;
}

gotoxy(col,ren);
_setcursortype(_NORMALCURSOR);/*Cursor Nomral*/

columna=3;
renglon=9;
while(columna<79&&renglon<44)
{
caracter=32;
if(columna==78)
{
caracter='\x0';
columna=3;renglon++;
}
fputc(caracter,fp);
columna++;
}

fclose(fp);/*Cerrando Puntero del archivo*/
return;
}

/*------------------------------------------------------------------------------------------
-------------- -----------------------------------------------
-------------- ABRIENDO EL ARCHIVO YA CREADO -----------------------------------------------
-------------- -----------------------------------------------
------------------------------------------------------------------------------------------*/
void Abre_archivo_NVO()
{
ROOT=NULL;
a=1;c=m=An=0;
_setcursortype(_NOCURSOR);/*Desaparece Cursor*/

limpiar();
int ren=5,col=5,i;

FILE *fp;/* Puntero para maniobrar Archivos */

char caracter;
char diagonal[]=":\\";
char *Extension_de_archivo=".txt";

clrscr();
fondo();
nombres();
clrscr();
fondo();

fflush(stdin);

/* CONCATENANDO RUTA PARA GUARDAR EL ARCHIVO */
strncat(unidad,diagonal,3);
strncat(unidad,Archivo_name,strlen(Archivo_name));
strncat(unidad,Extension_de_archivo,4);/*Concatenando Extension*/

/*Se esta abriendo el Archivo para editarlo */
fp=fopen(unidad,"r+t");

textcolor(11);gotoxy(5,1);cprintf(" EDITANDO ARCHIVO ");textcolor(15);
textcolor(12);gotoxy(50,3);cprintf("%s",unidad);textcolor(15);
for(i=46;i<79;i++){gotoxy(i,4);cprintf("-");}
for(i=2;i<80;i++){gotoxy(i,46);cprintf("_");}
textcolor(12);gotoxy(20,48);cprintf(" Para Salir del Editor Presione 'ESC'");textcolor(15);

/*En caso que no se pueda cargar el archivo*/
if(fp==NULL)
{
error();
getch();
bandera=1;
return;
}
gotoxy(col,ren);
contador=0;
bandera=0;
/* Leyendo Archivo caracter a caracter y mandando datos a la lista */
while((caracter=fgetc(fp))!=EOF)
{
auxiliar[contador++]=caracter;
if(caracter==NULL||caracter=='\x0'||caracter=='\n')
{
contador=0;meterlista();limpiar();
}
}
fclose(fp);/*Cerrando el puntero del archivo*/
meterlista();
clrscr();
}

/*-------------------------------------------------------------------------------------------
---------------- --------------------------------
---------------- ENLAZANDO PARA ABRIR Y EDITAR ARCHIVO --------------------------------
---------------- --------------------------------
-------------------------------------------------------------------------------------------*/
void analizar()
{
c=m=a=0; An=1;
clrscr();
fondo();
Abre_archivo_NVO();
_setcursortype(_NORMALCURSOR);
imprimelista();
}

/*------------------------------------------------------------------------------
-------------- --------------------------------
-------------- IMPRIMIENDO FONDO DE PANTALLA --------------------------------
-------------- --------------------------------
------------------------------------------------------------------------------*/
void fondo(void)
{
int l;
textcolor(15);
cprintf("É");

for(l=0;l<78;l++)cprintf("Í");gotoxy(78,0);cprintf("»");
for(l=2;l<49;l++){gotoxy(80,l);cprintf("º\n");}
for(l=2;l<49;l++){gotoxy(1,l);cprintf("º\n");}gotoxy(1,49);cprintf("È");
for(l=1;l<79;l++)cprintf("Í");gotoxy(80,49);cprintf("¼");
textcolor(15);
}

Manejo de Archivos

2007-09-10T10:38:00.001-07:00

/*
ESTE PROGRAMA CREA UN ARCHIVO, LO ABRE Y AGREGA INFOMACION AL FINAL DEL MISMO

MATERIA : PROGRAMACION DE SISTEMAS;

ALUMNO : DARWIN SOSA GOMEZ 312 A

PROFESOR : JORGE OCHOA SOMUANO

*/
#include
#include
#include
#include

void Cre_archivo_NVO();
void Abre_archivo_NVO();
void Agrega_informacion();
void fondo();
void crea_recuadr_();
void nombres();
void error();
void encabezado();
void analizar();
void tablas();

int c=0,m=0,a=0,An=0;
char Archivo_name[10];
char opcion;

void encabezado()/*Encabezado En Portada*/
{
int i;
gotoxy(22,9);cprintf(" ANALIZADOR LEXICO GRAFICO Y ");
gotoxy(22,11);cprintf(" SISTEMA MANEJADOR DE ARCHIVOS ");
for(i=18;i<59;i++){textcolor(11);gotoxy(i,12);cprintf("Ü");}
textcolor(15);
}

void nombres()/*Tecleando Nombre de Archivo*/
{
int i;
_setcursortype(_NOCURSOR);/*Desaparece Cursor*/
for(i=21;i<35;i++)
{
gotoxy(15,i);cprintf("º");
gotoxy(55,i);cprintf("º");
}
for(i=16;i<55;i++)
{
gotoxy(i,20);cprintf("Í");
gotoxy(i,35);cprintf("Í");
}

gotoxy(15,20);cprintf("É");gotoxy(55,20);cprintf("»");
gotoxy(15,35);cprintf("È");gotoxy(55,35);cprintf("¼");

do
{
textcolor(10);
if(c==1&&m==0&&a==0&&An==0){gotoxy(18,20);cprintf(" CREAR ARCHIVO NUEVO ");}
if(c==0&&m==1&&a==0&&An==0){gotoxy(18,20);cprintf(" MODIFICAR ARCHIVO ");}
if(c==0&&m==0&&a==1&&An==0){gotoxy(18,20);cprintf(" ABRIR ARCHIVO ");}
if(c==0&&m==0&&a==0&&An==1){gotoxy(18,20);cprintf(" ANALIZAR ARCHIVO ");}
textcolor(15);

textcolor(12);gotoxy(17,26);cprintf("Maximo 10 caracteres");textcolor(15);
gotoxy(17,30);cprintf("Nombre del Archivo: ");gets(Archivo_name);
clrscr();fondo();
if(strlen(Archivo_name)>10){clrscr();fondo();nombres();}
}while(strlen(Archivo_name)>10);

}

void error()
{
int i;
_setcursortype(_NOCURSOR);/*Desaparece Cursor*/
for(i=19;i<24;i++)
{
gotoxy(23,i);cprintf("º");
gotoxy(70,i);cprintf("º");
}
for(i=24;i<70;i++)
{
gotoxy(i,18);cprintf("Í");
gotoxy(i,24);cprintf("Í");
}

gotoxy(23,18);cprintf("É");gotoxy(70,18);cprintf("»");
gotoxy(23,24);cprintf("È");gotoxy(70,24);cprintf("¼");

textcolor(10);gotoxy(26,18);cprintf(" UPPSS..ERROR... ");textcolor(15);
textcolor(12);
if(c==1&&m==0&&a==0&&An==0){gotoxy(27,22);cprintf(" ERROR, NO SE CREO EL ARCHIVO");}
if(c==0&&m==1&&a==0&&An==0){gotoxy(27,22);cprintf(" ERROR, NO SE PUEDE CARGAR EL ARCHIVO");}
if(c==0&&m==0&&a==1&&An==0){gotoxy(27,22);cprintf(" ERROR, NO SE PUEDE CARGAR EL ARCHIVO");}
if(c==0&&m==0&&a==0&&An==1){gotoxy(27,22);cprintf(" ERROR, NO SE PUEDE ANALIZAR EL ARCHIVO ");}
textcolor(15);

}
void crea_recuadro_()
{
textcolor(12);
gotoxy(37,31);cprintf("É");gotoxy(59,31);cprintf("»");
gotoxy(37,35);cprintf("È");gotoxy(59,35);cprintf("¼");

for(int i=38;i<59;i++)
{
gotoxy(i,31);cprintf("Í");
gotoxy(i,35);cprintf("Í");
}
textcolor(15);
}

void main()
{
do{
_setcursortype(_NORMALCURSOR);/*Cursor normal*/
clrscr();
fondo();
encabezado();
gotoxy(24,18);cprintf("1. CREAR ARCHIVO NUEVO");
gotoxy(24,20);cprintf("2. VER ARCHIVO");
gotoxy(24,22);cprintf("3. AGREGAR DATOS AL ARCHIVO");
gotoxy(24,24);cprintf("4. ANALIZAR ARCHIVO");
gotoxy(24,26);cprintf("5. SALIR\n");

crea_recuadro_();
textcolor(10);
gotoxy(40,33);cprintf("ELIJA OPCION : ");opcion=getche();
textcolor(15);

switch(opcion)
{
case '1':Cre_archivo_NVO();break;
case '2':Abre_archivo_NVO();break;
case '3':Agrega_informacion();break;
case '4':analizar();break;
case '5':exit(1);break;
}
}while(opcion!='5');
getch();
}

void Agrega_informacion()
{
_setcursortype(_NORMALCURSOR);/*Cursor Nomral*/
int col=5;int ren=5;int i;
FILE *fp;
char caracter;
char *Extension_de_archivo=".txt";
m=1;a=An=c=0;
clrscr();fondo();
nombres();
clrscr();fondo();
fflush(stdin);

strncat(Archivo_name,Extension_de_archivo,4);

fp=fopen(Archivo_name,"a+t");

if(fp==NULL)
{
error();
getch();
return;
}
textcolor(11);gotoxy(5,1);cprintf(" AGREGANDO INFORMACION AL ARCHIVO ");textcolor(15);
for(i=46;i<79;i++){gotoxy(i,4);cprintf("-");}
textcolor(12);gotoxy(50,3);cprintf("C:\\BC\\BIN\\%s",Archivo_name);textcolor(15);
for(i=2;i<80;i++){gotoxy(i,46);cprintf("_");}
textcolor(12);gotoxy(20,48);cprintf(" Para Guardar y Salir Presione 'ESC'");textcolor(15);

_setcursortype(_NORMALCURSOR);/*Cursor Nomral*/
gotoxy(col,ren);
while((caracter=fgetc(fp))!=EOF)
{
if(caracter=='\n'){ren++;col=5;}
gotoxy(col++,ren);cprintf("%c",caracter);
}

gotoxy(col++,ren);
while((caracter=getche())!=27)
{
if(caracter==13)
{
caracter='\n';
ren++;col=5;
}
gotoxy(col++,ren);fputc(caracter,fp);
}
fclose(fp);

}

void Cre_archivo_NVO()
{
int ren=5; int col=5;int i;
FILE *fp;
char caracter;
char Extension_de_archivo[]=".txt";
c=1;m=a=An=0;
clrscr();fondo();
nombres();
clrscr();fondo();
fflush(stdin);

strncat(Archivo_name,Extension_de_archivo,4);

fp=fopen(Archivo_name,"w+t");

textcolor(11);gotoxy(5,1);cprintf(" CREANDO ARCHIVO NUEVO ");textcolor(15);
textcolor(12);gotoxy(50,3);cprintf("C:\\BC\\BIN\\%s",Archivo_name);textcolor(15);
for(i=46;i<79;i++){gotoxy(i,4);cprintf("-");}

for(i=2;i<80;i++){gotoxy(i,46);cprintf("_");}
textcolor(12);gotoxy(20,48);cprintf(" Para Guardar y Salir Presione 'ESC'");textcolor(15);

if(fp==NULL)
{
error();
getch();
return;
}
gotoxy(col,ren);
_setcursortype(_NORMALCURSOR);/*Cursor Nomral*/
while((caracter=getche())!=27)
{
if(caracter==13)
{
caracter='\n';
ren++;col=5;
}
gotoxy(++col,ren);fputc(caracter,fp);
}
fclose(fp);
}

void Abre_archivo_NVO()
{
_setcursortype(_NOCURSOR);/*Desaparece Cursor*/
int ren=5; int col=5;int i;
FILE *fp;
char caracter;
char *Extension_de_archivo=".txt";
a=1;c=m=An=0;
clrscr();fondo();
nombres();
clrscr();fondo();

fflush(stdin);
strncat(Archivo_name,Extension_de_archivo,4);

fp=fopen(Archivo_name,"r+t");
textcolor(11);gotoxy(5,1);cprintf(" VISUALIZANDO ARCHIVO ");textcolor(15);
textcolor(12);gotoxy(50,3);cprintf("C:\\BC\\BIN\\%s",Archivo_name);textcolor(15);
for(i=46;i<79;i++){gotoxy(i,4);cprintf("-");}
for(i=2;i<80;i++){gotoxy(i,46);cprintf("_");}
textcolor(12);gotoxy(20,48);cprintf(" Para Salir Presione 'ESC'");textcolor(15);
if(fp==NULL)
{
error();
getch();
return;
}
gotoxy(col,ren);
while((caracter=fgetc(fp))!=EOF)
{
if(caracter=='\n'){ren++;col=5;}
gotoxy(col++,ren);cprintf("%c",caracter);
}
fclose(fp);

getch();
}

void analizar()/*Analizando Archivo.*/
{
int ren=5; int col=5;int i,j,k,l,m,n,o,cI,cO,cL,cP,cNP,cCLV,b1,b2,b3;
FILE *fp;
char caracter;
char *Extension_de_archivo=".txt";
An=1;a=c=m=0;
char todo_el_archivo[3000];
char identificadores[300];
char operadores[300];
char literales[300];
char puntuacion[300];
char no_permitidos[300];
char claves[300];

clrscr();fondo();
nombres();
clrscr();fondo();

fflush(stdin);
strncat(Archivo_name,Extension_de_archivo,4);

fp=fopen(Archivo_name,"r+t");

textcolor(11);gotoxy(5,1);cprintf(" ANALIZANDO ARCHIVO ");textcolor(15);
textcolor(12);gotoxy(50,3);cprintf("C:\\BC\\BIN\\%s",Archivo_name);textcolor(15);
for(i=46;i<79;i++){gotoxy(i,4);cprintf("-");}
for(i=2;i<80;i++){gotoxy(i,46);cprintf("_");}
textcolor(12);gotoxy(20,48);cprintf(" Para Salir Presione 'ESC'");textcolor(15);

if(fp==NULL)
{
error();
getch();
return;
}
for(i=0;i<300;i++)
{
identificadores[i]=NULL;
literales[i]=NULL;
operadores[i]=NULL;
puntuacion[i]=NULL;
no_permitidos[i]=NULL;
claves[i]=NULL;
}
for(i=0;i<3000;i++)todo_el_archivo[i]=NULL;
gotoxy(col,ren);
i=0;
while((caracter=fgetc(fp))!=EOF){todo_el_archivo[i++]=caracter;}

i=j=k=l=m=n=o=0;
/******************************************************************************
******************** **********************************
******************** CLASIFICANDO LOS TOKENS ***********************************
******************** **********************************
*******************************************************************************
*/
while(todo_el_archivo[i]!='\0')
{ b1=b2=b3=0;

/* CLASIFICANDO IDENTIFICADORES */
if((todo_el_archivo[i]>='A'&&todo_el_archivo[i]<='Z')||(todo_el_archivo[i]>='a'&&todo_el_archivo[i]<='z'))
{
/* CLASIFICANDO LA PALABRA RESERVADA 'Comienza' */
if((todo_el_archivo[i]=='C'||todo_el_archivo[i]=='c')&&(todo_el_archivo[i+1]=='O'||todo_el_archivo[i+1]=='o')&&(todo_el_archivo[i+2]=='M'||todo_el_archivo[i+2]=='m')&&(todo_el_archivo[i+3]=='I'||todo_el_archivo[i+3]=='i')&&(todo_el_archivo[i+4]=='E'||todo_el_archivo[i+4]=='e')&&(todo_el_archivo[i+5]=='N'||todo_el_archivo[i+5]=='n')&&(todo_el_archivo[i+6]=='Z'||todo_el_archivo[i+6]=='z')&&(todo_el_archivo[i+7]=='A'||todo_el_archivo[i+7]=='a'))
{
claves[o++]=todo_el_archivo[i]; /* C */
claves[o++]=todo_el_archivo[i+1];/* O */
claves[o++]=todo_el_archivo[i+2];/* M */
claves[o++]=todo_el_archivo[i+3];/* I */
claves[o++]=todo_el_archivo[i+4];/* E */
claves[o++]=todo_el_archivo[i+5];/* N */
claves[o++]=todo_el_archivo[i+6];/* Z */
claves[o++]=todo_el_archivo[i+7];/* A */
claves[o++]=32;
i+=8;
}
/* CLASIFICANDO LA PALABRA RESERVADA 'Termina' */
if((todo_el_archivo[i]=='T'||todo_el_archivo[i]=='t')&&(todo_el_archivo[i+1]=='E'||todo_el_archivo[i+1]=='e')&&(todo_el_archivo[i+2]=='R'||todo_el_archivo[i+2]=='r')&&(todo_el_archivo[i+3]=='M'||todo_el_archivo[i+3]=='m')&&(todo_el_archivo[i+4]=='I'||todo_el_archivo[i+4]=='i')&&(todo_el_archivo[i+5]=='N'||todo_el_archivo[i+5]=='n')&&(todo_el_archivo[i+6]=='A'||todo_el_archivo[i+6]=='a'))
{
claves[o++]=todo_el_archivo[i]; /* T */
claves[o++]=todo_el_archivo[i+1];/* E */
claves[o++]=todo_el_archivo[i+2];/* R */
claves[o++]=todo_el_archivo[i+3];/* M */
claves[o++]=todo_el_archivo[i+4];/* I */
claves[o++]=todo_el_archivo[i+5];/* N */
claves[o++]=todo_el_archivo[i+6];/* A */
claves[o++]=32;
i+=7;
}
/* CLASIFICANDO LA PALABRA RESERVADA 'SI' */
if((todo_el_archivo[i]=='S'||todo_el_archivo[i]=='s')&&(todo_el_archivo[i+1]=='I'||todo_el_archivo[i+1]=='i'))
{
claves[o++]=todo_el_archivo[i]; /* S */
claves[o++]=todo_el_archivo[i+1];/* I */
claves[o++]=32;
i+=2;
}
/* CLASIFICANDO LA PALABRA RESERVADA 'OTRO' */
if((todo_el_archivo[i]=='O'||todo_el_archivo[i]=='o')&&(todo_el_archivo[i+1]=='T'||todo_el_archivo[i+1]=='t')&&(todo_el_archivo[i+2]=='R'||todo_el_archivo[i+2]=='r')&&(todo_el_archivo[i+3]=='O'||todo_el_archivo[i+3]=='o'))
{
claves[o++]=todo_el_archivo[i]; /* O */
claves[o++]=todo_el_archivo[i+1];/* T */
claves[o++]=todo_el_archivo[i+2];/* R */
claves[o++]=todo_el_archivo[i+3];/* O */
claves[o++]=32;
i+=4;
}

identificadores[j++]=todo_el_archivo[i];
if(todo_el_archivo[i+1]>='0'&&todo_el_archivo[i+1]<='9')
{
identificadores[j++]=todo_el_archivo[i+1];
i+=2;
}
}
else
{
if((todo_el_archivo[i]=='+')||(todo_el_archivo[i]=='-')||(todo_el_archivo[i]=='*')||(todo_el_archivo[i]=='/')||(todo_el_archivo[i]=='!'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]==':'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]=='<'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]=='>'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]=='\n')||(todo_el_archivo[i]=='=')||(todo_el_archivo[i]=='>')||(todo_el_archivo[i]=='<'))b1=0;
else b1=1;
}
/* CLASIFICANDO LITERALES */
if(todo_el_archivo[i]>='0'&&todo_el_archivo[i]<='9')
{
if(todo_el_archivo[i+1]>='0'&&todo_el_archivo[i+1]<='9')
{literales[l++]=todo_el_archivo[i];}
else
{
literales[l++]=todo_el_archivo[i];
literales[l++]=32;
}
}
else
{
if((todo_el_archivo[i]=='+')||(todo_el_archivo[i]=='-')||(todo_el_archivo[i]=='*')||(todo_el_archivo[i]=='/')||(todo_el_archivo[i]=='!'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]==':'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]=='<'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]=='>'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]=='\n')||(todo_el_archivo[i]=='=')||(todo_el_archivo[i]=='>')||(todo_el_archivo[i]=='<'))b2=0;
else b2=1;
}
/* CLASIFICANDO SIGNOS DE PUNTUACION */
if((todo_el_archivo[i]=='{')||(todo_el_archivo[i]=='}')||(todo_el_archivo[i]=='[')||(todo_el_archivo[i]==']')||(todo_el_archivo[i]=='(')||(todo_el_archivo[i]==')')||(todo_el_archivo[i]==';'))
{
puntuacion[m++]=todo_el_archivo[i];
}
else
{
if((todo_el_archivo[i]=='+')||(todo_el_archivo[i]=='-')||(todo_el_archivo[i]=='*')||(todo_el_archivo[i]=='/')||(todo_el_archivo[i]=='!'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]==':'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]=='<'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]=='>'&&todo_el_archivo[i+1]=='=')||(todo_el_archivo[i]=='\n')||(todo_el_archivo[i]=='=')||(todo_el_archivo[i]=='>')||(todo_el_archivo[i]=='<'))b3=0;
else b3=1;
}
/* CLASIFICANDO CARACTERES NO PERMITIDOS */
if(b1==1&&b2==1&&b3==1){no_permitidos[n++]=todo_el_archivo[i];}

i++;
}

/* CLASIFICANDO OPERADORES */
i=0;
while(todo_el_archivo[i]!='\0')
{
if((todo_el_archivo[i]=='+')||(todo_el_archivo[i]=='-')||(todo_el_archivo[i]=='*')||(todo_el_archivo[i]=='/')||(todo_el_archivo[i]=='!')||(todo_el_archivo[i]==':')||(todo_el_archivo[i]=='<')||(todo_el_archivo[i]=='>')||(todo_el_archivo[i]=='='))
{
if((todo_el_archivo[i]=='!'&&todo_el_archivo[i+1]!='=')||(todo_el_archivo[i]=='=' && todo_el_archivo[i+1]!='='))
{
no_permitidos[n++]=todo_el_archivo[i];
}
else
{
operadores[k++]=todo_el_archivo[i];
if(todo_el_archivo[i+1]=='=')
{
operadores[k++]=todo_el_archivo[i+1];
i+=2;
}
else i++;
}
}
if(todo_el_archivo[i]=='='&& todo_el_archivo[i+1]=='=')
{
operadores[k++]=todo_el_archivo[i];
if(todo_el_archivo[i+1]=='=')
{
operadores[k++]=todo_el_archivo[i+1];
i+=2;
}
else i++;
}
i++;
}

j=k=l=m=13;cI=5;cL=34;cP=45;cO=22,cNP=57;n=15;cCLV=68;

i=0;
while(identificadores[i]!='\x0')
{
textcolor(11);
if(j<=42){gotoxy(cI,j++);cprintf("%c",identificadores[i]);}
else{cI+=2;j=13;}
i++;
}

i=0;
while(literales[i]!='\x0')
{
if(literales[i]==32){k++;cL=34;}
else{gotoxy(cL++,k);cprintf("%c",literales[i]);}
i++;
}

i=0;
while(puntuacion[i]!='\x0')
{
if(m==43){cP+=2;m=13;}
else{gotoxy(cP,m++);cprintf("%c",puntuacion[i]);}
i++;

}
i=0;
while(no_permitidos[i]!='\x0')
{
if(n==43){cNP+=2;n=15;}
else{gotoxy(cNP,n++);cprintf("%c",no_permitidos[i]);}
i++;
}

i=0;n=14;
while(claves[i]!='\x0')
{
if(claves[i]==32)
{
n++;
cCLV=68;
}
else
{
gotoxy(cCLV++,n);cprintf("%c",claves[i]);
}
i++;
}

i=0;
while(operadores[i]!='\x0')
{
if(l==43){cO+=3;l=13;}
if((operadores[i]==':'&&operadores[i+1]=='=')||(operadores[i]=='!'&&operadores[i+1]=='=')||(operadores[i]=='<'&&operadores[i+1]=='=')||(operadores[i]=='>'&&operadores[i+1]=='=')||(operadores[i]=='='&&operadores[i+1]=='='))
{
gotoxy(cO,l);cprintf("%c",operadores[i]);
gotoxy(cO+1,l++);cprintf("%c",operadores[++i]);
}
else{gotoxy(cO,l++);cprintf("%c",operadores[i]);}
i++;
}
textcolor(15);
fclose(fp);
tablas();
getch();
}
void tablas()
{
int i;
for(i=11;i<43;i++)
{
gotoxy(3,i);printf("³");/*Tabla de Identificadores*/
gotoxy(19,i);printf("³");

gotoxy(20,i);printf("³");/*Tabla de Operadores*/
gotoxy(31,i);printf("³");

gotoxy(32,i);printf("³");/*Tabla de Literales*/
gotoxy(42,i);printf("³");

gotoxy(43,i);printf("³");/*Tabla de Puntuacion*/
gotoxy(54,i);printf("³");

gotoxy(55,i);printf("³");/*Tabla de Caracteres no permitidos*/
gotoxy(66,i);printf("³");

gotoxy(67,i);printf("³");/*Tabla de Palabras Clave*/
gotoxy(78,i);printf("³");
}
/*Tabla de Identificadores*/
gotoxy(3,10);printf("Ú");gotoxy(19,10);printf("¿");
gotoxy(3,43);printf("À");gotoxy(19,43);printf("Ù");

textcolor(10);gotoxy(4,11);cprintf("Identificadores");textcolor(15);

for(i=4;i<19;i++)
{
gotoxy(i,12);printf("Ä");
gotoxy(i,43);printf("Ä");
}
/*Tabla de Operadores*/
gotoxy(20,10);printf("Ú");gotoxy(31,10);printf("¿");
gotoxy(20,43);printf("À");gotoxy(31,43);printf("Ù");

textcolor(10);gotoxy(21,11);cprintf("Operadores");textcolor(15);

for(i=21;i<31;i++)
{
gotoxy(i,12);printf("Ä");
gotoxy(i,43);printf("Ä");
}
/*Tabla de Literales*/
gotoxy(32,10);printf("Ú");gotoxy(42,10);printf("¿");
gotoxy(32,43);printf("À");gotoxy(42,43);printf("Ù");

textcolor(10);gotoxy(33,11);cprintf("Literales");textcolor(15);

for(i=33;i<42;i++)
{
gotoxy(i,12);printf("Ä");
gotoxy(i,43);printf("Ä");
}
/*Tabla de Puntuacion*/
gotoxy(43,10);printf("Ú");gotoxy(54,10);printf("¿");
gotoxy(43,43);printf("À");gotoxy(54,43);printf("Ù");

textcolor(10);gotoxy(44,11);cprintf("Puntuacion");textcolor(15);

for(i=44;i<54;i++)
{
gotoxy(i,12);printf("Ä");
gotoxy(i,43);printf("Ä");
}
/*Tabla de Caracteres no permitidos*/
gotoxy(55,10);printf("Ú");gotoxy(66,10);printf("¿");
gotoxy(55,43);printf("À");gotoxy(66,43);printf("Ù");
textcolor(10);gotoxy(56,11);cprintf("Caracteres");textcolor(15);
textcolor(10);gotoxy(58,12);cprintf(" NO");textcolor(15);
textcolor(10);gotoxy(56,13);cprintf("PERMITIDOS");textcolor(15);

for(i=56;i<66;i++)
{
gotoxy(i,14);printf("Ä");
gotoxy(i,43);printf("Ä");
}
/*Tabla de Palabras Clave*/
gotoxy(67,10);printf("Ú");gotoxy(78,10);printf("¿");
gotoxy(67,43);printf("À");gotoxy(78,43);printf("Ù");
textcolor(10);gotoxy(68,11);cprintf(" Palabras");textcolor(15);
textcolor(10);gotoxy(68,12);cprintf(" CLAVE");textcolor(15);

for(i=68;i<78;i++)
{
gotoxy(i,13);printf("Ä");
gotoxy(i,43);printf("Ä");
}
}

void fondo(void)
{ int l;
textcolor(14);
cprintf("É");
for(l=0;l<78;l++)cprintf("Í");gotoxy(78,0);cprintf("»");
for(l=2;l<49;l++){gotoxy(80,l);cprintf("º\n");}
for(l=2;l<49;l++){gotoxy(1,l);cprintf("º\n");}gotoxy(1,49);cprintf("È");
for(l=1;l<79;l++)cprintf("Í");gotoxy(80,49);cprintf("¼");
textcolor(15);

}

Analizador y evaluador de expresiones aritmeticas

2007-09-10T10:37:00.001-07:00

/* EXPRESS.C Analizador y evaluador de expresiones aritmeticas */

#include
#include
#include
#include
#include

#define DELIMITADOR 1
#define VARIABLE 2
#define NUMERO 3

char *prog;
char token[80];
char tipo_token;

void eval_expr( double *res );
void suma_resta( double *res );
void mult_div( double *res );
void exp( double *res );
void monario( double *res );
void parentesis( double *res );
void atomo( double *res );
void devuelve();
void serror( int error );
void obt_token( void );
int esdelim( char c );

main()
{
clrscr();
double res;
char *p;

/*clrscr();*/
p = ( char* ) malloc (100);
if(!p){
printf("\nFallo de asignacion de memoria\n");
exit(0);
}
do{
/*clrscr();*/
prog = p;
printf("\n\nIntroduzca EXPRESION");
printf("\n\n ==> ");
gets(prog);
if(!*prog) break;
eval_expr(&res);
printf("\nEl resultado es : \n\n %1.2f\n", res);
if(!getch()) getch();
} while(*p);

return 0;
}

void eval_expr( double *res )
{
obt_token();
if(!*token){
serror(2);
return;
}
suma_resta(res);
}

void suma_resta( double *res )
{
register char op;
double temp;

mult_div(res);
while((op = *token) == '+' || op == '-')
{
obt_token();
mult_div(&temp);
switch( op ){
case '-' : *res = *res - temp;
break;
case '+' : *res = *res + temp;
break;
}
}
}

void mult_div( double *res )
{
register char op;
double temp;

exp(res);
while((op = *token) == '*' || op == '/' || op == '%')
{
obt_token();
exp(&temp);
switch( op ){
case '*' : *res = *res * temp;
break;
case '/' : *res = *res / temp;
break;
case '%' : *res = (int) *res % (int) temp;
break;
}
}
}

void exp( double *res )
{
double temp, ex;
register int t;

monario(res);
if(*token == '^'){
obt_token();
exp(&temp);
ex = *res;
if(temp == 0.0){
*res = 1.0;
return;
}
for(t = temp-1; t > 0; --t)
*res = (*res) * (double) ex;
}
}

void monario( double *res )
{
register char op;

op = 0;
if((tipo_token == DELIMITADOR) && *token == '+' ||
*token == '-'){
op = *token;
obt_token();
}
parentesis(res);
if(op == '-') *res = -(*res);
}

void parentesis( double *res )
{
if((*token) == '('){
obt_token();
suma_resta(res);
if((*token) != ')')
serror(1);
obt_token();
}
else
atomo(res);
}

void atomo( double *res )
{
if(tipo_token == NUMERO){
*res = atof(token);
obt_token();
return;
}
serror(0);
}

void devuelve()
{
char *t;

t = token;
for(; *t; t++) prog--;
}

void serror( int error )
{
static char *e[] = {
"Error de sintaxis",
"Parentesis no emparejados",
"No hay expresion"
};
printf("\n%s\n", e[error]);
}

void obt_token( void )
{
register char *temp;

tipo_token = 0;
temp = token;
*temp = '\0';

if(!*prog) return;
while(isspace(*prog)) ++prog;

if(strchr("+-*/^%=()", *prog)){
tipo_token = DELIMITADOR;
*temp++ = *prog++;
}
else if(isalpha(*prog)){
while(!esdelim(*prog)) *temp++ = *prog++;
tipo_token = VARIABLE;
}
else if(isdigit(*prog)){
while(!esdelim(*prog)) *temp++ = *prog++;
tipo_token = NUMERO;
}
*temp = '\0';
}

int esdelim( char c )
{
if(strchr(" +-/*%^=()", c) || c==9 || c=='\r' || c==0)
return 1;
return 0;
}

Metodos de solucion de sistemas de ecuaciones

2007-09-10T10:32:00.000-07:00

/*
Descripcion : Multiplicacion dos Matrices, resolviendo sistemas de ecuaciones
Fecha : Martes 08 de Noviembre del 2005
Marteria : Algebra Lineal
Catedratico : Manuel Alejandro Valdez Marrero
*/

#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#define TamMatriz 10

int Row,Column;

void Menu_Principal(void){
gotoxy(10,5);printf("Menu");
gotoxy(5,6);printf("[1]--->Captura Sistema ");
gotoxy(5,7);printf("[2]--->Metodo de Solucion ");
gotoxy(5,8);printf("[3]--->Mostrar Sistema ");
gotoxy(5,9);printf("[4]--->Salir ");
gotoxy(5,610);printf("Elige una Opcion ");
}

void Menu_Operaciones_Sistemas(void){
gotoxy(5,11);printf("[1]--->Metodo de Gauss-Jordan ");
gotoxy(5,12);printf("[2]--->Regla de Cramer ");
gotoxy(5,13);printf("[3]--->Metodo de la Inversa ");
gotoxy(5,14);printf("[0]--->Salir ");
gotoxy(5,15);printf("Elige una Opcion ");
}

void Metodo_Gauss_Jordan(float Matriz1[TamMatriz][TamMatriz],int* Row1,int *Column1){
int i,ren=0,j,ban=0,aux,k;
for(i=0;i<(*Row1);i++)//es el pivote
{
ren=i+1;/*para k a la hora de comparar sea con el remgoln siguent*/
while(Matriz1[i][i]==0 )
{
if(ren<(*Row1))
{
if(Matriz1[ren][i]!=0) /*if(!(afMatrizTem1[ren][i]))*/
{/*INTERCAMBIO*/
for(j=0;j<(*Column1)+1;j++){
aux= Matriz1[i][j];
Matriz1[i][j] = Matriz1[ren][j];
Matriz1[ren][j]=aux;
}
}/*cirra el segundo if*/
ren++;
}/*cierra primer el if*/
else
break;

}/*ciere el while*/

aux = Matriz1[i][i];/*PARA HACER UNOS*/
for(j=0; j<(*Column1)+1&&aux!=0; j++)
Matriz1[i][j] = Matriz1[i][j] / aux;/*cierra for*/

for(j=0; j<(*Column1)+1; j++)/*PARA HACER CEROS*/
{
if(i != j)
{
aux=Matriz1[j][i] * (-1);
for(k=0; k<(*Column1)+1&&aux!=0; k++)
Matriz1[j][k] += Matriz1[i][k] * aux;/*cierra for*/
}/*cierra if*/
}/*cierra for*/

}//cierra el for

if(*Column1>*Row1){
printf("\nSistema con Multiples Soluciones");getch();ban=2;}

if(*Row1>*Column1){//Ecuaciones>Incognitas

if(Matriz1[(*Column1)-1][(*Column1)-1]==0 && Matriz1[(*Column1)-1][(*Column1)]!=0 ){
printf("\nSistema Sin Soluciones");getch();ban=1;}

if(!Matriz1[(*Column1)-1][(*Column1)-1]&&!Matriz1[(*Column1)-1][(*Column1)]){
printf("\nSistema con Multiples Soluciones");getch();ban=2;}

if(*Row1==*Column1&&ban==0)
for(i=0;i<(*Row1);i++)
for(j=0;j<(*Column1);j++)
if(i==j)
printf("\nX%d --> %.2f ",i+1,Matriz1[i][*Column1]);

}

if(*Column1==*Row1){
if(Matriz1[(*Row1)-1][(*Column1)-1]==0 && Matriz1[(*Row1)-1][(*Column1)]!=0 ){
printf("\nSistema Sin Soluciones");getch();ban=1;}

if(!Matriz1[(*Column1)-1][(*Row1)-1]&&!Matriz1[(*Column1)-1][(*Row1)]){
printf("\nSistema con Multiples Soluciones");getch();ban=2;}
if(*Row1==*Column1&&ban==0)
for(i=0;i<(*Row1);i++)
for(j=0;j<(*Column1);j++)
if(i==j)
printf("\nX%d --> %.2f ",i+1,Matriz1[i][*Column1]);
}

}

void main(void){
int Incognitas,Ecuaciones,i,j,con=0;
float MatrizS[TamMatriz][TamMatriz]={{0},{0}};
float VectorI[TamMatriz]={0};
char OpcionP,OpcionS;
do{
clrscr();
Menu_Principal();
OpcionP=getche();
switch(OpcionP){
case '1':clrscr();printf("\nDatos del Sistema de Ecuaciones ");
do{
printf("\n# Ecuaciones ");
scanf("%d",&Ecuaciones);
}while(Ecuaciones<1||Ecuaciones>10);
do{
printf("\n# Incognitas ");
scanf("%d",&Incognitas);
}while(Incognitas<1||Incognitas>10);
for(i=0;i for(j=0;j printf("Coeficiente X%d de la Ecuacion %d --> ",j+1,i+1);
scanf("%f",&MatrizS[i][j]);
}
printf("Termino Independiente de la Ecuacion %d --> ",i+1);
scanf("%f",&VectorI[i]);
}

break;
case '3':clrscr();
for(i=0;i for(j=0;j if(MatrizS[i][j]<0)
printf("%.2fX%d ",MatrizS[i][j],j+1);
else
if(MatrizS[i][j]>0&&j==0)
printf(" %.2fX%d ",MatrizS[i][j],j+1);
else
printf(" + %.2fX%d ",MatrizS[i][j],j+1);
}
printf(" = %f\n",VectorI[i]);
}
getch();
break;
case '2':do{
clrscr();Menu_Operaciones_Sistemas();getch();
OpcionS=getche();
switch(OpcionS){
case '1':for(i=0;i MatrizS[i][Incognitas]=VectorI[i];
if(!VectorI[i])
con++;//sistema Homog‚neo

}
Metodo_Gauss_Jordan(MatrizS,&Ecuaciones,&Incognitas);
getch();
break;
}
}while(OpcionS!='0');
break;

}

}while(OpcionP!='4');
getch();
}

Clase VentanaEliminaModificaProcesos

2007-09-10T09:45:00.001-07:00

import java.awt.*;
import java.awt.event.*;
import java.util.Vector;
import javax.swing.*;

public class VentanaEliminaModificaProcesos extends JFrame implements ActionListener {
Vector VectorProcesos;

private String StringNombre;

private int IntTiempoLlegada;

private int IntTiempoRafaga;

private int IntPrioridad;

private GridLayout GridControles;

private JPanel PanelProcesos;

private JLabel JLabelNombre, JLabelLlegada, JLabelRafaga, JLabelPrioridad;

private JTextField JTextLlegada, JTextRafaga, JTextPrioridad;
private JComboBox JComboNombre;
private int i=0,j=0;
private JMenu JMenuProcesos;

private JMenuItem JMeEliminar, JMenuModificar,JMenuGuardar, JMenuSalir;

public VentanaEliminaModificaProcesos(Vector VectorProcesos){
setTitle("ELIMINAR / EDITAR");
setSize(500, 600);
this.VectorProcesos = VectorProcesos;

JMenuProcesos = new JMenu("Proceso");

JMeEliminar = new JMenuItem("Eliminar", new ImageIcon("eVentana.png"));
JMeEliminar.addActionListener(this);
JMenuProcesos.add(JMeEliminar);
JMenuProcesos.addSeparator();

JMenuModificar=new JMenuItem("Modificar",new ImageIcon("modifica.png"));
JMenuModificar.addActionListener(this);
JMenuProcesos.add(JMenuModificar);
JMenuProcesos.addSeparator();

JMenuGuardar = new JMenuItem("Guardar", new ImageIcon("gVentana.png"));
JMenuGuardar.addActionListener(this);
JMenuGuardar.setEnabled(false);
JMenuProcesos.add(JMenuGuardar);
JMenuProcesos.addSeparator();

JMenuSalir = new JMenuItem("Salir", new ImageIcon("sVentana.png"));
JMenuSalir.addActionListener(this);
JMenuProcesos.add(JMenuSalir);

GridControles = new GridLayout(4, 2, 10, 10);
PanelProcesos = new JPanel();
PanelProcesos.setLayout(GridControles);

PanelProcesos.add(JLabelNombre = new JLabel(" Nombre del Proceso"));
PanelProcesos.add(JComboNombre = new JComboBox());
JComboNombre.addActionListener(this);

PanelProcesos.add(JLabelLlegada = new JLabel(" Tiempo de Llegada"));
PanelProcesos.add(JTextLlegada = new JTextField(10));
JTextLlegada.setHorizontalAlignment(JTextField.CENTER);
JTextLlegada.addActionListener(this);
JTextLlegada.setEditable(false);

PanelProcesos.add(JLabelRafaga = new JLabel(" Tiempo de Rafaga"));
PanelProcesos.add(JTextRafaga = new JTextField(10));
JTextRafaga.setHorizontalAlignment(JTextField.CENTER);
JTextRafaga.addActionListener(this);
JTextRafaga.setEditable(false);

PanelProcesos.add(JLabelPrioridad = new JLabel(" Prioridad"));
PanelProcesos.add(JTextPrioridad = new JTextField(10));
JTextPrioridad.setHorizontalAlignment(JTextField.CENTER);
JTextPrioridad.addActionListener(this);
JTextPrioridad.setEditable(false);

JMenuBar barra = new JMenuBar();
setJMenuBar(barra);
barra.add(JMenuProcesos);

getContentPane().add(PanelProcesos);
setSize(300, 250);
setResizable(false);

if (!VectorProcesos.isEmpty()){
setVisible(true);
LlenaCombo();
}
else{
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. Debe almacenar almenos un proceso","No hay procesos",JOptionPane.WARNING_MESSAGE);
}
}
public void LlenaCombo(){
i=0;
for (i=0;i JComboNombre.addItem(((Procesos)VectorProcesos.elementAt(i)).getStringNombre());
}
}
public void habilitaCampos(boolean estado){
JTextLlegada.setEditable(estado);
JTextRafaga.setEditable(estado);
JTextPrioridad.setEditable(estado);
}
public void actionPerformed(ActionEvent arg0) {
if (arg0.getSource().equals(JComboNombre)) {
j=0;
for (j=0;j if (((Procesos)VectorProcesos.elementAt(j)).getStringNombre()==JComboNombre.getSelectedItem().toString()){
JTextLlegada.setText(String.valueOf(((Procesos)VectorProcesos.elementAt(j)).getIntTiempoLlegada()));
JTextRafaga.setText(String.valueOf(((Procesos)VectorProcesos.elementAt(j)).getIntTiempoRafaga()));
JTextPrioridad.setText(String.valueOf(((Procesos)VectorProcesos.elementAt(j)).getIntPrioridad()));
}
}
}/*FIN EVENTO DEL COMBO*/
if (arg0.getSource().equals(JMeEliminar)) {
int EliminarProcesoOk=JOptionPane.showConfirmDialog(null,"¿Deseas eliminar este Proceso?","Eliminar Procesos",JOptionPane.YES_NO_OPTION,JOptionPane.WARNING_MESSAGE);
if (EliminarProcesoOk==JOptionPane.YES_OPTION){/*Si se hizo clic en el boton SI*/
VectorProcesos.remove(JComboNombre.getSelectedIndex());
JComboNombre.removeActionListener(this);
JComboNombre.removeAllItems();
LlenaCombo();
JComboNombre.addActionListener(this);
}
}/*FIN DEL EVENTO ELIMINAR PROCESO*/
if (arg0.getSource().equals(JMenuModificar)) {
habilitaCampos(true);
JMenuModificar.setEnabled(false);
JMenuGuardar.setEnabled(true);
JMeEliminar.setEnabled(false);
}/*FIN EVENTO MODIFICAR*/
if (arg0.getSource().equals(JMenuGuardar)) {
JMenuModificar.setEnabled(true);
JMeEliminar.setEnabled(true);
JMenuGuardar.setEnabled(false);
habilitaCampos(false);

StringNombre = JComboNombre.getSelectedItem().toString();
IntTiempoLlegada = Integer.parseInt(JTextLlegada.getText());
IntTiempoRafaga = Integer.parseInt(JTextRafaga.getText());
IntPrioridad = Integer.parseInt(JTextPrioridad.getText());

for (j=0;j if (((Procesos)VectorProcesos.elementAt(j)).getStringNombre()==StringNombre){
((Procesos)VectorProcesos.elementAt(j)).setStringNombre(StringNombre);
((Procesos)VectorProcesos.elementAt(j)).setIntTiempoLlegada(IntTiempoLlegada);
((Procesos)VectorProcesos.elementAt(j)).setIntTiempoRafaga(IntTiempoRafaga);
((Procesos)VectorProcesos.elementAt(j)).setIntPrioridad(IntPrioridad);
}
}

}/*FIN EVENTO GUARDAR*/
if (arg0.getSource().equals(JMenuSalir)) {
setVisible(false);
}/*FIN EVENTO SALIR*/
if (arg0.getSource().equals(JTextLlegada)) {
JTextRafaga.grabFocus();
}
if (arg0.getSource().equals(JTextRafaga)) {
JTextPrioridad.grabFocus();
}
if (arg0.getSource().equals(JTextPrioridad)) {
JTextLlegada.grabFocus();
}
}/*FIN DEL ACTION PERFORMED*/

}

Clase VentanaAgregaProcesos

2007-09-10T09:44:00.000-07:00

import java.awt.*;
import java.awt.event.*;
import java.util.Vector;
import javax.swing.*;

public class VentanaAgregaProcesos extends JFrame implements ActionListener {
Vector VectorProcesos;

int IntTiempoLlegada=0;
private String StringNombre;

private int IntTiempoRafaga;

private int IntPrioridad;

private GridLayout GridControles;

private JPanel PanelProcesos;

private JLabel JLabelNombre, JLabelLlegada, JLabelRafaga, JLabelPrioridad;

private JTextField JTextNombre, JTextLlegada, JTextRafaga, JTextPrioridad;

private JMenu JMenuProcesos;

private JMenuItem JMenuNuevo, JMenuGuardar, JMenuSalir;

public VentanaAgregaProcesos(Vector VectorProcesos) {
setTitle("AGREGAR PROCESOS");
setSize(500, 600);
this.VectorProcesos = VectorProcesos;

JMenuProcesos = new JMenu("Proceso");
JMenuProcesos.setMnemonic('P');

JMenuNuevo = new JMenuItem("Nuevo", new ImageIcon("mnuevo.png"));
JMenuNuevo.setMnemonic('N');
JMenuNuevo.addActionListener(this);
JMenuProcesos.add(JMenuNuevo);
JMenuProcesos.addSeparator();

JMenuGuardar = new JMenuItem("Guardar", new ImageIcon("gVentana.png"));
JMenuGuardar.setMnemonic('G');
JMenuGuardar.setEnabled(false);
JMenuGuardar.addActionListener(this);
JMenuProcesos.add(JMenuGuardar);
JMenuProcesos.addSeparator();

JMenuSalir = new JMenuItem("Salir", new ImageIcon("sVentana.png"));
JMenuSalir.setMnemonic('S');
JMenuSalir.addActionListener(this);
JMenuProcesos.add(JMenuSalir);

GridControles = new GridLayout(4, 2, 10, 10);
PanelProcesos = new JPanel();
PanelProcesos.setLayout(GridControles);

PanelProcesos.add(JLabelNombre = new JLabel(" Nombre del Proceso"));
PanelProcesos.add(JTextNombre = new JTextField(10));
JTextNombre.setHorizontalAlignment(JTextField.CENTER);
JTextNombre.addActionListener(this);
JTextNombre.setEditable(false);

PanelProcesos.add(JLabelLlegada = new JLabel(" Tiempo de Llegada"));
PanelProcesos.add(JTextLlegada = new JTextField(10));
JTextLlegada.setHorizontalAlignment(JTextField.CENTER);
JTextLlegada.addActionListener(this);
JTextLlegada.setEditable(false);

PanelProcesos.add(JLabelRafaga = new JLabel(" Tiempo de Rafaga"));
PanelProcesos.add(JTextRafaga = new JTextField(10));
JTextRafaga.setHorizontalAlignment(JTextField.CENTER);
JTextRafaga.addActionListener(this);
JTextRafaga.setEditable(false);

PanelProcesos.add(JLabelPrioridad = new JLabel(" Prioridad"));
PanelProcesos.add(JTextPrioridad = new JTextField(10));
JTextPrioridad.setHorizontalAlignment(JTextField.CENTER);
JTextPrioridad.addActionListener(this);
JTextPrioridad.setEditable(false);

JMenuBar barra = new JMenuBar();
setJMenuBar(barra);
barra.add(JMenuProcesos);

getContentPane().add(PanelProcesos);
setSize(300, 250);
setVisible(true);
setResizable(false);

}/* FIN DEL CONSTRUCTOR */
public void habilitaCampos(boolean estado){
//JTextNombre.setEditable(estado);
//JTextLlegada.setEditable(estado);
JTextRafaga.setEditable(estado);
JTextPrioridad.setEditable(estado);
}
public void actionPerformed(ActionEvent arg0) {
if (arg0.getSource().equals(JMenuNuevo)) {
JMenuGuardar.setEnabled(true);
JMenuSalir.setEnabled(false);
JMenuNuevo.setEnabled(false);

JTextNombre.setText("P"+String.valueOf(VectorProcesos.size()+1));
JTextLlegada.setText(String.valueOf(VectorProcesos.size()));
JTextRafaga.setText("");
JTextRafaga.grabFocus();
JTextPrioridad.setText("");
habilitaCampos(true);

}/* FIN EVENTO NUEVO */
if (arg0.getSource().equals(JMenuGuardar)) {
JMenuGuardar.setEnabled(false);
JMenuSalir.setEnabled(true);
JMenuNuevo.setEnabled(true);

StringNombre = JTextNombre.getText();
IntTiempoLlegada = Integer.parseInt(JTextLlegada.getText());
IntTiempoRafaga = Integer.parseInt(JTextRafaga.getText());
IntPrioridad = Integer.parseInt(JTextPrioridad.getText());
habilitaCampos(false);

Procesos agrega = new Procesos(StringNombre, IntTiempoLlegada,
IntTiempoRafaga, IntPrioridad);
VectorProcesos.addElement(agrega);
}/* FIN EVENTO GUARDAR */
if (arg0.getSource().equals(JMenuSalir)) {
setVisible(false);
}/* FIN EVENTO SALIR */
if (arg0.getSource().equals(JTextNombre)) {
JTextLlegada.grabFocus();
}
if (arg0.getSource().equals(JTextLlegada)) {
JTextRafaga.grabFocus();
}
if (arg0.getSource().equals(JTextRafaga)) {
JTextPrioridad.grabFocus();
}
if (arg0.getSource().equals(JTextPrioridad)) {
JTextRafaga.grabFocus();
}
}/* FIN DEL ACTION PERFORMED EVENT */

}/* FIN DE LA CLASE VENTANA */

Clase del algoritmo SJFCooperativo

2007-09-10T09:42:00.000-07:00

import java.util.Arrays;
import java.util.Vector;

public class SJFCooperativo {
/*ESTA CLASE RECIBE UN VECTOR CON TODOS LOS DATOS QUE SE NECESITAN PARA
EMPEZAR A EJECUTAR EL ALGORITMO, EN ESTE SE EVALUA EL TIEMPO DE RAFAGA
QUE SE LE ASIGNARON A LOS PROCESOS, Y EJECUTA EL PROCESO QUE TIENE EL TIEMPO DE RAFAGA MENOR*/
Vector VectorProcesos;
private int DoubleTiempoEspera;
private double DoubleTiempoEspera1;
private int NumeroProceso[];
Arrays vector;
private int vectoraux[];
private String ProcesosNombres[];
/*EN EL CONTRUCTOR SE RECIBE EL VECTOR CON TODOS LOS DATOS DE LOS PROCESOS*/
public SJFCooperativo(Vector VectorProcesos){
this.VectorProcesos = VectorProcesos;
vectoraux=new int[VectorProcesos.size()];
NumeroProceso=new int[VectorProcesos.size()];
ProcesosNombres=new String[VectorProcesos.size()];
}
/*EN ESTA PARTE SE CALCULA EL TIEMPO PROMEDIO DE ESPERA DEL ALGORTIMO*/
public void getTiempoEsperaPromedio(){
int i=0;
for (i=0;i vectoraux[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
ProcesosNombres[i]=((Procesos)VectorProcesos.elementAt(i)).getStringNombre();
NumeroProceso[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada()+1;
}
ordena(); /*ordenando los procesos*/
for (i=0;i System.out.println(ProcesosNombres[i]+">>"+vectoraux[i]);
}

DoubleTiempoEspera=vectoraux[0];
for (i=1;i DoubleTiempoEspera+=vectoraux[i];
vectoraux[i]=DoubleTiempoEspera;
}

DoubleTiempoEspera1=0;
for (i=0;i DoubleTiempoEspera1+=vectoraux[i];
}

DoubleTiempoEspera1=DoubleTiempoEspera1/VectorProcesos.size();
}
public void ordena(){
int aux,aux2,k,i;
String aux1;

for(i=1;i aux = vectoraux[i];
aux1= ProcesosNombres[i];
aux2=NumeroProceso[i];
k=i-1;
while (k >= 0 && aux < vectoraux[k]){
vectoraux[k+1] = vectoraux[k];
ProcesosNombres[k+1]=ProcesosNombres[k];
NumeroProceso[k+1]=NumeroProceso[k];
k=k-1;
}
vectoraux[k+1] = aux;
ProcesosNombres[k+1]=aux1;
NumeroProceso[k+1]=aux2;
}
}
/*DEVUELVE UN VECTOR CON EL NUEVO TIEMPO DE RAFAGA*/
public int[] getValores(){
return vectoraux;
}
/*SE DEVUELVE LOS NOMBRES DE LOS PROCESOS*/
public String []getNombre(){
return ProcesosNombres;
}
/*SE DEVUELVE EL NUMERO DEL PROCESO*/
public int[] getNumeroProceso(){
return NumeroProceso;
}
/*DEVUELVE EL TIEMPO PROMEDIO DE ESPERA*/
public double imprimeResultado(){
return DoubleTiempoEspera1;
}
}

Clase del algoritmo SJFApropiativo

2007-09-10T09:41:00.000-07:00

import java.util.Vector;

public class SJFApropiativo {
Vector VectorProcesos;
Vector ProcesosParaDiagrama=new Vector();
private double DoubleTiempoEspera=0;
private int DoubleTiempoEspera1=0;
private int VectorTiempoRafaga[];
private int NumeroProceso[];
private String ProcesosNombres[];
private double VectorTiempoLlegada[];

public SJFApropiativo(Vector VectorProcesos){
this.VectorProcesos = VectorProcesos;
VectorTiempoRafaga=new int[VectorProcesos.size()];
NumeroProceso=new int[VectorProcesos.size()];
ProcesosNombres=new String[VectorProcesos.size()];
VectorTiempoLlegada=new double[VectorProcesos.size()];
}
public void getTiempoEsperaPromedio(){
for (int i=0;i ProcesosNombres[i]=((Procesos)VectorProcesos.elementAt(i)).getStringNombre();
NumeroProceso[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada()+1;
VectorTiempoRafaga[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
VectorTiempoLlegada[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada();
}

for(int i=0;i for(int j=0;j if(VectorTiempoLlegada[j]==j){
VectorTiempoRafaga[j]-=j;
ProcesosParaDiagrama.add(j,new Integer(NumeroProceso[j]));
}
}
}
for(int i=0;i System.out.println(ProcesosParaDiagrama.elementAt(i).toString());
}

}
}

Clase SimuladorPORTURNOS

2007-09-10T09:40:00.000-07:00

/*ESTA CLASE AYUDA A HACER LA SIMULACION DEL ALGORITMO POR TURNOS*/
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class SimuladorPORTURNOS extends JFrame implements ActionListener{
private JButton Cuadricula[][]=new JButton[30][25];
private JPanel PanelContenedor=new JPanel();
private int NumProceso=0;
private int NumProceso1=0;
private int orden=0,orden1=0;;

public SimuladorPORTURNOS(){/*CONSTRUCTOR*/
PanelContenedor.setLayout(new GridLayout(30,25,0,0));
NumProceso1=NumProceso;
/*CREANDO LA CUADRICULA DE BOTONES QUE SIMULAN LOS PROCESOS*/
for(int i=0;i<30;i++){
for (int j=0;j<25;j++){
Cuadricula[i][j]=new JButton("");
Cuadricula[i][j].setVisible(false);
PanelContenedor.add(Cuadricula[i][j]);
/*ESTABLECIENDO EN POSICIONES FIJAS LOS ESTADOS*/
if (i==8 && j==8){
Cuadricula[i][j].setText("L");
Cuadricula[i][j].setToolTipText("Estado LISTO");
Cuadricula[i][j].setVisible(true);
}
if (i==8 && j==17){
Cuadricula[i][j].setText("E");
Cuadricula[i][j].setToolTipText("Estado EJECUCION");
Cuadricula[i][j].setVisible(true);
}
if (i==0 && j==0){
Cuadricula[i][j].setText("N");
Cuadricula[i][j].setToolTipText("Estado NUEVO");
Cuadricula[i][j].setVisible(true);
}
if (i==0 && j==24){
Cuadricula[i][j].setText("T");
Cuadricula[i][j].setToolTipText("Estado TERMINADO");
Cuadricula[i][j].setVisible(true);
}
}/*Termina FOR*/
}/*Termina FOR*/

getContentPane().add(PanelContenedor);
setSize(1000,800);
setResizable(true);
setVisible(true);
}/*FIN CONSTRUCTOR*/
/*MOVIENDO EL ESTADO ACTUAL DESDE EL ESTADO LSITO HASTA EL ESTADO EJECUCION
* limite EQUIVALE AL NUMERO DEL PROCESO*/
public void Listo_Ejecucion(int limite){
Cuadricula[7+limite][1].setVisible(false);
Color fondo=Cuadricula[7+limite][1].getBackground();

for(int i=8;i<=17;i++){
Cuadricula[7][i].setText(String.valueOf(limite));
Cuadricula[7][i].setBackground(fondo);
Cuadricula[7][i].setVisible(true);
Cuadricula[7][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
}/*FIN Listo_Ejecucion*/
/*MOVIENDO EL PROCESO ACTUAL DESDE EL ESTADO DE EJECUCION HASTA EL ESTADO DE
* LISTO, ESTO, CUANDO SE ES DESALJADO POR OTRO PORCESO. limite ES IGUAL AL NUMERO
* DEL PROCESO*/
public void Ejecucion_Listo(int limite){
Cuadricula[7+limite][1].setVisible(false);
Color fondo=Cuadricula[7+limite][1].getBackground();

for(int i=17;i>=8;i--){
Cuadricula[9][i].setText(String.valueOf(limite));
Cuadricula[9][i].setBackground(fondo);
Cuadricula[9][i].setVisible(true);
Cuadricula[9][i+1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
}/*FIN Ejecucion_Listo*/
/*MOVIENDO EL PROCESO DESDE EL ESTADO EJECUCION HASTA EL ESTADO TERMINADO, limite
* LLEVA EL NOMBRE O NUMERO DEL PROCESO*/
public void Ejecucion_Terminado(int limite){
orden1++;
NumProceso1++;
Color fondo=Cuadricula[7][17].getBackground();

for(int i=7,j=6;i>=1;i--,j--){
Cuadricula[i][17].setText(""+limite);
Cuadricula[i][17].setBackground(fondo);
Cuadricula[i][17].setVisible(true);
try {
Thread.sleep(100);
Cuadricula[j+1][17].setVisible(false);
}
catch (InterruptedException e){e.printStackTrace();}
}

for(int i=17;i<25;i++){
Cuadricula[1][i].setText(""+limite);
Cuadricula[1][i].setBackground(fondo);
Cuadricula[1][i].setVisible(true);
Cuadricula[1][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[1][24].setVisible(false);
/*COLOCANDO LOS PROCESOS TERMINADOS EN LA COLA DE TERMINADO, orden1 LLEVA LA
* POSICION DEL PROCESO EN LA COLA*/
switch(orden1)
{
case 1:
Cuadricula[8][24].setText(String.valueOf(limite));
Cuadricula[8][24].setBackground(fondo);
Cuadricula[8][24].setVisible(true);
break;
case 2:
Cuadricula[9][24].setText(String.valueOf(limite));
Cuadricula[9][24].setBackground(fondo);
Cuadricula[9][24].setVisible(true);
break;
case 3:
Cuadricula[10][24].setText(String.valueOf(limite));
Cuadricula[10][24].setBackground(fondo);
Cuadricula[10][24].setVisible(true);
break;
case 4:
Cuadricula[11][24].setText(String.valueOf(limite));
Cuadricula[11][24].setBackground(fondo);
Cuadricula[11][24].setVisible(true);
break;
case 5:
Cuadricula[12][24].setText(String.valueOf(limite));
Cuadricula[12][24].setBackground(fondo);
Cuadricula[12][24].setVisible(true);
break;
case 6:
Cuadricula[13][24].setText(String.valueOf(limite));
Cuadricula[13][24].setBackground(fondo);
Cuadricula[13][24].setVisible(true);
break;
case 7:
Cuadricula[14][24].setText(String.valueOf(limite));
Cuadricula[14][24].setBackground(fondo);;
Cuadricula[14][24].setVisible(true);
break;
case 8:
Cuadricula[15][24].setText(String.valueOf(limite));
Cuadricula[15][24].setBackground(fondo);
Cuadricula[15][24].setVisible(true);
break;
case 9:
Cuadricula[16][24].setText(String.valueOf(limite));
Cuadricula[16][24].setBackground(fondo);
Cuadricula[16][24].setVisible(true);
break;
case 10:
Cuadricula[17][24].setText(String.valueOf(limite));
Cuadricula[17][24].setBackground(fondo);
Cuadricula[17][24].setVisible(true);
break;
case 11:
Cuadricula[18][24].setText(String.valueOf(limite));
Cuadricula[18][24].setBackground(fondo);
Cuadricula[18][24].setVisible(true);
break;
case 12:
Cuadricula[19][24].setText(String.valueOf(limite));
Cuadricula[19][24].setBackground(fondo);
Cuadricula[19][24].setVisible(true);
break;
case 13:
Cuadricula[20][24].setText(String.valueOf(limite));
Cuadricula[20][24].setBackground(fondo);
Cuadricula[20][24].setVisible(true);
break;
case 14:
Cuadricula[21][24].setText(String.valueOf(limite));
Cuadricula[21][24].setBackground(fondo);
Cuadricula[21][24].setVisible(true);
break;
case 15:
Cuadricula[22][24].setText(String.valueOf(limite));
Cuadricula[22][24].setBackground(fondo);
Cuadricula[22][24].setVisible(true);
break;
case 16:
Cuadricula[23][24].setText(String.valueOf(limite));
Cuadricula[23][24].setBackground(fondo);
Cuadricula[23][24].setVisible(true);
break;
case 17:
Cuadricula[24][24].setText(String.valueOf(limite));
Cuadricula[24][24].setBackground(fondo);
Cuadricula[24][24].setVisible(true);
break;
case 18:
Cuadricula[25][24].setText(String.valueOf(limite));
Cuadricula[25][24].setBackground(fondo);
Cuadricula[25][24].setVisible(true);
break;
case 19:
Cuadricula[26][24].setText(String.valueOf(limite));
Cuadricula[26][24].setBackground(fondo);
Cuadricula[26][24].setVisible(true);
break;
case 20:
Cuadricula[27][24].setText(String.valueOf(limite));
Cuadricula[27][24].setBackground(fondo);
Cuadricula[27][24].setVisible(true);
break;
default:
JOptionPane.showMessageDialog(null,"Solo se soportan 20 procesos");
}/*FIN DEL SWITCH*/
}/*FIN Ejecucion_Terminado*/
/*CREANDO UN NUEVO PROCESO Y MOVIENDO EL PROCESO CREADO DESDE EL ESTADO NUEVO HASTA LA COLA DE
* LSITO, LOS TRES PARAMETROS RECIBIDOS (int red, int green,int blue) PERTENECEN AL COLOR DE
* FONDO QUE HA DE TOMAR BOTON QUE REPRESENTE EL NUEVO PROCESO*/
public void Nuevo_Listo(int red, int green,int blue){
NumProceso++;
for(int i=1;i<8;i++){
Cuadricula[1][i].setText(""+NumProceso);
Cuadricula[1][i].setBackground(new Color(red,green,blue));
Cuadricula[1][i].setVisible(true);
Cuadricula[1][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[1][7].setVisible(false);
for(int i=1;i<8;i++){
Cuadricula[i][8].setText(""+NumProceso);
Cuadricula[i][8].setBackground(new Color(red,green,blue));
Cuadricula[i][8].setVisible(true);
Cuadricula[i-1][8].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[7][8].setVisible(false);
}/*FIN Nuevo_Listo*/
/*MOVIENDO EL PROCESO CREADO DESDE EL ESTADO DE LISTO HASTA LA COLA DE ESPERA
* LOS TRES PARAMETROS RECIBIDOS (int red, int green,int blue) PERTENECEN AL COLOR DE
* FONDO QUE HA DE TOMAR BOTON QUE REPRESENTA AL PROCESO*/
public void Listo_Cola(int red, int green,int blue){
orden++;
for(int i=7;i>=1;i--){
if (i>1){
Cuadricula[8][i].setText(""+NumProceso);
Cuadricula[8][i].setBackground(new Color(red,green,blue));
Cuadricula[8][i].setVisible(true);
}
if(i!=7)
Cuadricula[8][i+1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
/*COLOCANDO EL PROCESO EN UNA POSICION ESPECIFICA DE LA CUADRICULA, orden
* GUARDA LA POSICION EN LA COLA*/
switch(orden)
{
case 1:
Cuadricula[8][1].setText(""+NumProceso);
Cuadricula[8][1].setBackground(new Color(red,green,blue));
Cuadricula[8][1].setVisible(true);
break;
case 2:
Cuadricula[9][1].setText(""+NumProceso);
Cuadricula[9][1].setBackground(new Color(red,green,blue));
Cuadricula[9][1].setVisible(true);
break;
case 3:
Cuadricula[10][1].setText(""+NumProceso);
Cuadricula[10][1].setBackground(new Color(red,green,blue));
Cuadricula[10][1].setVisible(true);
break;
case 4:
Cuadricula[11][1].setText(""+NumProceso);
Cuadricula[11][1].setBackground(new Color(red,green,blue));
Cuadricula[11][1].setVisible(true);
break;
case 5:
Cuadricula[12][1].setText(""+NumProceso);
Cuadricula[12][1].setBackground(new Color(red,green,blue));
Cuadricula[12][1].setVisible(true);
break;
case 6:
Cuadricula[13][1].setText(""+NumProceso);
Cuadricula[13][1].setBackground(new Color(red,green,blue));
Cuadricula[13][1].setVisible(true);
break;
case 7:
Cuadricula[14][1].setText(""+NumProceso);
Cuadricula[14][1].setBackground(new Color(red,green,blue));
Cuadricula[14][1].setVisible(true);
break;
case 8:
Cuadricula[15][1].setText(""+NumProceso);
Cuadricula[15][1].setBackground(new Color(red,green,blue));
Cuadricula[15][1].setVisible(true);
break;
case 9:
Cuadricula[16][1].setText(""+NumProceso);
Cuadricula[16][1].setBackground(new Color(red,green,blue));
Cuadricula[16][1].setVisible(true);
break;
case 10:
Cuadricula[17][1].setText(""+NumProceso);
Cuadricula[17][1].setBackground(new Color(red,green,blue));
Cuadricula[17][1].setVisible(true);
break;
case 11:
Cuadricula[18][1].setText(""+NumProceso);
Cuadricula[18][1].setBackground(new Color(red,green,blue));
Cuadricula[18][1].setVisible(true);
break;
case 12:
Cuadricula[19][1].setText(""+NumProceso);
Cuadricula[19][1].setBackground(new Color(red,green,blue));
Cuadricula[19][1].setVisible(true);
break;
case 13:
Cuadricula[20][1].setText(""+NumProceso);
Cuadricula[20][1].setBackground(new Color(red,green,blue));
Cuadricula[20][1].setVisible(true);
break;
case 14:
Cuadricula[21][1].setText(""+NumProceso);
Cuadricula[21][1].setBackground(new Color(red,green,blue));
Cuadricula[21][1].setVisible(true);
break;
case 15:
Cuadricula[22][1].setText(""+NumProceso);
Cuadricula[22][1].setBackground(new Color(red,green,blue));
Cuadricula[22][1].setVisible(true);
break;
case 16:
Cuadricula[23][1].setText(""+NumProceso);
Cuadricula[23][1].setBackground(new Color(red,green,blue));
Cuadricula[23][1].setVisible(true);
break;
case 17:
Cuadricula[24][1].setText(""+NumProceso);
Cuadricula[24][1].setBackground(new Color(red,green,blue));
Cuadricula[24][1].setVisible(true);
break;
case 18:
Cuadricula[25][1].setText(""+NumProceso);
Cuadricula[25][1].setBackground(new Color(red,green,blue));
Cuadricula[25][1].setVisible(true);
break;
case 19:
Cuadricula[26][1].setText(""+NumProceso);
Cuadricula[26][1].setBackground(new Color(red,green,blue));
Cuadricula[26][1].setVisible(true);
break;
case 20:
Cuadricula[27][1].setText(""+NumProceso);
Cuadricula[27][1].setBackground(new Color(red,green,blue));
Cuadricula[27][1].setVisible(true);
break;
default:
JOptionPane.showMessageDialog(null,"Solo se soportan 20 procesos");
}/*FIN SWITCH*/
}/*FIN Listo_Cola*/
public void actionPerformed(ActionEvent arg0) {
for(int i=0;i<25;i++){
for (int j=0;j<25;j++){
if (arg0.getSource().equals(Cuadricula[i][j])) {

}
}
}

}/*FIN actionPerformed*/
}/*FIN DE LA CLASE SimuladorPORTURNOS*/

Clase Simulador

2007-09-10T09:39:00.002-07:00

/*** ESTA CLASE SE UTILIZA PARA MOSTRAR EN PANTALLA LA SIMULACION DEL
* MOVIMIENTO DE LOS PORCESOS, SE USA UNA MATRIZ DE OBJETOS JTextField's
* PARA SIMULAR LOS PROCESOS Y SUS RESPECTIVOS ESTADOS */
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class Simulador extends JFrame implements ActionListener{
private JButton Cuadricula[][]=new JButton[30][25];
private JPanel PanelContenedor=new JPanel();
private int NumProceso=0;
private int NumProceso1=0;
private int orden=0,orden1=0;;
/*CONSTRUCTOR*/
public Simulador(){
PanelContenedor.setLayout(new GridLayout(30,25,0,0));
NumProceso1=NumProceso;
for(int i=0;i<30;i++){
for (int j=0;j<25;j++){
Cuadricula[i][j]=new JButton("");
Cuadricula[i][j].setVisible(false);
PanelContenedor.add(Cuadricula[i][j]);

if (i==8 && j==8){
Cuadricula[i][j].setText("L");
Cuadricula[i][j].setToolTipText("Estado LISTO");
Cuadricula[i][j].setVisible(true);
}
if (i==8 && j==17){
Cuadricula[i][j].setText("E");
Cuadricula[i][j].setToolTipText("Estado EJECUCION");
Cuadricula[i][j].setVisible(true);
}
if (i==0 && j==0){
Cuadricula[i][j].setText("N");
Cuadricula[i][j].setToolTipText("Estado NUEVO");
Cuadricula[i][j].setVisible(true);
}
if (i==0 && j==24){
Cuadricula[i][j].setText("T");
Cuadricula[i][j].setToolTipText("Estado TERMINADO");
Cuadricula[i][j].setVisible(true);
}
}/*Termina FOR*/
}/*Termina FOR*/

getContentPane().add(PanelContenedor);

setSize(1000,800);
setResizable(true);
setVisible(true);
}/*FIN CONSTRUCTOR*/
/*MOVIENDO EL PROCESO DESDE EL ESTADO DE LISTO HASTA EL ESTADO DE EJECUCION
* SE RECIBE EN limite EL NUMERO DEL PROCESO QUE ES EQUIVALENTE A SU NOMBRE*/
public void Listo_Ejecucion(int limite){
Cuadricula[7+limite][1].setVisible(false);
Color fondo=Cuadricula[7+limite][1].getBackground();

for(int i=8;i<=17;i++){
Cuadricula[7][i].setText(String.valueOf(limite));
Cuadricula[7][i].setBackground(fondo);
Cuadricula[7][i].setVisible(true);
Cuadricula[7][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
}/*FIN Listo_Ejecucion*/
/*MOVIENDOEL PROCESO DESDE ESTADO DE EJECUCION HASTA EL ESTADO DE LISTO, SE DEVUELVE EL COLOR
* DE FONDO PARA QUE SE PUEDA UTILIZAR EN LOS DEMAS MOVIMIENTOS, limite EQUIVALE AL NUMERO
* DEL PROCESO QUE SE ENCUENTRA EN MOVIMIENTO*/
public Color Ejecucion_Listo(int limite){
Cuadricula[7][17].setVisible(false);
Cuadricula[7+limite][1].setVisible(false);
Color fondo=Cuadricula[7+limite][1].getBackground();

for(int i=17;i>=8;i--){
Cuadricula[9][i].setText(String.valueOf(limite));
Cuadricula[9][i].setBackground(fondo);
Cuadricula[9][i].setVisible(true);
Cuadricula[9][i+1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[7][8].setVisible(false);
Cuadricula[9][8].setVisible(false);

return(Cuadricula[7][8].getBackground());
}/*FIN Ejecucion_Listo*/
/*COLOCANDO LOS PROCESOS QUE SE ENCUENTRAN EN EL ESTADO LISTO, EN LA COLA RESPECTIVA
* limite EQUIVALE EL NUMERO DE PROCESO*/
public void Listo_Cola1(Color fondo,int limite){
Cuadricula[7][8].setVisible(false);
orden++;
for(int i=7;i>=1;i--){
if (i>1){
Cuadricula[8][i].setText(""+limite);
Cuadricula[8][i].setBackground(fondo);
Cuadricula[8][i].setVisible(true);
}
if(i!=7)
Cuadricula[8][i+1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
/*EL SWITCH NOS AYUDA A COLOCAR LOS PROCESOS EN SUS POSICIONES RESPECTIVAS DENTRO DE LA COLA
*limite ES IGUAL AL NUMERO DEL PROCESO, Y TAMBIEN EL NUMERO DE POSICION EN RENGLONES DE
*LA CUADRICULA (LA COLA LISTO)*/
switch(limite)
{
case 1:
Cuadricula[8][1].setText(""+limite);
Cuadricula[8][1].setBackground(fondo);
Cuadricula[8][1].setVisible(true);
break;
case 2:
Cuadricula[9][1].setText(""+limite);
Cuadricula[9][1].setBackground(fondo);
Cuadricula[9][1].setVisible(true);
break;
case 3:
Cuadricula[10][1].setText(""+limite);
Cuadricula[10][1].setBackground(fondo);
Cuadricula[10][1].setVisible(true);
break;
case 4:
Cuadricula[11][1].setText(""+limite);
Cuadricula[11][1].setBackground(fondo);
Cuadricula[11][1].setVisible(true);
break;
case 5:
Cuadricula[12][1].setText(""+limite);
Cuadricula[12][1].setBackground(fondo);
Cuadricula[12][1].setVisible(true);
break;
case 6:
Cuadricula[13][1].setText(""+limite);
Cuadricula[13][1].setBackground(fondo);
Cuadricula[13][1].setVisible(true);
break;
case 7:
Cuadricula[14][1].setText(""+limite);
Cuadricula[14][1].setBackground(fondo);
Cuadricula[14][1].setVisible(true);
break;
case 8:
Cuadricula[15][1].setText(""+limite);
Cuadricula[15][1].setBackground(fondo);
Cuadricula[15][1].setVisible(true);
break;
case 9:
Cuadricula[16][1].setText(""+limite);
Cuadricula[16][1].setBackground(fondo);
Cuadricula[16][1].setVisible(true);
break;
case 10:
Cuadricula[17][1].setText(""+limite);
Cuadricula[17][1].setBackground(fondo);
Cuadricula[17][1].setVisible(true);
break;
case 11:
Cuadricula[18][1].setText(""+limite);
Cuadricula[18][1].setBackground(fondo);
Cuadricula[18][1].setVisible(true);
break;
case 12:
Cuadricula[19][1].setText(""+limite);
Cuadricula[19][1].setBackground(fondo);
Cuadricula[19][1].setVisible(true);
break;
case 13:
Cuadricula[20][1].setText(""+limite);
Cuadricula[20][1].setBackground(fondo);
Cuadricula[20][1].setVisible(true);
break;
case 14:
Cuadricula[21][1].setText(""+limite);
Cuadricula[21][1].setBackground(fondo);
Cuadricula[21][1].setVisible(true);
break;
case 15:
Cuadricula[22][1].setText(""+limite);
Cuadricula[22][1].setBackground(fondo);
Cuadricula[22][1].setVisible(true);
break;
case 16:
Cuadricula[23][1].setText(""+limite);
Cuadricula[23][1].setBackground(fondo);
Cuadricula[23][1].setVisible(true);
break;
case 17:
Cuadricula[24][1].setText(""+limite);
Cuadricula[24][1].setBackground(fondo);
Cuadricula[24][1].setVisible(true);
break;
case 18:
Cuadricula[25][1].setText(""+limite);
Cuadricula[25][1].setBackground(fondo);
Cuadricula[25][1].setVisible(true);
break;
case 19:
Cuadricula[26][1].setText(""+limite);
Cuadricula[26][1].setBackground(fondo);
Cuadricula[26][1].setVisible(true);
break;
case 20:
Cuadricula[27][1].setText(""+limite);
Cuadricula[27][1].setBackground(fondo);
Cuadricula[27][1].setVisible(true);
break;
default:
JOptionPane.showMessageDialog(null,"Solo se soportan 20 procesos");
}/*FIN SWITCH*/
}/*FIN Listo_Cola1*/
/*MOVIENDO EL PROCESO ACTUAL EN EJECUCION DESDE EL ESTADO EJECUCION HASTA EL ESTADO DE TERMINADO
* limite ES IGUAL AL NUMERO DEL PROCESO*/
public void Ejecucion_Terminado(int limite){
orden1++;
NumProceso1++;
Color fondo=Cuadricula[7][17].getBackground();

/*HACIENDO EL RECORRIDO POR LA CUADRICULA*/
for(int i=7,j=6;i>=1;i--,j--){
Cuadricula[i][17].setText(""+limite);
Cuadricula[i][17].setBackground(fondo);
Cuadricula[i][17].setVisible(true);
try {
Thread.sleep(100);
Cuadricula[j+1][17].setVisible(false);
}
catch (InterruptedException e){e.printStackTrace();}
}

for(int i=17;i<25;i++){
Cuadricula[1][i].setText(""+limite);
Cuadricula[1][i].setBackground(fondo);
Cuadricula[1][i].setVisible(true);
Cuadricula[1][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[1][24].setVisible(false);
/*EL SWITCH NOS AYUDA A COLOCAR LOS PROCESOS EN SUS POSICIONES RESPECTIVAS DENTRO DE LA COLA
*orden1 ES IGUAL AL NUMERO DEL PROCESO, Y TAMBIEN EL NUMERO DE POSICION EN RENGLONES DE
*LA CUADRICULA (LA COLA TERMINADO)*/
switch(orden1)
{
case 1:
Cuadricula[8][24].setText(String.valueOf(limite));
Cuadricula[8][24].setBackground(fondo);
Cuadricula[8][24].setVisible(true);
break;
case 2:
Cuadricula[9][24].setText(String.valueOf(limite));
Cuadricula[9][24].setBackground(fondo);
Cuadricula[9][24].setVisible(true);
break;
case 3:
Cuadricula[10][24].setText(String.valueOf(limite));
Cuadricula[10][24].setBackground(fondo);
Cuadricula[10][24].setVisible(true);
break;
case 4:
Cuadricula[11][24].setText(String.valueOf(limite));
Cuadricula[11][24].setBackground(fondo);
Cuadricula[11][24].setVisible(true);
break;
case 5:
Cuadricula[12][24].setText(String.valueOf(limite));
Cuadricula[12][24].setBackground(fondo);
Cuadricula[12][24].setVisible(true);
break;
case 6:
Cuadricula[13][24].setText(String.valueOf(limite));
Cuadricula[13][24].setBackground(fondo);
Cuadricula[13][24].setVisible(true);
break;
case 7:
Cuadricula[14][24].setText(String.valueOf(limite));
Cuadricula[14][24].setBackground(fondo);;
Cuadricula[14][24].setVisible(true);
break;
case 8:
Cuadricula[15][24].setText(String.valueOf(limite));
Cuadricula[15][24].setBackground(fondo);
Cuadricula[15][24].setVisible(true);
break;
case 9:
Cuadricula[16][24].setText(String.valueOf(limite));
Cuadricula[16][24].setBackground(fondo);
Cuadricula[16][24].setVisible(true);
break;
case 10:
Cuadricula[17][24].setText(String.valueOf(limite));
Cuadricula[17][24].setBackground(fondo);
Cuadricula[17][24].setVisible(true);
break;
case 11:
Cuadricula[18][24].setText(String.valueOf(limite));
Cuadricula[18][24].setBackground(fondo);
Cuadricula[18][24].setVisible(true);
break;
case 12:
Cuadricula[19][24].setText(String.valueOf(limite));
Cuadricula[19][24].setBackground(fondo);
Cuadricula[19][24].setVisible(true);
break;
case 13:
Cuadricula[20][24].setText(String.valueOf(limite));
Cuadricula[20][24].setBackground(fondo);
Cuadricula[20][24].setVisible(true);
break;
case 14:
Cuadricula[21][24].setText(String.valueOf(limite));
Cuadricula[21][24].setBackground(fondo);
Cuadricula[21][24].setVisible(true);
break;
case 15:
Cuadricula[22][24].setText(String.valueOf(limite));
Cuadricula[22][24].setBackground(fondo);
Cuadricula[22][24].setVisible(true);
break;
case 16:
Cuadricula[23][24].setText(String.valueOf(limite));
Cuadricula[23][24].setBackground(fondo);
Cuadricula[23][24].setVisible(true);
break;
case 17:
Cuadricula[24][24].setText(String.valueOf(limite));
Cuadricula[24][24].setBackground(fondo);
Cuadricula[24][24].setVisible(true);
break;
case 18:
Cuadricula[25][24].setText(String.valueOf(limite));
Cuadricula[25][24].setBackground(fondo);
Cuadricula[25][24].setVisible(true);
break;
case 19:
Cuadricula[26][24].setText(String.valueOf(limite));
Cuadricula[26][24].setBackground(fondo);
Cuadricula[26][24].setVisible(true);
break;
case 20:
Cuadricula[27][24].setText(String.valueOf(limite));
Cuadricula[27][24].setBackground(fondo);
Cuadricula[27][24].setVisible(true);
break;
default:
JOptionPane.showMessageDialog(null,"Solo se soportan 20 procesos");
}/*FIN SWITCH*/
}/*FIN Ejecucion_Terminado*/
/*MOVIENDO EL PROCESO DESDE EL ESTADO NUEVO HASTA EL ESTADO LISTO SE ENVIAN TRES PARAMETROS
* QUE PERTENECEN A LOS COMPONENTES DEL COLOR QUE TOMARA COMO FONDO EL BOTON QUE REPRESENTA AL
* PROCESO. no es necesario enviar el numero del proceso, batsa con el contador NumProceso,pues
* con solo irse encrementando de 1 en 1 es mas que suficiente para definir el numero o nombre
* del nuevo proceso creado */
public void Nuevo_Listo(int red, int green,int blue){
NumProceso++;/*numero de los procesos*/
for(int i=1;i<8;i++){
Cuadricula[1][i].setText(""+NumProceso);
Cuadricula[1][i].setBackground(new Color(red,green,blue));
Cuadricula[1][i].setVisible(true);
Cuadricula[1][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[1][7].setVisible(false);
for(int i=1;i<8;i++){
Cuadricula[i][8].setText(""+NumProceso);
Cuadricula[i][8].setBackground(new Color(red,green,blue));
Cuadricula[i][8].setVisible(true);
Cuadricula[i-1][8].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[7][8].setVisible(false);
}/*Fin Nuevo_Listo*/
/*MOVIENDO LOS PROCESOS DESDE EL ESTADO LISTO A LA COLA DE ESPERA, ESTA FUNCION SE EJECUTA CUANDO
* LOS PROCESOS APENAS HAN SIDO CREADOS*/
public void Listo_Cola(int red, int green,int blue){
orden++;
for(int i=7;i>=1;i--){
if (i>1){
Cuadricula[8][i].setText(""+NumProceso);
Cuadricula[8][i].setBackground(new Color(red,green,blue));
Cuadricula[8][i].setVisible(true);
}
if(i!=7)
Cuadricula[8][i+1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
switch(orden)
{
case 1:
Cuadricula[8][1].setText(""+NumProceso);
Cuadricula[8][1].setBackground(new Color(red,green,blue));
Cuadricula[8][1].setVisible(true);
break;
case 2:
Cuadricula[9][1].setText(""+NumProceso);
Cuadricula[9][1].setBackground(new Color(red,green,blue));
Cuadricula[9][1].setVisible(true);
break;
case 3:
Cuadricula[10][1].setText(""+NumProceso);
Cuadricula[10][1].setBackground(new Color(red,green,blue));
Cuadricula[10][1].setVisible(true);
break;
case 4:
Cuadricula[11][1].setText(""+NumProceso);
Cuadricula[11][1].setBackground(new Color(red,green,blue));
Cuadricula[11][1].setVisible(true);
break;
case 5:
Cuadricula[12][1].setText(""+NumProceso);
Cuadricula[12][1].setBackground(new Color(red,green,blue));
Cuadricula[12][1].setVisible(true);
break;
case 6:
Cuadricula[13][1].setText(""+NumProceso);
Cuadricula[13][1].setBackground(new Color(red,green,blue));
Cuadricula[13][1].setVisible(true);
break;
case 7:
Cuadricula[14][1].setText(""+NumProceso);
Cuadricula[14][1].setBackground(new Color(red,green,blue));
Cuadricula[14][1].setVisible(true);
break;
case 8:
Cuadricula[15][1].setText(""+NumProceso);
Cuadricula[15][1].setBackground(new Color(red,green,blue));
Cuadricula[15][1].setVisible(true);
break;
case 9:
Cuadricula[16][1].setText(""+NumProceso);
Cuadricula[16][1].setBackground(new Color(red,green,blue));
Cuadricula[16][1].setVisible(true);
break;
case 10:
Cuadricula[17][1].setText(""+NumProceso);
Cuadricula[17][1].setBackground(new Color(red,green,blue));
Cuadricula[17][1].setVisible(true);
break;
case 11:
Cuadricula[18][1].setText(""+NumProceso);
Cuadricula[18][1].setBackground(new Color(red,green,blue));
Cuadricula[18][1].setVisible(true);
break;
case 12:
Cuadricula[19][1].setText(""+NumProceso);
Cuadricula[19][1].setBackground(new Color(red,green,blue));
Cuadricula[19][1].setVisible(true);
break;
case 13:
Cuadricula[20][1].setText(""+NumProceso);
Cuadricula[20][1].setBackground(new Color(red,green,blue));
Cuadricula[20][1].setVisible(true);
break;
case 14:
Cuadricula[21][1].setText(""+NumProceso);
Cuadricula[21][1].setBackground(new Color(red,green,blue));
Cuadricula[21][1].setVisible(true);
break;
case 15:
Cuadricula[22][1].setText(""+NumProceso);
Cuadricula[22][1].setBackground(new Color(red,green,blue));
Cuadricula[22][1].setVisible(true);
break;
case 16:
Cuadricula[23][1].setText(""+NumProceso);
Cuadricula[23][1].setBackground(new Color(red,green,blue));
Cuadricula[23][1].setVisible(true);
break;
case 17:
Cuadricula[24][1].setText(""+NumProceso);
Cuadricula[24][1].setBackground(new Color(red,green,blue));
Cuadricula[24][1].setVisible(true);
break;
case 18:
Cuadricula[25][1].setText(""+NumProceso);
Cuadricula[25][1].setBackground(new Color(red,green,blue));
Cuadricula[25][1].setVisible(true);
break;
case 19:
Cuadricula[26][1].setText(""+NumProceso);
Cuadricula[26][1].setBackground(new Color(red,green,blue));
Cuadricula[26][1].setVisible(true);
break;
case 20:
Cuadricula[27][1].setText(""+NumProceso);
Cuadricula[27][1].setBackground(new Color(red,green,blue));
Cuadricula[27][1].setVisible(true);
break;
default:
JOptionPane.showMessageDialog(null,"Solo se soportan 20 procesos");
}/*FIN SWITCH*/
}/*FIN Listo_Cola*/
public void actionPerformed(ActionEvent arg0) {
for(int i=0;i<25;i++){
for (int j=0;j<25;j++){
if (arg0.getSource().equals(Cuadricula[i][j])) {

}
}
}

}
}/*FIN DE LA CLAS Simulador*/

Clase Procesos

2007-09-10T09:39:00.001-07:00

public class Procesos {
private String StringNombre;
private int IntTiempoLlegada;
private int IntTiempoRafaga;
private int IntPrioridad;

public Procesos(String nombre,int TLLegada,int Trafaga,int Prioridad){
this.StringNombre=nombre;
this.IntTiempoLlegada=TLLegada;
this.IntTiempoRafaga=Trafaga;
this.IntPrioridad=Prioridad;
}

public int getIntPrioridad() {
return IntPrioridad;
}

public void setIntPrioridad(int intPrioridad) {
IntPrioridad = intPrioridad;
}

public int getIntTiempoLlegada() {
return IntTiempoLlegada;
}

public void setIntTiempoLlegada(int intTiempoLlegada) {
IntTiempoLlegada = intTiempoLlegada;
}

public int getIntTiempoRafaga() {
return IntTiempoRafaga;
}

public void setIntTiempoRafaga(int intTiempoRafaga) {
IntTiempoRafaga = intTiempoRafaga;
}

public String getStringNombre() {
return StringNombre;
}

public void setStringNombre(String stringNombre) {
StringNombre = stringNombre;
}
}

Clase Algoritmo por Prioridades

2007-09-10T09:36:00.001-07:00

import java.util.Arrays;
import java.util.Vector;

public class Prioridades {
/*ESTA CLASE RECIBE UN VECTOR CON TODOS LOS DATOS QUE SE NECESITAN PARA
EMPEZAR A EJECUTAR EL ALGORITMO, EN ESTE SE EVALUAN LAS PRIORIDADES
QUE SE LE ASIGNARON A LOS PROCESOS, Y EJECUTA EL PROCESO DE MAYOR PRIORIDAD =1*/
Vector VectorProcesos;
private int DoubleTiempoEspera;
private double DoubleTiempoEspera1;
Arrays vector;
private int vectoraux[];
private int NumeroProceso[];
private int VectorPrioridad[];
private String ProcesosNombres[];
/*EN EL CONTRUCTOR SE RECIBE EL VECTOR CON TODOS LOS DATOS DE LOS PROCESOS*/
public Prioridades(Vector VectorProcesos){
this.VectorProcesos = VectorProcesos;
vectoraux=new int[VectorProcesos.size()];
NumeroProceso=new int[VectorProcesos.size()];
VectorPrioridad=new int[VectorProcesos.size()];
ProcesosNombres=new String[VectorProcesos.size()];
}
/*EN ESTA PARTE SE CALCULA EL TIEMPO PROMEDIO DE ESPERA DEL ALGORTIMO*/
public void getTiempoEsperaPromedio(){
int i=0;
for (i=0;i vectoraux[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
VectorPrioridad[i]=((Procesos)VectorProcesos.elementAt(i)).getIntPrioridad();
ProcesosNombres[i]=((Procesos)VectorProcesos.elementAt(i)).getStringNombre();
NumeroProceso[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada()+1;
}
ordena(); /*ordenando los procesos*/
for (i=0;i System.out.println(ProcesosNombres[i]+">>"+vectoraux[i]+">>"+VectorPrioridad[i]);
}

DoubleTiempoEspera=vectoraux[0];
for (i=1;i DoubleTiempoEspera+=vectoraux[i];
vectoraux[i]=DoubleTiempoEspera;
}

DoubleTiempoEspera1=0;
for (i=0;i DoubleTiempoEspera1+=vectoraux[i];
}

DoubleTiempoEspera1=DoubleTiempoEspera1/VectorProcesos.size();
System.out.println(DoubleTiempoEspera1);
}

public void ordena(){
int aux,aux2,aux3,k,i;
String aux1;

for(i=1;i aux =VectorPrioridad[i];
aux2=vectoraux[i];
aux1= ProcesosNombres[i];
aux3=NumeroProceso[i];
k=i-1;
while (k >= 0 && aux < VectorPrioridad[k]){
vectoraux[k+1] = vectoraux[k];
ProcesosNombres[k+1]=ProcesosNombres[k];
VectorPrioridad[k+1]=VectorPrioridad[k];
NumeroProceso[k+1]=NumeroProceso[k];
k=k-1;
}
vectoraux[k+1] = aux2;
VectorPrioridad[k+1]=aux;
ProcesosNombres[k+1]=aux1;
NumeroProceso[k+1]=aux3;
}
}

public int[] getValores(){
return vectoraux;
}
/*DEVULEVE LOS NOMBRES DE LOS PROCESOS*/
public String []getNombre(){
return ProcesosNombres;
}
/*DEVUELVE LOS NUMEROS DE PROCESO*/
public int[] getNumeroProceso(){
return NumeroProceso;
}
/*DEVUELVE LOS RESULTADOS*/
public double imprimeResultado(){
return DoubleTiempoEspera1;
}

}

Clase algoritmo PorTurnos

2007-09-10T09:34:00.000-07:00

import java.util.Vector;
import javax.swing.*;

public class PorTurnos {
/*ESTA CLASE RECIBE UN VECTOR CON TODOS LOS DATOS QUE SE NECESITAN PARA
EMPEZAR A EJECUTAR EL ALGORITMO, EN ESTE SE NECESITA DAR UN QUANTUM DE TIEMPO
YA QUE EL ALGORITMO EJECUTA CADA PROCESO EN ESE TIEMPO Y PASA AL SIGUIENTE PROCESO
Y ASI SUCESIVAMENTE HASTA LLEGAR AL ULTIMO PROCESO Y VUELVE AL INICIO Y CUANDO
EL PROCESO YA TERMINA, SE VA SALIENDO*/
private int []TRafaga;
private int []RealTRafaga;
private int tamano=0;
private int Quantum=4;
private int []NewTRafaga =new int[30];
private int []NewTRafaga1;
private int NumeroProceso[];
private String []ProcesosNombres;
private String []NewNombres=new String[30];
private String []NewNombres1;
private double DoubleTiempoEspera1;
Vector VectorProcesos;
/*EN EL CONTRUCTOR SE RECIBE EL VECTOR CON TODOS LOS DATOS DE LOS PROCESOS*/
public PorTurnos(Vector VectorProcesos){
this.VectorProcesos=VectorProcesos;
TRafaga=new int[VectorProcesos.size()];
RealTRafaga=new int[VectorProcesos.size()];
ProcesosNombres=new String[VectorProcesos.size()];
NumeroProceso=new int[VectorProcesos.size()];
Quantum=Integer.parseInt(JOptionPane.showInputDialog(null,"Introduzca el valor del Quantum"));
for (int i=0;i TRafaga[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
RealTRafaga[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
ProcesosNombres[i]=((Procesos)VectorProcesos.elementAt(i)).getStringNombre();
NumeroProceso[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada()+1;
}
}
/*EN ESTA PARTE SE CALCULA EL TIEMPO PROMEDIO DE ESPERA DEL ALGORTIMO*/
public void getTiempoEspera(){
int mayor,valor,j=1,p=0,numQuantum=1;
String proceso;

mayor=TRafaga[0];/*Calculando el mayor*/
for (int i=0;i NewTRafaga[i]=-1;
}
for (int i=0;i if (mayor mayor=TRafaga[i];
}
}
NewTRafaga[0]=0;
valor=(mayor/Quantum);
for (int h=0;h for (int i=0;i if(TRafaga[i]!=0){
if(Quantum>TRafaga[i]){
NewTRafaga[j]=NewTRafaga[j-1]+TRafaga[i];
NewNombres[j-1]=ProcesosNombres[i];
TRafaga[i]=0;
j++;
}
else{
TRafaga[i]-=Quantum;
NewTRafaga[j]=NewTRafaga[j-1]+Quantum;
NewNombres[j-1]=ProcesosNombres[i];
j++;
}
}
}
}
for (int i=0;i if(NewTRafaga[i]!=-1){
tamano++;
}
}
NewTRafaga1 =new int[tamano];
NewNombres1=new String[tamano];
for(int z=0;z if(z NewTRafaga1[z]=NewTRafaga[z];
NewNombres1[z]=NewNombres [z];
}
else
break;
}

int numeroRepeticiones=0;
int UltimaPosicion=1;
DoubleTiempoEspera1=0;
double temporalT;

for(int i=0;i proceso=NewNombres1[i];
numeroRepeticiones=0;
for(int k=0;k
if(proceso==NewNombres1[k]){
numeroRepeticiones+=1;
UltimaPosicion=k;
}
}
temporalT=(numeroRepeticiones-1)*Quantum;
DoubleTiempoEspera1+=Math.abs(NewTRafaga1[UltimaPosicion]-temporalT);//Math.abs(TiempoRafaga[1]-nuevoQuantum);
}/*Fin FOR*/
DoubleTiempoEspera1=DoubleTiempoEspera1/VectorProcesos.size();
}
/*SE DEVUELVE EL TIEMPO DE RAFAGA*/
public int[] getValores() {
return NewTRafaga1;
}
/* SE DEVULVE LA NUEVA LA LONGITUD PARA EL VECTOR QUE CONTIENE LOS NUEVOS TIEMPOS DE RAFAGA*/
public int getTamano(){
return tamano;
}
/*SE DEVUELVE EL QUANTUM DE TIEMPO*/
public int getQuantum(){
return Quantum;
}
/*SE DEVUELVE EL VECTOR CON LOS NOMBRES DE LOS PROCESOS*/
public String[] getNombre() {
return NewNombres1;
}
/*SE DEVULVE EL TIEMPO PROMEDIO DE ESPERA*/
public double getTEP(){
return DoubleTiempoEspera1;
}
/*SE DEVUELVE LOS NUMEROS DE PROCESOS*/
public int[] getNumeroProceso(){
return NumeroProceso;
}
/*DEVUELVE EL TIEMPO DE RAFAGA, EL QUE TRAE REGISTRADO DESDE QUE SE CREA EL PROCESO */
public int []gerRealTRafaga(){
return RealTRafaga;
}
/*IMPRIME EL TIEMPO PROMEDIO DE ESPERA*/
public void imprimeResultado() {
System.out.println(DoubleTiempoEspera1);
}
}

Clase HiloPorTurnos

2007-09-10T09:33:00.000-07:00

/*ESTA CLASE HACE LA SIMULACION CON SU RESPECTIVO TIEMPO DE RETARDO
*UNICAMENTE PARA EL ALGORITMO POR TURNOS*/
import java.awt.Color;
import javax.swing.*;
public class HiloPorTurnos extends Thread {
int retardo;
int valorNew;
int limite=1;
int numeroProceso[];
int red,green,blue;
private int Quantum;
String nombre;
String Titulo;
JButton p1;
Simulador sim;
int tiempo;
int valores [];
private int RealTRafaga[];
/*CONSTRCUTOR. SE RECIBEN LOS TIEMPOS DE RAGAFA, NUMEROS O NOMBRES DE LOS PROCESOS,EL QUANTUM
* Y UN VECTOR ADICIONAL CON EL VERDADERO TIEMPO DE RAGAFA DE CADA PROCESO*/
public HiloPorTurnos(int []valores1,int [] NumeroProceso,String Title,int Quantum,int []RealTRafaga1){
this.valores=valores1;
this.Titulo=Title;
this.numeroProceso=NumeroProceso;
this.RealTRafaga=RealTRafaga1;
this.Quantum=Quantum;
sim=new Simulador();
sim.setExtendedState(SimuladorPORTURNOS.MAXIMIZED_BOTH);
tiempo = 0;
}/*FINCONSTRUCTOR*/
/*FUNCION RUN. SE ENCARGA DE EJECUTAR LA SIMULACION CON SU RESPECTIVO
* TIEMPO DE RETARDO, DESDE AQUI SE LLAMAN A LOS METODOS DE LA CLASE
* SimuladorPORTURNOS, QUE HACEN EL MOVIMIENTO DE LOS PROCESOS*/
public void run(){
while (limite<=numeroProceso.length) {
red=(int)(Math.random()*256);
green=(int)(Math.random()*256);
blue=(int)(Math.random()*256);
try {
sim.setTitle(" Simulación del algoritmo "+Titulo);
sim.Nuevo_Listo(red,green,blue);
sim.Listo_Cola(red,green,blue);
Thread.sleep(300);
tiempo = tiempo + 300;
limite++;
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
/*Ejecutando los procesos*/
limite=0;
while(true){
try{
sim.setTitle(" Simulación del algoritmo "+Titulo);
if (numeroProceso[limite]!=0)
sim.Listo_Ejecucion(numeroProceso[limite]);

valorNew=RealTRafaga[limite]-Quantum;
RealTRafaga[limite]=valorNew;
if (valorNew<=0 && numeroProceso[limite]!=0){
Thread.sleep(valores[limite]*100);
sim.Ejecucion_Terminado(numeroProceso[limite]);
numeroProceso[limite]=0;
}
else {
if (numeroProceso[limite]!=0){
Thread.sleep(Quantum*100);
Color fondo=sim.Ejecucion_Listo(numeroProceso[limite]);
sim.Listo_Cola1(fondo,limite+1);
}
}
tiempo = tiempo + 300;
} catch (InterruptedException e)
{
e.printStackTrace();
}
if (limite==numeroProceso.length-1)
limite=0;
else
limite++;

}/*Fin del ciclo que ejecuta los procesos*/
}/*Fin funcion RUN*/
}/*FIN DE LA CLASE HiloPorTurnos*/

Clase Hilo

2007-09-10T09:28:00.001-07:00

/*ESTA CLASE ES LA QUE HACE GRAN PARTE DE LA SIMULACION PARA LOS ALGORITMOS>
* -- FCFS
* -- SJF COOPERATIVO
* -- POR PRIORIDADES
*/
import javax.swing.*;
public class Hilo extends Thread {
int retardo;
int limite=1;
int numeroProceso[];
int red,green,blue;
String nombre;
String Titulo;
JButton p1;
Simulador sim;
int tiempo;
int valores [];
/*CONSTRUCTOR RECIBE LOS VALORES DE RAFAGA, LOS NMEROS DE LOS PROCESOS
* Y EL NOMBRE DEL ALGORITMO*/
public Hilo(int []valores1,int [] NumeroProceso,String Title){
this.valores=valores1;
this.Titulo=Title;
this.numeroProceso=NumeroProceso;
sim=new Simulador();
sim.setExtendedState(Simulador.MAXIMIZED_BOTH);
tiempo = 0;
}/*FIN CONSTRUCTOR*/
/*FUNCION RUN. SE ENCARGA DE EJECUTAR LA SIMULACION CON SU RESPECTIVO
* TIEMPO DE RETARDO, DESDE AQUI SE LLAMAN A LOS METODOS DE LA CLASE
* Simulador, QUE HACEN EL MOVIMIENTO DE LOS PROCESOS*/
public void run(){
while (limite<=valores.length) {
red=(int)(Math.random()*256);
green=(int)(Math.random()*256);
blue=(int)(Math.random()*256);
try {
sim.setTitle(" Simulación del algoritmo "+Titulo);
sim.Nuevo_Listo(red,green,blue);
sim.Listo_Cola(red,green,blue);
Thread.sleep(300);
tiempo = tiempo + 300;
limite++;
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
/*Ejecutando los procesos*/
limite=0;
while(limite try{
sim.setTitle(" Simulación del algoritmo "+Titulo);
sim.Listo_Ejecucion(numeroProceso[limite]);
Thread.sleep(valores[limite]*100);
sim.Ejecucion_Terminado(numeroProceso[limite]);

tiempo = tiempo + 300;
limite++;
} catch (InterruptedException e)
{
e.printStackTrace();
}
}/*Fin del ciclo que ejecuta los procesos*/
}/*Fin funcion RUN*/
}/*FIN DE LA CLASE Hilo*/

Algoritmo FCFS

2007-09-10T09:24:00.000-07:00

import java.util.*;
public class FCFS {
/*ESTA CLASE RECIBE UN VECTOR CON TODOS LOS DATOS QUE SE NECESITAN PARA
EMPEZAR A EJECUTAR EL ALGORITMO, EN ESTE SE EMPIEZAN A
EJECUTAR LOS PROCESOS A COMO FUERON LLEGANDO*/
Vector VectorProcesos;
private double DoubleTiempoEspera=0;
private int DoubleTiempoEspera1=0;
private int vectoraux[];
private int NumeroProceso[];
private String ProcesosNombres[];
private double vectoraux1[];
/*EN EL CONTRUCTOR SE RECIBE EL VECTOR CON TODOS LOS DATOS DE LOS PROCESOS*/
public FCFS(Vector VectorProcesos){
this.VectorProcesos = VectorProcesos;
vectoraux=new int[VectorProcesos.size()];
NumeroProceso=new int[VectorProcesos.size()];
ProcesosNombres=new String[VectorProcesos.size()];
vectoraux1=new double[VectorProcesos.size()];
}
/*EN ESTA PARTE SE CALCULA EL TIEMPO PROMEDIO DE ESPERA DEL ALGORTIMO*/
public double getTiempoEsperaPromedio(){
for (int i=0;i DoubleTiempoEspera+=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
DoubleTiempoEspera1+=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
ProcesosNombres[i]=((Procesos)VectorProcesos.elementAt(i)).getStringNombre();
NumeroProceso[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada()+1;
vectoraux[i]=DoubleTiempoEspera1;
vectoraux1[i]=DoubleTiempoEspera;
}
DoubleTiempoEspera=0;
for (int i=0;i DoubleTiempoEspera+=vectoraux1[i];
}
DoubleTiempoEspera=DoubleTiempoEspera/VectorProcesos.size();
return DoubleTiempoEspera;
}
/*SE DEVUELVEN LOS TIEMPOS DE RAFAGA*/
public int[] getValores(){
return vectoraux;
}
/*SE DEVUELVEN EL TIEMPO DE RAFAGA*/
public String[] getNombre(){
return ProcesosNombres;
}
/*SE DEVUELVE EL NUMERO DE PROCESO*/
public int[] getNumeroProceso(){
return NumeroProceso;
}
/*SE DEVUELVE EL TIEMPO PROMEDIO DE ESPERA*/
public double imprimeResultado(){
System.out.println(DoubleTiempoEspera);
return DoubleTiempoEspera;
}

}

Clase DiagramaGantt

2007-09-10T09:18:00.000-07:00

/**ESTA CLASE HACE EL DIBUJO DEL DIAGRAMA DE GANTT PARA
* CADA ALGORITMO EJECUTADO*/
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.LayoutManager;
import java.util.Vector;
import javax.swing.*;

public class DiagramaGantt extends JFrame{
Vector VectorProcesos=new Vector();/*el vector que va a contener todos los procesos creados*/
private JPanel PanelDiagrama=new JPanel();/*en este panel se dibujará el diagrama de gantt*/
private JPanel PanelTEP;/*en este panel se mostrará el Tiempo promedio de espera*/
private JLabel GanttBotones[];
private JLabel GanttEtiquetas[];
private GridLayout GridBotonesEtiquetas;
private double TiempEsperaPromedio;

/*CONSTRUCTOR*/
public DiagramaGantt(Vector VectorProcesos,String algoritmo){
this.setTitle("Diagrama de Gantt '"+algoritmo+"'");
this.VectorProcesos=VectorProcesos;
GanttBotones=new JLabel[(VectorProcesos.size()*2)+1];
GanttEtiquetas=new JLabel[(VectorProcesos.size()*2)+1];

PanelTEP=new JPanel();
PanelTEP.setLayout(new BorderLayout());
this.setLayout(new GridLayout(2,1,0,0));
}/*FIN DEL CONSTRUCTOR*/

/*ESTA FUNCION CREA EL DIAGRAMA DE GANTT PARA EL ALGORITMO SOLICITADO*/
public void crearDiagrama(int [] vectoraux,String [] ProcesosNombres1,double TEP){
GridBotonesEtiquetas = new GridLayout(2, (VectorProcesos.size()*2)+1, 5, 5);
PanelDiagrama.setLayout(GridBotonesEtiquetas);

this.TiempEsperaPromedio=TEP;
int j=0;
int vectorux[]=vectoraux;
String ProcesosNombres[]=ProcesosNombres1;

/*CREANDO LAS ETIQUETAS CON LOS NOMBRES DE LOS PROCESOS*/
for (int i=0;i<(VectorProcesos.size()*2)+1;i++){
if (i%2!=0){
GanttBotones[i]=new JLabel(ProcesosNombres[j]);
GanttBotones[i].setBorder(BorderFactory.createLineBorder(Color.BLUE, 2));
GanttBotones[i].setFont(new Font("Arial", Font.BOLD, 14));
GanttBotones[i].setHorizontalAlignment(JLabel.CENTER);
PanelDiagrama.add(GanttBotones[i]);
j++;
}
else{
GanttBotones[i]=new JLabel("");
GanttBotones[i].setVisible(false);
PanelDiagrama.add(GanttBotones[i]);
}
}
JLabel PrimerElemento=new JLabel("0");
PrimerElemento.setFont(new Font("Arial", Font.BOLD, 14));
GanttEtiquetas[0]=PrimerElemento;
PanelDiagrama.add(GanttEtiquetas[0]);
j=0;
/*CREANDO LAS ETIQUETAS CON LAS LEYENDAS DE LOS TIEMPOS DE
* RAFAGA RESPECTIVOS PARA CADA PROCESO*/
for (int i=1;i<(VectorProcesos.size()*2)+1;i++){
if(i%2==0){
String datos=new String(String.valueOf(vectorux[j]));
GanttEtiquetas[j+1]=new JLabel(datos);
GanttEtiquetas[j+1].setFont(new Font("Arial", Font.BOLD, 14));
PanelDiagrama.add(GanttEtiquetas[j+1]);
j++;
}
else{
GanttEtiquetas[i]=new JLabel("");
GanttEtiquetas[i].setVisible(false);
PanelDiagrama.add(GanttEtiquetas[i]);
}
}
/*COLOCANDO LA LEYENDA CON EL TIEMPO DE ESPERA PROMEDIO*/
JLabel LabelTEP=new JLabel("Tiempo de Espera Promedio = "+String.valueOf(TiempEsperaPromedio));
LabelTEP.setFont(new Font("Arial", Font.BOLD, 14));
PanelTEP.add(LabelTEP,BorderLayout.SOUTH);
getContentPane().add(PanelDiagrama);
getContentPane().add(PanelTEP);
setSize(400, 100);
setVisible(true);
setResizable(true);
}/*FIN DE LA FUNCION crearDiagrama*/

/*ESTA FUNCION SIRVE PARA CREAR EL DIAGRAMA DEL ALORITMO POR TURNOS*/
public void crearDiagramaPorTurnos(int [] vectoraux1,int tamano,String [] ProcesosNombres1,double TiempoEspera){
GridBotonesEtiquetas = new GridLayout(2, (tamano*2)+1, 5, 5);
PanelDiagrama.setLayout(GridBotonesEtiquetas);

GanttBotones=new JLabel[(tamano*2)+1];
GanttEtiquetas=new JLabel[(tamano*2)+1];

int j=0;
int vectorux[]=vectoraux1;
/*CREANDO LAS ETIQUETAS CON LOS NOMBRES DE LOS PROCESOS*/
for (int i=0;i<(tamano*2)-1;i++){
if (i%2!=0){
GanttBotones[i]=new JLabel(ProcesosNombres1[j]);
GanttBotones[i].setBorder(BorderFactory.createLineBorder(Color.BLUE, 2));
GanttBotones[i].setHorizontalAlignment(JLabel.CENTER);
PanelDiagrama.add(GanttBotones[i]);
j++;
}
else{
GanttBotones[i]=new JLabel("");
GanttBotones[i].setVisible(false);
PanelDiagrama.add(GanttBotones[i]);
}

}
j=0;
/*CREANDO LAS ETIQUETAS CON LAS LEYENDAS DE LOS TIEMPOS DE
* RAFAGA RESPECTIVOS PARA CADA PROCESO*/
for (int i=1;i<(tamano*2)+1;i++){
if(i%2==0){
String datos=new String(String.valueOf(vectorux[j]));
GanttEtiquetas[j]=new JLabel(datos);
PanelDiagrama.add(GanttEtiquetas[j]);
j++;
}
else{
GanttEtiquetas[i]=new JLabel("");
GanttEtiquetas[i].setVisible(false);
PanelDiagrama.add(GanttEtiquetas[i]);
}
}
/*COLOCANDO LA LEYENDA CON EL TIEMPO DE ESPERA PROMEDIO*/
JLabel LabelTEP=new JLabel("Tiempo de Espera Promedio = "+String.valueOf(TiempoEspera));
LabelTEP.setFont(new Font("Arial", Font.BOLD, 14));
PanelTEP.add(LabelTEP,BorderLayout.SOUTH);
getContentPane().add(PanelDiagrama);
getContentPane().add(PanelTEP);
setSize(400, 100);
setVisible(true);
setResizable(true);
}/* FIN DE LA FUNCION crearDiagramaPorTurnos*/
}/*FIN DE LA CLASE DiagramaGantt*/

Clase Aplicacion

2007-09-10T09:16:00.000-07:00

/** CLASE PRINCIPAL, DESDE AQUI SE HACEN LAS LLAMADAS A TODOS LOS EVENTOS
* QUE EJECUTA EL SISTEMA, COMO SON:
* --AGREGAR PROCESOS
* --ELIMINAR O MODIFICAR PROCESOS
* --HACER LA LLAMADA PARA EJECUTAR LOS ALGORITMOS*/
import java.awt.*;
import java.awt.event.*;
import java.util.Vector;
import javax.swing.*;

public class Aplicacion extends JFrame implements ActionListener{
private JMenu JMenuProcesos,JMenuAlgoritmos;
private JMenuItem JMenuFCFS,JMenuSJFCooperativo,JMenuSJFApropiativo,JMenuPrioridades,JMenuTurnos;
private JMenuItem JMenuAgregar,JMenuEliminarEditar,JMenuSalir;
private JLabel fondo;
Vector VectorProcesos=new Vector();/*el vector que va a contener todos los procesos creados*/

public Aplicacion(){
super("SISTEMA CON ALGORITMOS DE PLANIFICACION");
setSize(1180,870);
fondo= new JLabel(new ImageIcon("linux.jpg"));
getContentPane().add(fondo);

JMenuProcesos=new JMenu("Procesos");
JMenuAlgoritmos=new JMenu("Algoritmos");

/************************************************************/
/******** ******************/
/******** CONTENIDO DEL MENU PROCESOS ******************/
/******** ******************/
/************************************************************/
JMenuAgregar=new JMenuItem("Agregar un proceso",new ImageIcon("agrega.png"));
JMenuAgregar.addActionListener(this);
JMenuEliminarEditar=new JMenuItem("Eliminar / Modificar Procesos",new ImageIcon("elim.png"));
JMenuEliminarEditar.addActionListener(this);
JMenuSalir=new JMenuItem("Salir del sistema",new ImageIcon("exit.png"));
JMenuSalir.addActionListener(this);

JMenuProcesos.add(JMenuAgregar);
JMenuProcesos.add(JMenuEliminarEditar);JMenuProcesos.addSeparator();
JMenuProcesos.add(JMenuSalir);

/************************************************************/
/******** ******************/
/******** CONTENIDO DEL MENU ALGORITMOS ******************/
/******** ******************/
/************************************************************/
JMenuFCFS=new JMenuItem("FCFS",new ImageIcon("I1.png"));
JMenuFCFS.addActionListener(this);
JMenuSJFCooperativo=new JMenuItem("SJF Cooperativo",new ImageIcon("I2.png"));
JMenuSJFCooperativo.addActionListener(this);
JMenuSJFApropiativo=new JMenuItem("SJF Apropiativo",new ImageIcon("I4.png"));
JMenuSJFApropiativo.addActionListener(this);
JMenuPrioridades=new JMenuItem("Por prioridades",new ImageIcon("I3.png"));
JMenuPrioridades.addActionListener(this);
JMenuTurnos=new JMenuItem("Por Turnos",new ImageIcon("I5.png"));
JMenuTurnos.addActionListener(this);

JMenuAlgoritmos.add(JMenuFCFS);JMenuAlgoritmos.addSeparator();
JMenuAlgoritmos.add(JMenuSJFCooperativo);JMenuAlgoritmos.addSeparator();
JMenuAlgoritmos.add(JMenuSJFApropiativo);JMenuAlgoritmos.addSeparator();
JMenuAlgoritmos.add(JMenuPrioridades);JMenuAlgoritmos.addSeparator();
JMenuAlgoritmos.add(JMenuTurnos);

JMenuBar barra=new JMenuBar();
setJMenuBar(barra);
barra.add(JMenuProcesos);
barra.add(JMenuAlgoritmos);
setVisible(true);
}/*FIN DEL CONSTRUCTOR*/

/*MANEJO DE LOS EVENTOS PARA LOS MSUBMENUS DEL SISTEMA*/
public void actionPerformed(ActionEvent arg0) {
/*LLAMADA A LA VENTANA PARA AGREGAR LOS PROCESOS*/
if (arg0.getSource().equals(JMenuAgregar)) {
VentanaAgregaProcesos agrega=new VentanaAgregaProcesos(VectorProcesos);
agrega.setLocationRelativeTo(null);
}
/*LLAMADA A LA VENTANA QUE MODIFICA O ELIMINA LOS PROCESOS*/
if (arg0.getSource().equals(JMenuEliminarEditar)) {
if (!VectorProcesos.isEmpty()){
VentanaEliminaModificaProcesos EliminaEdita=new VentanaEliminaModificaProcesos(VectorProcesos);
EliminaEdita.setLocationRelativeTo(null);
}
else{
int respuesta=JOptionPane.showConfirmDialog(null,"No existen procesos almacenados. \n\n Desea abrir la ventana de captura ahora?","No hay procesos",JOptionPane.YES_NO_OPTION,JOptionPane.WARNING_MESSAGE);

if(respuesta==JOptionPane.YES_OPTION){
VentanaAgregaProcesos agrega=new VentanaAgregaProcesos(VectorProcesos);
agrega.setLocationRelativeTo(null);
}
}
}
/*SALIENDO DEL PROGRAMA*/
if (arg0.getSource().equals(JMenuSalir)) {
System.exit(0);
}
/*HACIENDO LA LLAMADA PARA EL ALGORITMO FCFS*/
if (arg0.getSource().equals(JMenuFCFS)) {
if(VectorProcesos.isEmpty()){
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. \n Debe almacenar almenos dos procesos para ejecutar este algoritmo.","No hay procesos almacenados",JOptionPane.WARNING_MESSAGE);
}else{
FCFS fcfs=new FCFS(VectorProcesos);
fcfs.getTiempoEsperaPromedio();
Hilo grafHilo = new Hilo(fcfs.getValores(),fcfs.getNumeroProceso(),"FCFS");
grafHilo.start();

DiagramaGantt gantt=new DiagramaGantt(VectorProcesos,"FSFS");
gantt.setLocationRelativeTo(null);
gantt.crearDiagrama(fcfs.getValores(),fcfs.getNombre(),fcfs.imprimeResultado());

}
}
/*HACIENDO LA LLAMADA PARA EL ALGORITMO SJF Cooperativo*/
if (arg0.getSource().equals(JMenuSJFCooperativo)) {
if(VectorProcesos.isEmpty()){
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. \n Debe almacenar almenos dos procesos para ejecutar este algoritmo.","No hay procesos almacenados",JOptionPane.WARNING_MESSAGE);
}else{
SJFCooperativo sjfcooperativo=new SJFCooperativo(VectorProcesos);
sjfcooperativo.getTiempoEsperaPromedio();
sjfcooperativo.imprimeResultado();
Hilo grafHilo = new Hilo(sjfcooperativo.getValores(),sjfcooperativo.getNumeroProceso(),"SJF Cooperativo");
grafHilo.start();

DiagramaGantt gantt=new DiagramaGantt(VectorProcesos,"SJF Cooperativo");
gantt.setLocationRelativeTo(null);
gantt.crearDiagrama(sjfcooperativo.getValores(),sjfcooperativo.getNombre(),sjfcooperativo.imprimeResultado());
}
}
/*HACIENDO LA LLAMADA PARA EL ALGORITMO SJF Apropiativo*/
if (arg0.getSource().equals(JMenuSJFApropiativo)) {
if(VectorProcesos.isEmpty()){
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. \n Debe almacenar almenos dos procesos para ejecutar este algoritmo.","No hay procesos almacenados",JOptionPane.WARNING_MESSAGE);
}else{
JOptionPane.showMessageDialog(null,"ESTA FUNCION AUN NO SE HA DESARROLLADO ","UPPPS.",JOptionPane.WARNING_MESSAGE);
}
}
/*HACIENDO LA LLAMADA PARA EL ALGORITMO "POR PRIORIDADES"*/
if (arg0.getSource().equals(JMenuPrioridades)) {
if(VectorProcesos.isEmpty()){
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. \n Debe almacenar almenos dos procesos para ejecutar este algoritmo.","No hay procesos almacenados",JOptionPane.WARNING_MESSAGE);
}else{
Prioridades prioridad=new Prioridades(VectorProcesos);
prioridad.getTiempoEsperaPromedio();

Hilo grafHilo = new Hilo(prioridad.getValores(),prioridad.getNumeroProceso(),"Por Prioridades");
grafHilo.start();

DiagramaGantt gantt=new DiagramaGantt(VectorProcesos,"Por Prioridades");
gantt.setLocationRelativeTo(null);
gantt.crearDiagrama(prioridad.getValores(),prioridad.getNombre(),prioridad.imprimeResultado());
}
}
/*HACIENDO LA LLAMADA PARA EL ALGORITMO "POR TURNOS"*/
if (arg0.getSource().equals(JMenuTurnos)) {
if(VectorProcesos.isEmpty()){
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. \n Debe almacenar almenos dos procesos para ejecutar este algoritmo.","No hay procesos almacenados",JOptionPane.WARNING_MESSAGE);
}else{
PorTurnos turno=new PorTurnos(VectorProcesos);
turno.getTiempoEspera();
turno.imprimeResultado();
HiloPorTurnos grafHilo = new HiloPorTurnos(turno.getValores(),turno.getNumeroProceso(),"Por Turnos",turno.getQuantum(),turno.gerRealTRafaga());
grafHilo.start();

DiagramaGantt gantt=new DiagramaGantt(VectorProcesos,"Por Turnos");
gantt.setLocationRelativeTo(null);
gantt.crearDiagramaPorTurnos(turno.getValores(),turno.getTamano(),turno.getNombre(),turno.getTEP());
}

}
}/*FIN DE ACTION PERFORMED*/

public static void main(String[] args) {
/*PARA QUE LAS PANTALLAS DEL PROGRAMA TOMEN LA APARIENCIA DEL TEMA
* DEL SISTEMA OPERATIVO*/
// try {
// UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
// } catch (Exception e){}

Aplicacion Algoritmos=new Aplicacion();
Algoritmos.setExtendedState(Aplicacion.MAXIMIZED_BOTH);
Algoritmos.setDefaultCloseOperation(Aplicacion.EXIT_ON_CLOSE);
}/*FIN DEL MAIN*/
}/*FIN CLASE APLICACION*/

Snake

2007-09-10T09:10:00.000-07:00

/*
PROGRAMA QUE SIMULA EL MOVIMIENTO DE LA CLASICA CULEBRA
DE LOS CELULARES...EL OBJETIVO, ES GUIAR LA CULEBRA, HACIA
LOS OBJETOS QUE APARECEN EN LA PANTALLA...Haciendola Crecer

UTILICE LAS TECLAS DE DIRECCION PARA CAMBIAR LA DIRECCION DE LA
CULEBRA...

MATERIA: ESTRUCTURA DE DATOS.

PROFESOR: FREDY JUAREZ.
ALUMNO: DARWIN SOSA GOMEZ.

INFORMATICA GRUPO: 312 A
*/

#include
#include
#include
#include
#define arriba 72
#define abajo 80
#define izquierda 75
#define derecha 77
#define instrucciones 59

/*Funciones Usadas*/
void finaliza();
void inicializa();
void culebra();
void objeto();
void pantalla();
void pantalla1();
void juego();
int sonido();

/*Variabes Usadas*/
int col;
int v=60;
int s=440;
int color1,puntos,nivel,cn;
int FinVxy=-1;/*Tope de los vectores de Direcciones*/
int vectorx[10000];
int vectory[10000];
int i,j;
int x=10;
int y=15;
int color=1;
int objetoX=1;
int objetoY=1;
char direccion1=0;
char direccion=0;
char Jnuevo=0;

void objeto()/*Funcion que genera posicion para el objeto*/
{
objetoX=(rand()%38)+1;
objetoY=(rand()%48)+1;

if(objetoX==1 || objetoY==1){objetoY+=1;objetoX+=1;}

textcolor(10);gotoxy(objetoX,objetoY);cprintf("%c",1);
}
void finaliza()
{
int fcol=0;Jnuevo=0;direccion=0;
puntos=0;nivel=0;cn=0;v=60;x=10;y=15;
clrscr();
while(Jnuevo!=60 && Jnuevo!=27)
{
while(!kbhit())
{
fcol=(rand()%15)+1;
textcolor(fcol);delay(200);
gotoxy(20,9);cprintf("²²²²²²²²²²²²²²²");
gotoxy(20,10);cprintf("²²²²²²²²²²²²²²²");
gotoxy(21,15);cprintf("²²²²²²²²²²");
gotoxy(21,16);cprintf("²²²²²²²²²²");
for(i=11;i<=25;i++){gotoxy(20,i);cprintf("²²");}
for(i=9;i<=25;i++){gotoxy(36,i);cprintf("°°");}
for(i=9;i<=25;i++){gotoxy(40,i);cprintf("±±");}
for(j=40,i=9;i<=25;i++,j++){gotoxy(j,i);cprintf("±±");}
for(i=9;i<=25;i++){gotoxy(56,i);cprintf("±±");}

for(i=3;i<=34;i++){gotoxy(i,35);cprintf("Í");}
for(i=3;i<=34;i++){gotoxy(i,43);cprintf("Í");}
gotoxy(2,35);cprintf("É");
gotoxy(43,35);cprintf("É");
gotoxy(76,35);cprintf("»");
gotoxy(35,35);cprintf("»");

gotoxy(76,43);cprintf("¼");
gotoxy(35,43);cprintf("¼");

gotoxy(2,43);cprintf("È");
gotoxy(43,43);cprintf("È");
for(i=44;i<=75;i++){gotoxy(i,35);cprintf("Í");}
for(i=44;i<=75;i++){gotoxy(i,43);cprintf("Í");}

gotoxy(7,39);cprintf("JUEGO NUEVO..Presione 'F2'");
gotoxy(50,39);cprintf("SALIR..Presione 'ESC'");
}
Jnuevo=getch();
if(Jnuevo==27)abort();
if(Jnuevo==60)
{
textcolor(10);
for(i=0;i<10000;i++)
{
vectorx[i]=0;
vectory[i]=0;
}
FinVxy=-1;
juego();
}
}
clrscr();
}

void inicializa()
{
int fcol=0;Jnuevo=0;direccion=0;
puntos=0;nivel=0;cn=0;v=60;x=10;y=15;
clrscr();
while(Jnuevo!=60 && Jnuevo!=27)
{
while(!kbhit())
{
fcol=(rand()%15)+1;
textcolor(fcol);delay(200);
gotoxy(4,2);cprintf("ÉÉ");
gotoxy(17,2);cprintf("»");
gotoxy(17,3);cprintf("¼");
gotoxy(5,11);cprintf("È");
gotoxy(4,11);cprintf("Ç");
gotoxy(4,12);cprintf("È");

for(i=6;i<=16;i++){gotoxy(i,11);cprintf("Í");}
for(i=5;i<=15;i++){gotoxy(i,12);cprintf("Í");}
gotoxy(17,11);cprintf("»");
gotoxy(16,12);cprintf("»");gotoxy(17,12);cprintf("×");
for(i=13;i<=20;i++){gotoxy(16,i);cprintf("××");}
gotoxy(17,21);cprintf("×");gotoxy(17,22);cprintf("¼");
gotoxy(16,21);cprintf("¼");

for(i=5;i<=16;i++){gotoxy(i,2);cprintf("Í");}
for(i=6;i<=16;i++){gotoxy(i,3);cprintf("Í");}
gotoxy(4,21);cprintf("É");gotoxy(4,22);cprintf("È");
for(i=5;i<=15;i++){gotoxy(i,21);cprintf("Í");}
for(i=5;i<=16;i++){gotoxy(i,22);cprintf("Í");}

for(i=3;i<=10;i++){gotoxy(4,i);cprintf("××");}
for(i=5;i<=15;i++){gotoxy(i,2);cprintf("Í");}
for(i=6;i<=15;i++){gotoxy(i,3);cprintf("Í");}

for(i=3;i<=34;i++){gotoxy(i,35);cprintf("Í");}
for(i=3;i<=34;i++){gotoxy(i,43);cprintf("Í");}

/*Dibujando la letra N*/
gotoxy(21,2);cprintf("É»");gotoxy(21,22);cprintf("È¼");
for(i=3;i<=21;i++){gotoxy(21,i);cprintf("××");}
gotoxy(37,2);cprintf("É»");gotoxy(37,22);cprintf("È¼");
for(i=3;i<=21;i++){gotoxy(37,i);cprintf("××");}
for(j=22,i=5;i<=19;i++,j++){gotoxy(j,i);cprintf("È»");}

/*Dibujando la letra A*/
gotoxy(41,2);cprintf("É");gotoxy(42,3);cprintf("É");
gotoxy(41,22);cprintf("È¼");gotoxy(41,3);cprintf("×");
for(i=4;i<=21;i++){gotoxy(41,i);cprintf("××");}
gotoxy(52,2);cprintf("»");gotoxy(51,3);cprintf("»");
for(i=42;i<=51;i++){gotoxy(i,2);cprintf("Í");}
for(i=43;i<=50;i++){gotoxy(i,3);cprintf("Í");}
gotoxy(52,3);cprintf("×");
for(i=4;i<=21;i++){gotoxy(51,i);cprintf("××");}
gotoxy(51,22);cprintf("È¼");
for(i=42;i<=51;i++){gotoxy(i,11);cprintf("Í");}
for(i=42;i<=51;i++){gotoxy(i,12);cprintf("Í");}

/*Dibujando la Letra K*/
gotoxy(55,2);cprintf("É");gotoxy(56,2);cprintf("»");
gotoxy(55,22);cprintf("È¼");
for(i=3;i<=21;i++){gotoxy(55,i);cprintf("××");}
for(i=56;i<=64;i++){gotoxy(i,12);cprintf("Í");}
for(i=56;i<=63;i++){gotoxy(i,13);cprintf("Í");}
gotoxy(65,12);cprintf("»");
gotoxy(64,13);cprintf("»");
for(i=13;i<=21;i++){gotoxy(64,i);cprintf("××");}
gotoxy(64,22);cprintf("È¼");
for(j=65,i=3;i<=12;i++,j--){gotoxy(j,i);cprintf("É¼");}

/*Dibujando la letra E*/
gotoxy(68,2);cprintf("É");gotoxy(69,3);cprintf("É");
gotoxy(68,3);cprintf("×");gotoxy(68,21);cprintf("×");
gotoxy(68,22);cprintf("È");gotoxy(69,21);cprintf("È");
for(i=4;i<=20;i++){gotoxy(68,i);cprintf("××");}

for(i=69;i<=79;i++){gotoxy(i,2);cprintf("Í");}
for(i=70;i<=79;i++){gotoxy(i,3);cprintf("Í");}
gotoxy(80,2);cprintf("»");gotoxy(80,3);cprintf("¼");

for(i=70;i<=79;i++){gotoxy(i,21);cprintf("Í");}
for(i=69;i<=79;i++){gotoxy(i,22);cprintf("Í");}
gotoxy(80,21);cprintf("»");gotoxy(80,22);cprintf("¼");

for(i=69;i<=79;i++){gotoxy(i,12);cprintf("Í");}
for(i=69;i<=79;i++){gotoxy(i,13);cprintf("Í");}
gotoxy(80,12);cprintf("»");gotoxy(80,13);cprintf("¼");

/*Margenes de Pantalla*/
gotoxy(2,35);cprintf("É");
gotoxy(43,35);cprintf("É");
gotoxy(76,35);cprintf("»");
gotoxy(35,35);cprintf("»");

gotoxy(76,43);cprintf("¼");
gotoxy(35,43);cprintf("¼");

gotoxy(2,43);cprintf("È");
gotoxy(43,43);cprintf("È");
for(i=44;i<=75;i++){gotoxy(i,35);cprintf("Í");}
for(i=44;i<=75;i++){gotoxy(i,43);cprintf("Í");}
gotoxy(7,39);cprintf("JUEGO NUEVO..Presione 'F2'");
gotoxy(50,39);cprintf("SALIR..Presione 'ESC'");
}
Jnuevo=getch();
if(Jnuevo==27)abort();
if(Jnuevo==60)
{
textcolor(10);
for(i=0;i<10000;i++)
{
vectorx[i]=0;
vectory[i]=0;
}
FinVxy=-1;
juego();
}
}
clrscr();
}
void culebra()
{
int color;
textcolor(14);gotoxy(48,12);cprintf("%d",puntos);gotoxy(66,12);cprintf("%d",nivel);
color=(rand()%15)+1;
textcolor(color);
/*Dibujando LOGO (Culebra)*/
gotoxy(46,34);cprintf(" ");
gotoxy(47,34);cprintf("%c%c%c%c%c%c",4,4,4,4,4,4);
gotoxy(53,35);cprintf("%c",4);
gotoxy(53,36);cprintf("%c",4);

gotoxy(49,37);cprintf("%c%c%c%c",4,4,4,4);
gotoxy(48,36);cprintf("%c",4);
gotoxy(44,36);cprintf("%c%c%c%c",4,4,4,4);
gotoxy(43,37);cprintf("%c",4);
gotoxy(43,38);cprintf("%c",4);
gotoxy(44,39);cprintf("%c%c%c%c%c%c%c%c%c%c",4,4,4,4,4,4,4,4,4,4);
gotoxy(54,40);cprintf("%c",4);
gotoxy(54,41);cprintf("%c",4);
gotoxy(49,42);cprintf("%c%c%c%c%c",4,4,4,4,4);
gotoxy(48,41);cprintf("%c",4);
gotoxy(43,41);cprintf("%c%c%c%c%c",4,4,4,4,4);
gotoxy(42,42);cprintf("%c",4);
gotoxy(42,43);cprintf("%c",4);
gotoxy(43,44);cprintf("%c%c%c%c%c%c%c%c%c%c%c%c",4,4,4,4,4,4,4,4,4,4,4,4,4);

gotoxy(58,32);cprintf("O B J E T I V O");
textcolor(11);
gotoxy(56,34);cprintf("Hacer que la Culebra");
gotoxy(57,35);cprintf("coma los Objetos. ");
gotoxy(56,37);cprintf("Evitar que la Culebra");
gotoxy(57,38);cprintf("choque con su Cuerpo.");
textcolor(color);
gotoxy(61,41);cprintf("N O T A");
textcolor(11);
gotoxy(56,43);cprintf("Si la Culebra Choca con");
gotoxy(56,45);cprintf("cualquier parte de su");
gotoxy(56,47);cprintf("cuerpo. El juego Termina");
textcolor(10);
}

void pantalla1()
{
col=(rand()%14)+1;if(col==0)col=14;
gotoxy(41,1);textcolor(col);cprintf("É");gotoxy(80,1);cprintf("»");
gotoxy(49,3);textcolor(color1);cprintf("C U L E B R A....U M A R");
textcolor(14);
gotoxy(43,7);cprintf(" P U N T O S ");
gotoxy(59,7);cprintf("N I V E L ");
gotoxy(46,17);cprintf(" I N S T R U C C I O N E S ");

/*Instrucciones de USO*/
gotoxy(46,20);cprintf("Flecha - Girar a la Derecha");
gotoxy(46,22);cprintf("Flecha %c Girar a la Izquierda",27);
gotoxy(46,24);cprintf("Flecha %c Girar hacia arriba",24);
gotoxy(46,26);cprintf("Flecha %c Girar hacia Abajo",25);
gotoxy(46,28);cprintf("ESC Terminar Juego");
textcolor(color1);

/*Imprimiendo Margenes de Pantalla*/
for(i=42;i<80;i++)
{
gotoxy(i,1);textcolor(col);cprintf("Í");
}
gotoxy(41,5);textcolor(col);cprintf("ÌÍÍÍÍÍÍÍÍÍÍÍÍÍÍËÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ¹");
for (i=6;i<15;i++){textcolor(col);gotoxy(56,i);cprintf("º");}

gotoxy(41,15);textcolor(col);cprintf("ÌÍÍÍÍÍÍÍÍÍÍÍÍÍÍÊÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ¹");
gotoxy(41,30);textcolor(col);cprintf("ÌÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ¹");
for(i=2;i<5;i++){textcolor(col);gotoxy(41,i);cprintf("º");}

for(i=6;i<15;i++){textcolor(col);gotoxy(41,i);cprintf("º");}

for(i=16;i<30;i++){textcolor(col);gotoxy(41,i);cprintf("º");}
for(i=31;i<50;i++){textcolor(col);gotoxy(41,i);cprintf("º");}
for(i=6;i<15;i++){textcolor(col);gotoxy(80,i);cprintf("º");}

for(i=16;i<30;i++){textcolor(col);gotoxy(80,i);cprintf("º");}
for(i=31;i<50;i++){textcolor(col);gotoxy(80,i);cprintf("º");}
for(i=2;i<5;i++){textcolor(col);gotoxy(80,i);cprintf("º");}gotoxy(41,49);cprintf("È");

for(i=42;i<80;i++){textcolor(col);gotoxy(i,49);cprintf("Í");}gotoxy(80,49);cprintf("¼");

textcolor(10);
}
void pantalla()/*Escribe la pantalla donde juega la Culebra*/
{
color1=(rand()%15)+1;
textcolor(color1);
gotoxy(1,1);cprintf("É");
for(i=1;i<40;i++)cprintf("Í");gotoxy(40,1);cprintf("»");
for(i=2;i<50;i++){gotoxy(40,i);cprintf("º\n");}
for(i=2;i<50;i++){gotoxy(1,i);cprintf("º\n");}gotoxy(1,49);cprintf("È");
for(i=1;i<40;i++)cprintf("Í");gotoxy(40,49);cprintf("¼");
textcolor(10);
}

int sonido()/*Genera el sonido*/
{
sound(s);
delay(100);
nosound();
return 0;
}

/*FUNCION PRINCIPAL*/
void main(void)
{
clrscr();
_setcursortype(_NOCURSOR);/*Desaparece Cursor*/
inicializa();
if(Jnuevo==60){textcolor(10);juego();}

}/*Cerrando el Main*/

void juego(void)
{

clrscr();
objeto();
/*While de direcciones*/
while(direccion!=27)
{
pantalla();pantalla1();textcolor(10);

direccion=getch();/*Capturando Direccion*/

if(direccion==27)finaliza();
/*Validando Direcciones*/
if(direccion1==derecha && direccion==izquierda)direccion=derecha;
if(direccion1==izquierda && direccion==derecha)direccion=izquierda;
if(direccion1==arriba && direccion==abajo)direccion=arriba;
if(direccion1==abajo && direccion==arriba)direccion=abajo;

/*While de Movimientos*/
while(!kbhit())
{
culebra();
color1=(rand()%14)+1;if(color1==0)col=14;

/*DIRECCIONES*/
if(direccion==derecha){x=(x==39?2:x+1);direccion1=direccion;}

if(direccion==izquierda){x=(x==2?39:x-1);direccion1=direccion;}

if(direccion==abajo){y=(y==48?2:y+1);direccion1=direccion;}

if(direccion==arriba){y=(y==2?48:y-1);direccion1=direccion;}

if(FinVxy==0)FinVxy=-1; /*Comprobando si existen elementos en los vectores*/
else if(FinVxy>0) /*Si existe mas de 1 elemento en los vectores*/
{
for(i=0;i<10000;i++) /*Moviendo elementos*/
{
vectorx[i]=vectorx[i+1];
vectory[i]=vectory[i+1];
}
FinVxy--;

/*Imprimiendo cuerpo de la culebra*/
for(i=0;i<=FinVxy;i++)
{
textcolor(RED);
/*Comprobando si ha chocado con su cuerpo*/
if(vectorx[i]==x && vectory[i]==y)
{
gotoxy(15,15);cprintf(" JUEGO TERMINADO ");
gotoxy(13,17);cprintf(" Puntos Alcanzados = %d ",puntos);
gotoxy(13,19);cprintf(" Nivel Logrado = %d ",nivel);
delay(6000);finaliza();
}
gotoxy(vectorx[i],vectory[i]);
cprintf("%c",233);
}
}

/*Imprimiendo y borrando cabeza*/
textcolor(14);gotoxy(x,y);cprintf(" ");
delay(v);gotoxy(x,y);printf("%c",32);

if(FinVxy>=0)/*Existe 1 o mas elementos, borrando cola*/
{
for(i=0;i<=FinVxy;i++)
{
gotoxy(vectorx[i],vectory[i]);cprintf("%c",32);
}
}

if(x==objetoX && y==objetoY)/*Comiendo objeto*/
{
FinVxy++;sonido();
puntos+=3;
cn++;/*Incrementando nivel*/
if(cn==4){nivel++;v-=5;cn=0;}

vectorx[FinVxy]=objetoX;
vectory[FinVxy]=objetoY;
objeto();
}

FinVxy++;
vectorx[FinVxy]=x;
vectory[FinVxy]=y;

}/*Cerrando While DE MOVIMIENTOS */
}/*Cierre del While DE DIRECCIONES*/

}/*Cerrando JUEGO*/