import java.awt.BorderLayout;
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;
import java.awt.Canvas;
import java.awt.Dimension;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.Color;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;

import Console.*;

public class PlacementBordure extends JFrame implements WindowListener,AdjustmentListener {
        Canvas dessin=new Canvas();
        JScrollBar slider1=new JScrollBar();
        JScrollBar slider2=new JScrollBar(0);
        JScrollBar slider3=new JScrollBar();
        JScrollBar slider4=new JScrollBar(0);
        JScrollPane panell;
        JPanel pane = new JPanel();
        JPanel paneHaut = new JPanel();
        JPanel paneBas = new JPanel();
        JPanel paneCentre = new JPanel();
        JPanel paneCentre2 = new JPanel();
        JPanel paneCentre3 = new JPanel();
        JPanel paneAjout = new JPanel();
       
        GridBagLayout gbl = new GridBagLayout();
        GridBagConstraints gbc = new GridBagConstraints();
        public PlacementBordure() {
        super("Projet M1");

        this.creerInterface();

        super.pack();

        super.setSize(500,500);
        super.setVisible(true);
    }
    public void creerInterface() {
        slider1.addAdjustmentListener(this);
        slider3.addAdjustmentListener(this);
        slider2.addAdjustmentListener(this);
        slider4.addAdjustmentListener(this);        

       
        JPanel pan = (JPanel)this.getContentPane();
        paneCentre.setBackground(Color.green);
        paneCentre2.setBackground(Color.blue);
        paneCentre3.setBackground(Color.red);
       
        JTextArea texte = new JTextArea("texte      ");
        JTextArea texte1 = new JTextArea("texte1       ");
        JTextArea texte2 = new JTextArea("texte2         ");
        texte.setPreferredSize(new Dimension(120, 120));
        pane.setLayout(new BorderLayout());
       
       
       
        paneAjout.setLayout(gbl);
        pane.add("Center",paneAjout);
       
        gbc.fill = gbc.NONE;
        gbc = paneCen(paneCentre,1);
        paneAjout.add(paneCentre,gbc);
        gbc = paneCen(paneCentre2,2);
        paneAjout.add(paneCentre2,gbc);       
        gbc = paneCen(paneCentre3,3);
        paneAjout.add(paneCentre3,gbc);       
       
       
        pane.add("South",slider2);
        pane.add("East",slider1);
        paneHaut.setLayout(new BorderLayout());
        paneHaut.add("Center",texte1);
        paneHaut.add("South",slider4);
        paneBas.setLayout(new BorderLayout());
        paneBas.add("Center",texte2);
        paneBas.add("East",slider3);
 //       panell = new JScrollPane(texte);
 
 //       panell.add(slider2);
 //       panell.createHorizontalScrollBar();
        //panell.setHorizontalScrollBar(slider2);
       
        BorderLayout gestionnaire = new BorderLayout();
        pan.setLayout(gestionnaire);
        pan.add(pane, BorderLayout.CENTER);
        pan.add(paneHaut, BorderLayout.NORTH);
        pan.add(paneBas, BorderLayout.WEST);
    }
   
    public GridBagConstraints paneCen(JPanel jp,int i){
        int gX,gY,gH,gW;
        System.out.println("1");
        gX = saisirInt();
        gY = saisirInt();
        gH = saisirInt();
        gW = saisirInt();
        System.out.println("5");
       
        GridBagConstraints c = new GridBagConstraints();
        c.gridx = gX;
        c.gridy = gY;
        c.gridheight = gH;
        c.gridwidth = gW;
        c.weightx = gH;
        c.weighty = gW;
        return c;
    }
   
        public void adjustmentValueChanged(AdjustmentEvent e){
                JScrollBar sb = (JScrollBar) e.getSource();
                if(sb == slider2){
                        slider4.setValue(slider2.getValue());
                }
                if(sb == slider4){
                        slider2.setValue(slider4.getValue());
                }              
                if(sb == slider1){
                        slider3.setValue(slider1.getValue());
                }
                if(sb == slider3){
                        slider1.setValue(slider3.getValue());
                }       
        }
       
    public static void main(String[] args) {
        PlacementBordure boite = new PlacementBordure();
    }

   
   
   
    public String saisirLigne(){
        try{
            BufferedReader entreeClavier = new BufferedReader(
                                           new InputStreamReader(System.in));
            return entreeClavier.readLine();
        }
        catch (IOException e) {
            return null;
        }
    }
    /**

     * La méthode verifNombre permet de vérifier la validité
 
     * des nombres saisis par l'utilisateur.

     * Il est possible de vérifier soit des entiers, soit des réels.

     * @param valeur représente la valeur saisie par l'opérateur.

     * @param type représente le type de nombres à vérifier.
 
     *  <ul>

     *  <li>La valeur 'reel' permet de tester les nombres réels,</li>

     *  <li>La valeur 'entier' permet de tester les nombres entiers.</li>

     * </ul>

     * @return retourne 'true' si la valeur testée est un nombre
 
     *          ou 'false' dans le cas contraire.

     */
    private boolean verifNombre(String valeur, String type) {
        String regexp;
        if(type.equals("entier"))
            regexp = "[+-]?[0-9]*";
        else
            regexp = "[+-]?[0-9]*[.Ee]?[+-]?[0-9]*";
        Pattern modele = Pattern.compile(regexp);
        Matcher correspondance = modele.matcher(valeur);
        if(valeur != null && !valeur.equals("") && correspondance.matches())
            return true;
        else
            return false;
    }
    /**

     * La méthode saisirLong permet de lire des nombres entiers
 
     * de type primitif 'long'.

     * @return retourne une valeur entière de type 'long'.

     *  Si la valeur saisie par l'opérateur excède les limites du type 'long'
 
     *  alors la valeur entière maximum ou minimum selon le cas est retournée.

     */
    public long saisirLong(){
        double nb = 0;
        String valeur = saisirLigne();
        if(verifNombre(valeur, "entier"))
            nb = Double.parseDouble(valeur);
        if(nb < Long.MAX_VALUE && nb > Long.MIN_VALUE)
            return Long.parseLong(valeur);
        else if(nb > 0)
            return Long.MAX_VALUE;
        else
            return Long.MIN_VALUE;
    }
    /**

     * La méthode saisirInt permet de lire des nombres entiers de type primitif 'int'.

     * @return retourne une valeur entière de type 'int'.

     *  Si la valeur saisie par l'opérateur excède les limites du type 'int'
 
     *  alors la valeur entière maximum ou minimum selon le cas est retournée.

     */
    public int saisirInt(){
        long valeur = saisirLong();
        if(valeur < Integer.MAX_VALUE && valeur > Integer.MIN_VALUE)
            return (int)valeur;
        else if(valeur > 0)
            return Integer.MAX_VALUE;
        else
            return Integer.MIN_VALUE;
    }   
        public void windowActivated(WindowEvent e)  {}
        public void windowDeactivated(WindowEvent e)  {}
        public void windowOpened(WindowEvent e)  {}
        public void windowIconified(WindowEvent e)  {}
        public void windowDeiconified(WindowEvent e) {}
        public void windowClosed(WindowEvent e) {}

        public void windowClosing(WindowEvent e){
                System.exit(0); 
        }
}