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

public class Programa1 extends JFrame implements ActionListener
{
  //declaracion de variables
  JButton btnprocesar;
  JTextArea txts;
  JLabel lblhoras;
  JLabel lbltarifa;
  JTextField txthoras;
  JTextField txttarifa;
  JScrollPane scpscroll;
 
  //crea la interfaz grafica de usuario GUI (ves como le cambie el nombre)
  public Programa1()
  {
      setSize(430,250);  //Tamanio del formulario
      setTitle("MI primer programa"); //TItulo del formulario
      setResizable(false); //Para que no sea redimensionable
      setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//Para salir al cerrar

      getContentPane().setLayout(null);
 
      //lblhoras
      lblhoras = new JLabel ("Horas");
      lblhoras.setBounds(15 ,15 , 45, 23);
      getContentPane().add(lblhoras);
   
      //lbltarifa
      lbltarifa = new JLabel ("Tarifa");
      lbltarifa.setBounds(15, 39, 45, 23);
      getContentPane().add(lbltarifa);
   
      //txthoras
      txthoras = new JTextField();
      txthoras.setBounds(61, 15, 107, 23);
      getContentPane().add(txthoras);
   
      //txttarifa
      txttarifa = new JTextField();
      txttarifa.setBounds(61, 39, 107, 23);
      getContentPane().add(txttarifa);
   
      //btn procesar
      btnprocesar = new JButton("Procesar");
      btnprocesar.setBounds(305, 15, 101, 23);
      btnprocesar.addActionListener(this);
      getContentPane().add(btnprocesar);
   
      //txts
      txts= new JTextArea();
      txts.setFont(new Font("monospaced", 0, 12));
   
      //scpscroll
      scpscroll = new JScrollPane(txts);
      scpscroll.setBounds(15, 75, 394, 130);
      getContentPane().add(scpscroll);  
  }
 
  //procesa eventes de tipo action event
  public void actionPerformed(ActionEvent e)
  {
 
      //declaracion de variables
      double horastrab, tarifahor;
      double sueldobas, montoboni, sueldobru, montodesc, sueldonet;
   
      //entrada de datos
      horastrab = Double.parseDouble(txthoras.getText());
      tarifahor = Double.parseDouble(txttarifa.getText());
   
      //calculo demontos
      sueldobas = horastrab*tarifahor;
      montoboni = 0.20*sueldobas;
      sueldobru = sueldobas+montoboni;
      montodesc = 0.10*sueldobru;
      sueldonet = sueldobru-montodesc;
   
      //salida de resultados
      txts.setText("reporte genera\n");
      txts.append("sueldo basico : s/. " + sueldobas + "\n");
      txts.append("Bonificacion : s/. " + montoboni + "\n");
      txts.append("sueldo bruto : s/. " + sueldobru + "\n");
      txts.append("descuentos : s/. " + montodesc + "\n");
      txts.append("Sueldo Neto : s/. " + sueldonet + "\n");
  }
 
  //Metodo principal
  public static void main(String args[])
  {
      new Programa1().setVisible(true);
  }
}

import javax.swing.JApplet;

public class Programa1 extends JApplet implements ActionListener

//crea la interfaz grafica de usuario GUI
 public void init()

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.JApplet;

public class Programa1 extends JApplet implements ActionListener
{
 //declaracion de variables
 JButton btnprocesar;
 JTextArea txts;
 JLabel lblhoras;
 JLabel lbltarifa;
 JTextField txthoras;
 JTextField txttarifa;
 JScrollPane scpscroll;
 
