[JToolBar] qui disparait après déplacement

Hello !

J'ai besoin pour un projet d'avoir une "boite à outils" qui se ballade au
dessus de l'interface graphique générale. Après être parti sur plusieures
pistes, j'ai opté pour une JToolBar. La solution consistant à mettre la
boite à outils et l'interface générale sur le même niveau ne me
satisfaisait pas au niveau esthétique, j'ai donc tenté d'utiliser le
JLayeredPane de ma fenêtre principale, comme expliqué dans un tutoriel Sun.

Cela donne (voir plus loin pour le code):
- un JPanel appelé rootLayeredPane qui encpasule toute l'interface générale
et à qui l'on passe en argument le JLayeredPane de la fenêtre (on règle le
ContentPane sur ce rootLayeredPane)
- une JToolBar "boite à outils" que l'on place sur un des niveaux du
JLayeredPane de la fenêtre.

Problème 1)
J'obtiens exactement ce que je veux, mais dès que je déplace la JToolBar
elle se cache je ne sais où et impossible de la faire réapparaitre (j'ai
quasiment tout essayé).

Quelqu'un a-t-il déjà utilisé une boite à outils dans mon genre ? Dans ce
cas, comment a-t-il fait ?

Problème 2)
La solution d'une JToolBar ne me convient pas parfaitement : j'aurais
préféré avoir quelquechose qui ressemble à une vrai fenêtre et qui ne se
scotche pas à chaque coin de la fenêtre principale. Malheureusement,
impossible d'ajouter une JFrame ou JWindow à un conteneur. Je pense à deux
solutions : soit je sous-classe JPanel pour avoir un panneau qui se déplace
grâce à MouseDragged() et auquel je fais de jolies bordures ; soit je fous
toute mon interface graphique en JInternalFrame dans un JDesktopPane, mais
là bonjour la gestion du Layout !
Une idée ?

Merci d'avance pour vos conseils

--
Arnaud

voici le code (version archi-simplifiée) :

*********** Fichier FenêtrePrincipale.java ****************
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JLayeredPane;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JToolBar;

public class FenetrePrincipale extends JFrame {

/*---------------------------------------------------------------------
* Déclarations
*--------------------------------------------------------------------*/

// Divers
Dimension dimEcran = Toolkit.getDefaultToolkit().getScreenSize();
RootLayeredPane rootLayeredPane;

//Barre de menu
JMenuBar menuBar1 = new JMenuBar();
JMenu mnu1 = new JMenu("Fichier");
JMenuItem mnu1Item1 = new JMenuItem ("Ouvrir");
JMenuItem mnu1Item2 = new JMenuItem ("Fermer");
JMenu mnu2 = new JMenu("Outils");
JMenuItem mnu2Item1 = new JMenuItem ("Fenêtre SQL");
JMenu mnu3 = new JMenu("Aide");
JMenuItem mnu3Item1 = new JMenuItem ("A propos ...");



/*---------------------------------------------------------------------
* Constructeur :
* on délègue la construction de l'interface multicouches
* au RootLayeredPane qui manipule le JLayeredPane de la JFrame en cours
*--------------------------------------------------------------------*/

public FenetrePrincipale() {
// Construction du RootLayeredPane
// avec passage en argument du JLayeredPane de la JFrame en cours
rootLayeredPane = new RootLayeredPane(this.getLayeredPane());

// setOpaque (obligatoire pour le contentPane)
rootLayeredPane.setOpaque(true);

// Réglage du contentPane à rootLayeredPane
this.setContentPane(rootLayeredPane);

// Barre de menu
menuBar1.add(mnu1);
mnu1.add(mnu1Item1);
mnu1.add(mnu1Item2);
menuBar1.add(mnu2);
mnu2.add(mnu2Item1);
menuBar1.add(mnu3);
mnu3.add(mnu3Item1);
this.setJMenuBar(menuBar1);

// Allure générale : fenêtre plein écran, titre
this.setSize((int) dimEcran.getWidth(), (int) dimEcran.getHeight());
this.setTitle("Essai de fenêtre");

//Affichage
this.setVisible(true);
}

/*
* main
*
*/
public static void main(String[] args) {
new FenetrePrincipale();

}
}




/**---------------------------------------------------------------------
* Classe Interne : RootLayeredPane
* Prend en charge l'affichage multicouches
*---------------------------------------------------------------------*/


class RootLayeredPane extends JPanel {

/*---------------------------------------------------------------------
* Déclarations
*--------------------------------------------------------------------*/

// Divers
private JLayeredPane layeredPane;
JPanel pane = new JPanel();
private int compteurFormulaires = 0;
ToolBox toolBox = new ToolBox();

//Barre d'outils en haut
JToolBar toolBar1 = new JToolBar();
JButton button1 = new JButton("Bouton 1");
JButton button2 = new JButton("Bouton 2");
JButton button3 = new JButton("Bouton 3");

// Panneau de gauche
JPanel panneauGauche = new JPanel();
JLabel label1 = new JLabel("Panneau de gauche");

// Panneau à onglet du milieu
JTabbedPane panneauOnglet = new JTabbedPane();

// Panneau de droite
JPanel panneauDroite = new JPanel();
JLabel label2 = new JLabel("Panneau de droite");


// Barre d'état en bas
JLabel barreEtat = new JLabel("Aide contextuelle");


/*---------------------------------------------------------------------
* Constructeur
*--------------------------------------------------------------------*/

public RootLayeredPane (JLayeredPane layeredPane){
// Construction d'un JPanel avec un BorderLayout
super(new BorderLayout());

// Barre d'outils en haut
toolBar1.add(button1);
toolBar1.add(button2);
toolBar1.add(button3);
add(toolBar1, BorderLayout.NORTH);
toolBar1.setFloatable(false);

// Panneau de gauche
panneauGauche.add(label1);
add(new JScrollPane(panneauGauche), BorderLayout.WEST);

// Panneau à onglet du milieu
add(panneauOnglet, BorderLayout.CENTER);

// Panneau de droite
panneauDroite.add(label2);
add(panneauDroite, BorderLayout.EAST);

// Barre d'état en bas
add(barreEtat, BorderLayout.SOUTH);

// Récupération du JLayeredPane passé en argument (= celui de la JFrame)
this.layeredPane = layeredPane;

// Ajout de la toolBox
layeredPane.add(toolBox, JLayeredPane.PALETTE_LAYER, 0);
}
}

*********** Fichier ToolBox.java ****************
import java.awt.GridLayout;

import javax.swing.JToggleButton;
import javax.swing.JToolBar;


public class ToolBox extends JToolBar {

/*--------------------------------------------------------------------
* Déclarations
*-------------------------------------------------------------------*/
private JToggleButton toggle1, toggle2;


/*--------------------------------------------------------------------
* Constructeur
*-------------------------------------------------------------------*/
public ToolBox(){
// allure générale
setBounds(50, 50, 100, 400);

// Layout
setLayout(new GridLayout(4, 2, 10, 10));

// Boutons
toggle1 = new JToggleButton("Bouton 1");
toggle2 = new JToggleButton("Bouton 2");

// Ajout des boutons
add(toggle1);
add(toggle2);

// Boite à outils flotante
setFloatable(true);

// Affichage
setVisible(true);
}
}