gridbaglayout

podrian darme un ejemplo del usode gridbaglayout e usado el broder y el grid aunque e encontrado algunos ejemplos de eso no son muy claros

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de Shadonwk

especificamente que es lo

especificamente que es lo que quieres hacer.. talvez te puedo ayudar.. saludos

¿En que parte necesitas ayuda?

El GridBagLayout tiene varias partes, que hay que admitirlo, no son tan fáciles de entender. ¿Cual de esas partes es la que no te queda clara?

El GridBagLayout se usa junto con otro objeto que se llama GridBagContraints, la idea es que el contraints es el objeto que te dice donde va a componente y el GBL ya lo pone por tí.

Un ejemplo muy básico sería este formulario:

A pesar de que se ve apantallador, el código para hacerlo es muy sencillo ( aunque algo extenso )

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

public class GblDemo {
        public static void main( String [] args ) {
                // Crear el gridbag layout y su constraints
                GridBagLayout gbl = new GridBagLayout();
                GridBagConstraints gbc = new GridBagConstraints();
       
                // crear un panel y ponerle ese layout
                JPanel panel = new JPanel();
                panel.setLayout( gbl );
               
                // crear las partes del formulario
                JLabel          name                    = new JLabel("Nombre:");
                JTextField      nameTxt                 = new JTextField(20);
                JLabel          lastName                = new JLabel("Apellido:");
                JTextField      lastNameTxt     = new JTextField(20);
                JButton         submit                  = new JButton("Ok");
                JButton         cancel                  = new JButton("Cancel");
               
                // ponerlos
                // en coords ( x=0,  y=0 )
                gbc.gridx = 0; gbc.gridy = 0;
                // fijar esas coordenadas al componente        
                gbl.setConstraints( name, gbc );
                // ponerlos en el panel
                panel.add( name );     
               
                // y se repite
                gbc.gridx = 1; gbc.gridy = 0;          
                gbl.setConstraints( nameTxt, gbc );
                panel.add( nameTxt );
               
                gbc.gridx = 0; gbc.gridy = 1;
                gbl.setConstraints( lastName, gbc );
                panel.add( lastName );
               
                gbc.gridx = 1; gbc.gridy = 1;
                gbl.setConstraints( lastNameTxt, gbc );
                panel.add( lastNameTxt );
               
                gbc.gridx = 0; gbc.gridy = 2;
                gbl.setConstraints( submit, gbc );             
                panel.add( submit );
               
                gbc.gridx = 1; gbc.gridy = 2;  
                // Especial para que el "cancel" quede "jalado"  a la izq
                gbc.anchor = GridBagConstraints.WEST;
                gbl.setConstraints( cancel, gbc );     
                panel.add( cancel);
               
                // finalmente pintar todo
                JFrame frame = new JFrame();
                frame.add( panel );
                frame.pack();
                frame.setVisible( true );      
        }
}

Aunque claro, un IDE con un GUI Builder hace esto mucho más rápido.

La idea es, que el GridBagContraint pone las "propiedades" donde va a ser dibujado el componente, y el GridBagLayout, lo dibuja por tí.

El poder de los Layout managers viene de combinarlos correctamente. No es muy recomendable querer hacer todo el GUI con uno solo.

Otro que surgió me parece en la versión 1.6 es el GroupLayout que me parece un poco mejor de usar, aunque al principio cuesta más trabajo entenderle :P

sale

pues la verdad no le eh entendido a la forma de utilizarlo por lo que las interfaces graficas la eh tenido que hacer con el border y el grid una dentro de otr, hasta que mas o menos queda