4 Componentes¶
Introducción¶
Como ya hemos visto, los componentes en JavaFX están definidos como nodos por la clase Node. La mayoría de los controles tienen un compartimiento similar. Sin embargo, existen algunos controles más avanzados que requieren una especial atención.
Campos de texto¶
En JavaFX, TextField, TextArea y PasswordField son componentes de entrada de texto que permiten a los usuarios ingresar información de manera interactiva. Cada uno tiene características específicas que los hacen adecuados para diferentes tipos de entrada de datos.
TextField es un control de entrada de una sola línea que permite al usuario ingresar y editar texto de longitud limitada, mientras que TextArea permite múltiples líneas que permite al usuario ingresar y editar texto de longitud potencialmente ilimitada. PasswordFiled es similar a TextField pero ocultando el texto escrito y suele ser útiles para contraseñas.
Las clases tienen los siguientes métodos en común:
setText(String text): Establece el texto dentro del campo.getText(): Obtiene el texto del campo.setPromptText(String text): Establece un texto de sugerencia que aparece cuando el campo está vacío.clear(): Elimina el contenido del campo de texto.setPrefColumnCount(): Estable el número preferido de columnas del campo.
Para la clase TextArea, además, existe el método setPrefRowCount() que establece el número preferido de filas del campo. También se dispone del método setWrapText(boolean value) que establece si el texto debe ajustarse automáticamente al tamaño del área de texto. Veamos un ejemplo:
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
TextField textField = new TextField();
textField.setPromptText("Ingrese su nombre");
TextArea textArea = new TextArea();
textArea.setPromptText("Ingrese una descripción");
PasswordField passwordField = new PasswordField();
passwordField.setPromptText("Ingrese su contraseña");
VBox vbox = new VBox(10);
vbox.getChildren().addAll(textField, textArea, passwordField);
// Crear escena y configurar el escenario
Scene scene = new Scene(vbox, 300, 200);
stage.setTitle("Ejemplo de Controles de Entrada");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
Botones¶
Button representa un botón estándar que el usuario puede clicar para activar una acción. Con el método setText(String text) establece el texto que se muestra en el botón y setDisable(boolean value) habilita o deshabilita el botón. EL método fire() activa el evento ActionEvent asociado al botón programáticamente, es decir, es como hacer clic desde código. Además, con los métodos setDefaultButton(boolean value) marca el botón como el botón predeterminado que responde a la tecla Enter en el foco de la ventana, y setCancelButton(boolean value) marca el botón como el botón de cancelación que responde a la tecla Esc en el foco de la ventana.
ToggleButton es un botón que mantiene su estado (activado o desactivado) después de ser clicado. Tiene métodos similares a la clase Button, pero además tiene los siguientes métodos:
isSelected(): Retorna si el ToggleButton está seleccionado o no.setSelected(boolean selected): Establece el estado seleccionado delToggleButton.toggle(): Cambia el estado seleccionado delToggleButtonde forma programática.
Veamos un ejemplo:
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
Button button = new Button("Click Me");
ToggleButton toggleButton = new ToggleButton("Toggle Me");
VBox vbox = new VBox(10);
vbox.getChildren().addAll(button, toggleButton);
Scene scene = new Scene(vbox, 300, 200);
stage.setTitle("Button and ToggleButton Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
Botones de selección¶
Los botones de selección son botones que al ser clicado cambia su estado, es decir, pasan de estar seleccionados a no seleccionados y viceversa. Existen dos tipos de botones de selección CheckBox y los RadioButton. Los Checkbox permite seleccionar varias opciones mientras que los RadioButton pertenecientes a un mismo grupo, solo pueden ser seleccionados uno de ellos.
Los checkboxes suelen ser utilizados para las opciones que son independientes, por ejemplo, para una lista de tareas a realizar, no es necesario que las opciones tengan relación entre sí. Mientras los radios, suelen ser utilizados para aquellas opciones en la cuales solo tiene cabida que sea seleccionada una de ellas, como el sexo de una persona.
Ambas clases tienen los siguientes métodos comunes:
setText(String text): establece el texto asociado.setSelected(boolean b)establece si el botón está o no seleccionado.isSelected(): devuelve si el botón está seleccionado.
Los checkboxes, además, pueden tener un tercer estado llamado indeterminado. Suele ser útil cuando necesitamos un estado intermedio entre seleccionado y no seleccionado. Por ejemplo, supongamos que tenemos checkboxes para indicar si una tarea ha sido finalizado. Si ha sido finalizada, el estado del checkbox pasa a estar seleccionado, si aún no ha sido finalizada pasa a ser no seleccionado, pero si no ha sido seleccionada pero ya se ha comenzado con ella se puede indicar como indeterminado. Para ello se usa el método, setIndeterminate(boolean b) para indicar si su estado es indeterminado o no. Con el método indeterminateProperty() obtiene si el estado es indeterminado.
Los botones de selección RadioButton deben ser implementados en un mismo grupo, por lo que es necesario crear un objeto de la clase ToggleGroup. A través de los métodos setToggleGroup(ToggleGroup t) se establece al grupo al que pertenece. Además, se dispone de un método getter getToggleGroup() que obtiene el grupo.
Los métodos getToggles() y getSelectedToggle(), sirve para obtener todos los elementos del grupo y el elemento seleccionado, respectivamente.
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
CheckBox checkBox1 = new CheckBox("Opción 1");
CheckBox checkBox2 = new CheckBox("Opción 2");
ToggleGroup toggleGroup = new ToggleGroup();
RadioButton radioButton1 = new RadioButton("Opción A");
radioButton1.setToggleGroup(toggleGroup);
RadioButton radioButton2 = new RadioButton("Opción B");
radioButton2.setToggleGroup(toggleGroup);
VBox vbox = new VBox(10);
vbox.getChildren().addAll(checkBox1, checkBox2, radioButton1, radioButton2);
Scene scene = new Scene(vbox, 300, 200);
stage.setTitle("CheckBox and RadioButton Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
Controles de lista¶
ComboBox¶
El ComboBox en JavaFX es un control que permite al usuario seleccionar una opción de una lista desplegable o ingresar su propia opción. Una de sus características principales es su capacidad de ser editable, lo que permite al usuario ingresar texto directamente. Se puede tener una lista de opciones predefinidas pero le permite al usuario poder editar más opciones. Solo permite tener un único valor seleccionado a la vez.
El constructor ComboBox(ObservableList<T> items) puede recibir una lista observable de JavaFx como parámetro. Además, se puede añadir elementos con el método setItems(ObservableList<T> items). También tiene un getter para obtener los elementos de la lista: getItems().
Para indicar el valor seleccionado, se puede usar el método setValue(T value) y se puede obtener el valor a través del método getValue(). Además, con el método setEditable(boolean b) permite o no la edición por parte del usuario. Con el método isEditable() se comprueba si el usuario puede o no realizar la edición.
Veamos un ejemplo:
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
ComboBox<String> comboBox = new ComboBox<>(FXCollections.observableArrayList("Option 1", "Option 2", "Option 3"));
comboBox.setValue("Option 1");
comboBox.setEditable(true);
StackPane root = new StackPane();
root.getChildren().add(comboBox);
Scene scene = new Scene(root, 300, 200);
stage.setTitle("ComboBox Event Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
ChoiceBox¶
ChoiceBox es un control en JavaFX que permite al usuario seleccionar una opción de una lista desplegable de opciones predefinidas. Es similar a un combo box pero más sencillo, sin la capacidad de edición. Solo permite una única opción seleccionada a la vez y las opciones deben ser predefinidas, ya que no permite la edición por parte del usuario.
El constructor ChoiceBox(ObservableList<T> items) puede recibir una lista observable de JavaFx como parámetro. Además, se puede añadir elementos con el método setItems(ObservableList<T> items). También tiene un getter para obtener los elementos de la lista: getItems().
Para indicar el valor seleccionado, se puede usar el método setValue(T value) y se puede obtener el valor a través del método getValue().
Veamos un ejemplo:
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
ChoiceBox<String> choiceBox = new ChoiceBox<>(FXCollections.observableArrayList("Option 1", "Option 2", "Option 3"));
choiceBox.setValue("Option 1");
StackPane root = new StackPane();
root.getChildren().add(choiceBox);
Scene scene = new Scene(root, 300, 200);
stage.setTitle("ChoiceBox Event Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
ListView¶
El ListView en JavaFX es un control que permite mostrar una lista desplazable de elementos. Es útil para mostrar grandes conjuntos de datos de manera organizada, permitiendo al usuario seleccionar uno o varios elementos.
A través del constructor ListView(ObservableList<T>) o del método setItems(ObservableList<T>) se puede añadir elementos a la lista. Con el método getItems() se obtienen los elementos de la lista. Además, se puede indicar la orientación (vertical u horizontal) de la lista a través del método setOrientation(Orientation o) (por defecto es vertical).
El modelo de selección es un mecanismo que permite gestionar la selección de elementos en controles de interfaz de usuario que contienen una colección de elementos. El modelo de selección es responsable de controlar y manejar qué elementos están seleccionados en un control dado, proporcionando métodos para acceder y manipular esta selección.
Existen dos clases principales para la selección:
SingleSelectionModel: Utilizado para controles donde solo un elemento puede ser seleccionado a la vez.MultipleSelectionModel: Utilizado para controles donde múltiples elementos pueden ser seleccionados simultáneamente.
Ambas clases son abstractas, por lo que para indicar el modo de selección, es necesario obtener el modelo con el método getSelectionModel() que devuelve un MultipleSelectionModel, cuyo modo puede ser simple o múltiple. A través del método setSelectionModel(SelectionModel mode) se puede modificar su comportamiento a múltiple, a través de SelectionModel.MULTIPLE o a simple (por defecto) SelectionModel.SINGLE. Otros métodos de interés de la clase MultipleSelectionModel son:
getSelectedItem(): Retorna el valor seleccionado.getSelectedItems(): Devuelve una lista observable de los elementos actualmente seleccionados (relevante para modelos de selección múltiple).select(T item): Selecciona el elemento especificado.select(int index): Selecciona el elemento en el índice especificado.clearSelection(): Deselecciona todos los elementos.isSelected(int index): Devuelvetruesi el elemento en el índice especificado está seleccionado.
Con el método setCellFactory(Callback<ListView<T>, ListCell<T>> valu) se utiliza para proporcionar una manera personalizada de representar cada celda en la lista, es decir, permite definir cómo se deben mostrar los elementos en el ListView, lo que es útil cuando necesitas una representación más compleja que el simple texto. Un CellFactory es responsable de crear las celdas que se utilizarán para representar los elementos del ListView. Al definir un CellFactory personalizado, puedes controlar exactamente cómo se debe mostrar cada elemento de la lista.
Veamos un ejemplo:
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
ObservableList<String> items = FXCollections.observableArrayList(
"Item 1", "Item 2", "Item 3", "Item 4", "Item 5");
ListView<String> listView = new ListView<>(items);
listView.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
listView.setCellFactory(new Callback<>() {
@Override
public ListCell<String> call(ListView<String> param) {
return new ListCell<>() {
@Override
protected void updateItem(String item, boolean empty) {
super.updateItem(item, empty);
if (empty || item == null) {
setText(null);
} else {
setText("Customized: " + item);
}
}
};
}
});
StackPane root = new StackPane();
root.getChildren().add(listView);
Scene scene = new Scene(root, 300, 200);
stage.setTitle("ListView Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
ImageView¶
ImageView es una clase en JavaFX que se utiliza para mostrar imágenes. Es una parte fundamental del paquete javafx.scene.image y ofrece una amplia gama de funcionalidades para manipular y mostrar imágenes en la interfaz gráfica de una aplicación JavaFX. Entre sus características principales encontramos:
- Cargar imágenes desde archivos, URL o recursos
- Escalar, recortar y ajustar imágenes
- Rotar imágenes
- Aplicar efectos a las imágenes
Para utilizar un ImageView, generalmente primero creas una instancia de la clase Image, que contiene la imagen que deseas mostrar, y luego pasas esa instancia al constructor del ImageView(Image i).
A través del método setImage(Image i) se puede especificar la imagen a mostrar. Con el método getImage() se obtiene la imagen. Con los métodos setFitWidth(double value) y setFitHeight(double value) se establece el ancho y alto al que se debe ajustar la imagen. Si se desea preservar la relación aspecto de la imagen, se puede utilizar el método setPreserveRatio(boolean b) con el parámetro a true.
Con el método setSmooth(boolean value) se establece si se debe aplicar un filtrado suave al escalar la imagen. Y, con el método setRotate(double angle) se rota la imagen en el ángulo especificado.
Veamos un ejemplo:
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
Image image = new Image("https://upload.wikimedia.org/wikipedia/commons/thumb/b/b6/Image_created_with_a_mobile_phone.png/220px-Image_created_with_a_mobile_phone.png");
ImageView imageView = new ImageView(image);
imageView.setFitWidth(300);
imageView.setFitHeight(300);
imageView.setPreserveRatio(true);
imageView.setSmooth(true);
imageView.setRotate(30);
StackPane root = new StackPane();
root.getChildren().add(imageView);
Scene scene = new Scene(root, 400, 400);
stage.setTitle("ImageView Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
Slider¶
El Slider es un control de interfaz de usuario en JavaFX que permite al usuario seleccionar un valor numérico de un rango continuo arrastrando un indicador a lo largo de una barra. Es útil en situaciones donde se necesita un control preciso y visualmente intuitivo para seleccionar valores dentro de un rango definido.
Para configurar un Slider se puede utilizar los getters y setters de las siguientes propiedades:
min: El valor mínimo del rango del Slider.max: El valor máximo del rango del Slider.value: El valor actual del Slider.showTickMarks: Muestra u oculta las marcas de las unidades en el Slider.showTickLabels: Muestra u oculta las etiquetas de los valores en el Slider.majorTickUnit: Define la distancia entre las marcas principales en el Slider.minorTickCount: Define la cantidad de marcas menores entre dos marcas principales.blockIncrement: Define el incremento de los valores cuando se usa el teclado para mover el Slider.orientation: Define la orientación del Slider (horizontal o vertical).
Progresos¶
En JavaFX, ProgressBar y ProgressIndicator son componentes utilizados para mostrar el progreso de una operación en curso en una aplicación. Ambos sirven para indicar visualmente al usuario cuánto tiempo o qué parte de una tarea se ha completado.
ProgressBar es un componente visual que muestra el progreso de una tarea en forma de una barra horizontal. Mientras que, ProgressIndicator es un componente visual que muestra el progreso de una tarea en forma de un indicador circular o lineal.
SA través del método setProgress(double value) se establece el valor de progreso del indicador. El valor debe estar entre 0.0 y 1.0, donde 0.0 indica que no se ha iniciado la tarea y 1.0 indica que la tarea está completa. Si se indica -1 (ProgressBar.INDETERMINATE_PROGRESS o ProgressIndicator.INDETERMINATE_PROGRESS), estable que el indicador del progreso se indeterminado, es decir, el indicador muestra animación continua mientras se desconoce la duración de la tarea.
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
ProgressBar progressBar = new ProgressBar();
progressBar.setProgress(0.6); // Establecer progreso al 60%
ProgressIndicator progressIndicator = new ProgressIndicator();
progressIndicator.setProgress(0.25); // Establecer progreso al 25%
ProgressIndicator progressIndeterminate = new ProgressIndicator();
progressIndeterminate.setProgress(ProgressIndicator.INDETERMINATE_PROGRESS);
VBox vbox = new VBox(20);
vbox.getChildren().addAll(progressBar, progressIndicator, progressIndeterminate);
Scene scene = new Scene(vbox, 300, 150);
stage.setTitle("ProgressBar and ProgressIndicator Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
TableView¶
TableView es una clase en JavaFX que se utiliza para mostrar datos tabulares. Es similar a una tabla en una hoja de cálculo o una base de datos, y permite a los desarrolladores crear tablas de forma sencilla en sus aplicaciones. TableView es parte del paquete javafx.scene.control. Entre sus características, encontramos:
- Mostrar datos en filas y columnas
- Soporte para múltiples tipos de datos
- Ordenación y filtrado de datos
- Selección de filas y celdas
- Personalización de celdas mediante CellFactory
Para utilizar un TableView, debes definir las columnas y los datos que se mostrarán. Cada columna se representa mediante una instancia de TableColumn, y los datos se organizan en filas utilizando una lista observable (ObservableList).
Las columnas tiene un compartimiento similar a ListView. Veamos un ejemplo:
public class Person {
private final StringProperty firstName;
private final StringProperty lastName;
public Person(String firstName, String lastName) {
this.firstName = new SimpleStringProperty(firstName);
this.lastName = new SimpleStringProperty(lastName);
}
public String getFirstName() {
return firstName.get();
}
public void setFirstName(String firstName) {
this.firstName.set(firstName);
}
public StringProperty firstNameProperty() {
return firstName;
}
public String getLastName() {
return lastName.get();
}
public void setLastName(String lastName) {
this.lastName.set(lastName);
}
public StringProperty lastNameProperty() {
return lastName;
}
}
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
TableView<Person> tableView = new TableView<>();
TableColumn<Person, String> firstNameColumn = new TableColumn<>("First Name");
firstNameColumn.setCellValueFactory(new PropertyValueFactory<>("firstName"));
TableColumn<Person, String> lastNameColumn = new TableColumn<>("Last Name");
lastNameColumn.setCellValueFactory(new PropertyValueFactory<>("lastName"));
tableView.getColumns().add(firstNameColumn);
tableView.getColumns().add(lastNameColumn);
firstNameColumn.setCellFactory(new Callback<>() {
@Override
public TableCell<Person, String> call(TableColumn<Person, String> param) {
return new TableCell<>() {
@Override
protected void updateItem(String item, boolean empty) {
super.updateItem(item, empty);
if (item == null || empty) {
setText(null);
} else {
setText("Name: " + item);
}
}
};
}
});
ObservableList<Person> data = FXCollections.observableArrayList(
new Person("John", "Doe"),
new Person("Jane", "Doe"),
new Person("Mike", "Smith")
);
tableView.setItems(data);
tableView.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
StackPane root = new StackPane();
root.getChildren().add(tableView);
Scene scene = new Scene(root, 400, 300);
stage.setTitle("Row Selection TableView Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
Como puedes observar, en el ejemplo anterior, las propiedad de la clase Person son de tipo StringProperty. Este tipo de propiedades son específicas de JavaFX y tiene una serie de ventajas:
- Observabilidad: Las propiedades de JavaFX (StringProperty, IntegerProperty, etc.) son observables. Esto significa que puedes agregar listeners para reaccionar automáticamente a los cambios en los valores de estas propiedades.
- Enlace de Datos (Data Binding): Las propiedades permiten el enlace de datos, lo que facilita la sincronización de datos entre el modelo y la vista. Esto es útil para mantener la interfaz de usuario actualizada automáticamente cuando cambian los datos subyacentes.
- Compatibilidad con Controles JavaFX: Muchos controles JavaFX, como
TableView, están diseñados para trabajar directamente con propiedades observables.
TreeView¶
TreeView es una clase en JavaFX que se utiliza para mostrar datos jerárquicos en forma de árbol. Cada elemento en un TreeView es un TreeItem, que puede contener subelementos, permitiendo la creación de estructuras de datos anidadas. Es útil para mostrar información que tiene una estructura de árbol, como sistemas de archivos, estructuras organizativas, etc. Sus características son:
- Mostrar datos jerárquicos
- Expandir y contraer nodos
- Personalización de celdas
- Soporte para múltiples tipos de datos
Veamos sus métodos principales:
setRoot(TreeItem<T> root): Establece el nodo raíz del TreeView.getRoot(): Obtiene el nodo raíz del TreeView.getSelectionModel(): Obtiene el modelo de selección del TreeView.setCellFactory(Callback<> c): Permite personalizar la apariencia de las celdas en unTreeViewutilizando unaTreeCellFactory.setExpanded(boolean b): Expande o no el árbol.
Veamos un ejemplo:
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
TreeItem<String> rootItem = new TreeItem<>("Root");
rootItem.setExpanded(true);
TreeItem<String> item1 = new TreeItem<>("Item 1");
TreeItem<String> item2 = new TreeItem<>("Item 2");
TreeItem<String> item3 = new TreeItem<>("Item 3");
rootItem.getChildren().addAll(item1, item2, item3);
// Crear nodos hijos para item1
TreeItem<String> item1Child1 = new TreeItem<>("Item 1.1");
TreeItem<String> item1Child2 = new TreeItem<>("Item 1.2");
item1.getChildren().addAll(item1Child1, item1Child2);
// Crear un TreeView y añadir el nodo raíz
TreeView<String> treeView = new TreeView<>(rootItem);
// Añadir el TreeView a un layout
StackPane root = new StackPane();
root.getChildren().add(treeView);
// Crear una escena y añadir el layout
Scene scene = new Scene(root, 300, 250);
// Configurar el escenario
stage.setTitle("TreeView Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
DatePicker y ColorPicker¶
DatePicker es un control de JavaFX que permite al usuario seleccionar una fecha desde un calendario emergente. Es útil para aplicaciones donde se necesita ingresar o seleccionar fechas.
- Permite seleccionar fechas.
- Puede ser inicializado con una fecha específica.
- Se puede personalizar el formato de la fecha.
- Permite añadir listeners para manejar cambios en la fecha seleccionada.
ColorPicker es un control de JavaFX que permite al usuario seleccionar un color desde un diálogo emergente. Es útil para aplicaciones donde se necesita seleccionar colores.
- Permite seleccionar colores.
- Puede ser inicializado con un color específico.
- Permite añadir listeners para manejar cambios en el color seleccionado.
TabPane¶
TabPane es un contenedor en JavaFX que permite organizar el contenido de una aplicación en pestañas. Cada pestaña puede contener diferentes nodos o layouts, proporcionando una manera conveniente de mostrar y alternar entre diferentes vistas o funcionalidades en una sola ventana.
Con la clase Tab se puede crear una pestaña. A través de su método setContent(Node n) se indica el contenido de la pestaña.
Por defecto, las pestañas tienen la opción de ser cerrada, eso se puede impedir, haciendo uso del método setTabClosingPolicy(TabClosingPolicy t). Veamos un ejemplo:
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
Tab tab1 = new Tab("Tab 1");
Tab tab2 = new Tab("Tab 2");
Tab tab3 = new Tab("Tab 3");
StackPane tab1Content = new StackPane();
tab1Content.getChildren().add(new Label("Content of Tab 1"));
StackPane tab2Content = new StackPane();
tab2Content.getChildren().add(new Label("Content of Tab 2"));
StackPane tab3Content = new StackPane();
tab3Content.getChildren().add(new Label("Content of Tab 3"));
tab1.setContent(tab1Content);
tab2.setContent(tab2Content);
tab3.setContent(tab3Content);
TabPane tabPane = new TabPane();
tabPane.getTabs().addAll(tab1, tab2, tab3);
tabPane.setTabClosingPolicy(TabPane.TabClosingPolicy.UNAVAILABLE);
Scene scene = new Scene(tabPane, 400, 300);
stage.setTitle("TabPane Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
MenuBar¶
MenuBar en JavaFX es un componente que permite crear y gestionar menús dentro de una aplicación. Es útil para agrupar opciones y funcionalidades en una estructura organizada de menús y submenús, proporcionando una forma estándar y accesible para que los usuarios interactúen con la aplicación.
La clase Menu representa una opción del menú principal, y la clase MenuItem representa un hijo de dicha clase Menu.
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
Menu fileMenu = new Menu("File");
MenuItem newMenuItem = new MenuItem("New");
MenuItem openMenuItem = new MenuItem("Open");
MenuItem saveMenuItem = new MenuItem("Save");
MenuItem exitMenuItem = new MenuItem("Exit");
fileMenu.getItems().addAll(newMenuItem, openMenuItem, saveMenuItem, exitMenuItem);
Menu editMenu = new Menu("Edit");
MenuItem cutMenuItem = new MenuItem("Cut");
MenuItem copyMenuItem = new MenuItem("Copy");
MenuItem pasteMenuItem = new MenuItem("Paste");
editMenu.getItems().addAll(cutMenuItem, copyMenuItem, pasteMenuItem);
MenuBar menuBar = new MenuBar();
menuBar.getMenus().addAll(fileMenu, editMenu);
BorderPane borderPane = new BorderPane();
borderPane.setTop(menuBar);
Scene scene = new Scene(borderPane, 400, 300);
stage.setTitle("MenuBar Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}
ContextMenu¶
Un pop-up menu (menú emergente) en JavaFX se puede implementar utilizando la clase ContextMenu. Este tipo de menú proporciona opciones contextuales que aparecen en respuesta a una acción específica del usuario, como hacer clic con el botón derecho del ratón sobre un elemento. Tiene un funcionamiento similar a MenuBar
public class HelloApplication extends Application {
@Override
public void start(Stage stage) throws IOException {
TextArea textArea = new TextArea();
textArea.setPrefSize(300, 200);
ContextMenu contextMenu = new ContextMenu();
MenuItem cutMenuItem = new MenuItem("Cut");
MenuItem copyMenuItem = new MenuItem("Copy");
MenuItem pasteMenuItem = new MenuItem("Paste");
contextMenu.getItems().addAll(cutMenuItem, copyMenuItem, pasteMenuItem);
textArea.setContextMenu(contextMenu);
StackPane root = new StackPane();
root.getChildren().add(textArea);
Scene scene = new Scene(root, 400, 300);
stage.setTitle("ContextMenu Example");
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
}