Jython - Gestión de diseño

Los administradores de diseño en Java son clases de aquellas que administran la ubicación de los controles en los objetos contenedores como Frame, Dialog o Panel. Los administradores de diseño mantienen la posición relativa de los controles en un marco, incluso si cambia la resolución o si se cambia el tamaño del marco.

Estas clases implementan el Layout interface. Los siguientes administradores de diseño se definen en elAWT library -

  • BorderLayout
  • FlowLayout
  • GridLayout
  • CardLayout
  • GridBagLayout

Los siguientes administradores de diseño se definen en el Swing library -

  • BoxLayout
  • GroupLayout
  • ScrollPaneLayout
  • SpringLayout

Usaremos administradores de diseño de AWT así como administradores de diseño de swing en los siguientes ejemplos.

  • Diseño absoluto
  • Diseño de flujo
  • Diseño de cuadrícula
  • Diseño de borde
  • Diseño de caja
  • Diseño de grupo

Analicemos ahora cada uno de estos en detalle.

Diseño absoluto

Antes de explorar todos los administradores de diseño anteriores, debemos mirar el posicionamiento absoluto de los controles en un contenedor. Tenemos que establecer el método de diseño del objeto de marco en 'Ninguno'.

frame.setLayout(None)

Luego coloque el control llamando al setBounds()método. Toma cuatro argumentos: posición x, posición y, ancho y alto.

Por ejemplo: para colocar un objeto de botón en la posición absoluta y con el tamaño absoluto.

btn = JButton("Add")
btn.setBounds(60,80,60,20)

Del mismo modo, todos los controles se pueden colocar asignando correctamente la posición y el tamaño. Este diseño es relativamente fácil de usar, pero no conserva su apariencia cuando se cambia el tamaño de la ventana o si el programa se ejecuta cuando cambia la resolución de la pantalla.

En el siguiente script Jython, se utilizan tres objetos Jlabel para mostrar el texto "phy", "maths" y "Total" respectivamente. Delante de estos tres se colocan los objetos JTextField. Un objeto Botón se coloca encima de la etiqueta "Total".

En primer lugar, la ventana JFrame se crea con un diseño establecido en ninguno.

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(300,200)
frame.setLayout(None)

Luego se agregan diferentes controles según su posición absoluta y tamaño. El código completo se proporciona a continuación:

from javax.swing import JFrame, JLabel, JButton, JTextField

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(300,200)
frame.setLayout(None)

lbl1 = JLabel("Phy")
lbl1.setBounds(60,20,40,20)
txt1 = JTextField(10)
txt1.setBounds(120,20,60,20)
lbl2 = JLabel("Maths")
lbl2.setBounds(60,50,40,20)
txt2 = JTextField(10)
txt2.setBounds(120, 50, 60,20)
btn = JButton("Add")
btn.setBounds(60,80,60,20)
lbl3 = JLabel("Total")
lbl3.setBounds(60,110,40,20)
txt3 = JTextField(10)
txt3.setBounds(120, 110, 60,20)

frame.add(lbl1)
frame.add(txt1)
frame.add(lbl2)
frame.add(txt2)
frame.add(btn)
frame.add(lbl3)
frame.add(txt3)
frame.setVisible(True)

El resultado del código anterior es el siguiente.

Jython FlowLayout

FlowLayout es el administrador de diseño predeterminado para las clases de contenedores. Organiza el control de izquierda a derecha y luego de arriba a abajo.

En el siguiente ejemplo, un objeto Jlabel, un objeto JTextField y un objeto JButton se mostrarán en un JFrame usando el administrador FlowLayout. Para empezar, importemos las clases necesarias deljavax.swing paquete y el java.awt paquete.

from javax.swing import JFrame, JLabel, JButton, JTextField
from java.awt import FlowLayout

Luego cree un objeto JFrame y establezca su Ubicación, así como las propiedades de tamaño.

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(200,200)
Set the layout manager for the frame as FlowLayout.
frame.setLayout(FlowLayout())

Ahora declare objetos para las clases JLabel, JTextfield y JButton.

label = JLabel("Welcome to Jython Swing")
txt = JTextField(30)
btn = JButton("ok")

Finalmente agregue estos controles en el marco llamando al add() método de la clase JFrame.

frame.add(label)
frame.add(txt)
frame.add(btn)

Para mostrar el marco, establezca su propiedad visible en verdadero. El script completo de Jython y su salida son los que se indican a continuación:

from javax.swing import JFrame, JLabel, JButton, JTextField
from java.awt import FlowLayout

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(200,200)

frame.setLayout(FlowLayout())

label = JLabel("Welcome to Jython Swing")
txt = JTextField(30)
btn = JButton("ok")

