Swing

Ressources : Udemy + Youtube + ChatGPT + https://rmdiscala.developpez.com/cours/LesChapitres.html/Java/Cours2/Chap2.4.htm (opens in a new tab)

Classes

Aperçu sur https://www.javatpoint.com/java-swing (opens in a new tab) le 17 juin 2023

Coordinate System

le point de référence est en à gauche

Advances Methods and Package

Toolkit

Java JFrame

JFrame

les constructeurs :

• JFrame(): crée une frame invisible
• JFrame (String title) : crée un titre à la fenêtre

Aperçu sur https://rmdiscala.developpez.com/cours/LesChapitres.html/Java/Cours2/Chap2.4.htm (opens in a new tab) le 17 juin 2023

JPanel

Le 'Panel est une classe de conteneur très simple. Il fournit un espace dans lequel une application peut attacher n'importe quel autre composant. Il hérite de la classe JComponents.

JPanel, faisant partie du package Java Swing, est un conteneur qui peut stocker un groupe de composants. La tâche principale de JPanel est d'organiser les composants. Différents agencements peuvent être définis dans JPanel, ce qui permet une meilleure organisation des composants, cependant, il n'a pas de barre de titre.

Les constructeurs de JPanel sont les suivants :

• JPanel() : crée un nouveau panneau avec un agencement de flux (flow layout).
• JPanel(LayoutManager l) : crée un nouveau JPanel avec un gestionnaire d'agencement spécifié.
• JPanel(boolean isDoubleBuffered) : crée un nouveau JPanel avec une stratégie de mise en mémoire tampon spécifiée.
• JPanel(LayoutManager l, boolean isDoubleBuffered) : crée un nouveau JPanel avec un gestionnaire d'agencement spécifié et une stratégie de mise en mémoire tampon spécifiée.

JPnael est ajouté à la JFrame pour crée l'interface

Le cadre rouge = à la JFrame Le carré gris = au JPanel

• les coordonnées sont sur la ligne de code : panel.setBounds(40,80,200,200)

Swing Icon and Image Icon