 //crea la interfaz grafica de usuario GUI (ves como le cambie el nombre)
 public void init()
 {
     setSize(430,250);  //Tamanio del formulario
     //setTitle("MI primer programa"); //TItulo del formulario
    // setResizable(false); //Para que no sea redimensionable
    // setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//Para salir al cerrar

     getContentPane().setLayout(null);
 
     //lblhoras
     lblhoras = new JLabel ("Horas");
     lblhoras.setBounds(15 ,15 , 45, 23);
     getContentPane().add(lblhoras);
 
     //lbltarifa
     lbltarifa = new JLabel ("Tarifa");
     lbltarifa.setBounds(15, 39, 45, 23);
     getContentPane().add(lbltarifa);
 
     //txthoras
     txthoras = new JTextField();
     txthoras.setBounds(61, 15, 107, 23);
     getContentPane().add(txthoras);
 
     //txttarifa
     txttarifa = new JTextField();
     txttarifa.setBounds(61, 39, 107, 23);
     getContentPane().add(txttarifa);
 
     //btn procesar
     btnprocesar = new JButton("Procesar");
     btnprocesar.setBounds(305, 15, 101, 23);
     btnprocesar.addActionListener(this);
     getContentPane().add(btnprocesar);
 
     //txts
     txts= new JTextArea();
     txts.setFont(new Font("monospaced", 0, 12));
 
     //scpscroll
     scpscroll = new JScrollPane(txts);
     scpscroll.setBounds(15, 75, 394, 130);
     getContentPane().add(scpscroll);  

 }
 
 //procesa eventes de tipo action event
 public void actionPerformed(ActionEvent e)
 {
 
     //declaracion de variables
     double horastrab, tarifahor;
     double sueldobas, montoboni, sueldobru, montodesc, sueldonet;
 
     //entrada de datos
     horastrab = Double.parseDouble(txthoras.getText());
     tarifahor = Double.parseDouble(txttarifa.getText());
 
     //calculo demontos
     sueldobas = horastrab*tarifahor;
     montoboni = 0.20*sueldobas;
     sueldobru = sueldobas+montoboni;
     montodesc = 0.10*sueldobru;
     sueldonet = sueldobru-montodesc;
 
     //salida de resultados
     txts.setText("reporte genera\n");
     txts.append("sueldo basico : s/. " + sueldobas + "\n");
     txts.append("Bonificacion : s/. " + montoboni + "\n");
     txts.append("sueldo bruto : s/. " + sueldobru + "\n");
     txts.append("descuentos : s/. " + montodesc + "\n");
     txts.append("Sueldo Neto : s/. " + sueldonet + "\n");
 }
}

<html>
   <head>
   <title>Ejemplo de applet</title>
   </head>
   <body>
       <applet code=Programa1.class width=430 height=250
    alt="Error, JAVA NO INSTALADO O ALGO MAL EN LAS OPCIONES">
</applet>
   </body>
</html>

// ### Inicio del fichero Engine.java ###

import javax.swing.table.*;
import java.lang.reflect.*;
import javax.swing.event.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.text.*;
import java.beans.*;
import java.io.*;


import analisisEspectral.*;


public class Engine extends JFrame
{
/** Ventana principal accesible de la aplicacio. */
public static Engine mainWindow = null;
/** Ventana interna fija dentro de la ventana principal. */
public static VentanaInternaFija v_fija = null;

/** Ventana que contiene las tablas. */
public static VentanaInterna v_tablas = null;

/** Ventana interna que contiene las graficas. */
public static VentanaInterna v_graficas = null;

/** Objeto encargado de mostrar las caracteristicas de la tabla a traves
 *  del componente que se representara en la ventana fija de la
 *  aplicacion. */
public static ShowConfig config = null;

/** Numero de la grafica activa en cada momento. */
public static int numGraficaActiva = -1;

/** Variable que controla si hay ya una ventana con graficas o no. */
public static boolean b_graficas = false;

/** Componente activo (tiene el &quot;foco&quot;). */
public static Object activo = null;
/** Ventana (interna) activa. */
public static JInternalFrame activa = null;

/**
 * Registro de las tablas (tipo Tabla) abiertas.
 * @see Tabla
 */
public static ArrayList tbls = null;

/**
 * Registro de las graficas representadas.
 * @see Grafica
 */
public static ArrayList grafs = null;

/** Contenedor que posiblita la apertura de multiples ventanas. */
private static JDesktopPane desktop = null;

/** Numero de ventanas abiertas. */
static int numeroVentanas = 0;



 public static int graficaActiva = -1;

 /** Boolean que controla si se trazan lineas en las graficas.*/
 public static boolean trazarLineas = false;

