PintaLlop - Programa de dibujo

Llop Site Home > JAVA > PintaLlop > Clases complementarias

Clases complementarias:

Clase PanelPropiedades

package pintallop;

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

/** Título: PintaLlop
    Descripción: Prácticas capítulo 11, ejercicio 3
    Copyright: Copyright (c) 2005
    Empresa: Casa_Llop
    @author Albert_Lobo
    @version 1.0 */

/** Clase que extiende 'JPanel'. Muestra, y permite modificar, las propiedades de la herramienta en uso. */
public class PanelPropiedades extends JPanel
{
  // La herramienta cuyas propiedades muestra el panel.
  private Herramienta herramientaEnUso;

  // Etiqueta para el icono correspondiente a la herramienta.
  private JLabel iconoHerramienta;
  // Etiqueta y 'JComboBox' para tratar el grosor del borde del trazo/figura.
  private JLabel etiquetaGrueso;
  private JComboBox listaGrueso;
  // Etiquetas y botones que permitirán modificar el color del borde y el fondo de una figura.
  private JLabel etiquetaColorBorde;
  private JButton botonColorBorde;
  private JLabel etiquetaColorFondo;
  private JButton botonColorFondo;

  // Estos componentes son propios de la herramienta de texto.
  // Una lista para seleccionar la fuente.
  private JComboBox listaFuentes;
  // Una etiqueta y un 'JComboBox' para ajustar el tamaño de la fuente.
  private JLabel etiquetaTamano;
  private JComboBox listaTamano;
  // Una serie de botones que permitirán escribir texto normal, en negrita, y cursiva.
  private ButtonGroup grupoBotones;
  private JButton botonTxtPlano;
  private JButton botonTxtNegrita;
  private JButton botonTxtCursiva;

  // Panel para seleccionar un color.
  private JColorChooser paleta;

  /** Constructor. Solamente necesita conocer qué herramienta se está actualizando.
      @param nuevaHerramientaEnUso Herramienta  La herramienta actualmente en uso. */
  public PanelPropiedades (Herramienta nuevaHerramientaEnUso)
  {
    // Construir un 'JPanel' con un 'BorderLayout'.
    super ();
    setLayout (new GridBagLayout ());
    // Definir la herramienta en uso.
    herramientaEnUso = nuevaHerramientaEnUso;
    // 'JColorChooser' para seleccionar colores.
    paleta = new JColorChooser ();

    // Inicializar todos los componentes.
    inicializaComponetes ();
    // Añadir los componentes adecuados al panel.
    if (herramientaEnUso.getTipo () != ColeccionHerramientas.TEXTO)
      anadePropiedades ();
    else
      anadePropiedadesTexto ();
    // Refrescar los componentes, por si ha habido cambios.
    refrescaComponentes ();
  }

