1.19 Swing et NetBeans (Création de JFrame) - Free
Ils disposent d'un poids horaire important : 3,5 heures hebdomadaires pour ...
renforcé en premier cycle, avec l'exigence d'un niveau minimum à l'issue de ce
cycle. .... TD. PROJET. SEMINAIRE. Semestre 7 ? enseignements non polarisés.
7 ..... choix du sujet et du groupe de PFE parmi une offre très diversifiée (de 25 à
30 ...
part of the document
JAVA, SWING ET SQL
Sommaire
TOC \o "1-3" \h \z HYPERLINK \l "_Toc266781955" 1.1 Présentation PAGEREF _Toc266781955 \h 4
HYPERLINK \l "_Toc266781956" 1.2 Structure d'une application à base de Swing PAGEREF _Toc266781956 \h 5
HYPERLINK \l "_Toc266781957" 1.2.1 Eléments de base PAGEREF _Toc266781957 \h 5
HYPERLINK \l "_Toc266781958" 1.2.2 Interface PAGEREF _Toc266781958 \h 5
HYPERLINK \l "_Toc266781959" 1.2.3 Script PAGEREF _Toc266781959 \h 5
HYPERLINK \l "_Toc266781960" 1.2.4 Affichage de la fenêtre PAGEREF _Toc266781960 \h 7
HYPERLINK \l "_Toc266781961" 1.2.5 La fermeture de la fenêtre PAGEREF _Toc266781961 \h 8
HYPERLINK \l "_Toc266781962" 1.2.6 Le style d'interface PAGEREF _Toc266781962 \h 9
HYPERLINK \l "_Toc266781963" 1.3 Classes Swing utilisées (JFrame, JPanel,
) PAGEREF _Toc266781963 \h 10
HYPERLINK \l "_Toc266781964" 1.3.1 JFrame : une fenêtre PAGEREF _Toc266781964 \h 10
HYPERLINK \l "_Toc266781965" 1.3.2 JPanel : un panneau PAGEREF _Toc266781965 \h 11
HYPERLINK \l "_Toc266781966" 1.3.3 JLabel : une étiquette PAGEREF _Toc266781966 \h 12
HYPERLINK \l "_Toc266781967" 1.3.4 JTextField : une zone de texte PAGEREF _Toc266781967 \h 13
HYPERLINK \l "_Toc266781968" 1.3.5 JButton : un bouton de commande PAGEREF _Toc266781968 \h 14
HYPERLINK \l "_Toc266781969" 1.4 Les événements avec Swing PAGEREF _Toc266781969 \h 15
HYPERLINK \l "_Toc266781970" 1.5 Les JPanels PAGEREF _Toc266781970 \h 17
HYPERLINK \l "_Toc266781971" 1.6 Retour sur le positionnement des éléments PAGEREF _Toc266781971 \h 20
HYPERLINK \l "_Toc266781972" 1.6.1 Le Layout par défaut PAGEREF _Toc266781972 \h 20
HYPERLINK \l "_Toc266781973" 1.6.2 Le GridLayout PAGEREF _Toc266781973 \h 20
HYPERLINK \l "_Toc266781974" 1.6.3 Le GridBagLayout PAGEREF _Toc266781974 \h 20
HYPERLINK \l "_Toc266781975" 1.7 Les images et les icônes PAGEREF _Toc266781975 \h 24
HYPERLINK \l "_Toc266781976" 1.7.1 Les images PAGEREF _Toc266781976 \h 24
HYPERLINK \l "_Toc266781977" 1.7.2 Une icône directement dans une JFrame PAGEREF _Toc266781977 \h 25
HYPERLINK \l "_Toc266781978" 1.7.3 Une icône dans un JLabel PAGEREF _Toc266781978 \h 27
HYPERLINK \l "_Toc266781979" 1.7.4 Les imageIcon et les listes (JList) PAGEREF _Toc266781979 \h 29
HYPERLINK \l "_Toc266781980" 1.7.5 Les images, le JComboBox et le JSlider PAGEREF _Toc266781980 \h 33
HYPERLINK \l "_Toc266781981" 1.8 Visualiser une table SQL dans des JTextField PAGEREF _Toc266781981 \h 40
HYPERLINK \l "_Toc266781982" 1.9 La JDialog pour des inserts dépendants PAGEREF _Toc266781982 \h 46
HYPERLINK \l "_Toc266781983" 1.10 Créer dynamiquement les composants d'une fenêtre : la FreeForm de visualisation d'une table BD PAGEREF _Toc266781983 \h 53
HYPERLINK \l "_Toc266781984" 1.10.1 Objectif PAGEREF _Toc266781984 \h 53
HYPERLINK \l "_Toc266781985" 1.10.2 Principe PAGEREF _Toc266781985 \h 53
HYPERLINK \l "_Toc266781986" 1.10.3 Ecrans PAGEREF _Toc266781986 \h 54
HYPERLINK \l "_Toc266781987" 1.10.4 Script PAGEREF _Toc266781987 \h 55
HYPERLINK \l "_Toc266781988" 1.10.5 Ajouter un composant dans JFrame créée avec NetBeans PAGEREF _Toc266781988 \h 59
HYPERLINK \l "_Toc266781989" 1.10.6 Ajouter dynamiquement un composant dans JFrame créée avec NetBeans PAGEREF _Toc266781989 \h 59
HYPERLINK \l "_Toc266781990" 1.11 JList, JSrollPane et SQL PAGEREF _Toc266781990 \h 60
HYPERLINK \l "_Toc266781991" 1.12 La JTable, JScrollPane et SQL PAGEREF _Toc266781991 \h 63
HYPERLINK \l "_Toc266781992" 1.12.1 Visualisation d'une table avec une grille (JScrollPane et JTable) PAGEREF _Toc266781992 \h 63
HYPERLINK \l "_Toc266781993" 1.12.2 Visualisation Maître-Détails avec une grille PAGEREF _Toc266781993 \h 68
HYPERLINK \l "_Toc266781994" 1.12.3 Mise à jour dans une grille PAGEREF _Toc266781994 \h 74
HYPERLINK \l "_Toc266781995" 1.12.4 Ajout Maître-Détails (Pays-Villes) PAGEREF _Toc266781995 \h 83
HYPERLINK \l "_Toc266781996" 1.13 Le JTree et SQL PAGEREF _Toc266781996 \h 85
HYPERLINK \l "_Toc266781997" 1.13.1 JTree statique PAGEREF _Toc266781997 \h 85
HYPERLINK \l "_Toc266781998" 1.13.2 Création dynamique (SQL) d'un JTree PAGEREF _Toc266781998 \h 88
HYPERLINK \l "_Toc266781999" 1.13.3 Gestion dynamique d'un JTree PAGEREF _Toc266781999 \h 91
HYPERLINK \l "_Toc266782000" 1.14 Héritage de JFrame PAGEREF _Toc266782000 \h 92
HYPERLINK \l "_Toc266782001" 1.15 Gestion des fenêtres PAGEREF _Toc266782001 \h 94
HYPERLINK \l "_Toc266782002" 1.15.1 Les fenêtres MDI et les fenêtres enfants PAGEREF _Toc266782002 \h 94
HYPERLINK \l "_Toc266782003" 1.15.2 L'item FermerTout PAGEREF _Toc266782003 \h 103
HYPERLINK \l "_Toc266782004" 1.15.3 L'item Fermer PAGEREF _Toc266782004 \h 103
HYPERLINK \l "_Toc266782005" 1.15.4 Le menu fenêtre PAGEREF _Toc266782005 \h 104
HYPERLINK \l "_Toc266782006" 1.15.5 Réorganisation des fenêtres PAGEREF _Toc266782006 \h 105
HYPERLINK \l "_Toc266782007" 1.15.6 Les popup PAGEREF _Toc266782007 \h 108
HYPERLINK \l "_Toc266782008" 1.16 TP images : le diaporama PAGEREF _Toc266782008 \h 109
HYPERLINK \l "_Toc266782009" 1.16.1 Enoncé PAGEREF _Toc266782009 \h 109
HYPERLINK \l "_Toc266782010" 1.16.2 Ecran de sélection PAGEREF _Toc266782010 \h 110
HYPERLINK \l "_Toc266782011" 1.16.3 Ecran de visualisation PAGEREF _Toc266782011 \h 111
HYPERLINK \l "_Toc266782012" 1.16.4 Le script de l'interface création PAGEREF _Toc266782012 \h 112
HYPERLINK \l "_Toc266782013" 1.17 TP intermédiaire : CRUD sur la table [produits] PAGEREF _Toc266782013 \h 117
HYPERLINK \l "_Toc266782014" 1.18 Annexes PAGEREF _Toc266782014 \h 126
HYPERLINK \l "_Toc266782015" 1.18.1 La classe AbsJTable PAGEREF _Toc266782015 \h 126
HYPERLINK \l "_Toc266782016" 1.18.2 La classe Boutons PAGEREF _Toc266782016 \h 128
HYPERLINK \l "_Toc266782017" 1.18.3 La classe FreeForm PAGEREF _Toc266782017 \h 129
HYPERLINK \l "_Toc266782018" 1.18.4 La gestion des événements avec SWING PAGEREF _Toc266782018 \h 130
HYPERLINK \l "_Toc266782019" 1.19 Swing et NetBeans (Création de JFrame) PAGEREF _Toc266782019 \h 135
HYPERLINK \l "_Toc266782020" 1.20 Swing et NetBeans (Création de projets) PAGEREF _Toc266782020 \h 136
HYPERLINK \l "_Toc266782021" 1.20.1 Création du projet PAGEREF _Toc266782021 \h 136
HYPERLINK \l "_Toc266782022" 1.20.2 Ajout d'une JFrame correspondant à une table PAGEREF _Toc266782022 \h 143
HYPERLINK \l "_Toc266782023" 1.21 Récapitulatif exemples et exercices PAGEREF _Toc266782023 \h 144
HYPERLINK \l "_Toc266782024" 1.22 Swing et DAO PAGEREF _Toc266782024 \h 145
Présentation
Swing fait partie de la bibliothèque des JFC (Java Foundation Classes) et permet de créer des interfaces graphiques plus élaborées qu'avec AWT.
C'est une extension d'AWT intégrée à partir de Java 2.
Les composants graphiques de l'interface Swing sont complètement écrits en Java (à la différence d'AWT) et emploient le style du système d'exploitation (Windows, Solaris,
).
Tous les éléments de Swing font partie du package javax.swing. Pour utiliser une classe utilisez l'instruction import :
import javax.swing.*;
Pour la gestion des événements c'est le package java.awt.event qu'il faut continuer à utiliser.
Les composants Swing sont des descendants de la classe JComponent.
Structure d'une application à base de Swing
Eléments de base
Une fenêtre hérite d'une JFrame.
Une JFrame doit contenir un panneau (JPanel).
Les composants de base (JLabel, JTextField, JButton,
) sont ajoutés au panneau.
Le panneau est ajouté à la fenêtre.
Interface
Script
package packageSwing;
import javax.swing.*;
public class Swing1 extends JFrame
{
// --- Déclarations et créations des attributs graphiques
JPanel panneau = new JPanel(); // --- Le panneau
JLabel lbl1 = new JLabel("Nom : "); // --- Les éléments
JTextField tf1 = new JTextField("",20);
JButton cbOk = new JButton("Ok");
// ------------------------------
// --- Constructeur de la fenêtre
// ------------------------------
public Swing1()
{
super("Fenêtre 1");
panneau.add(lbl1); // --- L'ajout des éléments au panneau
panneau.add(tf1);
panneau.add(cbOk);
this.setContentPane(panneau); // L'ajout du panneau à la JFrame
this.pack();
this.setVisible(true);
}
}
Note : à la place de setContentPane(panneau) vous pouvez trouver getContentPane().add(panneau);
Commentaires
Création de la fenêtre qui est une sous-classe de JFrame.
public class Swing1 extends JFrame
Création du panneau de contenu qui est un conteneur d'éléments.
JPanel panneau = new JPanel();
Création des éléments
Une étiquette
JLabel lbl1 = new JLabel("Nom : ");
Une zone de texte
JTextField tf1 = new JTextField("",20);
Un bouton de commande
JButton cbOk = new JButton("Ok");
L'ajout des éléments au panneau
panneau.add(lbl1);
L'ajout du panneau à la fenêtre
this.setContentPane(panneau);
L'affichage
this.pack();
this.setVisible(true);
Affichage de la fenêtre
Il existe deux possibilités :
Externe
Instanciation de la fenêtre dans une classe avec une procédure main().
new Swing1();
Interne
En ajoutant une procédure main() à la Classe seulement en période de test.
// -----------------------------------
public static void main(String[] args)
// -----------------------------------
{
new Swing1().setVisible(true);
}
La fermeture de la fenêtre
Par défaut, à la différence d'AWT, le fait de cliquer sur la x d'une fenêtre la ferme.
Pour que le clic sur la x quitte l'application vous devez ajouter ceci dans le constructeur :
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
Et il existe trois autres constantes au sens explicite :
HIDE_ON_CLOSE
DISPOSE_ON_CLOSE
DO_NOTHING_ON_CLOSE
Pour réaliser les trois premières actions à partir d'un bouton utilisez les méthodes suivantes :
System.exit(0);
setVisible(false);
dispose();
Pour quitter l'appication à partir d'un bouton ajoutez un JButton et le code qui suit dans le constructeur de la classe :
cbFermer.addMouseListener(new java.awt.event.MouseAdapter()
{
public void mouseClicked(java.awt.event.MouseEvent evt)
{
System.exit(0);
}
});
Note : vous pouvez simplifier si vous avez importé java.awt.event.*;
cbFermer.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent evt)
{
System.exit(0);
}
});
Le style d'interface
Principe
Vous pouvez contrôler le style d'interface.
Pour cela vous utilisez la méthode setLookAndFeel() de la classe UIManager qui possède un argument de type LookAndFeel.
Pour obtenir le style Metal propre à Java vous utilisez la méthode getCrossPlatormLookAndFeelClassname()
// --- Le style du système d'exploitation d'exécution
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
// --- Le style Métal
UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
Le style Windows
Le style métal
Le script
public static void main(String args[] )
{
try
{
// --- Le style Métal
//UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
// --- Le style du système d'exploitation d'exécution
// UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
catch(Exception erreur)
{
System.out.println(erreur);
}
new Swing1();
}
Classes Swing utilisées (JFrame, JPanel,
)
JFrame : une fenêtre
JFrameConstructeur
JFrame()
JFrame(titre)
Constructeur
Constructeur avec titreMéthodes
setLayout(LayoutManager)
setContentPane(Container)
Container = getContentPane()
Update(Graphics)
setDefaultCloseOperation(int opération)
this.setSize(largeur, hauteur)
this.pack()
this.setVisible(booléan)
Définit l'agencement
Définit le container de la JFrame
Renvoie le container de la JFrame
Appelle la méthode paint()
EXIT_ON_CLOSE par exemple qui ferme l'application ou HIDE_ON_CLOSE ou DISPOSE_ON_CLOSE.
Définit la taille de la fenêtre
Compacte spatialement les éléments. Indispensable si setSize() n'est pas défini.
Affiche ou masque la fenêtre
JPanel : un panneau
JPanelConstructeur
JPanel()
JPanel(LayoutManager)
Constructeur
Constructeur avec un agencement particulierMéthodes
Add()
Ajoute un composant au Panel
JLabel : une étiquette
JLabelConstructeur
JLabel()
JLabel("Texte")
JLabel(Icône)
Constructeur
Constructeur avec un texte
Constructeur avec une icôneMéthodes
setText(string)
String = getText()
setIcon(icône)
setHorizontalAlignment(int alignement)
setVerticalAlignment(int alignement)
Ajoute un texte
Renvoie le texte de l'étiquette
Affecte une icône
Aligne le texte horizontalement (LEFT, CENTER, RIGHT)
Aligne le texte verticalement (CENTER, TOP, BOTTOM)
Ce sont les constantes de la série SwingConstants
JTextField : une zone de texte
JTextFieldConstructeur
JTextField()
JTextField ("Texte")
JTextField (Colonnes)
JTextField ("Texte", Colonnes)
Constructeur
Constructeur avec un texte
Constructeur spécifiant la longueur
Constructeur avec un texte et la longueurMéthodes
setText("Texte")
string = getText()
setFont(Font)
Affecte un texte
Renvoie le texte
Affecte une police
JButton : un bouton de commande
JButtonConstructeur
JButton()
JButton("Texte")
JButton(Icône)
Constructeur
Constructeur avec un texte
Constructeur avec une icôneMéthodes
setEnabled(booléen)
Paramètre le caractère actif/inactif du bouton
Les événements avec Swing
La gestion des événements avec Swing est dérivée de la gestion des événements d'AWT. Il faut donc importer le package java.awt.event et le package javax.swing.event.
Cette gestion est faite soit via l'extension d'une classe soit via une interface.
import java.awt.event.*;
Exemple de script avec une gestion événementielle de niveau fenêtre.
package packageSwing;
import javax.swing.*;
import java.awt.event.*;
public class Swing1 extends JFrame
{
// --- Déclarations et créations des attributs graphiques
JPanel panneau = new JPanel(); // --- Le panneau
// --- etc
JButton cbOk = new JButton("Ok");
// ------------------------------
// --- Constructeur de la fenêtre
// ------------------------------
public Swing1()
{
super("Fenêtre 1");
this.addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
} );
this.panneau.add(lbl1);
// --- etc
Commentaires
Dans cet exemple nous ajoutons un écouteur d'événement avec la méthode addWindowListener pour la fermeture de la fenêtre en surchargeant la méthode windowClosing de la classe WindowAdapter.
Le code est le même que celui que l'on pouvait trouver avec AWT.
Nous approfondirons la gestion d'événements par la suite.
Référez-vous à l'annexe de fin pour une liste non exhaustive des événements.
Exemple au niveau d'un composant : un bouton de commande
cbPrecedent.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
precedent();
}
});
Ici c'est l'interface ActionListener qui reçoit l'événement et la méthode actionPerformed qui est invoquée.
Notes
Les packages java.awt.event et javax.swing.event sont tous les deux composés d'interfaces et de classes. Les noms des listeners sont du type xxxListener et les noms des classes sont du type xxxEvent ou xxxAdapter.
Cf aussi l'annexe.
Les JPanels
Présentation
Les JPanels permettent une gestion souple de l'agencement dans une JFrame (comme les panels dans les Frames avec AWT).
Il est par ailleurs obligatoire d'en ajouter au moins un à une JFrame.
Dans ce paragraphe nous allons voir la manipulation de plusieurs JPanels.
L'interface n'est pas bien différente de l'interface précédente mais elle est structurée de façon différente et pourra servir de base pour des écrans plus complexes.
Cette fenêtre contient un panneau qui lui même contient deux panneaux qui eux-mêmes contiennent les composants utilisateurs.
Le schéma suivant représente la structure de cette JFrame.
Nom : Ok
Script
// --- Swing2 : SWING et les Jpanels
package packageSwing;
import javax.swing.*;
import java.awt.GridLayout;
import java.awt.event.*;
// -------------------------------
public class Swing2 extends JFrame
// -------------------------------
{
// --- Déclarations et créations des attributs graphiques
JPanel panneau = new JPanel(); // --- Le panneau général
JPanel panneau1 = new JPanel(); // --- Le panneau1
JPanel panneau2 = new JPanel(); // --- Le panneau2
JLabel lbl1 = new JLabel("Nom : "); // --- Les éléments
JTextField tf1 = new JTextField("",20);
JButton cbOk = new JButton("Ok");
// ------------------------------
// --- Constructeur de la fenêtre
// ------------------------------
public Swing2(String asTitre)
{
super(asTitre);
addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
} );
panneau.setLayout(new GridLayout(2,1));
panneau1.setLayout(new GridLayout(1,2));
panneau1.add(lbl1); // --- L'ajout des éléments au panneau
panneau1.add(tf1);
panneau2.setLayout(new GridLayout(1,1));
panneau2.add(cbOk);
panneau.add(panneau1);
panneau.add(panneau2);
setContentPane(panneau); // --- L'ajout du panneau à la JFrame
setVisible(true);
pack();
}
}
Commentaires
La création de Panels
JPanel panneau = new JPanel(); // --- Le panneau général
La spécification du type d'agencement
panneau.setLayout(new GridLayout(2,1));
L'ajout d'éléments au panel
panneau2.add(cbOk);
L'ajout du panel à la fenêtre
setContentPane(panneau); // --- L'ajout du panneau à la JFrame
le paramètre de setContentPane est de type container. Cette méthode spécifie que le container de base de la fenêtre sera le JPanel panneau.
L'ajout d'un listener (module d'écoute)
addWindowListener(
Retour sur le positionnement des éléments
Le Layout par défaut
Le type de positionnement par défaut est le BorderLayout (cf AWT).
EMBED MSPhotoEd.3
Le GridLayout
EMBED MSPhotoEd.3
Le GridBagLayout
Démarche
Instancier le composant
Label lblCodeFilm = new Label("Code Film : ");
Déterminer le Layout du conteneur
setLayout(new GridBagLayout());
Créer la contrainte
GridBagConstraints gbc = new GridBagConstraints();
Paramétrer l'espacement entre composants
gbc.insets = new Insets(2,2,2,2);
Paramétrer la position X (cellule)
gbc.gridx = 0;
Paramétrer la position Y (cellule)
gbc.gridy = 0;
Paramétrer la hauteur (cellule)
gbc.gridheight = 1;
Paramétrer la largeur (cellule)
gbc.gridwidth = 2;
Paramétrer de type de redimensionnement
gbc.fill = GridBagConstraints.NONE; // --- BOTH VERTICAL - HORIZONTAL
Paramétrer la répartition dans l'espace au moins pour un composant pour ligne et colonne.
gbc.weightx = 1.0;
gbc.weighty = 1.0;
Ajouter le composant avec comme deuxième paramètre la contrainte.
add(lblCodeFilm , gbc);
Pour simplifier nous créons une fonction nommée pos()(cf script)
// x, y, ht, larg, poidsX, poidsY, redimensionnement
// x et y en numérotation de cellule, ht et larg en nombre de cellules ...
//pos(gbContrainte,1,2,1,1,10,10,GridBagConstraints.HORIZONTAL);
Script
package packageSwing;
import javax.swing.*;
import java.awt.*;
public class GBC extends JFrame
{
private JButton cb_suivant = new JButton("Suivant");
private JButton cb_fermer = new JButton("Fermer");
private JLabel lbl1 = new JLabel("CP",Label.LEFT);
private JLabel lbl2 = new JLabel("Ville",Label.LEFT);
private JTextField tf1 = new JTextField("75011");
private JTextField tf2 = new JTextField("Paris");
public GBC()
{
GridBagLayout gbl = new GridBagLayout();
GridBagConstraints gbContrainte = new GridBagConstraints();
gbContrainte.insets = new Insets(2,2,2,2);
setLayout(gbl);
// --- Ajout des composants
pos(gbContrainte,1,2,1,1,10,10,GridBagConstraints.HORIZONTAL);
gbl.setConstraints(lbl1, gbContrainte);
add(lbl1);
pos(gbContrainte,2,2,1,1,10,10,GridBagConstraints.HORIZONTAL);
gbl.setConstraints(tf1, gbContrainte);
add(tf1);
pos(gbContrainte,1,3,1,1,10,10,GridBagConstraints.HORIZONTAL);
gbl.setConstraints(lbl2, gbContrainte);
add(lbl2);
pos(gbContrainte,2,3,1,1,10,10,GridBagConstraints.HORIZONTAL);
gbl.setConstraints(tf2, gbContrainte);
add(tf2);
pos(gbContrainte,1,4,1,1,10,10,GridBagConstraints.HORIZONTAL);
gbl.setConstraints(cb_suivant, gbContrainte);
add(cb_suivant);
pos(gbContrainte,2,4,1,1,10,10,GridBagConstraints.HORIZONTAL);
gbl.setConstraints(cb_fermer, gbContrainte);
add(cb_fermer);
pack();
setVisible(true);
}
// -------------
private void pos(GridBagConstraints gbc, int x, int y, int haut, int larg, int wx, int wy, int fill)
// -------------
{
// ---- Contrainte, x , y , hauteur, largeur, poids x , poids y , extension remplissage
gbc.gridx = x;
gbc.gridy = y;
gbc.gridheight = haut;
gbc.gridwidth = larg;
gbc.weightx = wx; // = 0 --> Fixe; 0 --> Variable
gbc.weighty = wy; // = 0 --> Fixe; 0 --> Variable
gbc.fill = fill;
}
}
Les images et les icônes
Les images
Ecran
Script
package packageSwing;
// --- Le tout début sur l'image : une image directement dans une JFrame
// --- Classes et méthodes utilisées :
// --- Image, getToolkit() , getImage(), paint()
import javax.swing.*; // Pour JFrame, ...
import java.awt.*; // Pour image, paint,...
class Image1 extends JFrame
{
Image imJulia;
public Image1() // --- Le constructeur
{
// --- Chargement de l'image : technique de base et rudimentaire
imJulia = getToolkit().getImage("c:/images/julia4.jpg");
this.setSize(300,300);
this.setVisible(true);
}
// --- Affichage de l'image : la méthode paint surchargée avec drawImage
// --- La méthode est exécutée automatiquement
public void paint(Graphics g)
{
g.drawImage(imJulia,0,0,200,200,this);
}
}
Notes pour les chemins :
Soit un chemin absolu : c:\\images\\confidences.jpg
Soit un chemin relatif à partir de la racine du projet : ../images/
Une icône directement dans une JFrame
Objectif
Afficher une photo dans une JFrame.
L'objet ImageIcon
L'imageIcon est une classe du package javax.swing
ImageIconConstructeur
ImageIcon()
ImageIcon(nom de fichier)
ImageIcon(nom de fichier , description)
ImageIcon(URL)
ImageIcon(image)
ImageIcon(byte[])
Constructeur vide
Création à partir d'un nom de fichier
Idem plus une description
Création à partir d'une URL
Création à partir d'une image
Création à partir d'un fichier de byte (lecture d'un fichier jpg ou gif)Méthodes
paintIcon(container, Graphics, x , y)
int = getIconHeight()
int = getIconWidth()
string = getDescription()
setDescription(string)
setImage(Image)
image = getImage()
protected loadImage(Image)
Dessine l'icône dans le container à la position (x,y)
Renvoie la hauteur de l'icône
Renvoie la largeur de l'icône
Renvoie la description de l'icône
Affecte une description
Affecte une image
Renvoie l'image
Charge une image
Script
import javax.swing.*; // Pour JFrame,ImageIcon ...
import java.awt.*; // Pour paint
// ------------------------
class Icone1 extends JFrame
// ------------------------
{
ImageIcon icIcone;
public Icone1()
{
super("Mission impossible - Icone");
// --- Chargement de l'icône
// --- Chemin absolu
icIcone = new ImageIcon("/pascal/cine_jpg/sandra2.jpg");
// --- Dimensionnement et affichage de la fenêtre
this.setSize(icIcone.getIconWidth(),icIcone.getIconHeight());
this.setVisible(true);
}
// --- La méthode paint s'exécute automatiquement
// ---------------------------
public void paint (Graphics g)
{
icIcone.paintIcon(this,g,0,0);
}
}
Commentaires
L'icône est chargée à partir d'un fichier.
La fenêtre est dimensionnée aux dimensions de l'icône.
La méthode paint() est exécutée automatiquement et dessine l'image.
Une icône dans un JLabel
Ecrans
SandraJulia
Fonctionnalités
L'interface présente deux boutons de commande et un label avec une photo.
Lorsque l'utilisateur clique sur un bouton la photo correspondante s'affiche.
Script
// --- Directement dans un composant (un JLabel) d'une JFrame
// --- On clique sur un bouton et l'image change
// --- Classes et Méthodes utilisées : ImageIcon, setIcon
package packageSwing;
import javax.swing.*; // Pour JFrame,ImageIcon ...
import java.awt.*; // Pour paint
import java.awt.event.*; // Pour les listeners
// ----------------------------------
public class IconeSwap extends JFrame
// ----------------------------------
{
JPanel panneau = new JPanel();
JPanel panneau_boutons = new JPanel();
JPanel panneau_photo = new JPanel();
JButton cb_bouton_julia = new JButton("Julia");
JButton cb_bouton_sandra = new JButton("Sandra");
JLabel lbl_image = new JLabel();
ImageIcon ic_sandra;
ImageIcon ic_julia;
public IconeSwap() // --- Le constructeur doit être public
{
super("Mission impossible - Icone6");
// --------------- Les listeners ----------
ActionListener al_cb = new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
Object ljb;
ljb = e.getSource();
if(ljb == cb_bouton_julia) { lbl_image.setIcon(ic_julia); setSize(ic_julia.getIconWidth() + 20, ic_julia.getIconHeight() + 50); validate(); }
if(ljb == cb_bouton_sandra) { lbl_image.setIcon(ic_sandra); setSize(ic_sandra.getIconWidth() + 20 , ic_sandra.getIconHeight() + 50); validate(); }
}
};
cb_bouton_julia.addActionListener(al_cb);
cb_bouton_sandra.addActionListener(al_cb);
// --- Récupération des images
ic_sandra = new ImageIcon("/images/sandra2.jpg");
ic_julia = new ImageIcon("/images/julia4.jpg");
// --- Chargement de l'image.Création d'un label avec une icône
lbl_image.setIcon(ic_sandra);
// ---
panneau_boutons.setLayout(new GridLayout(1,2));
panneau_photo.add(lbl_image);
panneau_boutons.add(cb_bouton_sandra);
panneau_boutons.add(cb_bouton_julia);
// --- Ajout du panneau
getContentPane().add(panneau);
panneau.add(panneau_boutons, BorderLayout.NORTH);
panneau.add(panneau_photo, BorderLayout.CENTER);
// --- Dimensionnement de la fenêtre
setSize(ic_sandra.getIconWidth() + 20 , ic_sandra.getIconHeight() + 50);
this.setVisible(true);
}
}
Commentaires
Dans ce script l'unique nouveauté est l'affectation d'une image à un JLabel au moyen de la méthode setIcon(icône).
La fenêtre est construite à partir de deux panneaux : un pour les boutons et un autre pour le label contenant l'icône.
La fenêtre est redimensionnée en fonction de la hauteur et de la largeur de l'icône.
La méthode validate() actualise complètement le redimensionnement.
lbl_image.setIcon(ic_sandra);
setSize(ic_sandra.getIconWidth() + 20 , ic_sandra.getIconHeight() + 50); validate();
Les imageIcon et les listes (JList)
Objectif
L'utilisateur clique sur un item de la liste et la photo correspondante s'affiche ainsi que sa description.
Les listes
Une JList est une interface graphique pour présenter une liste de valeurs.
JListConstructeur
JList()
JList(objet)
JList(Vecteur)
Constructeur vide
Construction avec un tableau
Construction avec un vecteurMéthodes
setListData(objet | vector)
setSelectionMode(int)
int = getSelectionMode()
setDragEnabled(booléen)
setSelectedIndex(index)
int = getSelectedIndex()
setSelectedIndices(index[])
int[] = getSelectedIndices()
setSelectedValue(objet, shouldScroll)
objet = getSelectedValue()
objet[] = getSelectedValues()
setVisibleRowCount(int)
booléen = isSelectedIndex(index)
booléen = isSelectionEmpty()
Affecte un tableau ou un vecteur à la liste
Définit le mode de sélection (cf Notes)
Renvoie le mode de sélection
Définit le mode Drag & Drop
Définit une sélection
Renvoie l'index de l'item sélectionné
Définit plusieurs sélections
Renvoie les sélections
Sélectionne une valeur
Renvoie la valeur sélectionnée
Renvoie les valeurs sélectionnées
Définit le nombre d'items visibles
Renvoie vrai si l'item indice index est sélectionné
Renvoie vrai si aucune sélection n'est faite
Notes :
ListSelectionMode.SINGLE_SELECTION
ListSelectionMode.SINGLE_INTERVAL_SELECTION
ListSelectionMode.MULTIPLE_INTERVAL_SELECTION
Script
// --- Une liste propose les images un bouton et l'image change
import javax.swing.*; // Pour JFrame, ImageIcon ...
import java.awt.event.*; // Pour les listeners
import java.awt.*; // Pour le Container
// -----------------------------------
public class IconeListe extends JFrame
// -----------------------------------
{
JList lb_images = new JList();
JScrollPane jsp_liste;
ImageIcon ic_icone;
JLabel lbl_image = new JLabel();
JLabel lbl_description = new JLabel();
String lsImage;
String lsDescription;
String[] lsItems = {"Sandra", "Julia1", "Julia2", "Julia3","Julia4"};
String[] lsFichiers = {"sandra2.jpg","julia1.jpg", "julia2.jpg", "julia3.jpg", "julia4.jpg"};
int liImage;
public IconeListe() // --- Le constructeur doit être public
{
super("Mission impossible - Icone_7");
// --- Les listeners ---
Container c = getContentPane();
lb_images.setListData(lsItems);
lb_images.setVisibleRowCount(3);
jsp_liste = new JScrollPane(lb_images);
// --------------- Le listener -----------------
MouseListener mouseListener = new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
liImage = lb_images.getSelectedIndex();
affichage(liImage);
}
};
lb_images.addMouseListener(mouseListener);
// --- Chargement de l'image
affichage(1);
// --- Ajout des composants
c.add(jsp_liste, BorderLayout.NORTH);
c.add(lbl_image, BorderLayout.CENTER);
c.add(lbl_description, BorderLayout.SOUTH);
// --- Dimensionnement et affichage de la fenêtre
this.setSize(300,500);
this.setVisible(true);
}
// -------------------------------
public void affichage(int aiIndex)
{
lsImage = "c:\\pascal\\cine_jpg\\" + lsFichiers[aiIndex];
lsDescription = lsItems[aiIndex];
ic_icone = new ImageIcon(lsImage, lsDescription );
lbl_image.setIcon(ic_icone);
lbl_description.setText(ic_icone.getDescription());
}
}
Commentaires
On déclare une liste
JList lb_images;
On déclare un tableau de chaînes de caractères pour les descriptions
String[] lsItems = {"Sandra", "Julia1", "Julia2", "Julia3","Julia4"};
On déclare un tableau de chaînes de caractères pour les noms des fichiers
String[] lsFichiers = {"sandra2.jpg","julia1.jpg", "julia2.jpg", "julia3.jpg", "julia4.jpg"};
On crée une liste et on ajoute des éléments à cette liste (un tableau)
lb_images = new JList();
lb_images.setListData(lsItems);
On déclare une barre de défilement (c'est un container)
JScrollPane jsp_liste;
On crée (on associe) la barre de défilement à la liste
jsp_liste = new JScrollPane(lb_images);
On ajoute le container JScrollPane au panel (et pas la liste).
c.add(jsp_liste, BorderLayout.NORTH);
On récupère l'index de l'élément sélectionné de la liste
liImage = lb_images.getSelectedIndex();
On récupère le nom du fichier dans le premier tableau
lsImage = "c:\\pascal\\cine_jpg\\" + lsFichiers[aiIndex];
On récupère la description dans le deuxième tableau
lsDescription = lsItems[aiIndex];
lsImage = (String)lb_images.getSelectedValue();
On crée l'icône
ic_icone = new ImageIcon(lsImage, lsDescription);
Les images, le JComboBox et le JSlider
Fonctionnalité : Le zoomage d'images
La zone de liste combinée présente une liste de noms de fichiers image.
L'utilisateur en sélectionne une, celle-ci s'affiche.
Il peut ensuite la zoomer de 1% à 200%.
Zoom 50%Zoom 25%La JComboBox
JComboBoxConstructeur
JComboBox()
JComboBox(objets[])
JComboBox(Vecteur)
Constructeur vide
Constructeur avec un tableau d'objets
Constructeur avec un vecteurMéthodes
addItem(Objet)
Objet = getItemAt(index)
Int = getItemCount()
Int = getMaximumRowCount()
Int = getSelectedIndex()
Objet = getSelecteditem()
insertItemAt(objet)
removeAllItems()
removeItem(objet)
removeItemAt(index)
setSeletedIndex(index)
setSelectedItem(objet)
setMaximunRowCount()
Ajoute un item à la fin
Renvoie l'item de position index
Renvoie le nombre d'items
Renvoie le nombre maximum d'items affiché sans ascenseur
Renvoie le rang de l'item sélectionné
Renvoie l'item sélectionné
Insert un item à la position index
Supprime tous les items
Supprime l'item correspondant la valeur Objet
Supprime l'item de rang index
Sélectionne l'item de rang index
Sélectionne l'item de valeur Objet
Paramètre le nombre d'items visibles sans ascenseur
Le JSlider
JSliderConstructeur
JSlider ()
JSlider([orientation, Min, Max , Valeur])
Constructeur vide
Constructeur avec orientation (SwingConstants.VERTICAL ou SwingConstants.HORIZONTAL), valeur minimum, valeur maximum et valeur de départ Méthodes
setMinimumValue(int)
setMaximumValue(int)
setValue(int)
setOrientation(orientation)
setMajorTickSpacing(int)
setPaintTicks(booléen)
setPaintTrack(booléen)
+ les méthodes getXXX correspondantes
Définit la valeur minimum
Définit la valeur maximum
Définit la valeur actuelle
Définit l'orientation (cf plus haut)
Définit l'espace de graduation
Définit si le curseur est gradué
Renvoient les différents valeurs ou états
Les images
ImageConstructeur
Image ()
Constructeur videMéthodes
flush()
graphics = getGraphics()
int = getHeight(observateur)
int = getWidth(observateur)
ImageProducer = getSource()
Vidange les ressources utilisées par l'image et l'image se retrouve dans son état au moment de la création.
Crée un contexte graphique
Renvoie la hauteur
Renvoie la largeur
Renvoie le producteur de pixels
Autres classes ou méthodes utilisées
MediaTracker : classe du package AWT. La classe MediaTracker est une classe de service qui permet de dépister le statut des objets de type media (Images, clips sonores,
).
getToolKit() : méthode de la classe Component qui renvoie un ToolKit.
getImage() : méthode de la classe ToolKit qui renvoie une image - à partir d'un fichier JPEG, GIF ou PNG par exemple.
Les scripts
Le composant image
import javax.swing.*; // Pour Jpanel ,.....
import java.awt.*; // Pour Image
// ----------------------------------------
public class JComposantImage extends JPanel
// ----------------------------------------
{
private int iiLargeur, iiHauteur;
private float ifLargeur, ifHauteur;
private float ifLargeurDepart, ifHauteurDepart;
public Image imImage;
MediaTracker mt;
// ------------------- Constructeur
public JComposantImage(String asFichier)
{
charger(asFichier);
}
// ----------------------- Dessin de bas niveau
public void paintComponent(Graphics g)
{
super.paintComponent(g);
g.drawImage(imImage,30,30,iiLargeur,iiHauteur,this);
}
// ---------------- Création
public void charger(String asFichier)
{
imImage = getToolkit().getImage(asFichier);
// --- La suite (le mt) est indispensable autrement ça affiche l'image en boucle !!! Très consommateur
mt = new MediaTracker(this); // Surveille le chargement ou la création intégrale de l'image
mt.addImage(imImage,0); // Liaison mt à image
try
{
mt.waitForAll(); // Attente pour chargement d'image
}
catch (InterruptedException e)
{
/* Ne rien faire : attendre */
}
ifHauteurDepart = imImage.getHeight(this);
ifLargeurDepart = imImage.getWidth(this);
dessiner(100);
}
// ------------------------------ Dessin
public void dessiner(int ai_zoom)
{
ifLargeur = (ifLargeurDepart/100) * ai_zoom;
ifHauteur = (ifHauteurDepart/100) * ai_zoom;
iiLargeur = (int)ifLargeur;
iiHauteur = (int)ifHauteur;
repaint(); // Appel paintComponent
}
}
L'utilisateur du composant
import javax.swing.*;
import javax.swing.event.*; // Pour ChangeListener
import java.awt.*;
import java.awt.event.*;
// ----------------------------------
public class ImageZoom extends JFrame
// ----------------------------------
{
private JComboBox cbx_photos;
private JSlider curseur_zoom;
private JComposantImage cim_julia;
private int liZoom;
Container c;
public ImageZoom() // --- Le constructeur doit être public
{
super("Zoom, Slider et Combo - Image8");
c = getContentPane();
// --- L'image
cim_julia = new JComposantImage("c:\\pascal\\cine_jpg\\julia1.jpg");
cim_julia.setBackground(Color.cyan);
// --- Le SLider (Orientation, Min, Max, Pos)
curseur_zoom = new JSlider(SwingConstants.HORIZONTAL, 1 ,200, 100);
curseur_zoom.addChangeListener(new ChangeListener()
{
public void stateChanged(ChangeEvent e)
{
liZoom = curseur_zoom.getValue();
cim_julia.dessiner(liZoom);
}
});
// --- La liste et ses événements
cbx_photos = new JComboBox();
cbx_photos.addActionListener(new ActionListener()
{
String lsFichier;
public void actionPerformed(ActionEvent e)
{
lsFichier = (String)cbx_photos.getSelectedItem();
cim_julia.charger(lsFichier);
curseur_zoom.setValue(100);
}
});
cbx_photos.setMaximumRowCount(5);
cbx_photos.addItem("c:\\pascal\\cine_jpg\\julia1.jpg");
cbx_photos.addItem("c:\\pascal\\cine_jpg\\julia2.jpg");
// --- L'ajout des composants
c.add(cbx_photos, BorderLayout.NORTH);
c.add(cim_julia , BorderLayout.CENTER);
c.add(curseur_zoom, BorderLayout.SOUTH);
this.setSize(450,380);
this.setVisible(true);
}
}
Commentaires
Le JComposantImage
La classe dérive de la classe JPanel.
Le constructeur appelle la méthode charger()
Cette méthode crée l'image au moyen de la méthode getImage() de la classe MediaTracker.
Les dimensions de l'image sont récupérées et l'image sera dessinée avec un zoom 100% par un appel à la méthode dessiner().
La méthode dessiner(), qui reçoit comme paramètre le facteur de zoomage, calcule les nouvelles dimensions de l'image et appelle la méthode java paintComponent().
La méthode dessiner() est appelée aussi bien à la création qu'en exécution lorsque l'utilisateur manipulera le slider.
La classe Image_8
La fenêtre est décomposée en trois parties. Un panneau sera le réceptacle de l'image. Les deux autres panneaux recevront la JComboBox et le JSlider.
On ajoute à la JComboBox un écouteur pour la sélection d'un élément; sur cet événement on appelle la méthode charger() du composant.
On ajoute au JSlider un écouteur pour modifier la taille de l'image; sur cet événement on appelle la méthode dessiner() du composant.
Visualiser une table SQL dans des JTextField
Objectif
Créer une interface graphique avec deux JLabels, deux TextFields et quatre JButtons pour visualiser les enregistrements de la table Genres(code_genre, libelle_genre).
Les quatre boutons permettent de se positionner sur le premier, le précédent, le suivant et le dernier enregistrement.
C'est sur l'événement clic du bouton que l'on va appeler la procédure positionnement(aiBouton) en passant un paramètre : le rang du bouton; il s'agit d'un numéro arbitraire.
Les boutons sont activés et désactivés selon le contexte.
C'est dans une procédure affichageChamps() qu'est géré l'affichage des champs, l'activation et la désactivation des boutons.
La connexion à la BD est faite au préalable, c'est un argument du constructeur de la fenêtre, avec la méthode seConnecter() de la classe BD.
La création du curseur est faite avec la méthode getCurseur() de la classe Curseur.
Rappel sur quelques méthodes en rapport avec les BD.
MéthodesDescriptionClass.forName("org.gjt.mm.mysql.Driver")Spécification du piloteConnection = DriverManager.getConnection("jdbc:mysql://localhost/cours", user, pwd)Connexionstatement = connection.createStatement(Sens, Lecture-écriture)Création d'un ordre SQLRs = statement.executeQuery("SELECT SQL") Création d'un curseurRs.first()Premier enregistrementRs.previous()Enregistrement précédentRs.next()Enregistrement suivantRs.last()Dernier enregistrementBooléen = Rs.isFirst()Premier enregistrement ?Booléen = Rs.isLast()Dernier enregistrement ?String = Rs.getString(colonne)Renvoie la valeur texte de la colonneRs.close()Ferme un curseurStatement.close()Ferme un ordre SQLConnection.close()Ferme une connexion
Les bibliothèques du projet.
EMBED MSPhotoEd.3
Script
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.sql.*;
import packageBD.BD;
// -----------------------------------
public class GenresVisu extends JFrame
// -----------------------------------
{
// --- Déclaration et Création du panneau
JPanel panneau = new JPanel();
// --- Déclaration et création des labels
JLabel lblCodeGenre = new JLabel("Code genre");
JLabel lblLibelleGenre = new JLabel("Libelle genre");
// --- Déclaration et création des TextField
JTextField tfCodeGenre = new JTextField("",2);
JTextField tfLibelleGenre = new JTextField("",20);
// --- Déclaration et création des boutons
JButton cbPremier = new JButton("");
// --- Les variables SQL
ResultSet iRs = null;
// -----------------------------
public GenresVisu(ResultSet aRs)
// -----------------------------
{
super();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
// --- Ajout des événements de fenêtres
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
try
{
iRs.close();
System.out.println("Fermeture");
}
catch(SQLException erreur)
{
System.err.println("\nErreur SQL:" + erreur);
}
}
} );
// --- Ajout des événements de boutons
ActionListener al = new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if(e.getSource()==cbPremier) positionnement(1);
if(e.getSource()==cbPrecedent) positionnement(2);
if(e.getSource()==cbSuivant) positionnement(3);
if(e.getSource()==cbDernier) positionnement(4);
}
};
cbPremier.addActionListener(al);
cbPrecedent.addActionListener(al);
cbSuivant.addActionListener(al);
cbDernier.addActionListener(al);
// --- Définition de l'agencement dans le panneau
panneau.setLayout(new GridLayout(2,4));
// --- Ajout d'éléments au panneau
panneau.add(lblCodeGenre);
panneau.add(tfCodeGenre);
panneau.add(lblLibelleGenre);
panneau.add(tfLibelleGenre);
panneau.add(cbPremier);
panneau.add(cbPrecedent);
panneau.add(cbSuivant);
panneau.add(cbDernier);
// --- "Affichage du panneau"
setContentPane(panneau);
setTitle("Visu Genres");
setSize(400,100);
iRs = aRs;
setVisible(true);
positionnement(1);
}
// --- Procédures de manipulation de curseur
// --------------------------------------
private void positionnement(int aiBouton)
// --------------------------------------
{
try
{
switch (aiBouton)
{
case 1 : iRs.first() ; break;
case 2 : iRs.previous(); break;
case 3 : iRs.next() ; break;
case 4 : iRs.last() ; break;
}
afficherChamps();
}
catch(SQLException erreur) { System.err.println(erreur); }
}
// --------------------------
private void afficherChamps()
// --------------------------
{
try
{
tfCodeGenre.setText(iRs.getString(1));
tfLibelleGenre.setText(iRs.getString(2));
// && ET logique; || OU logique; ! NON logique
cbPremier.setEnabled(!iRs.isFirst());
cbPrecedent.setEnabled(!iRs.isFirst());
cbSuivant.setEnabled(!iRs.isLast());
cbDernier.setEnabled(!iRs.isLast());
}
catch(SQLException erreur) { System.err.println(erreur); }
}
// -----------------------------------
public static void main(String[] args)
// -----------------------------------
{
BD bd = new BD();
bd.seConnecter("cours", "root", "", "mysql");
new GenresVisu(bd.getCurseur("SELECT * FROM genres"));
}
}
Commentaires
L'ajout des écouteurs sur les boutons de commande et l'appel de la procédure de positionnement dans le curseur
On crée une instance de listener (ActionListener). A l'intérieur de celle-ci on teste l'origine de l'action et on oriente vers la procédure en passant comme paramètre le numéro du bouton.
// --- Ajout des événements de boutons
ActionListener al = new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if(e.getSource() == cbPremier) positionnement(1);
if(e.getSource() == cbPrecedent) positionnement(2);
if(e.getSource() == cbSuivant) positionnement(3);
if(e.getSource() == cbDernier) positionnement(4);
}
};
cbPremier.addActionListener(al);
//
Le positionnement dans le curseur
On utilise les méthodes de déplacement dans les curseurs (first(),previous(),next() et last() ).
Puis on affiche en appelant la procédure afficherChamps
switch (aiBouton)
{
case 1 : iRs.first() ; break;
case 2 : iRs.previous(); break;
case 3 : iRs.next() ; break;
case 4 : iRs.last() ; break;
}
afficherChamps();
Affichage des valeurs
On utilise les méthodes getXXX d'un objet curseur ici en l'occurrence la méthode getString(numéro de colonne).
La gestion des boutons
Les boutons sont activés et désactivés en fonction du retour des méthodes isLast() et isFirst().
Exercice
Ajoutez un compteur pour afficher [position actuelle/nombre d'enregistrements].
La JDialog pour des inserts dépendants
Présentation
La JDialog hérite de la classe Dialog du package AWT.
Elle permet de créer des boîtes de dialogue modales ou non.
JDialogConstructeur
JDialog()
JDialog(JFrame Propriétaire, Booléen Modale, String Titre)
Constructeur vide.
Constructeur avec le maximum de paramètres (Il existe de multiple constructeurs combinant les différentes possibilités).Méthodes
super(parent, titre, modale)
dialogInit()
setContentpane(Container)
Container = GetContentPane()
SetJMenuBar(JMenuBar)
JMenuBar = getJMenuBar()
setLayout(Layout)
Layout = getLayout()
Appelé dans le constructeur pour initialiser les propriétés de la JDialog.
Exemple
La fenêtre appelanteLa JDialog appelée
L'utilisateur saisit une nouvelle ville. Si le département correspondant n'existe pas la boîte de dialogue "Nouveau Département" est ouverte avec le code département saisi dans la précédente.
Lorsque l'utilisateur clique sur le bouton OK de la JDialog, les données sont insérées dans la base et la fenêtre est fermée. Le code saisi dans cette fenêtre est réaffecté dans la fenêtre Nouvelle ville.
Le passage de paramètre se fera au moyen d'une classe Globale - comportant deux méthodes getStringParm() et setStringParm().
Remarques :
La présentation des départements peut être faite au moyen d'une zone de liste déroulante.
La transmission du département (à l'aller) peut être faite par le passage d'argument au constructeur.
Script
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.sql.*;
public class DlgNouveauDepartement extends JDialog
{
// --- Déclarations des composants
// --- Placez ici le code de déclaration des composants (JLabels, JButtons,
)
// --- Les variables SQL
Connection icConnexion;
String isCodeDepartement;
public DlgNouveauDepartement(Frame afParent,String asTitre, boolean abModal, Connection acConnexion)
{
// --- Il faut et Super() et dialogInit()
super(afParent, asTitre, abModal);
// --- Nécessaire pour initialiser les propriétés. Est appelée par le(s) contructeurs
dialogInit();
icConnexion = acConnexion;
// --- Récupération du paramètre passé via ClsGlobale
tf_code_departement.setText(Globale.getStringParm());
ajouterListeners();
ajouterElements();
}
// ----------------------------
private void ajouterListeners()
// ----------------------------
{
//Placez ici le code d'ajout des listeners
}
// ---------------------------
private void ajouterElements()
// ---------------------------
{
//Placez ici le code d'ajout des composants et d'affichage de la fenêtre
}
// -------------------
private void annuler()
// -------------------
{
// --- Retour avec chaîne vide
Globale.setStringParm("");
this.setVisible(false);
this.dispose();
}
// -------------------
private void valider()
// -------------------
{
Statement lstInsertDept = null;
String sInsert, lsCd, lsNd;
try
{
// --- Récupération des valeurs saisies
lsCd = tf_code_departement.getText();
lsNd = tf_nom_departement.getText();
// --- Formation de l'ordre SQL insert
lsInsert = "INSERT INTO departements(code_departement, nom_departement) VALUES('" + lsCd + "','" + lsNd + "')";
// --- Insertion dans la BD
lstInsertDept = icConnexion.createStatement();
lstInsertDept.executeUpdate(lsInsert);
// --- Préparation pour le retour de la valeur
Globale.setStringParm(lsCd);
// --- Fermeture
this.setVisible(false);
this.dispose();
}
catch(SQLException erreur)
{
// --- Récupération de l'erreur dans la fenêtre
tf_nom_departement.setText(erreur.toString());
}
}
}
Classe Globale
Permet de traiter des variables globales pour faire des transferts d'une fenêtre à une autre fenêtre, ceci grâce à une variable statique.
GlobaleisChaineVoid setStringParm(String)
String getStringParm()
// -----------------
public class Globale
// -----------------
{
private static String isChaine = null;
public static String getStringParm()
{
return isChaine;
}
public static void setStringParm(String asChaine)
{
isChaine = asChaine;
}
}
Commentaires
Ouverture
La boîte dialogue est ouverte avec un passage de trois paramètres :
Le propriétaire la fenêtre Nouvelle Ville -,
Le titre,
Le mode (Modal ou non).
Ces trois paramètres sont transmis à la méthode super().
Un autre paramètre est passé : c'est la connexion.
La méthode dialogInit() est sollicitée.
On récupère à partir de la "variable globale" la valeur du code_departement et on l'affecte au composant de la fenêtre
tf_code_departement.setText(Globale.getStringParm());
Plutôt que de solliciter la "variable globale" nous aurions pu passer un cinquième paramètre.
Fermeture
L'utilisateur clique sur Annuler ou OK.
Dans les deux cas la fenêtre est fermée et la valeur du code est passée via la classe ClsGlobale comme à l'ouverture.
Sur le bouton OK l'ordre SQL Insert est exécuté.
Script de la fenêtre appelante
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.sql.*;
pubic class WNouvelleVille extends JFrame
{
//Placez ici le code de déclaration des composants (JLabels, JButtons,
)
// --- Les variables SQL
ResultSet iRs = null;
Connection icConnexion;
// ------------------------------------------- Le constructeur
public WNouvelleVille(Connection acConnexion)
// ------------------------------------------
{
super("Nouvelle Ville");
icConnexion = acConnexion;
ajouterListeners();
ajouterElements();
setVisible(true);
pack();
}
// ----------------------------
private void ajouterListeners()
// ----------------------------
{
// --- Placez ici le code d'ajout des listeners de niveau fenêtre et de niveau composant
// ---- Evénements de focus dans un TextField
FocusAdapter fa_tf = new FocusAdapter()
{
public void focusLost(FocusEvent e) { test_code_departement(); }
};
tf_code_departement.addFocusListener(fa_tf);
}
// ---------------------------
private void ajouterElements()
// ---------------------------
{
// --- Ajoutez ici le code d'ajout des composants et d'affichage de la fenêtre
}
// -------------------
private void annuler()
// -------------------
{
this.setVisible(false);
this.dispose();
}
// -------------------
private void valider()
// -------------------
{
Statement lst;
String lsCv, lsNv, lsCd, lsInsert;
try
{
lsCv = tf_code_ville.getText();
lsNv = tf_nom_ville.getText();
lsCd = tf_code_departement.getText();
lsInsert = "INSERT INTO villes(cp, ville, code_departement) ";
lsInsert += " VALUES('" + lsCv + "','" + lsNv + "','" + lsCd + "')";
lst = icConnexion.createStatement();
lst.execute(lsInsert);
icConnexion.commit();
this.hide();
this.dispose();
}
catch(SQLException erreur)
{
lbl_message_erreur.setText(erreur.toString());
}
}
// ---------------------------------
private void test_code_departement()
// ---------------------------------
{
String lsCodeDepartement;
Statement lst;
ResultSet lrs;
int liCount;
lsCodeDepartement = tf_code_departement.getText();
try
{
lst = icConnexion.createStatement();
lrs = lst.executeQuery("SELECT COUNT(code_departement) FROM departements WHERE code_departement ='" + lsCodeDepartement + "'");
lrs.next();
liCount = lrs.getInt(1);
if (liCount == 0)
{
Globale.setStringParm(lsCodeDepartement);
DlgNouveauDepartement ldlgNouveauDepartement = new DlgNouveauDepartement(this,"Nouveau Département",true,icConnexion);
// --- Le retour de la valeur du code_departement
tf_code_departement.setText(Globale.getStringParm());
}
}
catch(SQLException erreur)
{
System.err.println(erreur);
}
}
}
Commentaires
Gestion de l'événement "Perte de Focus"
Créer dynamiquement les composants d'une fenêtre : la FreeForm de visualisation d'une table BD
Objectif
L'objectif est de créer une fenêtre générique, relativement simple de structure, qui pourra permettre de manipuler n'importe quelle table ou n'importe quel ordre SELECT de n'importe quelle BD.
Dans l'exemple qui est proposé ici, la manipulation de la table ou du SELECT est réduite à la navigation du curseur.
Principe
Nous avons 4 JPanels : un panneau général et à l'intérieur un pour les champs, un autre pour les boutons et un dernier pour le label message.
Le principe de base utilisé ici est que la création dynamique des JLabels et des JTextFields est dépendante de la structure du curseur.
Il faut donc récupérer cette structure grâce à la méthode getMetaData applicable à un ResultSet.
Le nombre de colonnes du ResultSetMetaData donnera le nombre de lignes du GridLayout du panneau de champs et le nombre d'étiquettes et de zones de texte à créer dans ce panneau.
Nous créons les JLabels et les JTextFields grâce à deux tableaux de JLabels et de JTextFields.
Pour l'affichage des données du curseur nous réutilisons le tableau de JTextField.
Vous noterez le décalage entre l'indice des éléments du curseur (Début à 1) et l'indice des éléments du tableau de composants (Début à 0).
Ecrans
Les deux écrans qui suivent sont générés à partir du même code. Ce qui diffère c'est le curseur qui est envoyé comme paramètre.
Script
package packageSQL;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.sql.*;
// ----------------------------------------
public class FFGeneriqueRead extends JFrame
// ----------------------------------------
{
// --- Ces composants d'interface
JPanel panneauGeneral = new JPanel();
JPanel panneauChamps = new JPanel();
JPanel panneauBoutons = new JPanel();
JPanel panneauMessage = new JPanel();
JButton cbPremier = new JButton("");
JLabel lblMessage = new JLabel("Message");
JLabel[] iaLabels;
JTextField[] iaTextFields;
// --- Variables SQL
ResultSet iRs;
String isCount;
int iiCountColonnes;
// --- Le constructeur --------------
public FFGeneriqueRead(ResultSet aRs)
// ----------------------------------
{
super("Visualisation");
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
this.setIconImage(new ImageIcon("icon.gif").getImage());
iRs = aRs;
ajouterListeners();
panneauBoutons.add(cbPremier);
panneauBoutons.add(cbPrecedent);
panneauBoutons.add(cbSuivant);
panneauBoutons.add(cbDernier);
panneauMessage.add(lblMessage);
panneauBoutons.setLayout(new GridLayout(1,4));
panneauGeneral.setLayout(new BorderLayout());
genererChamps();
this.panneauGeneral.add(panneauChamps,BorderLayout.NORTH);
this.panneauGeneral.add(panneauBoutons,BorderLayout.CENTER);
this.panneauGeneral.add(panneauMessage,BorderLayout.SOUTH);
this.setContentPane(panneauGeneral);
this.pack();
this.validate();
this.setVisible(true);
// --- Pour sortir de l'application lorsque l'on ferme la fenêtre
this.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
// --- Récupération du nombre d'enregistrements et affichage du premier
try
{
iRs.last();
isCount = Integer.toString(iRs.getRow());
iRs.first();
afficherChamps();
}
catch(SQLException e)
{
lblMessage.setText(e.getMessage());
}
} // --- FIN du constructeur
// ----------------------------
private void ajouterListeners()
// ----------------------------
{
// --- Ajout des événements des boutons
ActionListener alCB = new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
try
{
if(e.getSource()==cbPremier) {iRs.first();afficherChamps();}
if(e.getSource()==cbPrecedent) {iRs.previous();afficherChamps();}
if(e.getSource()==cbSuivant) {iRs.next();afficherChamps();}
if(e.getSource()==cbDernier) {iRs.last();afficherChamps();}
}
catch(SQLException err) { lblMessage.setText(err.getMessage()); }
}
};
cbPremier.addActionListener(alCB);
cbPrecedent.addActionListener(alCB);
cbSuivant.addActionListener(alCB);
cbDernier.addActionListener(alCB);
} // --- FIN ajouterListerners
// -------------------------
private void genererChamps()
// -------------------------
{
ResultSetMetaData lrsmd;
panneauChamps.setLayout(new GridLayout(0,2));
// --- Les en-têtes de colonnes et les champs
try
{
lrsmd = iRs.getMetaData();
iiCountColonnes = lrsmd.getColumnCount();
iaLabels = new JLabel[iiCountColonnes];
iaTextFields = new JTextField[iiCountColonnes];
for(int i=0; i Fixe; 0 --> Variable
gbContrainte.weighty = gwy; // = 0 --> Fixe; 0 --> Variable
gbContrainte.fill = gfill;
}
// ----------------------------
private void ajouterListeners()
// ----------------------------
{
iw_diaporama_creation.addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
sl_photo.addChangeListener(new ChangeListener()
{
public void stateChanged(ChangeEvent e)
{
int liZoom = sl_photo.getValue();
imPhoto.dessiner(liZoom);
}
});
ActionListener al = new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if(e.getSource() == cb_select_photo)
{
// --- cf AWT
FileDialog fldgOuvrir = new FileDialog(iw_diaporama_creation,"Choisir JPG",FileDialog.LOAD);
fldgOuvrir.setDirectory(isChemin);
fldgOuvrir.setVisible(true);
tf_chemin.setText(fldgOuvrir.getDirectory() + fldgOuvrir.getFile());
}
if(e.getSource() == cb_voir_photo)
{
// lbl_photo.setIcon(new ImageIcon(tf_chemin.getText()));
sl_photo.setValue(100);
imPhoto.charger(tf_chemin.getText());
}
if(e.getSource() == cb_ajout_photo)
{
lb_prepa_fichier.add(tf_chemin.getText() );
}
if(e.getSource() == cb_ajout_commentaire)
{
lb_prepa_fichier.add(ta_commentaire.getText() );
}
if(e.getSource() == cb_valider)
{
// --- cf AWT
String lsLigne;
FileDialog fldgEnregistrer = new FileDialog(iw_diaporama_creation, "Enregistrer DIA", FileDialog.SAVE);
fldgEnregistrer.setDirectory(isChemin);
fldgEnregistrer.setFile(tf_nom_fichier.getText());
fldgEnregistrer.setVisible(true);
tf_nom_fichier.setText( fldgEnregistrer.getDirectory() + fldgEnregistrer.getFile());
try
{
String lsNomFichier = tf_nom_fichier.getText();
BufferedWriter bwOut = new BufferedWriter(new FileWriter(lsNomFichier));
int liCount = lb_prepa_fichier.getItemCount();
for(int i = 0; i < liCount; i++)
{
lsLigne = lb_prepa_fichier.getItem(i);
bwOut.write(lsLigne);
bwOut.newLine();
}
bwOut.close();
}
catch(IOException erreur)
{
System.out.println("Erreur : " + erreur);
}
}
}
};
cb_select_photo.addActionListener(al);
cb_voir_photo.addActionListener(al);
cb_ajout_photo.addActionListener(al);
cb_ajout_commentaire.addActionListener(al);
cb_valider.addActionListener(al);
}
// ------------------------------
// --- Constructeur de la fenêtre
// ------------------------------
public DiaporamaCreation(String asTitre)
{
super(asTitre);
iw_diaporama_creation = this;
// --- Définition de l'agencement
panneau.setLayout(gbTrace);
// --- Création de la contrainte
gbContrainte.insets = new Insets(2,2,2,2);
// ------------------------- 1 ème colonne
// ---- Contrainte, x, y, hauteur, largeur, poids x, poids y, extension remplissage
// --- Positionnement : ta commentaire
afficherElement(gbContrainte,0,0,1,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(cb_select_photo, gbContrainte);
// --- Positionnement : ta commentaire
afficherElement(gbContrainte,0,1,1,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(tf_chemin, gbContrainte);
// --- Positionnement : cb_voir_photo
afficherElement(gbContrainte,0,2,1,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(cb_voir_photo , gbContrainte);
// --- Positionnement : lbl_photo
imPhoto = new JComposantImage(isChemin + "sandra2.jpg");
afficherElement(gbContrainte,0,3,6,1,10,10,GridBagConstraints.BOTH );
gbTrace.setConstraints(imPhoto, gbContrainte);
// --- Positionnement : sl_photo
afficherElement(gbContrainte,0,9,1,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(sl_photo, gbContrainte);
// -------------------------2 ème colonne
// --- Positionnement : lbl_commentaire
afficherElement(gbContrainte,1,2,1,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(lbl_commentaire, gbContrainte);
// --- Positionnement : ta_commentaire
afficherElement(gbContrainte,1,3,3,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(jsp_ta_commentaire, gbContrainte);
// --- Positionnement : cb_ajout_photo
afficherElement(gbContrainte,1,6,1,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(cb_ajout_photo, gbContrainte);
// --- Positionnement : cb_ajout_commentaire
afficherElement(gbContrainte,1,7,1,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(cb_ajout_commentaire, gbContrainte);
// --- Positionnement : lbl_nom_fichier
afficherElement(gbContrainte,1,8,1,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(lbl_nom_fichier, gbContrainte);
// ------------------------- 3ème colonne
// --- Positionnement : lb_prepa_fichier
afficherElement(gbContrainte,2,0,6,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(jsp_lb_prepa_fichier, gbContrainte);
// --- Positionnement : tf_nom_fichier
afficherElement(gbContrainte,2,8,1,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(tf_nom_fichier, gbContrainte);
// --- Positionnement : cb_valider
afficherElement(gbContrainte,2,9,1,1,10,10,GridBagConstraints.HORIZONTAL );
gbTrace.setConstraints(cb_valider, gbContrainte);
// --- Ajout des éléments au panneau
panneau.add(cb_select_photo);
panneau.add(tf_chemin);
panneau.add(cb_voir_photo);
panneau.add(imPhoto);
panneau.add(sl_photo);
panneau.add(lbl_commentaire);
panneau.add(jsp_ta_commentaire);
panneau.add(cb_ajout_photo);
panneau.add(cb_ajout_commentaire);
panneau.add(lbl_nom_fichier);
panneau.add(jsp_lb_prepa_fichier);
panneau.add(tf_nom_fichier);
panneau.add(cb_valider);
this.setContentPane(panneau); // L'ajout du panneau à la Frame
ajouterListeners();
this.setVisible(true);
this.pack();
} // --- Fin du constructeur
} // --- Fin
TP intermédiaire : CRUD sur la table [produits]
Objectif
Gérer le CRUD sur une table BD.
L'interface est créée avec NetBeans.
A l'ouverture de la fenêtre la Combo et la grille sont remplies.
Pour ajouter il faut saisir dans les zones de saisie et valider. Un contrôle de surface est effectué.
Pour la suppression il faut sélectionner dans la liste et valider.
Pour la modification il faut sélectionner dans la liste, les valeurs s'affichent dans les zones de saisie, il faut modifier les valeurs puis valider.
La combo et la grille sont actualisées à chaque opération.
Notes : techniques utilisées :
JComboBox, JtextField, Jlabel, Jbutton, Jtable
Contrôle de surface : expressions régulières.
Concordance Combo et ArrayList.
Accès BD.
Scripts
Les imports
import packageBD.BD;
import java.util.*;
import java.sql.*;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
Les variables d'instances
BD iBd = null;
ResultSet iRs = null;
ArrayList ialIdProduits = null;
boolean ibAffiche = false;
String isSelectSQL = "";
// --- CONSTRUCTEUR ---
public TpCrudProduits()
// --------------------
{
super("CRUD Produits");
initComponents();
ialIdProduits = new ArrayList();
iBd = new BD();
iBd.seConnecter();
isSelectSQL = "SELECT id_produit, designation, prix FROM produits ORDER BY id_produit";
iRs = iBd.getCurseur(isSelectSQL);
try
{
while(iRs.next())
{
// --- Remplissage de la Combo
jComboBoxProduits.addItem(iRs.getString(2));
// --- Remplissage du tableau de clés
ialIdProduits.add(iRs.getString(1));
}
remplirGrille(iRs);
}
catch(SQLException e) {}
ibAffiche = true;
} // --- FIN CONSTRUCTEUR
// ------------------------------
private boolean controleSaisies()
// ------------------------------
{
boolean lbOk = true;
String lsDesignation = jTextFieldDesignation.getText();
String lsPrix = jTextFieldPrix.getText();
if(lsDesignation.trim().equals("")) lbOk = false;
if(!lsPrix.matches("^[0-9]{1,}[,]?[0-9]{1,}$")) lbOk = false;
return lbOk;
}
// ----------------------------
private void actualiserGrille()
// ----------------------------
{
viderGrille();
try
{
iRs.close();
}
catch(SQLException e) {}
iRs = iBd.getCurseur(isSelectSQL);
remplirGrille(iRs);
}
// -----------------------
private void viderGrille()
// -----------------------
{
DefaultTableModel dtm = (DefaultTableModel)jTableProduits.getModel();
int liLignes = dtm.getRowCount();
for(int i=liLignes-1; i>=0; i--)
{
dtm.removeRow(i);
}
} // --- FIN viderGrille
// -----------------------
private void remplirGrille(ResultSet aRs)
// -----------------------
{
Vector lvEntete = new Vector();
Vector lvLignes = new Vector();
Vector lvLigne = new Vector();
ResultSetMetaData lrsmd;
try
{
// --- Les en-têtes
lrsmd = aRs.getMetaData();
for(int i=1; i