 public static int modeloEdad = FactoriaAnalisisEspectral.VACIO; // Tipo de modelo de edad.
 public static boolean utilizarOrigen = false; // Indica si hay que añadir el (0,0) a los pointers.
 public static java.util.List variable; // Lista con los valores de la variable.
 public static java.util.List edad; // Lista con los valores de la edad.

 public static int interpolacion = FactoriaAnalisisEspectral.INTERPOLACION_LINEAL; // Tipo de interpolacion.
 public static double factorInterpolacion = 1; // Factor para el intervalo de la interpolacion.

 public static int ahusador = FactoriaAnalisisEspectral.AHUSADOR_RECTANGULAR; // Tipo de ahusado.

 public static int detrender = FactoriaAnalisisEspectral.DETRENDER_MEDIA; // Tipo de detrending.

 public static int preblanqueador = FactoriaAnalisisEspectral.PREBLANQUEADOR_SIMPLE; // Tipo de preblanqueado.
 public static double constantePreblanqueado = 0.6; // Constante de preblanqueado.
 
 public static String seleccionAlisado; // Indica si el usuario especifica el ancho de banda o la fiabilidad.
 public static double fiabilidad = 0.80; // Fiabilidad.
 public static double anchoBanda = 0.0; // Ancho de Banda.

 public static AnalisisEspectral analisis;


/**
 * Constructor: crea la ventana principal del programa con los
 * menus del mismo y o la ventana fija interna. A su vez inicia
 * muchos de los atributos de la clase.
 */
public Engine()
{

 super("Aplicacion creada");

 variable = new ArrayList();
 edad = new ArrayList();
 seleccionAlisado = new String("fiabilidad");

 numeroVentanas = 0;
 b_graficas = false;
 
 // Obtención de una nueva ventana dentro de la ventana principal
 v_fija = new VentanaInternaFija("PaleoPlot - Monitor/Control");

 // Componente activo (tiene el "foco")
 activo = new Object();
 // Ventana activa
 activa = new JInternalFrame();
 
 // Tablas abiertas
 tbls = new ArrayList(); // Tablas que hay dentro de la ventana

 // Gráficas representadas
 grafs = new ArrayList();

 // "Indentación" de la ventana principal 50 pixels desde cada uno
 // de los extremos de la pantalla
 int inset = 30;
 Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

 setBounds(0, 0, screenSize.width, screenSize.height);


       // Clausura de la aplicación cuando se cierra la ventana principal
             addWindowListener(new WindowAdapter()
  {
            public void windowClosing(WindowEvent e)
   {
                System.exit(0);
            }
        });

 // Registraremos la actuación de los componentes que nos interesen

       // Establecimiento de la Interfaz Gráfica de Usuario
       desktop = new JDesktopPane(); // "Manager" de las ventanas
 desktop.setBackground(new Color(140, 180, 170));
       setContentPane(desktop);

 // Adesión de la barra de menús
 Menus programMenus = new Menus();
       setJMenuBar(programMenus.nuevos());

       // Hace el arrastre más rápido (ventanas transparentes)
       desktop.putClientProperty("JDesktopPane.dragMode", "outline");
   }
/* -------------------------------------------------------------------- */
/**
 * Metodo que establece como activa una ventana interna.
 * @param jif ventana interna que sera activada.
 */
public void activar (JInternalFrame jif)
{
 try
 {
  jif.setSelected(true);
  jif.setRequestFocusEnabled(true);
  jif.requestFocus();

 }
 catch (java.beans.PropertyVetoException ex)
 {
  System.out.println("¡¡¡ERROR en la selección!!!");
 }
}

/**
 * Metodo que desactiva una ventana interna.
 * @param jif ventana interna que sera activada.
 */
public void desactivar (JInternalFrame jif)
{
 try
 {
  jif.setSelected(false);
 }
 catch (java.beans.PropertyVetoException ex)
 {
  System.out.println("¡¡¡ERROR en la selección!!!");
 }
}

/**
 * Crea una nueva ventana (interna) dentro de la ventana principal.
 * @param nombre nombre que se le dara a la nueva ventana.
 * @param color_fondo color de fondo que se establecera en la nueva
 *        ventana.
 * @return ventana que ha sido creada y a&ntilde;adida a la ventana
 *         principal.
 */
public VentanaInterna
 nuevaVentana(String nombre, Color color_fondo, int tamx, int tamy, int desplx, int desply)
{
 VentanaInterna frame = new VentanaInterna(nombre, color_fondo, tamx, tamy, desplx, desply);
 frame.setVisible(true); // Imprescindible hacerlo visible

 // Adesión de la ventana a la principal, seleccionándola
 desktop.add(frame);
 validate();
 activar(frame);
 frame.show();
   
 return frame;
}

/**
 * Elimina una ventana interna existente.
 * @param ventana interna a eliminar.
 */
public void eliminarVentana (VentanaInterna vi)
{
 vi.setVisible(false);
 numeroVentanas--;
}


/**
 * A&ntilde;ade una nueva grafica a la ventana de graficas.
 * @param g grafica a a&ntilde;adir.
 * @param tab el tab donde se quiere a&ntilde;adir la grafica
 * @return tab en el que se ha añadido la grafica realmente
 */
public static int agregarGrafica(Grafica g, int tab)
{
 int tabReal;
 if (tab == -1)
 {
  v_graficas.agregarTab(g.nombreX());
  v_graficas.agregarComponente(v_graficas.devolverPanel().getTabCount()-1, g);
  tabReal = v_graficas.devolverPanel().getTabCount()-1;
 }
 else
 {
  v_graficas.agregarComponente(tab, g);
  tabReal = tab;
 }
 v_graficas.refrescar();
 grafs.add(g);
 g.establecerGrafID(grafs.indexOf(g));
 g.tabID = tabReal;

 return tabReal;
}

/**
 * Elimina una tabla de la grafica de ventanas y de la lista de graficas
 * representadas actualmente.
 * @param g grafica a eliminar.
 */
public void eliminarGrafica(Grafica g)
{
 v_graficas.eliminarComponente(g);
 int pos = grafs.indexOf(g);
 grafs.remove(pos);
 if (grafs.size() == 0)
 {
  eliminarVentana(v_graficas);
  v_graficas = null;
  b_graficas = false;
 }
}


/** Metodo &quot;principal&quot; de la aplicacion a la que lanza. */
public static void main (String args[])
{
 // Establece el aspecto de la aplicación al del sistema actual
 try
 {
  UIManager.setLookAndFeel(UIManager.
   getSystemLookAndFeelClassName());
 }
 catch (Exception ex)
 {
  ex.printStackTrace();
 }
 
 // Lectura del logotipo del programa
 // Creación de la ventana pricipal de la aplicación
 mainWindow = new Engine();

 // Visualización de la ventana principal de la aplicación
 mainWindow.setVisible(true);
}
/*  * * * * * * * * * * * * * * * * * * * * * * */
}