  /** Inicializa los componentes que puede tener el panel. */
  private void inicializaComponetes ()
  {
    // Etiqueta para el icono de la herramienta.
    iconoHerramienta = new JLabel ();

    // Con estos componentes se puede manipular el grosor del trazo.
    // Nótese que, para que la función 'fillPolygon ()' pinte algo siempre, el grosor mínimo debe ser 2.
    etiquetaGrueso = new JLabel ("Grosor Trazo: ");
    String contenidoLista [] = new String [127];
    for (byte i = 0; i < 127; i++)
      contenidoLista [i] = String.valueOf (i + 2);
    listaGrueso = new JComboBox (contenidoLista);
    listaGrueso.setAction (new AbstractAction ()
    {
      public void actionPerformed (ActionEvent evento)
      {
        herramientaEnUso.setGrueso ((byte) (listaGrueso.getSelectedIndex () + 1));
      }
    });

    // Con estos componentes se puede manipular el color del trazo, y el del texto.
    etiquetaColorBorde = new JLabel ("Color Borde: ");
    botonColorBorde = new JButton ();
    botonColorBorde.setAction (new AbstractAction ("", PintaLlop.getIcono ("color.gif"))
    {
      public void actionPerformed (ActionEvent evento)
      {
        Color nuevoColorBorde = paleta.showDialog
            (null, "Elija el color para el borde", botonColorBorde.getBackground ());
        herramientaEnUso.setColorBorde (nuevoColorBorde);
        botonColorBorde.setBackground (nuevoColorBorde);
      }
    });

    // Con estos componentes se puede manipular el color del relleno (sólo en 'ovalo y rectángulo).
    etiquetaColorFondo = new JLabel ("Color Fondo: ");
    botonColorFondo = new JButton ();
    botonColorFondo.setAction (new AbstractAction ("", PintaLlop.getIcono ("color.gif"))
    {
      public void actionPerformed (ActionEvent evento)
      {
        Color nuevoColorRelleno = paleta.showDialog
            (null, "Elija el color para el relleno", botonColorBorde.getBackground ());
        herramientaEnUso.setColorRelleno (nuevoColorRelleno);
        botonColorFondo.setBackground (nuevoColorRelleno);
      }
    });

    // Los siguientes componetes son sólo para la herramienta de texto.
    // Con estos componentes se puede elegir la fuente del texto.
    // Podemos obtener las fuentes para Java en una sola línea.
    String fuentes [] = GraphicsEnvironment.getLocalGraphicsEnvironment ().getAvailableFontFamilyNames ();
    listaFuentes = new JComboBox (fuentes);
    listaFuentes.setAction (new AbstractAction ()
    {
      public void actionPerformed (ActionEvent evento)
      {
        herramientaEnUso.setNombreFuente ((String) listaFuentes.getSelectedItem ());
      }
    });
    // Con estos componentes se puede elegir el tamaño del texto.
    etiquetaTamano = new JLabel ("Tamaño: ");
    listaTamano = new JComboBox (contenidoLista);
    listaTamano.setAction (new AbstractAction ()
    {
      public void actionPerformed (ActionEvent evento)
      {
        herramientaEnUso.setTamano (listaTamano.getSelectedIndex () + 1);
      }
    });

    // Con los 3 siguientes botones, se puede poner el texto normal, en negrita, y en cursiva.
    botonTxtPlano = new JButton ();
    botonTxtPlano.setAction (new AbstractAction ("", PintaLlop.getIcono ("plano.gif"))
    {
      public void actionPerformed (ActionEvent evento)
      {
        herramientaEnUso.setEstilo (Font.PLAIN);
      }
    });
    botonTxtNegrita = new JButton ();
    botonTxtNegrita.setAction (new AbstractAction ("", PintaLlop.getIcono ("negrita.gif"))
    {
      public void actionPerformed (ActionEvent evento)
      {
        herramientaEnUso.setEstilo (Font.BOLD);
      }
    });
    botonTxtCursiva = new JButton ();
    botonTxtCursiva.setAction (new AbstractAction ("", PintaLlop.getIcono ("cursiva.gif"))
    {
      public void actionPerformed (ActionEvent evento)
      {
        herramientaEnUso.setEstilo (Font.ITALIC);
      }
    });

    // Añadimos los botones a un 'ButtonGroup' para que sólo uno de ellos esté seleccionado a la vez.
    grupoBotones = new ButtonGroup ();
    grupoBotones.add (botonTxtPlano);
    grupoBotones.add (botonTxtNegrita);
    grupoBotones.add (botonTxtCursiva);
  }

  /** Añade al panel los componentes propios de la herramientas:
        - lápiz, goma, línea, rectángulo, y óvalo. */
  private void anadePropiedades ()
  {
    GridBagConstraints restricciones = new GridBagConstraints ();
    restricciones.fill = GridBagConstraints.BOTH;
    restricciones.gridheight = GridBagConstraints.REMAINDER;
    add (iconoHerramienta, restricciones);
    add (etiquetaGrueso, restricciones);
    add (listaGrueso, restricciones);
    add (etiquetaColorBorde, restricciones);
    add (botonColorBorde, restricciones);
    // Con el rectángulo y el óvalo vemos un componente más,
    // que nos permite ajustar el color de relleno de la figura.
    if ((herramientaEnUso.getTipo () == ColeccionHerramientas.RECTANGULO)
        || (herramientaEnUso.getTipo () == ColeccionHerramientas.OVALO))
    {
      add (etiquetaColorFondo, restricciones);
      add (botonColorFondo, restricciones);
    }
  }

  /** Añade al panel los componentes propios de la herramienta de texto. */
  private void anadePropiedadesTexto ()
  {
    GridBagConstraints restricciones = new GridBagConstraints ();
    restricciones.fill = GridBagConstraints.BOTH;
    restricciones.gridheight = GridBagConstraints.REMAINDER;
    restricciones.weightx = 0;
    add (iconoHerramienta, restricciones);
    restricciones.weightx = 1;
    add (botonColorBorde, restricciones);
    add (listaFuentes, restricciones);
    restricciones.weightx = 0;
    add (etiquetaTamano, restricciones);
    add (listaTamano, restricciones);
    restricciones.weightx = 1;
    add (botonTxtPlano, restricciones);
    add (botonTxtNegrita, restricciones);
    add (botonTxtCursiva, restricciones);
  }

  /** Define la herramienta en uso. Lógicamente, también ajusta los componentes a las propiedades.
      @param nuevaHerramientaEnUso Herramienta  La nueva herramienta en uso. */
  public void setHerramientaEnUso (Herramienta nuevaHerramientaEnUso)
  {
    // Si la herramienta es la misma que había, no hay por qué seguir.
    if (herramientaEnUso.getTipo () == nuevaHerramientaEnUso.getTipo ())
      return;

    // Definir la nueva herramienta en uso; quitar todos los componentes; añadir sólo los
    // adecuados; y validar el panel.
    herramientaEnUso = nuevaHerramientaEnUso;
    removeAll ();
    if (nuevaHerramientaEnUso.getTipo () == ColeccionHerramientas.TEXTO)
      anadePropiedadesTexto ();
    else
      anadePropiedades ();
    validate ();

    // Ajustar las nuevas propiedades.
    refrescaComponentes ();
  }

