Clase Nodo

/**
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 Nodo {
Nodo siguiente;
int VecesRepetidas;
Object Datos;
String WORD;

Nodo (Object o,Nodo n,String pal,int i){
Datos =o;
siguiente = n;
WORD=pal;
VecesRepetidas= i;
}

Nodo (String pal,int i){
VecesRepetidas= i;
WORD =pal;
}

public int getCuantas() {return VecesRepetidas;}

public void setCuantas(int cuantas) {this.VecesRepetidas= cuantas;}

public void setDatos(Object datos) {Datos = datos;}

public void setPalabra(String palabra) {this.WORD = palabra;}

Object getDatos(){return Datos;}

public String getPalabra() {return WORD;}

Object getSiguiente(){return siguiente;}
}

Clase Lista

/**
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

/**
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

/**
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

/**
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

/**
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

/*
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

/*

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

/*

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

/*

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

/*

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

/*

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

/*

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

/*

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

/*

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

/*
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

/*
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

/*
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

/*
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

/*
-----------------------------------------------------------------------------
-------------------- --------------------
-------------------- 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

/*
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

/* 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

/*
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

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

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

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

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

/*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

/*** 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

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

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

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

/*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

/*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

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

/**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

/** 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

/*
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*/