/**
* Clase que genera el logotipo de la aplicacion cuando esta se inicia.<BR>
* Se encarga de crear un cuadro de dialogo poniendo en su interior la imagen
* que se le pasa al constructor.
* @ author  Felipe Barbero Delgado
* @ version 1.0
*/
class Logo extends JDialog
{
/** Imagen del logotipo (JPEG o GIF) */
Image logo;

/**
 * Genera el logotipo con un tama&ntilde;o fijo que coincide con el
 * tama&ntilde;o del logotipo elegido para PaleoPlot 1.0.
 * @param logo imagen a representar como logotipo.
 */
Logo(Image logo)
{
 super((Frame)null,
  "PleoPlot 1.0 - Copyright© 2001 by Felipe Barbero Delgado, "
  + "para la Universidad de Salamanca", true);
 this.logo = logo;
 setSize(640, 434); // Tamaño de la imagen del logotipo
 setResizable(false);
}
/**
 * Genera un logotipo para la aplicacion con las dimensiones indicadas.
 * @param logo imagen a representar como logotipo.
 * @param ancho anchura de la imagen.
 * @param alto altura de la imagen.
 */
Logo(Image logo, int ancho, int alto)
{
 super((Frame)null,
  "Aplicacion creada", true);
 this.logo = logo;
 setSize(ancho, alto); // Tamaño de la imagen del logotipo
 setResizable(false);
}

public void paint(Graphics g)
{
 g.drawImage(logo, 0, 0, this);
}
}