  /** Actualiza los componentes para que reflejen las propiedades de la herramienta en uso. */
  public void refrescaComponentes ()
  {
    iconoHerramienta.setIcon (herramientaEnUso.getIcono ());
    listaGrueso.setSelectedIndex (herramientaEnUso.getGrueso () - 1);
    botonColorBorde.setBackground (herramientaEnUso.getColorBorde ());
    botonColorFondo.setBackground (herramientaEnUso.getColorRelleno ());
    listaFuentes.setSelectedItem (herramientaEnUso.getNombreFuente ());
    listaTamano.setSelectedIndex (herramientaEnUso.getTamano () - 1);
    // Averiguar el botón seleccionado del 'ButtonGroup'.
    ButtonModel modeloBotonSeleccionado = null;
    switch (herramientaEnUso.getEstilo ())
    {
      case Font.PLAIN:
        modeloBotonSeleccionado = botonTxtPlano.getModel ();
        break;
      case Font.BOLD:
        modeloBotonSeleccionado = botonTxtNegrita.getModel ();
        break;
      case Font.ITALIC:
        modeloBotonSeleccionado = botonTxtCursiva.getModel ();
    }
    grupoBotones.setSelected (modeloBotonSeleccionado, true);

    // Repinta el panel.
    repaint ();
  }
}



Clase SelectorImagenes

package pintallop;

import javax.swing.*;

/** Esta clase es básicamente un 'JFileChooser' personalizado:
    - Tiene un filtro -'FiltroImagenes'- que restringe los archivos disponibles a los '.gif',
      '.jpeg', y '.png'.
    - y puede poner nombre al botón de aceptar con el String que se pasa como argumento. */
public class SelectorImagenes extends JFileChooser
{
  /** Constructor.
      @param botonAprobar String  Cadena para el botón de aceptar del 'JFileChooser'. */
  public SelectorImagenes (String botonAprobar)
  {
    super ();

    addChoosableFileFilter (new FiltroImagenes (new String [] {".gif", ".jpeg", ".jpg", ".png"}));
    setApproveButtonText (botonAprobar);
  }
}



Clase FiltroImagenes

package pintallop;

import java.io.*;

/** La clase 'FileFilter' se encuentra tanto en 'javax.swing.filechooser', como en 'java.io'.
    Casualmente, hay que importar ambas bibliotecas. 'FiltroArchivos' se extiende de
    'javax.swing.filechooser.FileFilter', así que en lugar de importar las 2 bibliotecas
    sólo se importa 'java.io', y la otra se indica junto a 'extends'.
    Esta clase está pensada para limitar los archivos visibles en los 'JFileChooser'.
    Se sobrecargan los dos únicos métodos de la superclase. */
public class FiltroImagenes extends javax.swing.filechooser.FileFilter
{
  // Array para almacenar las extensiones de archivo permitidas por el filtro.
  private String extensiones [];

  /** Costructor. Define las extensiones aceptadas por el filtro.
      @param extensionesAceptadas String []  Array con las extensiones aceptadas por el filtro. */
  public FiltroImagenes (String extensionesAceptadas [])
  {
    extensiones = extensionesAceptadas;
  }

  /** Este método sirve para decidir los archivos disponibles en la ventanita 'JFileChooser';
      se le pasa como argumento un 'File' en el directorio de turno, y según
      el valor de retorno, el archivo se mostrará o no.
      @param archivo File  Archivo cuya extensión vamos a evaluar.
      @return boolean      'true' si la extensión del archivo es de las aceptadas; 'false' si no. */
  public boolean accept (File archivo)
  {
    String nombre = archivo.getName ().toLowerCase ();

    if (archivo.isDirectory ())
      return true;

    for (int i = 0; i < extensiones.length; i++)
      if (nombre.endsWith (extensiones [i]))
        return true;

    return false;
  }

  /** Este método establece el texto en el menú desplegable 'Tipos de archivo' para este filtro.
      @return String  Descripción de este filtro para mostrar en el 'JFileChooser'. */
  public String getDescription ()
  {
    String retorno = "Archivos de imagen: " + extensiones [0];

    for (int i = 1; i < extensiones.length; i++)
      retorno += ", " + extensiones [i];

    return retorno;
  }
}

¿Comentarios, sugerencias?: llopsite.at.yahoo.es | © 2005-07 Albert Lobo

Última actualización: 18-Feb-2007