Icone est une petite image de taille fixe, généralement utilisée pour décorer des composants. Imagelcon est une implémentation de l'interface Icon qui peint des icônes à partir d'images. Les images peuvent être créées à partir d'une URL, d'un nom de fichier ou d'un tableau d'octets. Imagelcon possède plusieurs constructeurs, notamment : • Imagelcon(byte[l imageData) - crée un Imagelcon à partir d'un tableau d'octets. • Imagelcon(lmage image) - crée un Imagelcon à partir d'un objet image. • Imagelcon(String filename) - crée un Imagelcon à partir du fichier spécifié. • Imagelcon(URL location) - crée un Imagelcon à partir de l'URL spécifiée. Imagelcon peut fonctionner avec des images PNG, JPEG et GIF. Si nous voulons travailler avec des images BMP ou ICO, nous pouvons utiliser la bibliothèque image4j.

Java Random

java.util.Random est principalement utilisé pour générer des objets prenant des nombres aléatoires. L'utilisateur peut avoir un ensemble prédéfini de nombres à partir desquels la fonction choisit un nombre aléatoire. • Pour utiliser cette classe pour générer des nombres aléatoires, nous devons d'abord créer une instance de cette classe, puis invoquer des méthodes telles que nextlnt(), nextDouble(), nextLong(), etc. en utilisant cette instance. Nous pouvons générer des nombres aléatoires de types entiers, float, double, long et boolean. Nous pouvons passer des arguments aux méthodes pour définir une limite supérieure sur la plage des nombres à générer. Par exemple, nextlnt(6) générera des nombres dans la plage de 0 à 6, inclusivement.

Key Listener & Action Listener

Key listener

L'interface KeyListener permet de recevoir des événements du clavier (frappes de touches). La classe qui souhaite traiter un événement du clavier implémente cette interface (et toutes les méthodes qu'elle contient) ou étend la classe abstraite KeyAdapter (en remplaçant uniquement les méthodes qui l'intéressent). L'objet écouteur créé à partir de cette classe est ensuite enregistré auprès d'un composant en utilisant la méthode addKeyListener du composant. Un événement du clavier est généré lorsqu'une touche est enfoncée, relâchée ou tapée. La méthode pertinente dans l'objet écouteur est ensuite invoquée, et l'événement KeyEvent lui est transmis.

Action Listener

Un événement d'action se produit chaque fois qu'une action est effectuée par l'utilisateur. Par exemple, lorsque l'utilisateur clique sur un bouton, sélectionne un élément de menu ou appuie sur Entrée dans un champ de texte. Le résultat est l'envoi d'un message actionPerformed à tous les écouteurs d'action enregistrés sur le composant pertinent.

Jcomponent

Les JComponents sont les éléments de base de Swing qui sont utilisés pour construire des interfaces graphiques. Voici une description détaillée de quelques-uns des JComponents les plus utilisés :

• JButton: Un bouton standard qui l'utilisateur peut cliquer pour déclencher une action.

• JLabel: Un affichage de texte non interactif. Les JLabels peuvent également contenir des images.

• JTextField: Un champ de texte à une seule ligne où l'utilisateur peut entrer du texte.

• JTextArea: Un champ de texte multiligne où l'utilisateur peut entrer du texte. Il peut également être utilisé pour afficher du texte multiligne.

• JCheckBox: Une case à cocher que l'utilisateur peut sélectionner ou désélectionner.

• JRadioButton: Un bouton radio qui est généralement utilisé dans un groupe de boutons radio, où un seul peut être sélectionné à la fois.

• JComboBox: Une liste déroulante d'éléments parmi lesquels l'utilisateur peut sélectionner.

• JList: Une liste d'éléments parmi lesquels l'utilisateur peut sélectionner.

• JMenu, JMenuItem, JMenuBar: Ces éléments sont utilisés pour créer des menus dans les applications Swing.

• JTable: Un tableau pour l'affichage des données tabulaires.

• JTree: Un composant qui peut afficher des données hiérarchiques, comme un arbre de fichiers.

• JScrollPane: Un composant qui fournit un défilement pour d'autres composants. Utile lorsque le composant contenu est trop grand pour tenir dans la zone visible.

Chacun de ces composants a sa propre série de méthodes pour gérer son comportement spécifique. Par exemple, un JButton a une méthode addActionListener() qui peut être utilisé pour définir ce qui se passe lorsque le bouton est cliqué. Une JTable a des méthodes pour définir son modèle de données, qui contrôle les données affichées dans le tableau.

Tous ces composants héritent de la classe de base JComponent, qui fournit des fonctionnalités communes à tous les composants Swing, comme la gestion de l'apparence et du comportement, la gestion des événements de la souris et du clavier, et l'ajout de bordures.

Conteneurs

Les conteneurs en Java Swing sont des composants qui peuvent contenir d'autres composants Swing, y compris d'autres conteneurs. Voici une description de certains des conteneurs Swing les plus couramment utilisés :

• JFrame: Il s'agit du conteneur de niveau supérieur qui représente une fenêtre de l'application. Il peut contenir d'autres composants et conteneurs. Une application Swing typique a une ou plusieurs instances de JFrame.

• JPanel: C'est un conteneur générique qui peut contenir d'autres composants. Il est souvent utilisé pour grouper des composants connexes ensemble et/ou pour contrôler la mise en page.

• JScrollPane: C'est un conteneur qui fournit une zone de défilement pour d'autres composants. Si le composant contenu est plus grand que la zone visible de la JScrollPane, des barres de défilement apparaissent que l'utilisateur peut utiliser pour faire défiler le contenu.

• JSplitPane: Il s'agit d'un conteneur qui contient deux autres conteneurs et place une barre entre eux que l'utilisateur peut glisser pour ajuster la quantité d'espace allouée à chaque conteneur.

• JTabbedPane: Il s'agit d'un conteneur qui affiche plusieurs onglets, chacun contenant un autre conteneur. L'utilisateur peut cliquer sur les onglets pour passer d'un conteneur à l'autre.

• JDialog: Un conteneur de niveau supérieur similaire à JFrame, mais généralement utilisé pour les fenêtres contextuelles et les boîtes de dialogue modales.

• JToolBar: Un conteneur spécialisé qui est utilisé pour contenir des boutons et d'autres éléments d'interface utilisateur que l'utilisateur peut utiliser pour interagir avec l'application.

• JMenuBar, JMenu, JMenuItem: Ces conteneurs sont utilisés pour créer des barres de menus et des menus déroulants dans les applications Swing.

Tous ces conteneurs ont en commun qu'ils peuvent contenir d'autres composants Swing. Cependant, chacun a aussi ses propres caractéristiques et comportements uniques. Par exemple, JFrame a une méthode setDefaultCloseOperation() pour contrôler ce qui se passe lorsque l'utilisateur ferme la fenêtre, tandis que JTabbedPane a des méthodes pour ajouter, supprimer et gérer les onglets.

les Gestionnaires de mise en page (Layout Managers)

Les gestionnaires de mise en page en Java Swing déterminent la manière dont les composants sont arrangés dans leurs conteneurs. Ils sont responsables du positionnement, de la taille et de l'orientation générale des composants. Voici une description de quelques gestionnaires de mise en page Swing couramment utilisés :

• FlowLayout: C'est le gestionnaire de mise en page par défaut pour les JPanel. Il organise les composants dans un flux de gauche à droite et passe à la ligne suivante lorsque l'espace est insuffisant.

• BorderLayout: Divise le conteneur en cinq régions : Nord, Sud, Est, Ouest et Centre. Chaque région ne peut contenir qu'un seul composant, mais les régions elles-mêmes peuvent contenir d'autres conteneurs.

Aperçu sur http://www.java2s.com/Code/Java/Swing-JFC/DemonstratesBorderLayout.htm le 17 juin 2023

• GridLayout: Arrange les composants en une grille d'un certain nombre de lignes et de colonnes. Tous les composants ont la même taille.

• BoxLayout: Arrange les composants soit verticalement, soit horizontalement. Contrairement à FlowLayout, BoxLayout respecte les tailles préférées, minimales et maximales des composants.

• CardLayout: Permet de basculer entre différents "cartes" (composants ou groupes de composants) dans le même espace. Une seule "carte" est visible à la fois.

• GridBagLayout: Une mise en page plus flexible et complexe qui permet d'organiser les composants en grille, mais avec des tailles de cellules variables et la possibilité pour un composant de s'étendre sur plusieurs cellules.

Chaque gestionnaire de mise en page a ses propres avantages et inconvénients, et est adapté à différents types de tâches. Par exemple, si vous voulez simplement aligner une série de boutons, FlowLayout ou BoxLayout pourrait être approprié. Si vous avez besoin d'une interface utilisateur complexe avec des widgets alignés en grille, GridBagLayout pourrait être une meilleure option.

Pour utiliser un gestionnaire de mise en page, vous créez une instance du gestionnaire de mise en page et l'attribuez à un conteneur à l'aide de la méthode setLayout(). Vous pouvez ensuite ajouter des composants à ce conteneur et le gestionnaire de mise en page les arrangera selon ses règles spécifiques.

Les événements

• Les Événements : Un événement est un objet qui représente une action spécifique. Par exemple, un clic de souris, une frappe au clavier, le redimensionnement d'une fenêtre, sont tous des types d'événements. En Java Swing, chaque type d'événement est représenté par une classe spécifique, comme MouseEvent, KeyEvent, WindowEvent, etc.

• Les Sources d'Événements : Une source d'événement est un objet qui génère un événement. Cela peut être un bouton qui génère un ActionEvent lorsque l'utilisateur clique dessus, une fenêtre qui génère un WindowEvent lorsque l'utilisateur la redimensionne, etc.

• Les Écouteurs d'Événements (Event Listeners) : Un écouteur d'événement est un objet qui est notifié lorsqu'un événement se produit. Les écouteurs sont généralement des interfaces avec des méthodes qui seront appelées lorsque l'événement correspondant se produit. Par exemple, un ActionListener a une méthode actionPerformed(ActionEvent) qui sera appelée lorsqu'un ActionEvent se produit.

• Enregistrement des Écouteurs : Pour qu'un écouteur soit notifié d'un événement, il doit être enregistré auprès de la source de l'événement. Par exemple, si vous avez un bouton (une instance de JButton) et que vous voulez qu'il génère un ActionEvent lorsque l'utilisateur clique dessus, vous devriez ajouter un ActionListener au bouton avec la méthode addActionListener.

• Gestion des Événements : La gestion des événements se fait en implémentant les méthodes de l'interface d'écouteur d'événements. Par exemple, pour répondre à un ActionEvent d'un bouton, vous pouvez créer une classe qui implémente ActionListener et implémenter la méthode actionPerformed. Dans cette méthode, vous mettez le code qui doit être exécuté lorsque l'événement se produit.

• Adapter Classes : Pour certains types d'événements, Swing fournit des classes d'adaptateur qui implémentent toutes les méthodes d'une interface d'écouteur avec des méthodes vides. Vous pouvez étendre ces classes et surcharger uniquement les méthodes que vous êtes intéressé à gérer. Par exemple, MouseAdapter est une classe qui implémente toutes les méthodes de MouseListener et MouseMotionListener.

En résumé, pour utiliser les événements en Swing, vous devez comprendre quels types d'événements sont disponibles, comment créer des écouteurs pour ces événements, comment enregistrer ces écouteurs auprès des sources d'év

Les rendus personnalisés

Java Swing vous permet de personnaliser l'apparence des composants de l'interface utilisateur en surchargeant les méthodes de dessin, en utilisant des icônes, des polices et des couleurs personnalisées, et en utilisant des rendus et des éditeurs personnalisés pour des composants comme JTable et JList. Voici un résumé détaillé :

• Personnalisation de l'apparence des composants: Tous les composants Swing héritent de la classe JComponent qui a plusieurs méthodes que vous pouvez surcharger pour personnaliser l'apparence de votre composant. Par exemple, vous pouvez surcharger la méthode paintComponent(Graphics g) pour dessiner votre composant d'une manière personnalisée.

• Utilisation d'icônes: Swing vous permet d'utiliser des icônes pour décorer vos composants. Par exemple, vous pouvez utiliser la méthode setIcon(Icon icon) pour définir une icône sur un JButton ou un JLabel. Vous pouvez utiliser des icônes à partir de fichiers d'image ou créer vos propres icônes en implémentant l'interface Icon et en surchargeant la méthode paintIcon.

• Définir des polices et des couleurs: Vous pouvez utiliser les méthodes setFont(Font font) et setForeground(Color color) pour définir la police de caractères et la couleur du texte de votre composant. Vous pouvez également utiliser setBackground(Color color) pour définir la couleur d'arrière-plan de votre composant.

• Renderers et Editors: Pour des composants comme JTable et JList, Swing utilise le concept de renderers et d'editors. Un renderer est un composant qui est utilisé pour dessiner chaque cellule de la table ou de la liste. Un editor est un composant qui est utilisé pour modifier le contenu de chaque cellule. Swing fournit des renderers et des éditeurs par défaut, mais vous pouvez également créer les vôtres pour personnaliser l'apparence et le comportement des cellules.

• Look and Feel (LaF): Swing vous permet de changer l'apparence globale de votre application en utilisant différentes interfaces utilisateur, appelées Look and Feel. Chaque Look and Feel a son propre ensemble de classes de rendu qui définissent comment chaque composant doit être dessiné. Vous pouvez choisir parmi plusieurs Look and Feels intégrés ou créer le vôtre.

• UIManger et UIManager.LookAndFeelInfo: La classe UIManager est une classe utilitaire centrale qui gère l'apparence de l'interface utilisateur pour une application Swing. Elle gère également un certain nombre de valeurs par défaut que les composants Swing utilisent.

En résumé, Swing fournit une grande flexibilité pour personnaliser le rendu de vos composants d'interface utilisateur. Vous pouvez contrôler les détails de bas niveau de comment les composants sont dessinés, ou utiliser des fonctionnalités de haut niveau comme les renderers, les éditeurs et les Look and Feels pour changer l'apparence globale de votre application.