/**
* Se trara del escuchador que registra el componente activo en cada momento.
* @author  Felipe Barbero Delgado
* @version 1.0
* @see     FocusListener
*/
class FLGeneral implements FocusListener
{
public void focusGained(FocusEvent e)
{
 Engine.mainWindow.activo = e.getSource();
 Menus.ItemsOnOff ioo;
 for (int i = 0; i < Menus.itemsOnOff.size(); i++)
 {
  ioo = (Menus.ItemsOnOff)Menus.itemsOnOff.get(i);
  ioo.item.setEnabled(false);
 }
}
public void focusLost(FocusEvent e)
{
}
}


/**
* &quot;Frame interno&quot; que constituira una nueva ventana.
* @author  Felipe Barbero Delgado (revisada por Alvaro Garcia Perez)
* @version 2.0
*/
class VentanaInterna extends JInternalFrame
{
/** Desplazamiento (<I>offset</I>) utilizado para la localizacion
 *  de la dentro de la ventana principal. */
private static final int xOffset = 20, yOffset = 20;

/** JTabbedPane que servira de soporte a los componentes que se agregen a la ventana.*/
private JTabbedPane panel = null;

/** Color del fondo del JTabbedPane y de los JPanel de cada tab. */
private Color color;

public String nombre;// DEBUG

/**
 * &quot;Layout manager&quot: que gestionara la distribucion de los
 *  componentes dentro de cada tab del JTabbedPane.
 */
private java.util.List listaLayout = null;
private java.util.List listaJPanel;

/**
 * Constructor que llevara a cabo la creacion de la nueva ventana.
 * @param nombre nombre de la nueva ventana.
 * @param color color de fondo de la nueva ventana (en realidad del
 *        panel de la nueva ventana).
// SE AÑADE:
  * @param tamx tama&ntilde;o x de la nueva ventana
  * @param tamy tama&ntilde;o y de la nueva ventana
  * @param desplx desplazamiento x de la nueva ventana
  * @param desply desplazamiento y de la nueva ventana
  */

 public VentanaInterna(String nombre, Color color, int tamx, int tamy, int desplx, int desply)

{
 super(nombre,
  true, // "resizable"
  true, // "closable"
  true, // "maximizable"
  true);// "iconifiable"
 // Obtención de una nueva ventana dentro de la ventana principal

 this.nombre = nombre;  // DEBUG

 Container cvi = new Container();
 cvi = getContentPane();

 this.color = color;


 final VentanaInterna estaVentana = this;
 panel = new JTabbedPane();
 panel.addMouseListener(new MouseAdapter() {
                public void mouseClicked(MouseEvent e) {

                 if (estaVentana == Engine.v_graficas) {
                  int grafID = ((Grafica)devolverJPanelActivo().getComponent(0)).grafID();
                  double precisionX = ((Grafica)devolverJPanelActivo().getComponent(0)).precisionX();
                  double precisionY = ((Grafica)devolverJPanelActivo().getComponent(0)).precisionY();
                  double escala = ((Grafica)devolverJPanelActivo().getComponent(0)).escala();
                  double zoomX = ((Grafica)devolverJPanelActivo().getComponent(0)).zoomX();
                  double zoomY = ((Grafica)devolverJPanelActivo().getComponent(0)).zoomY();
                  double saltoMarcaX = ((Grafica)devolverJPanelActivo().getComponent(0)).saltoMarcaX();
                  double saltoMarcaY = ((Grafica)devolverJPanelActivo().getComponent(0)).saltoMarcaY();
                  boolean enrejado = ((Grafica)devolverJPanelActivo().getComponent(0)).enrejado();
                  boolean ptoGordo = ((Grafica)devolverJPanelActivo().getComponent(0)).ptoGordo();
                  if (Engine.numGraficaActiva != grafID)
                  {
                   ((Grafica)Engine.grafs.get(Engine.numGraficaActiva)).setBorder(
                    BorderFactory.createEmptyBorder());
                   Grafica graf = (Grafica)Engine.grafs.get(grafID);
                   graf.setBorder(BorderFactory.createLineBorder(Color.red));
                   Engine.config.showFeatures(
                    grafID, precisionX, precisionY, escala, zoomX, zoomY,
                    saltoMarcaX, saltoMarcaY, enrejado, ptoGordo, graf.fiabilidad, graf.anchoBanda);
                   Engine.v_graficas.refrescar();
                  }
                 }
                }
               });
 listaLayout = new ArrayList();
 listaJPanel = new ArrayList();

 panel.setBackground(color);

 cvi.add(panel, BorderLayout.CENTER);

 
 setContentPane(cvi);
 cvi.validate();
 setVisible(true); // Imprescindible hacerlo visible
 
              setSize(tamx, tamy);
              setLocation(desplx, desply);

 panel.addComponentListener(new CL());
 addComponentListener(new CL());
 addInternalFrameListener(new IFL_VF());

 Engine.mainWindow.activa = this;
 Engine.mainWindow.numeroVentanas++;
}


/**
 * Devuelve el JTabbedPane que contiene la ventana.
 * @return el JTabbedPane ue contiene la vantana
 */
JTabbedPane devolverPanel()
{
 return panel;
}

/**
 * Devuelve el JPanel que contiene cada tab.
 * @param tab el tab que contiene al JPanel
 * @return el JPanel que contiene cada tab
 */
JPanel devolverJPanel(int tab)
{
 return (JPanel)listaJPanel.get(tab);
}

/**
 * Devuelve el JPanel que contiene cada el tab activo.
 * @param tab el tab que contiene al JPanel
 * @return el JPanel que contiene cada tab
 */
JPanel devolverJPanelActivo()
{
 return (JPanel)listaJPanel.get(panel.getSelectedIndex());
 }


/**
 * A&ntilde;ade un tab nuevo al JTabbedPane con el titulo que se le pase. Ese tab
 * contiene un JPanel con un FlowLayout donde se podran a&ntilde;adir componentes.
 * @param String titulo el titulo que tendra el nuevo tab.
 * @return el numero del nuevo tab.
 */
public void agregarTab(String titulo)
{
 FlowLayout layout = new FlowLayout();
 layout.setAlignment(FlowLayout.LEFT);
 layout.setVgap(0);
 layout.setHgap(0);
 JPanel panelInterno = new JPanel(layout);
 panelInterno.setBackground(color);

 listaLayout.add(layout);

 listaJPanel.add(panelInterno);

 JScrollPane scrollPane = new JScrollPane(panelInterno);

 panel.add(titulo, scrollPane);
}

/**
 * A&ntilde;ade un nuevo componente a la ventana en un tab determinado.
 * @param nc nuevo componente a a&ntilde;adir.
 */
public void agregarComponente(int tab, JComponent nc)
{
 nc.addComponentListener(new CL());
 ((JPanel)listaJPanel.get(tab)).add(nc);
 ((JPanel)listaJPanel.get(tab)).validate();
 panel.validate();
 validate();
}

/**
 * A&ntilde;ade un componente debajo del JTabbedPane.
 * @param nc nuevo componente a a&ntilde;adir.
 */
public void agregarAbajo(JComponent nc)
{
 Container c = getContentPane();
 c.add(nc, BorderLayout.SOUTH);
 setContentPane(c);
 c.validate();
 validate();
}

/**
 * Elimina de la ventana el componente indicado.
 * @param nc componente que sera eliminado de la ventana.
 */
public void eliminarComponente(JComponent nc)
{
 Container contenedor;
 for (int i = 0; i < panel.getTabCount(); i++) {
  contenedor = (Container)listaJPanel.get(i);
  contenedor.remove(nc);
  if (contenedor.getComponentCount() == 0) {
   panel.removeTabAt(i);
   listaLayout.remove(i);
   listaJPanel.remove(i);
   break;
  }
  contenedor.validate();
 }
     
 panel.validate();
 validate();
}

/**
 * Metodo destinado al refresco de la ventana y de todos los componetes
 * de la misma.
 */
public void refrescar()
{
 Container contenedor;
 for (int i = 0; i < panel.getTabCount(); i++) {
  contenedor = (Container)listaJPanel.get(i);
  Component[] c = contenedor.getComponents();
  int numComponents = contenedor.getComponentCount();
  for (int j = 0; j < numComponents; j++)
  {
   c[j].repaint();
  }
  contenedor.validate();
  contenedor.repaint();
 }
 
 panel.validate();
 panel.repaint();
 validate();
 repaint();

}

/**
 * Escuchador de la ventana que la registra como en el caso de que lo
 * este.
 * @see InternalFrameAdapter
 */
class IFL_VF extends InternalFrameAdapter
{
 public void internalFrameActivated(InternalFrameEvent e)
 {
  Engine.mainWindow.activa = (JInternalFrame)e.getSource();
  ((JInternalFrame)e.getSource()).requestFocus();
 }
}

/**
 * Escuchador de los componentes de la ventana que permite refrescar la
 * ventana asi como los componentes si se produce algun cambio en ellos.
 * @see ComponentListener
 */
class CL implements ComponentListener
{
 public void componentMoved(ComponentEvent e)
 {
  refrescar();
 }
 public void componentResized(ComponentEvent e)
 {
  refrescar();
 }
 public void componentHidden(ComponentEvent e)
 {
  refrescar();
 }
 public void componentShown(ComponentEvent e)
 {
  refrescar();
 }
}
}


