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