frame.add(label)
frame.add(txt)
frame.add(btn)
frame.setVisible(True)

Jython GridLayout

El administrador de Gridlayout permite colocar controles en una cuadrícula rectangular. Se coloca un control en cada celda de la cuadrícula.

En el siguiente ejemplo, GridLayout se aplica a un objeto JFrame dividiéndolo en 4 filas y 4 columnas. Se colocará un objeto JButton en cada celda de la cuadrícula.

Primero importemos las bibliotecas necesarias:

from javax.swing import JFrame, JButton
from java.awt import GridLayout

Luego crea el contenedor JFrame -

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(400,400)

Ahora, aplique GridLayout especificando sus dimensiones como 4 por 4.

frame.setLayout(GridLayout(4,4))

Ahora deberíamos usar dos bucles FOR, cada uno de los cuales va de 1 a 4, por lo que se colocan dieciséis objetos JButton en las celdas siguientes.

k = 0
frame.setLayout(GridLayout(4,4))
for i in range(1,5):
   for j in range(1,5):
      k = k+1
      frame.add(JButton(str(k)))

Finalmente, establezca la visibilidad del marco en verdadero. El código completo de Jython se proporciona a continuación.

from javax.swing import JFrame, JButton
from java.awt import GridLayout

frame = JFrame("Hello")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setLocation(100,100)
frame.setSize(400,400)

frame.setLayout(GridLayout(4,4))

k = 0
for i in range(1,5):
   for j in range(1,5):
      k = k+1
      frame.add(JButton(str(k)))

frame.setVisible(True)

La salida del código anterior es la siguiente:

Borde de Jython

El administrador de BorderLayout divide el contenedor en cinco regiones geográficas y lugares con un componente en cada región. Estas regiones están representadas por constantes definidas de la siguiente manera:

  • BorderLayout.NORTH
  • BorderLayout.SOUTH
  • BorderLayout.EAST
  • BorderLayout.WEST
  • BorderLayout.CENTER

Consideremos el siguiente ejemplo:

Jython BoxLayout

La clase BoxLayout se define en el javax.swing package. Se utiliza para organizar los componentes en el contenedor de forma vertical u horizontal. La dirección está determinada por las siguientes constantes:

  • X_AXIS
  • Y_AXIS
  • LINE_AXIS
  • PAGE_AXIS

La constante entera especifica el eje a lo largo del cual se deben colocar los componentes del contenedor. Cuando el contenedor tiene la orientación de componentes predeterminada, LINE_AXIS especifica que los componentes se distribuyan de izquierda a derecha y PAGE_AXIS especifica que los componentes se distribuyan de arriba a abajo.

En el siguiente ejemplo, el panel (de la clase JPanel) se agrega en un objeto JFrame. Se le aplica Vertical BoxLayout y se le agregan dos paneles más, superior e inferior. Estos dos paneles internos tienen dos botones, cada uno agregado en el diseño de caja horizontal.

Primero creemos la ventana JFrame de nivel superior.

frame = JFrame()
frame.setTitle("Buttons")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setSize(300, 150)

Se declara que el objeto JPanel tiene un BoxLayout vertical. Agréguelo en el marco de nivel superior.

panel = JPanel()
panel.setLayout(BoxLayout(panel, BoxLayout.Y_AXIS))
frame.add(panel)

En este panel, se le agregan dos paneles más arriba y abajo. Cada uno de ellos tiene dos objetos JButton agregados horizontalmente con un espacio de 25 píxeles que los separa.

###top panel
top = JPanel()
top.setLayout(BoxLayout(top, BoxLayout.X_AXIS))
b1 = JButton("OK")
b2 = JButton("Close")
top.add(Box.createVerticalGlue())
top.add(b1)
top.add(Box.createRigidArea(Dimension(25, 0)))
top.add(b2)

Del mismo modo, se construye el panel inferior.

###bottom panel
bottom = JPanel()
bottom.setLayout(BoxLayout(bottom, BoxLayout.X_AXIS))
b3 = JButton("Open")
b4 = JButton("Save")
bottom.add(b3)
bottom.add(Box.createRigidArea(Dimension(25, 0)))
bottom.add(b4)
bottom.add(Box.createVerticalGlue())

Tenga en cuenta que el createRigidArea()La función se utiliza para crear un espacio de 25 píxeles entre dos botones. También elcreateVerticalGlue() La función ocupa el espacio inicial o final en el diseño.

Para empezar, agregue los paneles superior e inferior y establezca la propiedad de visibilidad del marco en verdadero. El código completo es el siguiente:

from java.awt import Dimension
from javax.swing import JButton, JFrame,JPanel,BoxLayout,Box

frame = JFrame()
frame.setTitle("Buttons")
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.setSize(300, 150)

