La clase java.awt. Color encapsula colores utilizando el formato RGB (Red. Green. Blue). Las
componentes de cada color primario en el color resultante se expresan con números enteros entre 0
y 255. siendo 0 la intensidad mínima de ese color, y 255 la máxima.
En la clase Color existen constantes para colores predeterminados de uso frecuente: block,
n 'hite, green. blue. red. y el Ion'. magenta, cyan. orange. pink. gray. darkGray. lightGray. La Tabla
5.34 muestra algunos métodos de la clase Color.
Categorias del Blog
sábado, 29 de marzo de 2014
viernes, 28 de marzo de 2014
Clase FontMetries - II
La Tabla 5.33 muestra algunos métodos de la clase FontMetries. para los que se debe tener en
cuenta la terminología introducida en la Figura 5.14.
jueves, 27 de marzo de 2014
Clase FontMetries - I
La clase FontMetries permite obtener información sobre una font y sobre el espacio
que ocupa un char o un String utilizando
esa font.
Esto es muy útil cuando se
pretende rotular algo de modo que quede
siempre centrado y bien dimensionado.
La clase FontMetries es una clase
abstract. Esto quiere decir que no se pueden
crear directamente objetos de esta clase ni
llamar a su constuctor.
La forma habitual de
soslayar esta dificultad es creando una
subclase. En la práctica Java resuelve esta
dificultad para el usuario, ya que la clase
FontMetries tiene como variable miembro
un objeto de la clase Font.
Por ello, un objeto de la clase FontMetries contiene información sobre la font que se le ha pasado como
argumento al constructor. De todas formas, el camino más habitual para obtener esa información es
a partir de un objeto de la clase Graphics que ya tiene un font definido.
A partir de un objeto g de la
clase Graphics se puede obtener una referencia FontMetries en la forma:
FontMetries miFontMet = g.getFontMetrics();
donde está claro que se está utilizando una referencia de la clase abstract FontMetries para
refererirse a un objeto de una clase derivada creada dentro del API de Jara. Con una referencia de
tipo FontMetries se pueden utilizar todos los métodos propios de dicha clase.
miércoles, 26 de marzo de 2014
Clases Graphics y Fout
La clase Graphics permite "dibujar" texto, como alternativa al texto mostrado en los componentes
LabeL TextField y TextArea. Los métodos de esta clase para dibujar texto son los siguientes:
drawBytes(byte data[], int offset, int length, int x, int y);
drawChars(char data[], int offset, int length, int x, int y);
drawString(String str, int x, int y);
En estos métodos, los argumentos A: e y representan las coordenadas de la linea base (ver
Figura 5.13). El argumento offset indica el elemento del array que se empieza a imprimir.
Cada tipo de letra está representado por un objeto de la clase Font.
Las clases Component y
Graphics disponen de métodos setFontf) y getFontf). El constructor de Font tiene la forma:
Font(String ñame, int style, int size)
donde el style se puede definir con las constantes Font.PLAIN. Font.BOLD y Font.ITALIC. Estas
constantes se pueden combinar en la forma: Font.BOLD | Font.ITALIC.
La clase Font tiene tres variables protected.
llamadas ñame, style y size.
Además tiene tres
constantes enteras: PLAIN. BOLD e ITALIC. Esta
clase dispone de los métodos String getNameQ. int
getStylef). int getSize(). boolean isPlainf). boolean
isBoldf) y boolean isltalic(). cuyo significado es
inmediato.
Para mayor portabilidad se recomienda utilizar
nombres lógicos de fonts. tales como Serif (Times
New Román). SansSerif (Aria!) y Monospaced
(Couher).
martes, 25 de marzo de 2014
Primitivas gráficas
Java dispone de métodos para realizar dibujos sencillos, llamados a veces "primitivas" gráficas.
Como se ha dicho, las coordenadas se miden en pixels. empezando a contar desde cero. La clase
Graphics dispone de los métodos para primitivas gráficas reseñados en la Tabla 5.32.
Excepto los polígonos y las líneas, todas las fonnas geométricas se determinan por el
rectángulo que las comprende, cuyas dimensiones son w y //. Los polígonos admiten un argumento
de la clase java.awt.Polygon.
Los métodos draw3DRect(). fillSDRectQ. drawOvalQ. f¡llOval(). drawArcQ y fillArc()
dibujan objetos cuyo tamaño total es (w+1. h+1) pixels.
lunes, 24 de marzo de 2014
Clase Graphics
El único argumento de los métodos update() ypaint() es un objeto de esta clase. La clase Graphics
dispone de métodos para soportar dos tipos de gráficos:
1. Dibujo de primitivas gráficas (texto, líneas,
círculos, rectángulos.polígonos. ...).
2. Presentación de imágenes en formatos *.gif y
ypeg
Además, la clase Graphics mantiene un
contexto gráfico: un área de dibujo actual, un color
de dibujo del background y otro del foreground, un
font con todas sus propiedades, etc.
La Figura 5.12
muestra el sistema de coordenadas utilizado en
Java. Como es habitual en Informática, los ejes
están situados en la esquina superior izquierda, con
la orientación indicada en la Figura 5.12 (eje de
ordenadas descendente). Las coordenadas se miden siempre en pixels.
sábado, 22 de marzo de 2014
Capacidades gráficas del AWT: Métodos paint(), repaint() y update()
La clase Component tiene tres métodos muy importantes relacionados con gráficos: paint(),
repaint() y updatef). Cuando el usuario llama al método repaintO de im componente, el AWT llama
al método updatef) de ese componente, que por defecto llama al método paintQ.
Método paint(Graphics g)
El método paintO está definido en la clase Component. pero ese método no hace nada y hay que
redefinirlo en una de sus clases derivadas. El programador no tiene que preocuparse de llamar a este
método: el sistema operativo lo llama al dibujar por primera vez una ventana, y luego lo vuelve a
llamar cada vez que entiende que la ventana o una paite de la ventana debe ser re-dibujada (por
ejemplo, por haber estado tapada por otra ventana y quedar de nuevo a la vista).
Método update(Graphics g)
El método updateQ hace dos cosas: primero re-dibuja la ventana con el color de fondo y luego
llama al método paintf). Este método también es llamado por el AWT. y también puede ser llamado
por el programador, quizás porque ha realizado algún cambio en la ventana y necesita que se dibuje
de nuevo.
La propia estructura de este método -el comenzar pintando de nuevo con el color de fondo-
hace que se produzca parpadeo (flicker) en las animaciones. Una de las formas de evitar este efecto
es redeíinir este método de una forma diferente, cambiando de una imagen a otra sólo lo que haya
que cambiar, en vez de re-dibujar todo otra vez desde el principio. Este método no siempre propor-
ciona los resultados buscados y hay que recurrrir al método del doble buffer.
Método repaint()
Este es el método que con más frecuencia es llamado por el programador. El método repaintO llama
"lo antes posible" al método updatef) del componente. Se puede también especificar un número de
milisegundos para que el método update() se llame transcurrido ese tiempo.
El método repaint() tiene las cuatro formas siguientes:
repaint()
repaint(long time)
repaint(int x, int y, int w, int h)
repaint(long time, int x, int y, int w, int h)
Las formas tercera y cuarta permiten definir una zona rectangular de la ventana a la que
aplicar el método.
viernes, 21 de marzo de 2014
GRÁFICOS, TEXTO E IMÁGENES
En esta parte final del AWT se van a describir, también muy sucintamente, algunas clases y
métodos para realizar dibujos y añadir texto e imágenes a la interface gráfica de usuario.
jueves, 20 de marzo de 2014
GridBagLayout - II
- fill. En el caso en que el componente sea más pequeño que el espacio reservado, esta variable indica si debe ocupar o no todo el espacio disponible. Los posibles valores son: GridBagConstraints.NONE (no lo ocupa: defecto). GridBagConstramts.HORIZONTAL (lo ocupa en dilección horizontal). GridBagConstraints.VERTICAL (lo ocupa en vertical) y GridBagConstraints.BOTH (lo ocupa en ambas dilecciones).
- ipadx y ipady. Especifican el espacio a añadir en cada dirección al tamaño interno del componente. Los valores por defecto son cero. El tamaño del componente será el tamaño mínimo más dos veces el ipadx o el ipady.
- insets. Indican el espacio mínimo entre el componente y el espacio disponible. Se establece con un objeto de la clase java.awt.Insets. Por defecto es cero. • anchor. Se utiliza para determinar dónde se coloca el componente, cuando éste es menor que el espacio disponible. Sus posibles valores vienen dados por las constantes de la clase GridBagConstraints: CENTER (el valor por defecto). NORTH. NORTHEAST. EAST, SOUTHEAST. SOUTH. SOUTHWEST. WEST y NORTHWEST.
- weightx y neighty. Son míos coeficientes entre 0.0 y 1.0 que sirven para dar más o menos "peso" a las distintas filas y columnas. A más "peso" más probabilidades tienen de que se les dé más anchura o más altura.
A continuación se
muestra una forma típica de crear un container con GridBagLayout y de añadirle componentes:
GridBagLayout
unGBL = new GridBagLayout();
GridBagConstraints
unasConstr = new GridBagConstraints();
unContainer.setLayout(unGBL);
unContainer.setLayout(unGBL);
// Ahora ya se pueden añadir los componentes
//...Se crea un componente unComp
//...Se crea un componente unComp
//...Se da valor a las variables del objeto
unasConstr
// Se asocian las restricciones con el componente
unGBL.setConstraints(unComp, unasConstr) ;
// Se añade el componente al container
unContainer.add(unComp);
// Se asocian las restricciones con el componente
unGBL.setConstraints(unComp, unasConstr) ;
// Se añade el componente al container
unContainer.add(unComp);
miércoles, 19 de marzo de 2014
GridBagLayout - I
El GridBagLayout es el Layout Manager más completo y flexible, aunque también el más
complicado de entender y de manejar. Al igual que el GridLayout. el GridBagLayout parte de una
matriz de celdas en la que se sitúan los componentes. La diferencia está en que las filas pueden tener
distinta altura, las columnas pueden tener distinta anchura, y además en el GridBagLayout mi
componente puede ocupar varias celdas contiguas.
La posición y el tamaño de cada componente se especifican por medio de unas "restricciones''
o constraints. Las restricciones se establecen creando un objeto de la clase GridBagConstraints,
dando valor a sus propiedades (variables miembro) y asociando ese objeto con el componente por
medio del método setConstraints().
Las variables miembro de GridBagConstraints son las siguientes:
- gridx y gridy. Especifican la fila y la columna en la que situar la esquina superior izquierda del componente (se empieza a contar de cero). Con la constante GridBagConstraints.RELATIVE se indica que el componente se sitúa relativamente al anterior componente situado (es la condición por defecto).
- gridwidth y gridheight. Determinan el número de columnas y de filas que va a ocupar el componente. El valor por defecto es una columna y una fila. La constante GridBagConstraints.REMAIXDER indica que el componente es el último de la columna o de la fila, mientras que GridBagConstraints.RELATIVE indica que el componente se sitúa respecto al anterior componente de la fila o columna.
martes, 18 de marzo de 2014
CardLayout
CardLayout pemiite disponer distintos componentes (de ordinario Panels) que comparten la misma
ventana para ser mostrados sucesivamente. Son como transparencias, diapositivas o cartas de baraja
que van apareciendo una detrás de otra.
El orden de las "caitas" se puede establecer de los siguientes modos:
1. Yendo a la primera o a la última, de acuerdo con el orden en que fueron añadidas al
container.
2. Recorriendo las caitas hacia delante o hacia atrás, de una en una.
3. Mostrando una carta con un nombre determinado.
Los constructores de esta clase son:
CardLayout()
CardLayout(int horizGap, int vertGap)
Para añadir componentes a un container con CardLayout se utiliza el método:
Container.add(Component comp, int index)
donde index indica la posición en que hay que insertar la carta. Los siguientes métodos de
CardLayout permiten controlar el orden en que aparecen las cartas:
void first(Container cont);
void last(Container cont);
void previous(Container cont);
void next(Container cont);
void show(Container cont, String nameCard);
lunes, 17 de marzo de 2014
GridLayout
Con GridLayout las componentes se colocan en una matriz de celdas. Todas las celdas tienen el
mismo tamaño. Cada componente utiliza todo el espacio disponible en su celda, al igual que en
BorderLayout.
GridLayout tiene dos constructores:
GridLayout(int nfil, int ncol);
GridLayout(int nfil, int ncol, int horizontalGap, int verticalGap);
Al menos uno de los parámetros nfil y ncol debe ser distinto de cero. El valor por defecto para
el espacio entre filas y columnas es cero pixels.
domingo, 16 de marzo de 2014
BorderLayout
BorderLayout es el Layout Manager por defecto para Windows y Frames. BorderLayout define
cinco áreas: North. South. £Visf. FfVsr y Center. Si se aumenta el tamaño de la ventana todas las
zonas se mantienen en su mínimo tamaño posible excepto Center. que absorbe casi todo el
crecimiento. Los componentes añadidos en cada zona tratan de ocupar todo el espacio disponible.
Por ejemplo, si se añade un botón, el botón se hará tan grande como la celda, lo cual puede producir
efectos muy extraños. Para evitar esto se puede introducir en la celda un panel con FlowLayout y
añadir el botón al panel y el panel a la celda.
Los constructores de BorderLayout son los siguientes:
BorderLayout();
BorderLayout(int horizontalGap, int verticalGap);
Por defecto BorderLayout no deja espacio entre componentes. Al añadir un componente a un
Container con BorderLayout se debe especificar la zona como segundo argumento:
miContainer.add(new Button("Norte"), "North");
sábado, 15 de marzo de 2014
FlowLayout
FlowLayout es el Layout Manager por defecto para Panel. FlowLayout coloca los componentes
uno detrás deotro. en una fila, de izda a dcha y de arriba a abajo, en la misma forma en que procede
un procesador de texto con las palabras de un párrafo. Los componentes se añaden en el mismo
orden en que se ejecutan los métodos add(). Si se cambia el tamaño de la ventana los componentes
se redistribuyen de modo acorde, ocupando más filas si es necesario.
La clase FlowLayout tiene tres constructores:
FlowLayout();
FlowLayout(int alignement);
FlowLayout(int alignement, int horizontalGap,
int verticalGap);
Se puede establecer la alineación de los componentes (centrados, por defecto), por medio de
las constantes FlowLayout.LEFT. FlowLayout.CENTER y FlowLayout.RIGHT.
Es posible también establecer una distancia horizontal y vertical entre componentes (el gap,
en pixels). El valor por defecto son 5 pixels.
viernes, 14 de marzo de 2014
Ideas generales sobre los LavoutManagers
Se debe elegir el Layout Manager que mejor se adecúe a las necesidades de la aplicación que se
desea desarrollar. Recuérdese que cada Container tiene un Layout Manager por defecto. Si se
desea utilizar el Layout Manager por defecto basta crear el Container (su constructor crea un
objeto del Layout Manager por defecto e inicializa el Container para hacer uso de él).
Para utilizar un Layout Manager diferente hay que crear un objeto de dicho Layout Manager
y pasárselo al constructor del container o decirle a dicho container que lo utilice por medio del
método setLayoutQ. en la forma:
unContainer.setLayout(new GridLayout());
La clase Container dispone de métodos para manejar el Layout Manager (ver Tabla 5.31):
Si se cambia de modo indirecto el tamaño de un Component (por ejemplo cambiando el
tamaño del Font). hay que llamar al método invalidateQ del Component y luego al método
validateQ del Container, lo que hace que se ejecute el método doLayout() para reajustar el espacio
disponible.
Si se cambia de modo indirecto el tamaño de un Component (por ejemplo cambiando el
tamaño del Font). hay que llamar al método invalidateQ del Component y luego al método
validateQ del Container, lo que hace que se ejecute el método doLayout() para reajustar el espacio
disponible.
jueves, 13 de marzo de 2014
Concepto y Ejemplos de LayoutsManagers
El AWT define cinco Layout Managers: dos muy sencillos (FlowLayout y GridLayout), dos más
especializados (BorderLayout y CardLayout) y uno muy general (GridBagLayout). Además, los
usuarios pueden escribir su propio Layout Manager. implementando la interface LayoutManager,
que especifica 5 métodos. Jirzvfl permite también posicionar los Components de modo absoluto. sin
Layout Manager, pero de ordinario puede perderse la portabilidad y algunas otras características.
Todos los Containers tienen un Layout Manager por defecto, que se utiliza si no se indica
otra cosa: Para Panel, el defecto es un objeto de la clase FlowLayout. Para Window (Frame y
Dialog). el defecto es un objeto de la clase BorderLayout.
La Figura 5.5 muestra un ejemplo de FlowLayout: Los componentes se van añadiendo de izda
a dcha y de arriba hacia abajo. Se puede elegir alineación por la izquierda, centrada o por la derecha,
respecto al container.
La Figura 5.6 muestra un ejemplo de BorderLayout: el container se divide en 5 zonas: North,
South. East. West y Center (que ocupa el resto de espacio).
El ejemplo de GridLayout se muestra en la Figura 5.7. Se utiliza una matriz de celdas que se
numeran como se muestra en dicha figura (de izda a dcha y de arriba a abajo).
La Figura 5.8 muestra un ejemplo de uso del GridBagLayout. Se utiliza también una matriz
de celdas, pero permitiendo que algunos componentes ocupen más de una celda.
Finalmente, la Figura 5.9 y las dos Figuras siguientes muestran un ejemplo de CardLayout.
En este caso se permite que el mismo espacio sea utilizado sucesivamente por contenidos diferentes.
miércoles, 12 de marzo de 2014
LAYOUT MANAGERS
La portabilidad de Java a distintas plataformas y distintos sistemas operativos necesita flexibilidad
a la hora de situar los Components (Buttons. Canvas. TextAreas. etc.) en un Container (Window,
Panel, ...). Un Layout Manager es un objeto que controla cómo los Components se sitúan en un
Container.
Menus pop-up
Los menús pop-up son menús que aparecen en cualquier paite de la pantalla al clicar con el botón
derecho del ratón {pop-up trigger) sobre un componente determinado (parent Component). El
menú pop-up se muestra en unas coordenadas relativas al parent Component. que debe estar
visible.
Además, se pueden utilizar los métodos de la clase Menú (ver página 111). de la que deriva
PopupMenu. Para hacer que aparezca el PopupMenu habrá que registrar el MouseListener y
definir el método mouseClicked().
martes, 11 de marzo de 2014
Clase ClieckboxMemiItem
Son items de un Mentí que pueden estar activados o no activados. La clase CheckboxMennltem no
genera un ActionEvent. sino un ItemEvent, de modo similar a la clase Checkbox (ver Apartado
5.2.17 en la página 103). En este caso hará registrar un ItemListener. La Tabla 5.29 muestra
algunos métodos de esta clase.
lunes, 10 de marzo de 2014
Clase Menultem
Los objetos de la clase Menultem representan las distintas opciones de un menú. Al seleccionar, en
la ejecución del programa, un objeto Menultem se generan eventos del tipo ActionEvents. Para
cada item de un Menú se puede definir un ActionListener. que define el método
actionPerformed(). La Tabla 5.28 muestra algunos métodos de la clase Menultem.
El método getActionCommandf). asociado al getSource() del evento correspondiente, no permite identificar correctamente al item cuando éste se ha activado mediante el MenuShortcut (en ese caso devuelve nuil).
El método getActionCommandf). asociado al getSource() del evento correspondiente, no permite identificar correctamente al item cuando éste se ha activado mediante el MenuShortcut (en ese caso devuelve nuil).
domingo, 9 de marzo de 2014
Clase Menú
El objeto Menú define las opciones que aparecen al seleccionar uno de los menús de la baña de
menús. En un Menú se pueden introducir objetos Menú líe ni. otros objetos Menú (para crear sub-
menús), objetos CheckboxMenuItem. y separadores. La Tabla 5.27 muestra algunos métodos de la
clase Menú. Obsérvese que como Menú desciende de Menulteni. el método add(MenuItem)
permite añadir objetos Menú a otro Menú.
sábado, 8 de marzo de 2014
Clase MenuBar
La Tabla 5.26 muestra algunos métodos de la clase MenuBar. A una MenuBar sólo se pueden
añadir objetos Menú.
viernes, 7 de marzo de 2014
Clase MenuSkortcut
La clase ja va. a>vt. Metí uShortcut (derivada de Objeci) representa las teclas aceleradoras que pueden
utilizarse para activar los menús desde teclado, sin ayuda del ratón. Se establece mi Shortcut
creando un objeto de esta clase con el constructor MenuShortcut(int vk key). y pasándoselo al
constructor adecuado de Metía Item. Para más información, consúltese la adocumentación on-line
de Java. La Tabla 5.25 muestra algunos métodos de esta clase. Los MetiuShortcut de Java están
restringidos al uso la tecla control (CTRL). Al definir el MetiuShortcut no hace falta incluir dicha
tecla.
jueves, 6 de marzo de 2014
MENUS
Los Menus de Java no descienden de Component.
sino de Menú Component. pero tienen un compor-
tamiento similar, pues aceptan Events. La Figura
5.4 muestra la jerarquía de clases de los Menus de
Java 1.1.
Para crear un Menú se debe crear primero
una MenuBar. después se crean los Menus y los
Menú Item. Los Menultems se añaden al Menú
correspondiente; los Menus se añaden a la
MenuBar y la MenuBar se añade a un Erame.
Una MenuBar se añade a un Erame con el método
setMenuBarQ, de la clase Frarne.
También puede
añadirse un Menú a otro Menú para crear un sub-menú. del modo que es habitual en Windows.
La clase Menú es sub-clase de Menultetn. Esto es así precisamente para permitir que mi
Menú sea añadido a otro Menú.
miércoles, 5 de marzo de 2014
Clase KevEvent
Se produce un KeyEvent al pulsar sobre el teclado. Como el teclado no es un componente del AWT,
es el objeto que tiene el focus en ese momento quien genera los eventos KeyEvent (el objeto que es
el event so urce).
Hay dos tipos de KeyEvents:
1. key-typed. que representa la introducción de un carácter Unicode.
2. key-pressed y key-released. que representan pulsar o soltar una tecla. Son importantes
para teclas que no representan caracteres, como por ejemplo Fl.
Para estudiar estos eventos son muy importantes las Virtual KeyCodes (VKC). Las VKC son
unas constantes que se corresponden con las teclas físicas del teclado, sin considerar minúsculas
(que no tienen VKC). Se indican con el prefijo VK_. como VK_SHIFT o VK_A. La clase KeyEvent
(en el package java.awt.event) define constantes VKC para todas las teclas del teclado.
Por ejemplo, para escribir la letra "A" mayúscula se generan 5 eventos: key-pressed
VK_SHIFT. key-pressed VK_A. key-typed "A", key-released VK_A. y key-released VK_SHIFT. La
Tabla 5.24 muestra algunos métodos de la clase KeyEvent y otros heredados de InputEvent.
Las constantes de InputEvent permiten identificar las teclas modificadoras y los botones del
ratón. Estas constantes son SHIFT_MASK. CTRL_MASK. META_MASK y ALT_MASK. A estas
constantes se pueden aplicar las operaciones lógicas de bits para detectar combinaciones de teclas o
pulsaciones múltiples.
martes, 4 de marzo de 2014
Clase TextEveiit
Se produce un TextEvent cada vez que cambia algo en un TextComponent (TextArea y TextField).
Se puede desear evitar ciertos caracteres y para eso hay que gestionar los eventos correspondientes.
La interface TextListener tiene un único método: void textValueC1ianged(TextEvent te).
No hay métodos propios de la clase TextEvent. Se puede utilizar el método Object
getSourceQ. que es heredado de EventObject.
lunes, 3 de marzo de 2014
Clases TextArea y TextField
Ambas componentes heredan de la clase TextComponent y muestran texto seleccionable y editable.
La diferencia principal es que TextField sólo puede tener una línea, mientras que TextArea puede
tener varias líneas. Además. TextArea ofrece posibilidades de edición de texto adicionales.
Se pueden especificar el font y los colores de foreground y background. Sólo la clase
TextField genera ActionEvents. pero como las dos heredan de la clase TextComponent ambas
pueden recibir TextEvents. La Tabla 5.23 muestra algunos métodos de las clases TextComponent,
TextField y TextArea. No se pueden crear objetos de la clase TextComponent porque su
constructor no espublic; por eso su constructor no aparece en la Tabla 5.23.
La clase TextComponent recibe eventos TextEvent. y por lo tanto también los reciben sus
clases derivadas TextField y TextAreas. Este evento se produce cada vez que se modifica el texto
del componente. La caja TextField soporta también el evento ActionEvent. que se produce cada vez
que el usuario termina de editar la única línea de texto pulsando Intro.
Como es natural, las cajas de texto pueden recibir también los eventos de sus super-clases. y
más en concreto los eventos de Component: FocusErent. MouseEvent y sobre todo KeyEvent.
Estos eventos permiten capturar las teclas pulsadas por el usuario y tomar las medidas adecuadas.
Por ejemplo, si el usuario debe teclear un número en un TextField. se puede crear una función que
vaya capturando los caracteres tecleados y que rechace los que no sean numéricos.
Cuando se cambia desde programa el número de filas y de columnas de un TextField o
TextArea. hay que llamar al método validate() de la clase Component. para que vuelva a aplicar el
LayoutManager correspondiente. De todas formas, los tamaños fijados por el usuario tienen el
carácter de "recomendaciones" o tamaños "preferidos", que el LayoutManager puede cambiar si es
necesario.
domingo, 2 de marzo de 2014
Clase ScrollPane
Un ScrollPane es como una ventana de tamaño limitado en la que se puede mostrar un componente
de mayor tamaño con dos Scrollbars. una horizontal y otra vertical. El componente puede ser una
imagen, por ejemplo. Las Scrollbars son visibles sólo si son necesarias (por defecto). Las constantes
de la clase ScrollPane son (su significado es evidente): SCROLLBARS_AS_NEEDED,
SCROLLBARS_ALWAYS, SCROLLBARS_NEVER. Los ScrollPanes no generan eventos. La
Tabla 5.22 muestra algunos métodos de esta clase.
En el caso en que no aparezcan scrollbars (SCROLLBARS_NEVER) será necesario desplazar
el componente (hacer scrolling) desde programa, con el método setScrollPositionf).
sábado, 1 de marzo de 2014
Clase AdjustmentEveiit
Se produce un evento AdjustementEvent cada vez que se cambia el valor (entero) de una Scrollbar.
Hay cinco tipos de AdjustementEvent:
1. track: se arrastra el cursor de la Scrollbar.
2. unit incretnent. unit decrement: se clica en las flechas de la Scrollbar.
3. block incrementa block decrement: se clica encima o debajo del cursor.
La Tabla 5.21 muestra algunos métodos de esta clase. Las constantes UNIT_INCREMENT,
UNITDECREMENT. BLOCKJXCREMENT. BLOCK DECREMENT, TRACK permiten saber
el tipo de acción producida, comparando con el valor de retomo de getAdjustementType().
Suscribirse a:
Entradas (Atom)