[eside-ghost] GUI Java
SystemBD
sistema_paralelo en yahoo.es
Lun Ago 15 02:44:43 CEST 2005
Si piensas crear ventanas con Eclipse hay varias opciones:
a) Utilizar el plugin VE (Visual Editor), descargable desde el
apartado de descargas de la propia web de eclipse. En mi opinión,
todavía está MUY verde y es casi imposible hacer algo decente con él (si
los layouts pueden llegar a ser odiosos por sí solos, con este sistema
se vuelven insufribles). Por otra parte, requiere también la descarga
las herramientas EMF (Eclipse Modelling Framework) y GEF (Graphical
Editor Framework). Con suerte, podrás hacer un par de formularios antes
de que empiezen a desaparecer botones -¡¡de la propia GUI del VE!!-.
b) Buscar en eclipseplugincentral.com un plugin que se adapte a tus
necesidades. Lo malo es que la mayor parte son de pago. Si no tienes
problemas con ello, te redirecciono al WindowBuilder Pro (no lo he
probado pero lo ponen como diox, he incluso anuncian que tiene versiones
gratuitas).
c) Olvidarte de Eclipse para hacer las GUI, utilizar un programa
como JBuilder o similar para crearlas (en plan fácil a lo Visual Basic)
e importarlas después a Eclipse. Eso si, tendrás que sufrir bastante
para crear algo parecido a los Layouts de coordenadas XY que utilizan
estos sistemas.
d) Si ninguna otra opción te convence,siempre puedes hacer como un
servidor -es decir, yo mismo, no un servidor "de verdad"- y haz las
interfaces de usuario "a pelo". Esto tiene sus ventajas y sus -muchos-
incovenientes, pero si dedicas unas cuantas horas a crear un sistema de
ventanas/GUI propio, podrás reutilizarlo en otros proyectos y aprénderas
cómo funciona internamente el sistema.
EngaPuesss:
SystemBD
PD: Adjunto tres archivos de código propios para que te hagas una idea
de lo que implica la opción d). Considéralos bajo la licencia que más te
guste.
kapi59ttp escribió:
>Aupa txabaleria!!!
>Me gustaria hacer unas ventanitas para Java, y me gustaria que alguien
>me recomendase alguna app o plugin de eclipse
>por ejemplo que haya utilizado y sea sencillo y efectivo :D
>
>Zenkiu!!!
>
>
>
------------ próxima parte ------------
/*************************************************************************
* Proyecto: SCC
* Autor: SystemBD
* Nombre de archivo: Ventana.java
* Fecha de creación: 06-jun-2005 15:34:28
* Descripción: Esta clase se encargar de crear la ventana donde vamos a
* cargar la interfaz de usuario. (Sólo si es una aplicación)
*************************************************************************/
package interfazUsuario;
import java.awt.*;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import accesoDatos.Recurso;
/**
* Esta clase se encarga de crear la ventana donde vamos a cargar la interfaz
* de usuario. (Sólo si es una aplicación)
* @author SystemBD
*/
public class Ventana{
/** El JFrame asociado a la ventana. Esta clase podría haber sido una
* extensión de la clase JFrame pero, por motivos de claridad de código,
* se ha preferido este diseño (donde ventana hace de FACHADA de JFrame).*/
private JFrame miFrame = null;
/** Almacenar la configuración del modo de vídeo de la pantalla nos vendrá
* bien para "jugar" con la ventana. */
private DisplayMode modo = null;
/** El constructor principal de la clase. */
public Ventana (String titulo) {
// Creamos una nueva instancia de la clase JFrame para miFrame
miFrame = new JFrame(titulo);
// Obtenemos la modod de vídeo del dispositivo (pantalla)
modo = miFrame.getGraphicsConfiguration().getDevice().getDisplayMode();
}
/** Muestra la ventana (inicialmente oculta). */
public void mostrarVentana () { miFrame.setVisible(true); }
/** Oculta la ventana. */
public void ocultarVentana () { miFrame.setVisible(false); }
/** Establece un texto para al barra de título de la ventana.
* @param titulo El título de la ventana */
public void setTitulo(String titulo) { miFrame.setTitle(titulo); }
/** Obtiene el texto con el título de la ventana.
* @return String con el títul ode la ventana.*/
public String getTitulo () { return miFrame.getTitle(); }
/** Establece la posición y el tamaño de la ventana a partir de 4 valores.
* @param posX La posición horizontal en la pantalla
* @param posY La posición vertical en la pantalla
* @param ancho El ancho de la ventana
* @param alto El alto de la ventana */
public void setTamano (int posX, int posY, int ancho, int alto)
{ miFrame.setBounds(posX, posY, ancho, alto); }
/** Establece la posición y el tamaño de la ventana.
* @param tamano Rectángulo con la posición y el tamaño de la ventana.*/
public void setTamano ( Rectangle tamano ) { miFrame.setBounds (tamano); }
/** Devuelve los valores de posición y tamaño de la ventana.
* @return Rectangle con los valores de posición y tamaño de la ventana.*/
public Rectangle getTamano () { return miFrame.getBounds(); }
/** Establece si la ventana dispone de bordes (Manejar con cuidado) */
public void setSinBordes (boolean valor ) { miFrame.setUndecorated (valor);}
/** Establece si la ventana debe quedar siempre por encima de las demás, aún
* cuando esta pierde el foco.
* @param valor Valor booleano.*/
public void setSiempreArriba (boolean valor)
{ miFrame.setAlwaysOnTop(valor); }
/** Establece si el usuario puede cambiar de tamaño de la ventana.
* @param valor Valor booleano.*/
public void setAmpliable (boolean valor) { miFrame.setResizable(valor); }
/** Establece si al cerrar la ventana, el programa debe finalizar.
* @param valor Valor booleano.*/
public void salirAlCerrar(boolean valor) {
if (valor) miFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
else miFrame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
}
/** Carga el icono de la ventana desde un recurso.
* @param rutaRec La dirección relativa donde se encuentra el recurso.*/
public void setIcono (String rutaRec) {
miFrame.setIconImage(Recurso.getImagen(rutaRec).getImage()
.getScaledInstance(16,16,Image.SCALE_DEFAULT));
}
/** Sitúa la ventana de forma que quede centrada en pantalla. */
public void centrarEnPantalla() {
miFrame.setLocation((modo.getWidth() - miFrame.getWidth()) / 2,
(modo.getHeight() - miFrame.getHeight()) / 2);
}
/** Devuelve el Panel Contenedor de la ventana.
* @return Container Panel Contenedor de la ventana */
public Container getContenedor() { return miFrame.getContentPane(); }
/** Actualiza la ventana y su contenido, muy util cuando cambiamos el
* aspecto de la interfaz.*/
public void actualizarVentana() {
SwingUtilities.updateComponentTreeUI(miFrame);
}
}
------------ próxima parte ------------
/*************************************************************************
* Proyecto: SCC
* Autor: SystemBD
* Nombre de archivo: Coordenadas.java
* Fecha de creación: 07-jun-2005 13:06:26
* Descripción: La "estructura" que define el tipo Coordenadas.
*************************************************************************/
package interfazUsuario;
/**
* La "estructura" que define el tipo Coordenadas.
* @author SystemBD
*/
public class Coordenadas {
/** La posición horizontal de la esquina superior izquierda.*/
public int x;
/** La posición vertical de la esquina superior izquierda.*/
public int y;
/** El ancho en píxeles.*/
public int ancho;
/** El alto en píxeles.*/
public int alto;
/** El constructor simple */
public Coordenadas() { this(0,0,0,0); }
/** El constructor principal.*/
public Coordenadas(int x, int y, int ancho, int alto) {
this.x = x; this.y = y; this.ancho = ancho; this.alto = alto;
}
/** El generador de claves de Hash.
* @return Un entero con el código Hash.*/
public int hashCode() { return x ^ (y*5) ^ (ancho*8) ^ (alto*15); }
/** Comprueba si dos coordenadas son idénticas.
* @param objetoAComprobar Las coordenadas a comprobar.
* @return Un booleano con el resultado.*/
public boolean equals(Object objetoAComprobar) {
// Lo primero es comprobar si el objeto que nos han pasado es del tipo
// adecuado.
if (objetoAComprobar instanceof Coordenadas) {
// Si es del tipo Coordenadas, hacemos un casting.
Coordenadas otro = (Coordenadas)objetoAComprobar;
// Comprobación y devolución del resultado, todo en uno.
return otro.x == x && otro.y == y
&& otro.ancho == ancho && otro.alto == alto;
}
// Si no es del tipo Coordenadas, símplemente no es igual.
return false;
}
/** Crea un clon de este objeto.
* @return Un objeto coordenadas idéntico al original.*/
public Object clone() { return new Coordenadas(x, y, ancho, alto); }
/** Devuelve un String con la información de las coordenadas.
* @return El String con la información de las coordenadas*/
public String toString() {
return "Coordenadas: [" + x + "," + y + "," + ancho + "," + alto + "]";
}
}
------------ próxima parte ------------
/*************************************************************************
* Proyecto: SCC
* Autor: SystemBD
* Nombre de archivo: DistribucionPorCoordenadas.java
* Fecha de creación: 07-jun-2005 12:04:56
* Descripción: Como por defecto JAVA no proporciona ningún Layout (dis-
* tribución) que sitúe los objetos por coordenadas -x, y,
* ancho y alto- hemos de implementarlo por nuestra cuenta.
*************************************************************************/
package interfazUsuario;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager2;
import java.awt.Rectangle;
import java.util.Hashtable;
/**
* Como por defecto JAVA no proporciona ningún Layout (distribución) que sitúe
* los objetos por coordenadas -x, y, ancho y alto- hemos de implementarlo por
* nuestra cuenta.
* @author SystemBD
*/
public class DistribucionPorCoordenadas implements LayoutManager2{
/* El ancho y el alto del contenedor. Si alguno es <= 0, indicamos que el
* tamaño del contenedor es el definido por defecto.*/
int ancho, alto;
// Hastable con la información de los componentes
Hashtable info = new Hashtable();
// Las coordenadas por defecto.
static final Coordenadas coordenadasPorDefecto = new Coordenadas();
/** (Método implementado de LayoutManager2) Añade el componente a la
* distribución.
* @param componente El componente a añadir.
* @param coords Las coordenadas del componente a añadir.*/
@SuppressWarnings("unchecked")
public void addLayoutComponent(Component componente, Object coords) {
// Si el objeto es del tipo Coordenadas, podemos añadir el componente
// a la distribución.
if (coords instanceof Coordenadas) info.put(componente, coords);
}
/** (Método implementado de LayoutManager2) Obtiene las dimesiones
* máximas del Layout.
* @param contenedor*/
public Dimension maximumLayoutSize(Container contenedor)
{ return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE); }
/** (Método implementado de LayoutManager2) Devuelve 0,5 como valor de
* alineamiento horizontal del Layout*/
public float getLayoutAlignmentX(Container arg0) { return 0.5f; }
/** (Método implementado de LayoutManager2) Devuelve 0,5 como valor de
* alineamiento vertical del Layout*/
public float getLayoutAlignmentY(Container arg0) { return 0.5f; }
/** (Método implementado de LayoutManager2) Acción no definida.*/
public void invalidateLayout(Container arg0) {}
/** (Método implementado de LayoutManager)
* No realiza ninguna acción, para eso está addLayoutComponent(Component
* componente, Object coords) */
public void addLayoutComponent(String arg0, Component arg1) {}
/** (Método implementado de LayoutManager) Elimina un componente de la
* distribución.
* @param componente El componente a eliminar.*/
public void removeLayoutComponent(Component componente)
{ info.remove(componente); }
/** (Método implementado de LayoutManager) Obtiene las dimesiones
* "preferidas" del Layout.
* @param contenedor*/
public Dimension preferredLayoutSize(Container contenedor)
{ return obtenerTamanoLayout(contenedor, true); }
/** (Método implementado de LayoutManager)Obtiene las dimesiones
* mínimas del Layout.
* * @param contenedor*/
public Dimension minimumLayoutSize(Container contenedor)
{ return obtenerTamanoLayout(contenedor, true); }
/** (Método implementado de LayoutManager) Sitúa los objetos en función del
* contenedor al que pertenezcan.
* @param contenedor*/
public void layoutContainer(Container contenedor) {
// Obtenemos la posición de los bordes del contenedor
Insets insets = contenedor.getInsets();
// Obtenemos el número de componentes del contenedor
int numComponentes = contenedor.getComponentCount();
// Para cada componente...
for (int i = 0 ; i < numComponentes; i++) {
Component componente = contenedor.getComponent(i);
//...que esté visible en este momento...
if (componente.isVisible()) {
// ...obtenemos sus bordes...
Rectangle r = obtenerBordesComponente(componente, true);
//... y los actualizamos añadiendo la posición del contenedor
componente.setBounds(insets.left + r.x, insets.top + r.y,
r.width, r.height);
}
}
}
/** Obtiene un Rectangle con las coordenadas del componete.
* @param comp El componente del que deseamos saber sus bordes.
* @param cargarPreferred Un boolean con el que podemos decidir si queremos
* cargar los valores "preferidos" o los mínimos del componente.
* @return un Rectangle con las coordenadas del componete.*/
Rectangle obtenerBordesComponente(Component comp, boolean cargarPreferred) {
// Obtenemos las coordenadas desde la Hastable
Coordenadas crds = (Coordenadas)info.get(comp);
// Si no hemos conseguido encontrar las coordenadas adecuadas, les
// asignamos las que hemos definido como "por defecto"
if (crds == null) crds = coordenadasPorDefecto;
// Creamos un objeto de la clase Rectángulo con la informacón de crds.
Rectangle bordes = new Rectangle(crds.x, crds.y, crds.ancho, crds.alto);
// Si el ancho o el alto es menor que 0 entonces...
if (bordes.width <= 0 || bordes.height <= 0) {
// Si cargarPreferred es cierto, cargamos el tamaño Preferred y si
// no, el mínimo.
Dimension d = cargarPreferred ? comp.getPreferredSize()
: comp.getMinimumSize();
// Cargamos los datos nuevos en bordes
if (bordes.width <= 0) bordes.width = d.width;
if (bordes.height <= 0) bordes.height = d.height;
}
// Devolvemos el resultado
return bordes;
}
/** Obtiene el tamaño del contenedor pasado como parámetro.
* @param cont El contenedor del que queremos obtener su tamaño
* @param cargarPreferred Un boolean con el que podemos decidir si queremos
* cargar los valores "preferidos" o los mínimos del Layout
* @return el tamaño del contenedor pasado como parámetro.
*/
Dimension obtenerTamanoLayout(Container cont, boolean cargarPreferred) {
// Creamos un nuevo valor de dimensión de tamaño 0x0
Dimension dim = new Dimension(0, 0);
// Si el ancho o el alto es menor que 0 entonces...
if (ancho <= 0 || alto <= 0) {
// ...obtenemos el número de componentes del contenedor...
int numComp = cont.getComponentCount();
// ... y para cada uno de los componentes...
for (int i = 0; i < numComp; i++) {
// ... lo cargamos como tal en una variable local...
Component componente = cont.getComponent(i);
// ... y si es visible en ese momento...
if (componente.isVisible()) {
// ... obtenemos sus bordes...
Rectangle r = obtenerBordesComponente(componente,
cargarPreferred);
// ... y, dependiendo de cual sea mayor, se pasa bien el
// ancho original, bien el ancho del borde que acabamos de
// calcular.
dim.width = Math.max(dim.width , r.x + r.width);
// Lo mimo para el alto.
dim.height = Math.max(dim.height, r.y + r.height);
}
}
}
// Si el ancho/alto es mayor que cero, entonces podemos devolverlo sin
// problemas.
if (ancho > 0) dim.width = ancho;
if (alto > 0) dim.height = alto;
// Ahora sólo resta añadir al ancho/alto los bordes del contenedor
Insets insets = cont.getInsets();
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom;
// Devolvemos el resultado.
return dim;
}
}
Más información sobre la lista de distribución eside-ghost