PIbd-21_Bakalskaya_E.D._ElectricLocomotive._HARD/ProjectElectricLocomotive/FormLocomotiveConfig.java

package ProjectElectricLocomotive;

import javax.swing.*;
import java.awt.*;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.border.Border;
import java.awt.event.MouseListener;
import java.io.IOException;
import java.util.Random;

public class FormLocomotiveConfig{

    public DrawingLocomotive _loco;
    private JPanel MainPanel;
    private JPanel groupBoxObjectParameters;
    private JPanel groupBoxColors;
    private JSpinner numericUpDownSpeed;
    private JSpinner numericUpDownWeight;
    private JLabel labelSpeed;
    private JLabel labelWeight;
    private JCheckBox checkBoxHorns;
    private JCheckBox checkBoxSeifBatteries;
    public JLabel lableSimpleObject;
    private JLabel labelModifiedObject;
    public JButton buttonOk;
    private JButton buttonClose;
    private JLabel labelColor;
    private JLabel labelDopColor;
    public JComponent pictureBoxObject;
    private JPanel redPanel;
    private JPanel orangePanel;
    private JPanel yellowPanel;
    private JPanel ligthGreenPanel;
    private JPanel melissePanel;
    private JPanel ligthBluePanel;
    private JPanel bluePanel;
    private JPanel violetPanel;
    private JPanel panelBodyColor;
    private JPanel panelAdditionalColor;
    private JLabel labelWheels;
    public Canvas canvas;


    public JPanel getPictureBoxObject(){
        return MainPanel;
    }

//    MouseListener ml = new MouseListener() {
//        @Override
//        public void mouseClicked(MouseEvent e) {
//
//        }
//
//        @Override
//        public void mousePressed(MouseEvent e) {
//            JComponent jc = (JComponent)e.getSource();
//            TransferHandler th = jc.getTransferHandler();
//            th.exportAsDrag(jc, e, TransferHandler.COPY);
//        }
//
//        @Override
//        public void mouseReleased(MouseEvent e) {
//
//        }
//
//        @Override
//        public void mouseEntered(MouseEvent e) {
//
//        }
//
//        @Override
//        public void mouseExited(MouseEvent e) {
//
//        }
//    };

    private class Canvas extends JComponent{
        public Canvas(){
        }
        public void paintComponent (Graphics g){
            if (_loco == null){
                return;
            }
            super.paintComponents (g) ;
            Graphics2D g2d = (Graphics2D)g;
            _loco.DrawTransport(g2d);
            super.repaint();
        }
    }
    //класс для перетаскивания типа объекта
    private class LabelTransferHandler extends TransferHandler {
        @Override
        public int getSourceActions(JComponent c) {
            return TransferHandler.COPY;
        }

        @Override
        protected Transferable createTransferable(JComponent c) {
            return new StringSelection(((JLabel)c).getText());
        }
    }
    //что бы цвет можно было таскать
    private class ColorTransferable implements Transferable {
        private Color color;
        private static final DataFlavor colorDataFlavor = new DataFlavor(Color.class, "Color");

        public ColorTransferable(Color color) {
            this.color = color;
        }

        @Override
        public DataFlavor[] getTransferDataFlavors() {
            return new DataFlavor[]{colorDataFlavor};
        }

        @Override
        public boolean isDataFlavorSupported(DataFlavor flavor) {
            return colorDataFlavor.equals(flavor);
        }

