Introduction à JToolBar
Parmi de nombreux autres composants finement utilisables de SWING Package, JToolBar est encore un autre sucre ajouté sur le dessus. Comme son nom l'indique, JToolBar est utilisé pour implémenter une barre d'outils pour les fenêtres supportant un groupe de composants, par exemple, des menus déroulants, des boutons, etc. JToolBar est également déplaçable par l'utilisateur. JToolBar permet au programmeur de regrouper plusieurs composants comme des boutons ou seulement leurs icônes, en ligne ou en colonne. JToolBar est préférable si vous souhaitez afficher un composant pouvant fournir des actions, des boutons ou des contrôles à l'utilisateur. Habituellement placée sous les barres de menus, la barre d'outils agit comme un conteneur pour d'autres composants comme, comme indiqué, les boutons, les zones de liste déroulante et les menus, etc. La barre d'outils est ajoutée en haut du cadre se comportant comme un outil de sélection pour l'utilisateur, leur permettant d'accéder plus rapidement aux fonctionnalités de l'application. Les barres d'outils contiennent des boutons pour les actions ou commandes couramment utilisées dans une application.
Comment créer JToolBar?
Ci-dessous, la création d'une barre d'outils:
- À l'aide d'un composant JToolBar, une barre d'outils peut être placée sur l'un des quatre côtés ou bords de notre cadre ou panneau. Comme indiqué ci-dessus, une barre d'outils via JToolBar peut être rendue glissable et l'utilisateur peut faire glisser la barre d'outils vers l'extérieur, dans un panneau séparé en définissant une propriété appelée, «flottable» sur True.
- Dans le programme, nous pouvons utiliser JButtons et passer des icônes comme paramètres. De plus, nous pouvons ajouter une propriété de «survol» pour les icônes qui changeront l'icône lorsque la souris survolera la barre d'outils.
- Lors de la création d'une barre d'outils, nous utilisons une classe de Swing Package appelée, classe 'JToolBar'. Cette classe prend en charge les orientations horizontales et verticales. Pour les orientations verticales et horizontales, JToolBar utilise BoxLayout qui aide à organiser les composants dans les deux sens. Les alignements peuvent être ajustés à l'aide de setAlignmentY () et de définir l'alignement () pour chaque composant.
- La création des composants, horizontalement ou verticalement, est ordonnée et cet ordre est indexé à l'aide d'entiers, en interne, c'est-à-dire que le premier composant ajouté est déterminé avec l'index zéro et ainsi de suite.
Programme pour implémenter JToolBar en Java
Voici un exemple simple de barre d'outils créée à l'aide de la classe JToolBar du Swing Package:
Exemple 1
Nous allons créer une barre d'outils simple avec deux boutons et une zone de liste déroulante avec quelques options en dessous. Voir le code source de cet exemple.
Code:
import java.awt.BorderLayout;
import java.awt.Container;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JToolBar;
public class Java_JToolBar
(
public static void main(final String args())
(
//creating frame object
JFrame F = new JFrame("JToolBar Example");
//setting exit on close property
F.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//adding tool bar object
JToolBar TB = new JToolBar();
TB.setRollover(true);
//creating a button with text as File
JButton button = new JButton("File");
//adding our File button
TB.add(button);
//adding a separator
TB.addSeparator();
//adding another button named Edit
TB.add(new JButton("Edit"));
//adding a combo box with three options
TB.add(new JComboBox(new String() ("Option 1", "Option 2", "Option 3", "Option 4")));
Container contentPane = F.getContentPane();
contentPane.add(TB, BorderLayout.NORTH);
JTextArea textArea = new JTextArea();
JScrollPane P = new JScrollPane(textArea);
contentPane.add(P, BorderLayout.EAST);
//setting frame size and frame visibility property
F.setSize(450, 250);
F.setVisible(true);
)
)
Production:
- Ce n'était qu'un programme simple, ajoutons-y quelque chose d'intéressant. Dans notre prochain exemple de code, nous utiliserons des icônes au lieu de texte pour nos boutons.
- Dans l'exemple suivant, nous avons ajouté cinq actions d'utilisation générale et une zone de liste déroulante contenant des sous-éléments. La sortie de ce programme semble plus élégante et plus belle. Regarde.
Remarque: les commentaires écrits après une double barre oblique ( // ).
Exemple # 2
Code source de l'exemple de programme.
Code:
import javax.swing.*;
import java.awt.*;
class demo
(
//constructor being used
demo()
(
//creating our Frame object
JFrame frame = new JFrame("JToolBar Demo");
//creating out tool bar object
JToolBar toolbar = new JToolBar("Applications");
//adding button icons instead of text
JButton btnCalendar = new JButton(new ImageIcon("src/images/Calendar1.png.webp"));
JButton btnClock = new JButton(new ImageIcon("src/images/Clock1.png.webp"));
JButton btnContacts = new JButton(new ImageIcon("src/images/Contacts1.png.webp"));
JButton btnMail = new JButton(new ImageIcon("src/images/Mail1.png.webp"));
JButton btnMessages = new JButton(new ImageIcon("src/images/Message1.png.webp"));
//creating combo box object
JComboBox fonts=new JComboBox();
//adding combo box items
fonts.addItem("Arial");
fonts.addItem("Times New Roman");
fonts.addItem("Comic Sans Ms");
//adding combo box and buttons to our tool bar
toolbar.add(btnCalendar);
toolbar.add(btnClock);
toolbar.add(btnContacts);
toolbar.add(btnMail);
toolbar.add(btnMessages);
toolbar.add(fonts);
//setting properties for the Frame
frame.setLayout(new BorderLayout());
frame.getContentPane().add(toolbar, BorderLayout.PAGE_START);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(500, 200);
frame.setVisible(true);
)
public static void main(String args()) throws Exception
(
//calling our class
new demo();
)
)
Sortie 1:
Sortie 2:
Constructeurs de JToolBar
Il existe plusieurs constructeurs qui sont utilisés avec notre classe principale, JToolBar. Outre le constructeur par défaut JToolBar (), voici d'autres constructeurs qui peuvent également être utilisés:
- JToolBar (): ce constructeur crée notre barre d'outils avec une orientation par défaut. Il est orienté vers HORIZONTAL.
- JToolBar (int orientation): ce constructeur crée une nouvelle barre d'outils avec une orientation spécifiée par le programmeur. Il aligne notre barre d'outils spécifiquement vers le côté mentionné par le programmeur.
- JToolBar (String name): Ce constructeur est utilisé lorsque nous devons fournir un nom spécifique pour notre barre d'outils. Ainsi, ce constructeur crée la barre d'outils avec un titre spécifié en utilisant un paramètre.
- JToolBar (String name, int orientation): Le constructeur qui permet au programmeur de créer une nouvelle barre d'outils avec un nom ou un titre spécifié en utilisant un paramètre, ainsi que l'orientation de la barre d'outils, est spécifiquement mentionné dans le code lui-même.
Méthodes courantes pour JToolBar
Il existe plusieurs méthodes qui peuvent être utilisées en conjugaison avec notre classe JToolBar. Certains des plus importants sont énumérés ci-dessous:
- JButton add (Action a): Cette méthode permet d'ajouter un bouton qui initialisera une action spécifiée.
- void addSeparator (dimension d): pour ajouter un séparateur à un groupe de composants associés dans la barre d'outils, nous utilisons cette méthode qui ajoute un séparateur à la fin de notre barre d'outils. La dimension du séparateur est définie par le paramètre passé dans cette fonction.
- void addSeparator () : Cette méthode fonctionne de manière similaire à addSeparator (dimension d). La différence est qu'au lieu de donner spécifiquement le paramètre de dimension ici, les dimensions sont par défaut.
- Composant getComponentAtlndex (int index) : Cette méthode renvoie le composant à un index donné par le programmeur à l'aide du paramètre.
- int getComponentindex (Component c) : Cette méthode retourne l'index du composant qui est spécifié à l'aide du paramètre.
- void remove (Component c) : Cette méthode supprime simplement le composant spécifié à l'aide des paramètres de la barre d'outils.
Ainsi, ci-dessus étaient les méthodes parmi d'autres comme setUI () ou getUI () ou setOrientation (), qui peuvent être utilisées avec notre classe JToolBar si nécessaire.
Conclusion
Nous avons vu comment créer des barres d'outils à l'aide de la classe JToolBar du package SWING. Ces barres d'outils sont utilisées pour afficher les actions ou les contrôles couramment utilisés par l'utilisateur. JToolBar de SWING fournit des composants qui permettent au programmeur d'apprivoiser facilement les actions nécessaires comme les alignements, les orientations, le changement de police, etc.
Articles recommandés
Ceci est un guide de JToolBar. Ici, nous discutons de la création de la barre d'outils, des exemples avec des codes et des sorties, des constructeurs et quelques méthodes de JToolBar. Vous pouvez également consulter nos autres articles connexes pour en savoir plus-
- JScrollPane en Java
- Méthodes de tableaux en JavaScript
- StringBuffer en Java
- Déclaration de cas en JavaScript
- JFrame en Java