panel = JPanel()
panel.setLayout(BoxLayout(panel, BoxLayout.Y_AXIS))
frame.add(panel)

###top panel
top = JPanel()
top.setLayout(BoxLayout(top, BoxLayout.X_AXIS))
b1 = JButton("OK")
b2 = JButton("Close")
top.add(Box.createVerticalGlue())
top.add(b1)
top.add(Box.createRigidArea(Dimension(25, 0)))
top.add(b2)

###bottom panel
bottom = JPanel()
bottom.setLayout(BoxLayout(bottom, BoxLayout.X_AXIS))
b3 = JButton("Open")
b4 = JButton("Save")
bottom.add(b3)
bottom.add(Box.createRigidArea(Dimension(25, 0)))
bottom.add(b4)
bottom.add(Box.createVerticalGlue())

panel.add(bottom)
panel.add(top)
frame.setVisible(True)

El código anterior generará la siguiente salida.

Grupo Jython

El administrador de GroupLayout agrupa los componentes de forma jerárquica. La agrupación se realiza mediante dos clases,SequentialGroup y ParallelGroup, ambos implementan la interfaz de grupo en Java.

El procedimiento de diseño se divide en dos pasos. En un paso, los componentes se colocan junto con el eje horizontal y en el segundo a lo largo del eje vertical. Cada componente debe definirse dos veces en el diseño.

Hay dos tipos de arreglos, secuenciales y paralelos. En ambos, podemos ordenar los componentes de forma secuencial o en paralelo. En la disposición horizontal, la fila se denomina grupo secuencial y la columna se denomina grupo paralelo. Por otro lado, en la disposición paralela, la fila del elemento es un grupo paralelo y una columna, que se llama secuencial.

En el siguiente ejemplo, cinco botones están dispuestos de tal manera que tres aparecen cada uno en fila y columna. Para empezar, agregue un objeto Jpanel en una ventana JFrame y establezca su diseño como Grouplayout.

frame =  JFrame()
panel =  JPanel()
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
layout =  GroupLayout(panel)
panel.setLayout(layout)

Luego construya los objetos JButton -

buttonD = JButton("D")
buttonR = JButton("R")
buttonY = JButton("Y")
buttonO = JButton("O")
buttonT = JButton("T")

A continuación, creamos un SequentialGroup llamado LeftToRighta los que se añaden buttonD y buttonY. Entre ellos, se coloca un ParallelGroup ColumnMiddle (con otros tres botones agregados verticalmente).

leftToRight = layout.createSequentialGroup()
leftToRight.addComponent(buttonD)
columnMiddle = layout.createParallelGroup()
columnMiddle.addComponent(buttonR)
columnMiddle.addComponent(buttonO)
columnMiddle.addComponent(buttonT)
leftToRight.addGroup(columnMiddle)
leftToRight.addComponent(buttonY)

Ahora viene la definición de SequentialGroup vertical llamado TopToBottom. Agregue una fila ParallelGroup de tres botones y luego coloque dos botones verticalmente.

topToBottom = layout.createSequentialGroup()
rowTop = layout.createParallelGroup()
rowTop.addComponent(buttonD)
rowTop.addComponent(buttonR)
rowTop.addComponent(buttonY)
topToBottom.addGroup(rowTop)
topToBottom.addComponent(buttonO)
topToBottom.addComponent(buttonT)

Finalmente, configure el grupo LeftToRight horizontalmente y el grupo TopToBottom verticalmente en el objeto de diseño. El código completo se proporciona a continuación:

from javax.swing import JButton, JFrame,JPanel,GroupLayout

frame = JFrame()
panel = JPanel()
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
layout = GroupLayout(panel)
panel.setLayout(layout)

buttonD = JButton("D")
buttonR = JButton("R")
buttonY = JButton("Y")
buttonO = JButton("O")
buttonT = JButton("T")

leftToRight = layout.createSequentialGroup()
leftToRight.addComponent(buttonD)
columnMiddle = layout.createParallelGroup()
columnMiddle.addComponent(buttonR)
columnMiddle.addComponent(buttonO)
columnMiddle.addComponent(buttonT)
leftToRight.addGroup(columnMiddle)
leftToRight.addComponent(buttonY)

topToBottom = layout.createSequentialGroup()
rowTop = layout.createParallelGroup()
rowTop.addComponent(buttonD)
rowTop.addComponent(buttonR)
rowTop.addComponent(buttonY)
topToBottom.addGroup(rowTop)
topToBottom.addComponent(buttonO)
topToBottom.addComponent(buttonT)

layout.setHorizontalGroup(leftToRight)
layout.setVerticalGroup(topToBottom)

frame.add(panel)
frame.pack()
frame.setVisible(True)

La salida del código anterior es la siguiente: