package menus; import java.awt.*; import java.awt.datatransfer.*; import java.awt.event.*; import javax.swing.*; import javax.swing.JOptionPane; import java.io.*; /** * Clase de practica que nos va a permitir saber como utilizar menus. En esta * clase vamos a utilizar los dos tipos de menu que podemos manejar en Java y * veremos como utilizar algunas opciones extras. * @author Magus * @version 1.0 */ public class Main extends JFrame implements ActionListener, ItemListener, MouseListener, ClipboardOwner{ /** * Este bloque es el bloque con el que declaramos los menus, se necesita un * JMenuItem por cada opcion que queramos agregar al menu y se necesita un * JMenu por cada menu que queramos. Tambien necesitamos un JMenuBar que es * el contenedor de todos los controles */ private JMenuBar menuBar; private JMenu mnuArchivo; private JMenuItem mnuItemNuevo; private JMenuItem mnuItemAbrir; private JMenuItem mnuItemGuardar; private JMenuItem mnuItemGuardarComo; private JMenuItem mnuItemSalir; private JMenu mnuEdicion; private JMenuItem mnuItemCopiar; private JMenuItem mnuItemCortar; private JMenuItem mnuItemPegar; private JMenu mnuFormato; private JMenu mnuAlineacion; private JRadioButtonMenuItem mnuItemAlineacionIzquierda; private JRadioButtonMenuItem mnuItemAlineacionDerecha; private JRadioButtonMenuItem mnuItemAlineacionCentrado; private JMenuItem mnuItemContarLetra; private JMenu mnuVer; private JCheckBoxMenuItem mnuItemBarraEstado; private JTextArea txtTexto; private JPopupMenu popTexto; private JMenuItem popItemCopiar; private JMenuItem popItemCortar; private JMenuItem popItemPegar; private JLabel lblBarraEstado; private File openFile; /** * Constructor de la clase, crea una nueva ventana que incluye un menu y un * JTextField para la edicion de texto. */ public Main() { getContentPane().setLayout(new BorderLayout()); setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); /** * Aqui iniciamos el JMenuBar que es un contenedor donde vamos a ir * metiendo todos los demas menus y todos los elementos del menu que * queramos utilizar. */ menuBar = new JMenuBar(); /** * Utilizamos el constructor de la clase JMenu para crear un nuevo menu * llamado Archivo. El constructor de JMenu lo unico que recibe es el * letrero que queremos que tenga nuestro menu. */ mnuArchivo = new JMenu("Archivo"); /** * setMnemonic es una funcion que nos permite elegir la letra de acceso * rapido para hacer el programa mas sencillo de utilizar */ mnuArchivo.setMnemonic(KeyEvent.VK_A); /** * Agrego un MouseListener que me permite saber cuando el raton esta * sobre del menu, esto no es necesario para sus proyectos. En este * proyecto solamente lo utilizo para que la barra de informacion que * aparece hasta abajo este actualizada con la informacion correcta. */ mnuArchivo.addMouseListener(this); menuBar.add(mnuArchivo); mnuItemNuevo = new JMenuItem("Nuevo"); /** * setAccelerator es un metodo que nos permite presionar una combinacion * de teclas para acceder rapidamente a un comando del menu. Recibe un * objeto de tipo KeyStroke que podemos obtener mediante el metodo * KeyStroke.getKeyStroke(KeyEvent.VK_X, ActionEvent.MASK) * Donde: * X es una letra cualquiera, por ejemplo VK_A es la combinacion * que utilizamos para que el acceso directo utilice la tecla 'A' * * MASK es la tecla extra que queremos que se presione, las teclas * validas son CTRL_MASK, ALT_MASK, SHIFT_MASK, META_MASK (para * Mac) y 0 (cuando no se presiona ninguna tecla). Esta ultima es * muy poco recomendable. */ mnuItemNuevo.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_N, ActionEvent.CTRL_MASK)); mnuItemNuevo.setMnemonic(KeyEvent.VK_N); /** * Podemos poner iconos a los menus de la misma manera en la que podemos * ponerle iconos a cualquier otro componente de swing, si quieres ver * mas informacion sobre los iconos visita el trial de imagenes. */ mnuItemNuevo.setIcon(new ImageIcon( Main.class.getResource("filenew.png"))); mnuItemNuevo.addActionListener(this); mnuItemNuevo.addMouseListener(this); mnuArchivo.add(mnuItemNuevo); mnuArchivo.addSeparator(); mnuItemAbrir = new JMenuItem("Abrir..."); mnuItemAbrir.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_A, ActionEvent.CTRL_MASK) ); mnuItemAbrir.setMnemonic(KeyEvent.VK_A); mnuItemAbrir.setIcon(new ImageIcon( Main.class.getResource("fileopen.png"))); mnuItemAbrir.addActionListener(this); mnuItemAbrir.addMouseListener(this); mnuArchivo.add(mnuItemAbrir); mnuItemGuardar = new JMenuItem("Guardar..."); mnuItemGuardar.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_G, ActionEvent.CTRL_MASK) ); mnuItemGuardar.setMnemonic(KeyEvent.VK_G); mnuItemGuardar.setIcon(new ImageIcon( Main.class.getResource("filesave.png"))); mnuItemGuardar.addActionListener(this); mnuItemGuardar.addMouseListener(this); mnuArchivo.add(mnuItemGuardar); mnuItemGuardarComo = new JMenuItem("Guardar Como..."); mnuItemGuardarComo.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_F12, 0) ); mnuItemGuardarComo.setMnemonic(KeyEvent.VK_C); mnuItemGuardarComo.setIcon(new ImageIcon( Main.class.getResource("filesaveas.png"))); mnuItemGuardarComo.addActionListener(this); mnuItemGuardarComo.addMouseListener(this); mnuArchivo.add(mnuItemGuardarComo); mnuArchivo.addSeparator(); mnuItemSalir = new JMenuItem("Salir"); mnuItemSalir.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_F4, ActionEvent.ALT_MASK)); mnuItemSalir.setMnemonic(KeyEvent.VK_S); mnuItemSalir.setIcon(new ImageIcon( Main.class.getResource("exit.png"))); mnuItemSalir.addActionListener(this); mnuItemSalir.addMouseListener(this); mnuArchivo.add(mnuItemSalir); mnuEdicion = new JMenu("Edicion"); mnuEdicion.setMnemonic(KeyEvent.VK_E); mnuEdicion.addMouseListener(this); menuBar.add(mnuEdicion); mnuItemCopiar = new JMenuItem("Copiar"); mnuItemCopiar.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_C, ActionEvent.CTRL_MASK) ); mnuItemCopiar.setMnemonic(KeyEvent.VK_C); mnuItemCopiar.setIcon(new ImageIcon( Main.class.getResource("editcopy.png"))); mnuItemCopiar.addActionListener(this); mnuItemCopiar.addMouseListener(this); mnuEdicion.add(mnuItemCopiar); mnuItemCortar = new JMenuItem("Cortar"); mnuItemCortar.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_X, ActionEvent.CTRL_MASK) ); mnuItemCortar.setMnemonic(KeyEvent.VK_T); mnuItemCortar.setIcon(new ImageIcon( Main.class.getResource("editcut.png"))); mnuItemCortar.addActionListener(this); mnuItemCortar.addMouseListener(this); mnuEdicion.add(mnuItemCortar); mnuItemPegar = new JMenuItem("Pegar"); mnuItemPegar.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_V, ActionEvent.CTRL_MASK) ); mnuItemPegar.setMnemonic(KeyEvent.VK_P); mnuItemPegar.setIcon(new ImageIcon( Main.class.getResource("editpaste.png"))); mnuItemPegar.addActionListener(this); mnuItemPegar.addMouseListener(this); mnuEdicion.add(mnuItemPegar); mnuFormato = new JMenu("Formato"); mnuFormato.setMnemonic(KeyEvent.VK_F); mnuFormato.addMouseListener(this); menuBar.add(mnuFormato); /** * Para crear submenus podemos ponerun JMenu dentro de otro JMenu como * estamos haciendo ahorita donde mnuAlineacion va a estar dentro de * mnuFormato. Esto nos puede ser muy util cuando queremos poner una * gran cantidad de menus que estan relacionados dentro de dos grupos * (es decir Formato y Alineacion). */ mnuAlineacion = new JMenu("Alineacion"); mnuAlineacion.setMnemonic(KeyEvent.VK_A); mnuAlineacion.addMouseListener(this); mnuFormato.add(mnuAlineacion); /** * Al igual que los JRadioButton para poder utilizar los menus con * botones de radio JRadioButtonMenuItem tengo que ponerlos en un mismo * grupo de botones. */ ButtonGroup alineacionGroup = new ButtonGroup(); /** * Para crear un nuevo elemento del menu que tenga un radio button lo * que tengo que hacer es crear un JRadioButtonMenuItem que se crea de * la misma manera que los otros menus y se utiliza de la misma manera * que los JRadiobutton, para ver mas a fondo como utilizarlos puedes * ver el trial de JRadioButton. */ mnuItemAlineacionIzquierda = new JRadioButtonMenuItem("Izquierda"); mnuItemAlineacionIzquierda.setMnemonic(KeyEvent.VK_I); mnuItemAlineacionIzquierda.addActionListener(this); mnuItemAlineacionIzquierda.addMouseListener(this); mnuItemAlineacionIzquierda.setSelected(true); alineacionGroup.add(mnuItemAlineacionIzquierda); mnuAlineacion.add(mnuItemAlineacionIzquierda); mnuItemAlineacionDerecha = new JRadioButtonMenuItem("Derecha"); mnuItemAlineacionDerecha.setMnemonic(KeyEvent.VK_D); mnuItemAlineacionDerecha.addActionListener(this); mnuItemAlineacionDerecha.addMouseListener(this); alineacionGroup.add(mnuItemAlineacionDerecha); mnuAlineacion.add(mnuItemAlineacionDerecha); mnuItemAlineacionCentrado = new JRadioButtonMenuItem("Centrado"); mnuItemAlineacionCentrado.setMnemonic(KeyEvent.VK_C); mnuItemAlineacionCentrado.addActionListener(this); mnuItemAlineacionCentrado.addMouseListener(this); alineacionGroup.add(mnuItemAlineacionCentrado); mnuAlineacion.add(mnuItemAlineacionCentrado); mnuItemContarLetra = new JMenuItem("Contar letra..."); mnuItemContarLetra.setMnemonic(KeyEvent.VK_C); mnuItemContarLetra.addActionListener(this); mnuItemContarLetra.addMouseListener(this); mnuFormato.add(mnuItemContarLetra); mnuVer = new JMenu("Ver"); mnuVer.setMnemonic(KeyEvent.VK_V); mnuVer.addMouseListener(this); menuBar.add(mnuVer); /** * Al igual que el caso de los radio buttons para poder agregar un * JCheckBox en un menu debemos utilizar el JCheckBoxMenuItem que se * crea y utiliza en la misma manera que utilizamos los demas menus pero * ademas cuenta con mucha funcionalidad de los JCheckBox, para ver mas * a fondo como utilizarlo puedes ver el trial de JCheckBox. */ mnuItemBarraEstado = new JCheckBoxMenuItem("Barra de estados"); mnuItemBarraEstado.setMnemonic(KeyEvent.VK_B); mnuItemBarraEstado.setSelected(true); mnuItemBarraEstado.addItemListener(this); mnuItemBarraEstado.addMouseListener(this); mnuVer.add(mnuItemBarraEstado); /** * Aqui estamos agregando la barra de menu a la forma, this hace * referencia a esta ventana y setJMenuBar nos permite agregar una barra * de menu. */ this.setJMenuBar(menuBar); popTexto = new JPopupMenu(); popItemCopiar = new JMenuItem("Copiar"); popItemCopiar.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_C, ActionEvent.CTRL_MASK) ); popItemCopiar.setMnemonic(KeyEvent.VK_C); popItemCopiar.setIcon(new ImageIcon( Main.class.getResource("editcopy.png"))); popItemCopiar.addActionListener(this); popItemCopiar.addMouseListener(this); popTexto.add(popItemCopiar); popItemCortar = new JMenuItem("Cortar"); popItemCortar.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_X, ActionEvent.CTRL_MASK) ); popItemCortar.setMnemonic(KeyEvent.VK_T); popItemCortar.setIcon(new ImageIcon( Main.class.getResource("editcut.png"))); popItemCortar.addActionListener(this); popItemCortar.addMouseListener(this); popTexto.add(popItemCortar); popItemPegar = new JMenuItem("Pegar"); popItemPegar.setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_V, ActionEvent.CTRL_MASK) ); popItemPegar.setMnemonic(KeyEvent.VK_P); popItemPegar.setIcon(new ImageIcon( Main.class.getResource("editpaste.png"))); popItemPegar.addActionListener(this); popItemPegar.addMouseListener(this); popTexto.add(popItemPegar); txtTexto = new JTextArea(); txtTexto.setLineWrap(true); txtTexto.setWrapStyleWord(true); txtTexto.addMouseListener(this); JScrollPane scrollPane = new JScrollPane(txtTexto); scrollPane.setHorizontalScrollBarPolicy( JScrollPane.HORIZONTAL_SCROLLBAR_NEVER); add(scrollPane, BorderLayout.CENTER); lblBarraEstado = new JLabel(" "); add(lblBarraEstado, BorderLayout.SOUTH); setSize(500,500); setTitle("Editor de Texto"); setVisible(true); } /** * Crea una nueva instancia del programa. * * @param args argumentos de la lina de comandos */ public static void main(String[] args) { Main app = new Main(); } /** * Metodo que copia datos al portapapeles. * * @param str El String que queremos copiar al portapapeles */ private void setClipboard(String str) { /** * Esta linea nos permite obtener el portapapeles predeterminado del * sistema, es decir, nos permite ver que esta copiado en memoria. */ Clipboard clip = getToolkit().getSystemClipboard(); /** * En esta linea estamos creando un objeto de tipo StringSelection que * es necesario para mandarlos datos al portapapeles */ StringSelection fieldContent = new StringSelection (str); /** * Con el metodo setContents del objeto Clipboard podemos poner un dato * en el portapapeles. El primer parametro que recibe es un objeto de * tipo Transferable (que es el fieldContent que creamos) y el segundo * es el dueño del portapapeles que a menos que la aplicacion utilice * el portapapeles de alguna manera especial siempre va a ser la palabra * clave this. */ clip.setContents(fieldContent, this); } /** * Metodo que pega los datos al portapapeles. Utiliza un objeto Transferable * para poder leer desde el portapapeles y en caso de que el contenido de este * sea texto entonces regresa el texto que leyo. * * @return Regresa el texto que lee del portapapeles en caso de que pueda leer, * nulo en caso contrario. */ private String getClipboard() { /** * Esta linea es necesaria para poder leer del portapapeles, con ella * creamos un objeto de tipo Transferable que nos permite obtener los * datos guardados en memoria. */ Transferable t = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null); /** Es necesario usar un try porque puede mandar un error en el que el * dato guardado en el portapapeles no es un tipo soportado, por ejemplo * podria guardar un archivo y en el programa solo podemos pegar texto. */ try { if (t != null && t.isDataFlavorSupported(DataFlavor.stringFlavor)) { String text = (String)t.getTransferData(DataFlavor.stringFlavor); return text; } } catch (UnsupportedFlavorException e) { } catch (IOException e) { } return null; } /** * Metodo que nos permite abrir un archivo de texto y leerlo. El metodo nos * regresa el texto que leyo del archivo * * @param file El archivo a leer. * @return El texto que leyo del archivo. */ String abrir(File file) { String linea = ""; String texto = ""; BufferedReader fileIn = null; try { fileIn = new BufferedReader(new FileReader(file)); while ((linea = fileIn.readLine()) != null) { texto += linea + "\n"; } } catch (IOException ioe) { String err = "Error De Lectura\n" + "Posiblemente el disco esta lleno o protegido contra lectura"; JOptionPane.showMessageDialog(this, err, "Error De Lectura", JOptionPane.ERROR_MESSAGE); return(""); } finally { try { if (fileIn != null) { fileIn.close(); } } catch (IOException ioe) { } } return texto; } /** * Metodo que nos permite guardar a un archivo de texto. * * @param file El archivo a escribir. * @param texto Texto a guardar en el archivo. */ void guardar(File file, String texto) { try { PrintWriter fileOut = new PrintWriter(new FileWriter(file)); fileOut.print(texto); fileOut.flush(); fileOut.close(); } catch (IOException ioe) { String err = "Error De Escritura\n" + "Posiblemente el disco esta lleno o protegido contra escritura"; JOptionPane.showMessageDialog(this, err, "Error De Escritura", JOptionPane.ERROR_MESSAGE); } } /** * Metodo que maneja eventos. * * @param e Es el objeto que representa el evento */ public void actionPerformed(ActionEvent e) { /** * Como vas a poder ver en este metodo manejar eventos de JMenuItems se * hace en exactamente la misma manera en que se haria con botones. Para * saber que boton fue el que origino el evento utilizamos e.getSource() * y dependiendo de eso ya realizamos las acciones que sean necesarias. */ /** * Si el usuario hace click en "Nuevo" le pregunto si esta seguro que * quiere borrar el archivo. Si contesta que si entonces borro lo que * estaba en la caja de texto. */ if (e.getSource() == mnuItemNuevo) { int op; String msg = "Estas seguro de que quieres hacer un archivo " + "nuevo (perderas todos los cambios)"; op = JOptionPane.showConfirmDialog(this, msg, "Nuevo", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE); if (op == JOptionPane.OK_OPTION) { txtTexto.setText(""); openFile = null; } /** * Si el usuario hace click en "Abrir" le muestro una ventana para * elegir el archivo a elegir y mando a llamar el metodo abrir que me * devuelve un string y ese string lo pongo como el texto en la caja de * texto. */ } else if (e.getSource() == mnuItemAbrir) { JFileChooser fc = new JFileChooser(); fc.setFileSelectionMode(JFileChooser.FILES_ONLY); int ret = fc.showOpenDialog(this); if (ret == JFileChooser.APPROVE_OPTION) { openFile = fc.getSelectedFile(); txtTexto.setText(abrir(openFile)); } /** * Si el usuario hace click en "Guardar" y no hay archivo abierto le * muestro una ventana para elegir done quiere guardar el archivo y * mando a llamar el metodo guardar que se encarga de escribir el texto * a un archivo, si ya habia un archivo abierto nada mas mando llamar el * metodo guardar con el archivo abierto. */ } else if (e.getSource() == mnuItemGuardar) { if (openFile == null) { JFileChooser fc = new JFileChooser(); fc.setFileSelectionMode(JFileChooser.FILES_ONLY); int ret = fc.showSaveDialog(this); if (ret == JFileChooser.APPROVE_OPTION) { openFile = fc.getSelectedFile(); } } guardar(openFile, txtTexto.getText()); /** * Si el usuario hace click en "Guardar Como" le muestro una ventana * para elegir done quiere guardar el archivo y mando a llamar el * metodo guardar que se encarga de escribir el texto a un archivo, si * ya habia un archivo abierto nada mas mando llamar el metodo guardar * con el archivo abierto. */ } else if (e.getSource() == mnuItemGuardarComo) { JFileChooser fc = new JFileChooser(); fc.setFileSelectionMode(JFileChooser.FILES_ONLY); int ret = fc.showSaveDialog(this); if (ret == JFileChooser.APPROVE_OPTION) { openFile = fc.getSelectedFile(); guardar(openFile, txtTexto.getText()); } /** * Si el usuario hace click en "Salir" la aplicación se cierra */ } else if (e.getSource() == mnuItemSalir) { boolean cancel = false; if (openFile != null) { int r = 0; r = JOptionPane.showConfirmDialog(this, "Guardar cambios?", "Salir", JOptionPane.YES_NO_CANCEL_OPTION); if (r == JOptionPane.YES_OPTION) { guardar(openFile, txtTexto.getText()); } else if (r == JOptionPane.CANCEL_OPTION) { cancel = true; } } if (!cancel) { System.exit(0); } /** * Si el usuario hace click en "Copiar" copio el texto que este * seleccionado al portapapeles mediante la funcion setClipboard */ } else if (e.getSource() == mnuItemCopiar) { /** * setClipboard es una funcion que nos sirve para guardar cualquier * tipo de dato en el portapeles, dependiendo de como la * implementemos. */ setClipboard(txtTexto.getSelectedText()); /** * Si el usuario hace click en "Cortar" copio el texto elegido al * portapapeles y despues borro el texto elegido. */ } else if (e.getSource() == mnuItemCortar) { setClipboard(txtTexto.getSelectedText()); txtTexto.replaceSelection(""); /** * Si el usuario hace click en "Pegar" pongo el texto que esta en el * portapapeles en vez del texto que esta seleccionado */ } else if (e.getSource() == mnuItemPegar) { txtTexto.replaceSelection(getClipboard()); /** * Si el usuario hace click en "Izquierda" alineamos el texto a la * izquierda */ } else if (e.getSource() == mnuItemAlineacionIzquierda) { /** * Si el usuario hace click en "Derecha" alineamos el texto a la * derecha */ } else if (e.getSource() == mnuItemAlineacionDerecha) { /** Si el usuario hace click en "Centrado" centramos el texto */ } else if (e.getSource() == mnuItemAlineacionCentrado) { /** * Si el usuario hace click en "Contar Letra" le muestro un dialogo en * el que puede elegir una letra y despues muestro otro dialogo con el * numero de repeticiones de esa letra que se encuentran en el texto. */ } else if (e.getSource() == mnuItemContarLetra) { String r = JOptionPane.showInputDialog(this, "Que letra quieres buscar?"); if (!r.equals("") && r.length() == 1) { char c = r.charAt(0); if (c != '\0') JOptionPane.showMessageDialog(this, cuentaLetra(c, txtTexto.getText())); } else { JOptionPane.showMessageDialog(this, "Por favor pon un caracter", "Error", JOptionPane.ERROR_MESSAGE); } } } /** * Metodo que se encarga de manejar los eventos de los JCheckBoxMenuItem. El * metodo revisa si seleccionaron o deseleccionaron el JCheckBox que se * encuentra en el menu y dependiendo de eso muestra o no la barra de * estado. * * @param e Representa el evento que se disparo */ public void itemStateChanged(ItemEvent e) { boolean selected = (e.getStateChange() == ItemEvent.SELECTED); if (e.getSource() == mnuItemBarraEstado) { lblBarraEstado.setVisible(selected); } } /** * Metodo que devuelve el numero de repeticiones de la letra especificada * en el texto pasado como parametro y lo devuelve como un valor numerico. * El metodo no distingue entre mayusculas y minusculas. * * @param letra La letra de la que se buscan las repeticiones dentro del * archivo * @param texto El texto en el que se va a buscar * @return El numero de veces que aparece la letra especificada en el archivo */ public static int cuentaLetra(char letra, String texto) { int suma = 0; letra = Character.toUpperCase(letra); for (int i = 0; i < texto.length(); i++) { char c = texto.charAt(i); if (Character.toUpperCase(c) == letra) suma++; } return suma; } /** * Es un evento que se dispara cuando otro programa cambia el contenido que * hay en el portapapeles * * @param c El portapapeles que genera el evento * @param t Si es transferible */ public void lostOwnership(Clipboard c, Transferable t) {} /** * Maneja el evento cuando se presiona un boton del mouse sobre el componente * que escucha. * * @param e Representa el evento que se disparo */ public void mouseClicked(MouseEvent e) {} /** * Es un metodo que se dispara cuando el mouse se pone sobre el componente que * escucha eventos. * * @param e Representa el evento que se disparo */ public void mouseEntered(MouseEvent e) { if (e.getSource() == mnuArchivo) { lblBarraEstado.setText("Opciones de archivos"); } else if (e.getSource() == mnuItemNuevo) { lblBarraEstado.setText("Crear un archivo nuevo"); } else if (e.getSource() == mnuItemAbrir) { lblBarraEstado.setText("Abrir un archivo existente"); } else if (e.getSource() == mnuItemGuardar || e.getSource() == mnuItemGuardarComo) { lblBarraEstado.setText("Guardar el archivo actual"); } else if (e.getSource() == mnuItemSalir) { lblBarraEstado.setText("Salir de la aplicacion"); } else if (e.getSource() == mnuEdicion) { lblBarraEstado.setText("Opciones de edicion"); } else if (e.getSource() == mnuItemCopiar || e.getSource() == popItemCopiar) { lblBarraEstado.setText("Copiar el texto seleccionado"); } else if (e.getSource() == mnuItemCortar || e.getSource() == popItemCortar) { lblBarraEstado.setText("Cortar el texto seleccionado"); } else if (e.getSource() == mnuItemPegar || e.getSource() == popItemPegar) { lblBarraEstado.setText("Pegar el texto que se encuentra en el " + "portapapeles"); } else if (e.getSource() == mnuFormato) { lblBarraEstado.setText("Operaciones de formato"); } else if (e.getSource() == mnuAlineacion) { lblBarraEstado.setText("Cambiar la alineacion del texto"); } else if (e.getSource() == mnuItemAlineacionIzquierda) { lblBarraEstado.setText("Cambiar la alineacion a la izquierda"); } else if (e.getSource() == mnuItemAlineacionDerecha) { lblBarraEstado.setText("Cambiar la alineacion a la derecha"); } else if (e.getSource() == mnuItemAlineacionCentrado) { lblBarraEstado.setText("Cambiar la alineacion a centrado"); } else if (e.getSource() == mnuItemContarLetra) { lblBarraEstado.setText("Contar el numero de veces que aparece" + "una letra"); } else if (e.getSource() == mnuVer) { lblBarraEstado.setText("Opciones de visualizacion"); } else if (e.getSource() == mnuItemBarraEstado) { lblBarraEstado.setText("Hacer que desaparezca esta barra"); } } /** * Es un metodo que se dispara cuando el mouse sale de el componente que * escucha eventos. * * @param e Representa el evento que se disparo */ public void mouseExited(MouseEvent e) { lblBarraEstado.setText(" "); } /** * Es un metodo que se dispara cuando se presiona un boton del mouse sobre el * componente que escucha eventos. * * @param e Representa el evento que se disparo */ public void mousePressed(MouseEvent e) { if (e.isPopupTrigger() && e.getSource() == txtTexto) { popTexto.show(txtTexto, e.getX(), e.getY()); } } /** * Es un metodo que se dispara cuando se suelta un boton del mouse sobre el * componente que escucha eventos. * * @param e Representa el evento que se disparo */ public void mouseReleased(MouseEvent e) { if (e.isPopupTrigger() && e.getSource() == txtTexto) { popTexto.show(txtTexto, e.getX(), e.getY()); } } }