Con etiquetas a la consulta
Fuente: http://www.programandoconcafe.com/2010/11/java-llenar-un-jtable-con-resultset.html Centrar un JFrame/JDialog en pantalla
Al crear un nuevo JFrame ó JDialog en Swing, al hacerlos visibles estos aparecerán arriba a la izquierda de nuestra pantalla. Por ejemplo si realizamos:
import javax.swing.JFrame; public class Prueba{
public static void main(String[] args){
JFrame frame = new JFrame("Prueba JFrame"); frame.setSize(500, 500);
frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE); frame.setVisible(true);
} }
Si ahora especificamos por medio del método setLocationRelativeTo a null, la ventana se posicionará en el medio de la pantalla. Por lo que si agregamos la siguiente linea:
import javax.swing.JFrame; public class Prueba{
public static void main(String[] args){ JFrame frame = new JFrame("Prueba JFrame"); frame.setSize(500, 500); frame.setLocationRelativeTo(null); frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE); frame.setVisible(true); } }
tendremos un resultado similar a este:
Fuente: http://lefunes.wordpress.com/2008/02/11/centrar-un-jframejdialog-en-pantalla/ Centrar JDialog en Jframe
Si lo que deseamos es centrar un JDialog en el JFrame “padre”, lo que hacemos es usar el mismo método, pero esta vez especificando que la posicioón de apertura del JDialog será con respecta al JFrame:
import javax.swing.JFrame; public class Prueba{
public static void main(String[] args){
JFrame frame = new JFrame("Prueba JFrame"); frame.setSize(500, 500);
frame.setLocationRelativeTo(null);
final JButton botón = new JButton("Abrir Dialogo"); botón.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JDialog dialogo = new JDialog(frame); dialogo.setSize(100, 100); dialogo.setLocationRelativeTo(frame); dialogo.setVisible(true); } }); frame.add(botón); frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE); frame.setVisible(true); } }
Fuente: http://lefunes.wordpress.com/2008/02/11/centrar-un-jframejdialog-en-pantalla/ Asesoramiento en programa
Hice el acceso al programa mediante una contraseña(necesaria) con dos clases. la q contiene el metodo main:
Código:
public class aplicacion {
public static void main(String[] args) { contraseña obj=new contraseña(); }
}
Y la q contiene las especificaciones de la ventana: Código:
import java.awt.Color; import javax.swing.*; import javax.swing.JFrame; import java.awt.event.*; public class contraseña { public contraseña(){
final JFrame marco=new JFrame("Acceso de programa");//CREAMOS EL MARCO DE LA VENTANA
//espacio deonde van los componentes JDesktopPane esc=new JDesktopPane();
JLabel eusuario=new JLabel("Usuario:"); JLabel econtraseña=new JLabel("Contraseña:"); final JTextField usuario=new JTextField();
final JPasswordField contraseña = new JPasswordField(); JButton cerrar=new JButton("cerrar");
JButton ingresar=new JButton("ingresar"); //ubicacion en el plano eusuario.setBounds(10,10,100,30); usuario.setBounds(90,10,190,30); econtraseña.setBounds(10, 50, 100, 30); contraseña.setBounds(90,50,190,30); cerrar.setBounds(180, 100, 100, 30); ingresar.setBounds(10, 100, 100, 30); //ocultamos la contraseña rusticamente
//agregar al escritorio los diferentes objetos esc.add(eusuario); esc.add(usuario); esc.add(econtraseña); esc.add(contraseña); esc.add(cerrar); esc.add(ingresar);
esc.setBackground(Color.LIGHT_GRAY);//esto es solo para distinguir el escritorio de la ventana
marco.add(esc);//este agrega el escritorio a la ventana marco.setSize(300,180);//le damos tamaño variable marco.setLocationRelativeTo(null);
marco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco.setVisible(true);//luego ir al metodo main a ocupar esta clase como metodo para un objeto
//programamos los botónes
ingresar.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){ String user; String clave; clave=contraseña.getText(); user= usuario.getText(); if (user.equalsIgnoreCase("felipe")&&clave.equals("cbrfelipe")){ JOptionPane.showMessageDialog(null,"Bienvenido al sistema");//aprobacion //abrir otro FRAME Programa
programa frame=new programa();// con este me muevo a la siguiente ventana... me costo caleta pillarlo
marco.setVisible(false);
}else JOptionPane.showMessageDialog(null,"reintentar"); }
});
cerrar.addActionListener(new ActionListener(){//para el botón cerrar tan solo ocupamos exit public void actionPerformed(ActionEvent e){
System.exit(0); } }); } } Fuente: http://www.elcachondeo.cl/foro/f135/2031731-asesoramiento-en-programa/ Cómo usar frames y diálogos en Java Netbeans
Todos los programas que vemos en el escritorio de Windows o Linux usan ventanas es por eso una de las razones que el sistema más usado en el mundo tiene el nombre “ventana” en ingles Windows, cuando hacemos sistema en Java Netbeans existen dos tipos de ventanas que son: Frames y diálogos. A continuación te estaremos hablando de cada una de ellas.
Visita mi web:http://www.wix.com/foxsoftware/estudiosavefenix
Los FRAMES son ventanas principales que no necesitan de la existencia de otras para existir, por ejemplo la ventana principal de WORD o EXCEL podemos tener varios WORD abiertos al mismo tiempo todos son independientes esos y no necesitan de otra ventana para su existencias en JAVA estas ventanas principales se llaman FRAME y cuando se las da un nombre se acostumbra a poner el nombre que lo identifica y con la terminación FRAME por ejemplo MAINFRAME es el FRAMA principal, o NEWITEMFRAME u FRAME para crear un nuevo ítem.
Los DIALOGOS son ventanas también al igual que las ventanas de tipo FRAME pero con la diferencia que estos bloquean al formulario o ventana padre hasta que se cierre el DIALOGO.
Bueno primeramente vamos a crear un FRAME principal y abrir otro FRAME a través de un botón en el FRAME principal.
Creamos un nuevo proyecto:
Ahora escogemos JAVA y JAVA APPLICATION y después clic en el botón NEXT:
Luego dejamos las opciónes como se muestra en la siguiente imagen:
Ahora hacemos clic en FINISH, y ahora creamos nuestro primer JFRAME haciendo clic derecho en el icono en forma de una taza de café de nuestro proyecto que acabamos de crear como en la siguiente imagen:
Luego hacemos clic en FINISH recuerda que nuestro primer FRAME se llama NEWJFRAME como se muestra en la anterior imagen.
De la misma manera creamos otro FRAME llamado NEWJFRAME1:
Ahora ya tenemos dos JFRAME vamos abrir el JNEWFRAME1 a través del NEWJFRAME por medio de un JBUTTON.
Ahora hacemos clic en el NEWJFRAME1 y en sus propiedades cambiamos la propiedad
DEFAULTCLOSEOPERATION de EXIT_ON_CLOSE A DISPOSE, como se muestra en la siguiente imagen recuerda que es del NEWJFRAME1:
Esto hemos hecho para que cada FRAME sea independiente a la hora de cerrar y o se sierren todas cuando cerremos una.
Ahora agregamos un botón al otro NEWJFRAME al primero que creamos y abrimos su código de su evento con clic derecho como en la siguiente imagen:
Y escribimos en siguiente código como en la siguiente imagen:
Listo con eso cuando hagamos clic en el botón se abrirá nuestro NEWJFRAME1, cuando ejecutes el proyecto te pedirá que elijas el FRAME principal le dices que sea NEWJFRAME como en la siguiente imagen:
Ahora vamos a crear un DIALOGO que es el otro tipo de ventana que tiene el JAVA, de la misma forma que hemos creado un FRAME se crea un DIALOGO, como en la siguiente imagen:
Luego hacemos clic en FINISH, ahora para abrir este NEWJDIALOG por medio de nuestro FRAME de la misma forma que hicimos anteriormente arrastramos un botón en el NEWJFRAME y en su evento escribimos el siguiente código:
Listo ahora ejecuta tu proyecto y recuerda que el FRAME principal de be ser NEWJFRAME si te sale la siguiente ventana:
Elige NEWJFRAME, y cuando ejecute veras las diferencias que existen entre una ventana de tipo DIALOGO y una ventana de tipo FRAME, espero que te haya servido.
Cómo poner fondo a un formulario de Java Netbeans
Bueno si y has usado alguna vez un DELPHI o C++BUILDER o un VISUAL BASIC y UN VISUIAL C#, y has pensado que poner una imagen de fondo a un formulario de JAVA NETBEANS es tan fácil como en las otras tecnologías casi te equivocaste, no es para nada igual, es totalmente diferente muy diferente no es difícil porque una vez que sepas como se hace lo harás muy fácilmente después.
Visita mi web:http://www.wix.com/foxsoftware/estudiosavefenix
Entonces sigue estos pasos, abre tu NETBEANS, haz clic en FILE->NEW PROJECT:
Ahora escoge JAVA y después JAVA APPLICATION como se muestra en la siguiente imagen:
Luego de hacer clic en NEXT te saldrá otra ventana ponle un nombre a tu aplicación en nuestro caso será APLICACIONCONFONDO y deja las demás opciónes como en la siguiente imagen:
Después de hacer clic en FINSH se creara el siguiente paquete en la parte derecha como en la siguiente imagen:
Ahora vamos a crear nuestro formulario principal, haciendo clic en FILE después en NEW FILE como en la siguiente imagen:
Escogemos en categorías escogemos SWING GUI FORMS y tipo de archivo JDIALOG FORM y de pues hacemos clic en NEXT> como en la siguiente imagen:
Ahora solo le ponemos un nombre en mi caso “Principal” y luego le damos clic en FINISH:
Ahora creamos otro formulario de tipo PANEL para que sea el fondo de nuestro formulario principal. Y hacemos similar al anterior clic en FILE luego en NUEVO FILE:
Peo esta vez no escogemos JDIALOG FORM si no que JPANEL FORM de SWING GUI FORM como se muestra en la siguiente imagen:
Luego clic en NEXT y luego le ponemos un nombre en mi caso “Fondo” como en la siguiente imagen:
Luego hacemos clic en FINISH y se creara nuestro formulario y ahora listo vamos a empezar a trabajar en la configuración de nuestro Fondo, para eso nos ubicamos en nuestro formulario Fondo no en el formulario principal si no en fondo como muestra en la siguiente imagen:
Le arrastramos un JLabel1 y le ampliamos su tamaño por todo el formulario agarrándole de una esquina y agrandándole hasta que tape todo el formulario Fondo:
Ahora nos vamos a las propiedades del JLabel1 que está en la parte derecha y borramos su propiedad TEXT para que no se vea el título JLABEL1 y hacemos clic en la propiedad ICON en su botón buscar que está representado por un botón de tres puntos suspensivos como se muestra en la figura:
Luego nos saldrá una ventana done tenemos que elegir la imagen de fondo que queremos, como en la siguiente imagen:
Nosotros hacemos clic en el botón IMPORT TO PROJECT… y escogemos la imagen que queramos de nuestro ordenador como en la siguiente imagen:
Luego hacemos clic en NEXT y después clic en FINISH:
Luego clic en el botón OK, Y nos aparecerá el formulario llamado Fondo con la imagen de fondo que le escogimos ahora solo tenemos que importar este formulario Fondo a nuestro formulario Principal y lo hacemos de la siguiente forma:
Hacemos clic en Principal para entrar en el formulario Principal luego en clic en SOURCE para entrar en su código:
Luego buscamos las líneas siguientes:
Y escribimos las siguientes líneas de código dentro de las llaves de amarillo que se muestran en la imagen de arriba:
El código debe quedar así:
Ahora haz clic en el botón PLAY que es un triángulo verde: Y te pedirá que elijas en formulario principal:
Escoges Principal y listo ya tienes tu fondo pero solo se verá cuando se ejecute tu proyecto, recuerda que tienes que trabajar pone ido tus botónes y todo lo demás en el formulario Principal y n así en el
formulario Fondo. Para cada formulario que quieres con fondo tienes que crear otro formulario Fondo. Bueno es muy largo porque en Java de esa forma se pone un fondo, en la práctica es relativamente corto y sencillo.
¿Cómo ocultar el botón cerrar del JFrame? en NetBeans?
Puedes quitar el marco completo de la ventana con la siguiente propiedad del Jframe miventana.setUndecorated(true);
Fuente: http://es.answers.yahoo.com/question/index?qid=20110312080706AA40Qqw Inhabilitar botón cerrar Java en JFrame
Trata el siguiente código, a mi me funciono sin problema alguno, colócalo en la clase principal donde inicie el código del programa.
setDefaultCloseOperation(0); ejemplo:
class Programa extends JFrame{ Programa(){ setDefaultCloseOperation(0); } } Fuente: http://www.todoexpertos.com/categorias/tecnologia-e-internet/programacion/java/respuestas/1018742/inhabilitar- botón-cerrar-java-en-jframeg
JFrame, JDialog y otras ventanas
Cuando queremos hacer ventanitas en java nos encontramos con dos ventanas: El JFrame y el JDialog. ¿Cuándo se usa una u otra?, ¿Qué diferencias hay entre ellas?.
Los JDialog admiten un padre y pueden ser o no modales. ¿Para qué sirve ese padre? ¿Puedo hacer cualquier JDialog modal?
Otras veces queremos hacer una ventana de error, de aviso, para pedir un dato o confirmar algo. ¿Pongo
JFrame o JDialog para esas ventanas? ¿Tengo que construirla?
Vamos a tratar en este tutorial de echar un vistazo a JFrame y JDialog, así como a JOptionPane y ver cuándo usamos una u otra. Trataremos de responder a todas estas preguntas.
JFrame y JDialog
Los dos tipos de ventanas principales que tenemos en java son JFrame y JDialog. Hay varias diferencias entre ellas y en función de estas diferencias vamos a ver para qué sirven
• Si instanciamos un JFrame, en la barra de abajo de windows (creo que se llama "barra de herramientas") nos aparece un nuevo "botóncito" correspondiente a nuestra aplicación. Si instanciamos un JDialog, no aparece nada.
• Un JFrame tiene un método setIconImage() para cambiar el icono por defecto de la taza de café.
JDialog no tiene este método.
• Un JDialog admite otra ventana (JFrame o JDialog) como padre en el constructor. JFrame no admite padres.
• Un JDialog puede ser modal, un JFrame no. Todo esto nos indica lo siguiente:
• Un JFrame debe ser la ventana principal de nuestra aplicación y sólo debe haber una.
• Las ventanas secundarias de nuestra aplicación deben ser JDialog. Los motivos de esto son los siguientes.
Al mostrar el JFrame un botón en la barra de herramientas de windows y tener método para cambiar el icono, es la ventana ideal como ventana principal de nuestra aplicación y sólo debe haber una. Nos permite cambiar el icono y sólo debe haber un botón en la barra de herramientas de windows para nuestra aplicación.
Si usamos un JDialog como ventana principal, no tenemos botón en la barra de herramientas y no hay forma fácil de cambiarle el icono.
Los JDialog son ideales para ventanas secundarias porque admiten una ventana padre. Si la VentanaA es padre del JDialogB, entonces el JDialogB siempre estará por delante de VentanaA, nunca quedará por detrás. Lo ideal es que hagamos nuestras ventanas secundarias como JDialog cuyo padre sea el JFrame principal. De esta forma los JDialog siempre serán visibles por encima del JFrame y no se irán detrás ni quedarán ocultos por el JFrame.
Otra ventaja de admitir un padre es que heredan el icono de él. Si hemos cambiado el icono del JFrame con el método setIconImage(), entonces todos los JDialog que hagamos como hijos de este JFrame heredarán el icono. Todas las ventanas de nuestra aplicación tendrán el mismo icono en lugar de la taza de café por defecto.
Jerarquía de padres y ventanas modales
Un JDialog puede ser modal, pasándole un true en el constructor en el sitio adecuado o haciéndolo modal con el método setModal(). Si hacemos un JDialog modal, todas las demás ventanas se deshabilitarán hasta que el usuario de nuestro programa cierre el JDialog. Esto está estupendo para pedir un dato al usuario y evitar que toque otras cosas hasta que haya introducido el dato. Sin embargo, tiene un peligro.
Supongamos un JDialog que lo hacemos modal para pedir unos datos al usuario. Este JDialog tiene un botón de "Aceptar" para que el usuario lo pulse cuando haya terminado de introducir los datos. Supongamos que en el código de ese botón "Aceptar" comprobamos los datos que ha metido el usuario y vemos que son incorrectos. Le sacamos un segundo JDialog modal para indicarle el error y no cerramos el primero.
¿Quién debe ser el padre de ese segundo JDialog modal?. Si hacemos que el padre sea el JFrame tendremos dos JDialog modales hijos del JFrame, es decir, dos JDialog modales hermanos. Esto nos dará problemas, como que ambas ventanas queden deshabilitadas, que al cerrar una de ellas se nos oculten todas, que parte de la ventana quede deshabilitada mientras que otra parte no, etc.
Entonces, ¿cómo hacemos?. Para que java no haga cosas raras, el padre del segundo JDialog modal debe ser el primer JDialog modal. De esta forma, el segundo tiene "prioridad" sobre el primero. Todo queda deshabilitado excepto este segundo JDialog. Cuando lo cerremos, será el primero el que mande.
Resumiendo, si queremos varias ventanas modales simultáneamente en pantalla, cada ventana que se muestre debe ser padre de la siguiente, de forma que la cadena de ventanas modales sean padre, hijo, nieto, etc. Tener dos ventanas modales simultaneas que sean hermanas o primas o cualquier otra relación que no sea directa, nos dará problemas.
JOptionPane
Para hacer ventanas sencillas que avisen de un error al usuario y tengan un botón de "Cerrar", o que le pidan una confirmación para hacer algo (como borrar un fichero) y tengan dos botónes de "Si" y "No", o para pedirle que elija una opción entre varias disponibles ... tenemos suerte. No hay que construir la ventana.
La clase JOptionPane de java tiene métodos showConfirmDialog(), showInputDialog(),
showOptionDialog(), showMessageDialog(). Estos métodos mostarán una ventana modal que pide al
usuario una confirmación, que le pide un dato o le muestra un mensaje. En caso de que el usuario tenga que elegir algo, el método usado devuelve el valor elegido.
Por ejemplo, para mostrar un aviso de error, nos basta esta simple línea de código
JOptionPane.showMessageDialog(ventanaPadre, "mensaje de error", "título de la ventana", JOptionPane.ERROR_MESSAGE);
Esto mostrará el mensaje de error y detendrá la ejecución del código hasta que el usuario cierre la ventana.
Ahora viene el dato importante. Esta ventana es modal y admite un padre. Si ya hay una ventana modal visible en pantalla, deberías pasar esa ventana como padre de esta para no tener problemas.
JInternalFrame
El JInternalFrame es una ventana especial que ni es ventana ni es nada. De hecho, no hereda de
Window. En realidad es un componente java que se dibuja dentro de otro componente, pero adornado
con la barra de título de una ventana y sus botónes de maximizar, minimizar y cerrar. Puede incluso arrastrarse y modificarse de tamaño siempre que se mete dentro del componente adecuado.
El sitio bueno para meter los JInternalFrame es el JDesktopPane. Este panel admite JInternalFrame y sabe manejarlos.
JFrame ventana = new JFrame();
JDesktopPane desktop = new JDesktopPane(); ventana.getContentPane.add(desktop);
JInternalFrame internal = new JInternalFrame(); desktop.add(internal);
En este código el JInternalFrame se comportará como una ventana, pero que no puede salirse del JDesktop que la contiene.
Resumen
• En nuestra aplicación debe haber un JFrame y sólo uno, que será la ventana principal.
• Todas las ventanas secundarias deben ser JDialog y todos los JDialog deberían tener padre.
• Todos los JDialog modales visibles a la vez en pantalla, deben ser unos hijos de otros en una cadena "padre-hijo-nieto" directa. No pueden ser "hermanos", ni "primos" ni "sobrinos".
Cerrar la ventana JFrame o JDialog al pulsar la tecla ESCAPE
KeyboardFocusManager kb = KeyboardFocusManager.getCurrentKeyboardFocusManager(); kb.addKeyEventPostProcessor(new KeyEventPostProcessor(){
public boolean postProcessKeyEvent(KeyEvent e){
if (e.getKeyCode() == KeyEvent.VK_ESCAPE && this != null){ System.out.println("probando..."); dispose(); return false; } return true; } }); Fuente:http://foro.chuidiang.com/java-j2se/cerrar-la-ventana-jframe-o-jdialog-al-pulsar-la-tecla-escape/ JAVA desde cero
Clase JFrame
Por herencia la clase JFrame y sus clases descendientes (subclases directas ) pueden utilizar los datos y/o métodos de la superclase Frame, Window, Container, Component y Object de la librería awt.
La clase JFrame es ligeramente incompatible con la clase Frame. Como todo