/**
* &quot;Frame interno&quot; que constituira una ventana fija (no de cierra)
* dentro de la ventana principal.
* @author  Felipe Barbero Delgado
* @version 1.0
*/
class VentanaInternaFija extends JInternalFrame
{
/** Area de texto fija de la ventana fija */
public static JTextArea ta;
/** Caja utilizada como contenedor de los componentes de la ventana */
private static Box caja;
/** Etiqueta del area de texto */
private static JLabel l_ta;
/** Panel utilizado como soporte del resto de los componentes */
private static JPanel panel;
/** Dota a la ventana de barras de desplazamiento */
private static JScrollPane jsp;
/** Dota al area de texto de barras de desplazamiento */
private static JScrollPane jsp_ta;
/** Desplazamiento (<I>offset</I>) utilizado para la localizacion
 *  de la ventana interna fija dentro de la ventana principal. */
private static final int xOffset = 20, yOffset = 20;

/**
 * Constructor que genera la nueva ventana interna fija.
 * @param nombre nombre que se le dara a la ventana.
 */
public VentanaInternaFija(String nombre)
{
 super(nombre,
  true, // "resizable"
  false, // "closable"
  true, // "maximizable"
  true);// "iconifiable"
 // Obtención de una nueva ventana dentro de la ventana principal

 // Panel con barras de desplazamiento
 panel = new JPanel();
 panel.setLayout(new FlowLayout());
 panel.setBackground(new Color(140, 180, 200));
 jsp = new JScrollPane(panel);

 // Caja con sus elementos fijos
 l_ta = new JLabel("Acontecimientos: ");
 l_ta.setHorizontalTextPosition(SwingConstants.CENTER);
 ta = new JTextArea(5,40);
 jsp_ta = new JScrollPane(ta);
 caja = new Box(BoxLayout.Y_AXIS);
 
 ta.setLineWrap(true);
 ta.setWrapStyleWord(true);
 
 ta.addFocusListener(new FLGeneral());

 Container cvf = new Container();
 cvf = getContentPane();
 cvf.add(jsp);
 
 // Caja con sus componentes fijos
 caja.add(l_ta);  
 caja.add(jsp_ta);
 panel.add(caja);
 
 setContentPane(cvf);
 cvf.validate();
 setVisible(true); // Imprescindible hacerlo visible

 // Tamaño de la nueva ventana
 setSize(310, 310);

 // Localización de la nueva ventana
 setLocation(xOffset*Engine.mainWindow.numeroVentanas,
  yOffset*Engine.mainWindow.numeroVentanas);

 // Registraremos la actuación de los componentes que nos interesen
 ta.addFocusListener(new FLGeneral());
 ta.addCaretListener(new CarL());
 panel.addComponentListener(new CL());
 addComponentListener(new CL());
 addInternalFrameListener(new IFL_VF());
 addMouseListener(new ML());

 Engine.mainWindow.activa = this;
 Engine.mainWindow.numeroVentanas++;
}

/**
 * A&ntilde;ade un nuevo componente a la ventana.
 * @param nc nuevo componente a a&ntilde;adir.
 */
public void agregarComponente(JComponent nc)
{
 caja.add(nc);
 caja.validate();
 validate();
}

/**
 * Elimina de la ventana el componente indicado.
 * @param nc componente que sera eliminado de la ventana.
 */
public void eliminarComponente(JComponent nc)
{
 caja.remove(nc);
 caja.validate();
 validate();
}

/**
 * Metodo destinado al refresco de la ventana y de todos los componetes
 * de la misma.
 */
public void refrescar()
{
 Component[] c = panel.getComponents();
 int numComponents = panel.getComponentCount();
 for (int i = 0; i < numComponents; i++)
 {
  c[i].repaint();
 }
 
 panel.validate();
 panel.repaint();
 validate();
 repaint();
}

/**
 * Escuchador de la ventana que la registra como en el caso de que lo
 * este.
 * @see InternalFrameAdapter
 */
class IFL_VF extends InternalFrameAdapter
{
 public void internalFrameActivated(InternalFrameEvent e)
 {
  Engine.mainWindow.activa = (JInternalFrame)e.getSource();
  ((JInternalFrame)e.getSource()).requestFocus();

  // Activaremos/Desactivaremos los ítems correspondientes
  Menus.ItemsOnOff ioo;

  for (int i = 0; i < Menus.itemsOnOff.size(); i++)
  {
   ioo = (Menus.ItemsOnOff)Menus.itemsOnOff.get(i);
   if ( (ioo.nombre.compareTo("Cerrar") == 0) ||
    (ioo.nombre.compareTo("Guardar") == 0) ||
    (ioo.nombre.compareTo("Guardar como") == 0) ||
    (ioo.nombre.compareTo("Imprimir") == 0) ||
    (ioo.nombre.compareTo("Añadir fila") == 0) ||
    (ioo.nombre.compareTo("Añadir columna") == 0) ||
    (ioo.nombre.compareTo("Gráfica") == 0) ||

    (ioo.nombre.compareTo("Potencia") == 0) ||
    (ioo.nombre.compareTo("Autocorrelacion") == 0) ||
    (ioo.nombre.compareTo("Fase") == 0) ||
    (ioo.nombre.compareTo("Potencia cruzada") == 0) ||
    (ioo.nombre.compareTo("Correlacion cruzada") == 0) ||
    (ioo.nombre.compareTo("Fase cruzada") == 0)


   
     )
     ioo.item.setEnabled(false);
  }
 }
}

/**
 * Escuchador que detecta si se ha pinchado con el raton la ventana. Si
 * esto sucede, se activara la ventana.
 * @see MouseAdapter
 */
class ML extends MouseAdapter
{
 public void mouseClicked(MouseEvent e)
 {
  Engine.mainWindow.activar((JInternalFrame)e.getSource());
 }
}

/**
 * Escuchador de los componentes de la ventana que permite refrescar la
 * ventana asi como los componentes si se produce algun cambio en ellos.
 * @see ComponentListener
 */
class CL implements ComponentListener
{
 public void componentMoved(ComponentEvent e)
 {
  refrescar();
 }
 public void componentResized(ComponentEvent e)
 {
  refrescar();
 }
 public void componentHidden(ComponentEvent e)
 {
  refrescar();
 }
 public void componentShown(ComponentEvent e)
 {
  refrescar();
 }
}

/**
 * Escuchador de los componentes de texto de la ventana que permite
 * refrescar la ventana asi como los componentes si se produce algun
 * cambio en ellos.
 * @see CaretListener
 */
class CarL implements CaretListener
{
 public void caretUpdate(CaretEvent e)
 {
  refrescar();
 }
}
}
// ### Final del fichero Engine.java ###