        @Override
        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
            if (isDataFlavorSupported(flavor)) {
                return color;
            } else {
                throw new UnsupportedFlavorException(flavor);
            }
        }
    }
    //для перетаскивания цвета
    private class PanelTransferHandler extends TransferHandler {
        @Override
        public int getSourceActions(JComponent c) {
            return TransferHandler.COPY;
        }

        @Override
        protected Transferable createTransferable(JComponent c) {
            return new ColorTransferable(((JPanel)c).getBackground());
        }
    }
    //для обработки нажатий
    private class LabelMouseAdapter extends MouseAdapter {
        @Override
        public void mousePressed(MouseEvent e) {
            ((JLabel)e.getComponent()).getTransferHandler().exportAsDrag(((JLabel)e.getComponent()), e, TransferHandler.COPY);
        }
    }
    private class PanelMouseAdapter extends MouseAdapter{
        @Override
        public void mousePressed(MouseEvent e) {
            ((JPanel)e.getComponent()).getTransferHandler().exportAsDrag(((JPanel)e.getComponent()), e, TransferHandler.COPY);
        }
    }

    //что бы wheel'ы можно было тaскать
    private class WheelTransferable implements Transferable {
        private IDrawingWheels wheelDrawing;
        private static final DataFlavor wheelDrawingDataFlavor = new DataFlavor(IDrawingWheels.class, "Wheel Drawing");

        public WheelTransferable(IDrawingWheels wheelDrawing) {
            this.wheelDrawing = wheelDrawing;
        }

        @Override
        public DataFlavor[] getTransferDataFlavors() {
            return new DataFlavor[]{wheelDrawingDataFlavor};
        }

        @Override
        public boolean isDataFlavorSupported(DataFlavor flavor) {
            return flavor.equals(wheelDrawingDataFlavor);
        }

        @Override
        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
            if (isDataFlavorSupported(flavor)) {
                return wheelDrawing;
            } else {
                throw new UnsupportedFlavorException(flavor);
            }
        }
    }
    //для отрисовки wheel'ов, которые можно взять и потащить
    private class ComponentWheel extends JComponent {
        public IDrawingWheels wheelDrawing;

        public ComponentWheel(IDrawingWheels _wheelDrawing) {
            wheelDrawing = _wheelDrawing;
            this.addMouseListener(
                    new MouseAdapter() {
                        @Override
                        public void mousePressed(MouseEvent e) {
                            ((ComponentWheel) e.getComponent()).getTransferHandler().exportAsDrag(((ComponentWheel) e.getComponent()), e, TransferHandler.COPY);
                        }
                    }
            );
            this.setTransferHandler(
                    new TransferHandler() {
                        @Override
                        public int getSourceActions(JComponent c) {
                            return TransferHandler.COPY;
                        }

                        @Override
                        protected Transferable createTransferable(JComponent c) {
                            return new WheelTransferable(((ComponentWheel) c).wheelDrawing);
                        }
                    }
            );
        }
    }



    public FormLocomotiveConfig()
    {
        Border br = BorderFactory.createLineBorder(Color.BLACK);

        SpinnerModel numSpeed = new SpinnerNumberModel(100, 100, 1000, 1);
        numericUpDownSpeed = new JSpinner(numSpeed);

        SpinnerModel numWeight = new SpinnerNumberModel(100, 100, 1000, 1);
        numericUpDownWeight = new JSpinner(numWeight);

        lableSimpleObject.setTransferHandler(new LabelTransferHandler());
        lableSimpleObject.addMouseListener(new LabelMouseAdapter());
        lableSimpleObject.setBorder(br);

        labelModifiedObject.setTransferHandler(new LabelTransferHandler());
        labelModifiedObject.addMouseListener(new LabelMouseAdapter());
        labelModifiedObject.setBorder(br);

        labelWheels.setTransferHandler(new PanelTransferHandler());
        labelWheels.addMouseListener(new PanelMouseAdapter());
        labelWheels.setBorder(br);

        redPanel.setTransferHandler(new PanelTransferHandler());
        redPanel.addMouseListener(new PanelMouseAdapter());

        orangePanel.setTransferHandler(new PanelTransferHandler());
        orangePanel.addMouseListener(new PanelMouseAdapter());

        yellowPanel.setTransferHandler(new PanelTransferHandler());
        yellowPanel.addMouseListener(new PanelMouseAdapter());

        ligthGreenPanel.setTransferHandler(new PanelTransferHandler());
        ligthGreenPanel.addMouseListener(new PanelMouseAdapter());

        melissePanel.setTransferHandler(new PanelTransferHandler());
        melissePanel.addMouseListener(new PanelMouseAdapter());

        ligthBluePanel.setTransferHandler(new PanelTransferHandler());
        ligthBluePanel.addMouseListener(new PanelMouseAdapter());

        bluePanel.setTransferHandler(new PanelTransferHandler());
        bluePanel.addMouseListener(new PanelMouseAdapter());

        violetPanel.setTransferHandler(new PanelTransferHandler());
        violetPanel.addMouseListener(new PanelMouseAdapter());

        labelColor.setBorder(br);
        labelColor.setTransferHandler(
                new TransferHandler(){
                    @Override
                    public boolean canImport(TransferHandler.TransferSupport support)
                    {
                        try{
                            Color color = (Color) support.getTransferable().getTransferData(ColorTransferable.colorDataFlavor);
                            if(_loco == null) return false;
                            _loco.EntityLocomotive.SetBodyColor(color);

                            panelBodyColor.setBackground(color);

                            Border border = BorderFactory.createLineBorder(color);

                            labelColor.setBorder(border);
                            return true;
                        }
                        catch(UnsupportedFlavorException | IOException e){
                            e.printStackTrace();
                        }
                        return false;
                    }

                }
        );

        labelDopColor.setBorder(br);
        labelDopColor.setTransferHandler(
                new TransferHandler(){
                    @Override
                    public boolean canImport(TransferHandler.TransferSupport support)
                    {
                        try{
                            Color color = (Color) support.getTransferable().getTransferData(ColorTransferable.colorDataFlavor);
                            panelAdditionalColor.setBackground(color);
                            Border border = BorderFactory.createLineBorder(color);
                            labelDopColor.setBorder(border);
                            if(_loco == null) return false;
                            if(!(_loco instanceof DrawingLocomotive))
                                return false;
                            ((EntityElectricLocomotive)_loco.EntityLocomotive).SetAdditionalColor(color);
                            return true;
                        }
                        catch(UnsupportedFlavorException | IOException e){
                            e.printStackTrace();
                        }
                        return false;
                    }

                }
        );





        /*labelWheels.setBorder(br);
        labelWheels.setTransferHandler(
                new TransferHandler(){
                    @Override
                    public boolean canImport(TransferHandler.TransferSupport support) {
                        return support.isDataFlavorSupported(WheelTransferable.wheelDrawingDataFlavor);
                    }

                    @Override
                    public boolean importData(TransferHandler.TransferSupport support){
                        if(canImport(support)) {
                            try {
                                Random rnd = new Random();
                                IDrawingWheels wheels = (IDrawingWheels) support.getTransferable().getTransferData(WheelTransferable.wheelDrawingDataFlavor);
                                if (_loco == null) return false;

                                int wheelsChoice = rnd.nextInt(0, 3);

                                wheels.SetWheelsCount(rnd.nextInt(2, 5));

                                if (wheelsChoice == 0) {
                                    wheels = new DrawingWheel();
                                } else if (wheelsChoice == 1) {
                                    wheels = new DrawingEmptyWheels();
                                } else {
                                    wheels = new DrawingWheelsBlueCrom();
                                }
                                _loco._drawingWheels = wheels;
                                pictureBoxObject.repaint();
                                return true;
                            } catch (UnsupportedFlavorException | IOException e) {
                                e.printStackTrace();
                            }
                        }
                        return false;
                    }
                }
        );*/


        canvas = new Canvas();
        pictureBoxObject.setTransferHandler(
                new TransferHandler(){
                    @Override
                    public boolean canImport(TransferHandler.TransferSupport support) {
                        return support.isDataFlavorSupported(DataFlavor.stringFlavor);
                    }

                    @Override
                    public boolean importData(TransferHandler.TransferSupport support) {
                        if (canImport(support)) {
                            try {
                                Random rnd;
                                String data = (String) support.getTransferable().getTransferData(DataFlavor.stringFlavor);
                                switch (data) {
                                    case "Простой":
                                        _loco = new DrawingLocomotive(
                                                (int)numericUpDownSpeed.getValue(),
                                                (int)numericUpDownWeight.getValue(),
                                                Color.WHITE,/* (int)numericWheelNum.getValue(),*/ /*CanvasWidth,CanvasHeight*/
//                                                pictureBoxObject.getWidth(),
//                                                pictureBoxObject.getHeight()
                                                300,300
                                        );
                                        break;
                                    case "Сложный":
                                        _loco = new DrawingElectricLocomotive(
                                                (int)numericUpDownSpeed.getValue(),
                                                (int)numericUpDownWeight.getValue(),
                                                Color.WHITE, /*(int)numericWheelNum.getValue(),*/
                                                Color.BLACK,
                                                checkBoxHorns.isSelected(),
                                                checkBoxSeifBatteries.isSelected(), /*checkBoxLocoLine.isSelected(),*/
                                                pictureBoxObject.getWidth(),
                                                pictureBoxObject.getHeight()
                                        );
                                        break;
                                }
                                pictureBoxObject.repaint();
//                                Draw();
                                return true;
                            } catch (UnsupportedFlavorException | IOException e) {
                                e.printStackTrace();
                            }
                        }
                        return false;
                    }
                }
        );


    }
//        lableSimpleObject.addMouseListener(ml);
//        labelModifiedObject.setTransferHandler(new TransferHandler("rar"));

    public void Draw() {
        pictureBoxObject.repaint();
    }

    private void createUIComponents(){
        pictureBoxObject = new Canvas();
        pictureBoxObject.setBounds(new Rectangle(300, 300));
    }

}