package svgdevicestest.maps.SVG;

import art.client.models.ModelGUI.Icons;
import art.client.models.Shared;
import art.library.gui.FlatGUI;
import art.library.gui.flat.FlatButton;
import art.library.gui.flat.FlatMenu;
import art.library.gui.flat.FlatMenuItemCheck;
import art.library.gui.flat.FlatPopupMenu;
import art.library.model.devices.Device;
import art.library.utils.ArticJavaManagerCompiler;
import art.library.utils.ArticScalableVectorGraphics;
import static art.library.utils.ArticScalableVectorGraphics.setAttribute;
import static art.library.utils.ArticScalableVectorGraphics.getAttributeDouble;
import static art.library.utils.ArticScalableVectorGraphics.getAttributeString;
import static art.library.utils.ArticScalableVectorGraphics.getBoundingBox;
import static art.library.utils.ArticScalableVectorGraphics.getElementsWithAttribute;
import art.library.utils.ArticStrings;
import art.library.utils.resources.Resources;
import com.kitfox.svg.SVGDiagram;
import com.kitfox.svg.SVGElement;
import com.kitfox.svg.SVGUniverse;
import com.kitfox.svg.animation.AnimationElement;
import com.kitfox.svg.xml.StyleAttribute;
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JButton;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.Timer;



public class PanelScaleVectorGraphics extends JButton
{
    protected SVGDiagram diagram = null;
    protected FlatButton buttonMenu = null;
    protected FlatButton buttonTop = null;
    protected FlatButton buttonLeft = null;
    protected FlatButton buttonBottom = null;
    protected FlatButton buttonRight = null;
    protected FlatButton buttonCenter = null;
    protected FlatButton buttonMinus = null;
    protected FlatButton buttonPlus = null;

    private boolean lockNavigation = false;
    private boolean fitToPage = false;
    protected double scalex = 1.0;
    protected double scaley = 1.0;
    protected double translatex = 0.0;
    protected double translatey = 0.0;
    private boolean dragging = false;
    private double viewportx = 0;
    private double viewporty = 0;
    private double worldx = 0;
    private double worldy = 0;
    private double worlddraggingx = 0;
    private double worlddraggingy = 0;
    private Object selectedObject = null;
    private Timer timer = null;
    private boolean showButtonLayers = true;
    private boolean showButtonDevices = true;
    private boolean showButtonNavigation = true;
    private double viewbox_tx = 0.0;
    private double viewbox_ty = 0.0;
    private double viewbox_sx = 1.0;
    private double viewbox_sy = 1.0;
    private Color backgroundColor = FlatGUI.lookDesign.getColor("window.color.background.content");
    private List<SVGElement> lelement =  new ArrayList<SVGElement>();
    private List<SVGElement> listSelectedDevices =  new ArrayList<SVGElement>();
    
    private double CX = 0;
    private double CY = 0;
    
    public PanelScaleVectorGraphics()
    {
        initialise();
        events();
    }
    
    
    public PanelScaleVectorGraphics(File file)
    {
        reload(file);
        initialise();
        events();
    }
    
    
    public PanelScaleVectorGraphics(byte[] data)
    {
        reload(data);
        initialise();
        events();
    }
    
    
    public SVGDiagram getDiagram()
    {
        return diagram;
    }
        
    

    public boolean isValid()
    {
        return (diagram != null);
    }
    
    
    public void disableOptionLayers()
    {
        showButtonLayers = false;
    }

    public void disableOptionDevices()
    {
        showButtonDevices = false;
    }
    
    
    public void disableOptionNavigation()
    {
        showButtonNavigation = false;
        this.remove(buttonMenu);
        this.remove(buttonTop);
        this.remove(buttonLeft);
        this.remove(buttonBottom);
        this.remove(buttonRight);
        this.remove(buttonCenter);
        this.remove(buttonMinus);
        this.remove(buttonPlus);
    }
    
    public void enableOptionLayers()
    {
        showButtonLayers = true;
    }

    public void enableOptionDevices()
    {
        showButtonDevices = true;
    }
    
    public void enableOptionNavigation()
    {
        disableOptionNavigation();
        this.add(buttonMenu);
        this.add(buttonTop);
        this.add(buttonLeft);
        this.add(buttonBottom);
        this.add(buttonRight);
        this.add(buttonCenter);
        this.add(buttonMinus);
        this.add(buttonPlus);
        showButtonNavigation = true;
    }
    
    
    
    
    public void reload(File file)
    {
        try
        {
            reload(Files.readAllBytes(file.toPath()));
        }
        catch (Exception e)
        {
        }

        this.repaint();
    }
    
        
    
    
    public void reload(byte[] data)
    {
        this.scriptInstance = null;
        this.diagram = null;
        
        
        try
        {
            // Background color
            
            String xml = new String(data);
            int index1 = xml.indexOf("pagecolor=\"#");
            int index2 = xml.indexOf("\"", index1 + 11);
            String color = xml.substring(index1+12, index2);
            backgroundColor = new Color(Integer.parseInt(color, 16)); 
        }
        catch (Exception e)
        {
        }
            
        
        
        try
        {
            
            ByteArrayInputStream bis = new ByteArrayInputStream(data);
            SVGUniverse svgUniverse = new SVGUniverse();
            svgUniverse.setVerbose(false);
            diagram = svgUniverse.getDiagram(svgUniverse.loadSVG(bis, "diagram", true));
            
            StyleAttribute sty = new StyleAttribute();
            diagram.getRoot().getPres(sty.setName("viewBox"));
            float[] coords = sty.getFloatList();
            Rectangle2D.Float viewbox = new Rectangle2D.Float(coords[0], coords[1], coords[2], coords[3]);
            viewbox_sx = diagram.getRoot().getDeviceWidth() / viewbox.width;
            viewbox_sy = diagram.getRoot().getDeviceHeight() / viewbox.height;
            viewbox_tx = -viewbox.x;
            viewbox_ty = -viewbox.y;

            // Get art elements

            lelement = getElementsWithAttribute(diagram, "art.device");

            // Add display attribute, may be does not exists, user forgot
            
            for (SVGElement element : lelement)
            {
                try
                {
                    element.addAttribute("display", AnimationElement.AT_CSS, "none");
                }
                catch (Exception e)
                {
                }
            }

            refreshLayers();
        }
        catch (Exception e)
        {
        }

        this.fit();
    }
    
    
    private Object scriptInstance = null;
    
    
    public void revalidate(Device device, String...methodNames)
    {
        try
        {
            if (scriptInstance == null)
            {
                SVGElement element = diagram.getRoot().getChild("Metadata");
                String script = element.getPresAbsolute("art.script").getStringValue();
                String code = new String(Resources.getResourceData("data/art.client/runtime/DeviceGraphicsRuntime.java"));
                code = ArticStrings.replaceLast(code, "}", script + "}");
                Class clazz = ArticJavaManagerCompiler.getRuntimeClass(code, script);

                Constructor constructor = clazz.getDeclaredConstructor(new Class[]{Device.class, SVGDiagram.class});
                scriptInstance = constructor.newInstance(new Object[]{device, diagram});
            }
            
            for (String methodName : methodNames)
            {
                Method method = scriptInstance.getClass().getDeclaredMethod(methodName);
                method.invoke(scriptInstance);
            }
            
        }
        catch (Exception e)
        {
        }
        
        repaint();
    }

    
    
    

    public void paint(Graphics graphics)
    {
        try 
        {
            Graphics2D g2 = (Graphics2D)graphics;
            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
            g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB);
            g2.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DEFAULT);
            g2.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
            g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
            g2.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
            g2.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
            g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_DEFAULT);
            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
            g2.setBackground(backgroundColor);
            g2.clearRect(0, 0, getWidth(), getHeight());

            g2.scale(scalex, scaley); 
            g2.translate(translatex, translatey);
            {
                // Paint map
                
                diagram.render(g2); 

                // Paint selected devices
                {
                    g2.scale(viewbox_sx, viewbox_sy);
                    g2.translate(viewbox_tx, viewbox_ty);
                    g2.setStroke(new BasicStroke(1.0f));

                    g2.setColor(Color.BLUE);
                    g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.25f));

                    for (SVGElement element : listSelectedDevices)
                    {
                        Shape shape = getBoundingBox(element);
                        g2.fill(shape);
                    }

                    g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f));
                    g2.translate(-viewbox_tx, -viewbox_ty);
                    g2.scale(1/viewbox_sx, 1/viewbox_sy);
                }
            }            
            g2.translate(-translatex, -translatey);
            g2.scale(1/scalex, 1/scaley); 
            
              
            g2.setColor(Color.red);
            g2.fill(new Ellipse2D.Double(CX, CY, 15, 15));
            
            if (isFocusOwner() == true)
            {
                paintMenu(g2);
                paintPanTiltZoom(g2);
            }
            
        } 
        catch (Exception e)
        {
        }
    }
    

    

    
    
    
    private void initialise()
    {
        buttonMenu = createButtonMap(Icons.MENU_24x24);
        buttonMenu.addActionListener(new ActionListener() 
        {
            public void actionPerformed(ActionEvent e) 
            {
                showMenu(0, 0, true);
                repaint();
            }
        });
        
        
        buttonTop = createButtonMap(Icons.MOVE_UP_24x24);
        buttonLeft = createButtonMap(Icons.MOVE_LEFT_24x24);
        buttonBottom = createButtonMap(Icons.MOVE_DOWN_24x24);
        buttonRight = createButtonMap(Icons.MOVE_RIGHT_24x24);
        buttonCenter = createButtonMap(Icons.MOVE_CENTER_24x24);
        buttonMinus = createButtonMap(Icons.BUTTON_MINUS_24x24);
        buttonPlus = createButtonMap(Icons.BUTTON_PLUS_24x24);

        
        this.setLayout(null);
        this.add(buttonMenu);
        this.add(buttonTop);
        this.add(buttonLeft);
        this.add(buttonBottom);
        this.add(buttonRight);
        this.add(buttonCenter);
        this.add(buttonMinus);
        this.add(buttonPlus);
        disableOptionDevices();
        
    }
    
    
    
    // <editor-fold defaultstate="collapsed" desc="Events">
    
    
    private void events()
    {
        this.addComponentListener(new ComponentAdapter() 
        {
            public void componentResized(ComponentEvent e) 
            {
                fit();
            }

            public void componentShown(ComponentEvent e) 
            {
                fit();
            }
        });
        
        buttonTop.addMouseListener(new MouseAdapter() 
        {
            public void mousePressed(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                
                translatey = translatey + (30 / scaley);
                PanelScaleVectorGraphics.this.repaint();
                
                timer = new Timer(100, new ActionListener() 
                {
                   public void actionPerformed(ActionEvent evt) 
                   {
                       translatey = translatey + (30 / scaley);
                       PanelScaleVectorGraphics.this.repaint();
                   }
                });
                timer.start();
            }
            public void mouseReleased(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                timer = null;
            }
        });
        
        

        buttonBottom.addMouseListener(new MouseAdapter() 
        {
            public void mousePressed(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                translatey = translatey - (30 / scaley);
                PanelScaleVectorGraphics.this.repaint();
                
                timer = new Timer(100, new ActionListener() 
                {
                   public void actionPerformed(ActionEvent evt) 
                   {
                       translatey = translatey - (30 / scaley);
                       PanelScaleVectorGraphics.this.repaint();
                   }
                });
                timer.start();
            }
            public void mouseReleased(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                timer = null;
            }
        });        

        

        buttonLeft.addMouseListener(new MouseAdapter() 
        {
            public void mousePressed(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                translatex = translatex + (30 / scalex);
                PanelScaleVectorGraphics.this.repaint();
                
                timer = new Timer(100, new ActionListener() 
                {
                   public void actionPerformed(ActionEvent evt) 
                   {
                       translatex = translatex + (30 / scalex);
                       PanelScaleVectorGraphics.this.repaint();
                   }
                });
                timer.start();
            }
            public void mouseReleased(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                timer = null;
            }
        });
        
        

        buttonRight.addMouseListener(new MouseAdapter() 
        {
            public void mousePressed(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                translatex = translatex - (30 / scalex);
                PanelScaleVectorGraphics.this.repaint();
                
                timer = new Timer(100, new ActionListener() 
                {
                   public void actionPerformed(ActionEvent evt) 
                   {
                       translatex = translatex - (30 / scalex);
                       PanelScaleVectorGraphics.this.repaint();
                   }
                });
                timer.start();
            }
            public void mouseReleased(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                timer = null;
            }
        });        
        
        

        
        buttonCenter.addActionListener(new ActionListener() 
        {
            public void actionPerformed(ActionEvent e) 
            {
                fit();
            }
        });
        
        

        buttonMinus.addMouseListener(new MouseAdapter() 
        {
            public void mousePressed(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                zoom(1/1.1, getWidth()/2, getHeight()/2);
                
                timer = new Timer(100, new ActionListener() 
                {
                   public void actionPerformed(ActionEvent evt) 
                   {
                       zoom(1/1.1, getWidth()/2, getHeight()/2);
                   }
                });
                timer.start();
            }
            public void mouseReleased(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                timer = null;
            }
        });        
        
        

        buttonPlus.addMouseListener(new MouseAdapter() 
        {
            public void mousePressed(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                zoom(1.1, getWidth()/2, getHeight()/2);
                
                timer = new Timer(100, new ActionListener() 
                {
                   public void actionPerformed(ActionEvent evt) 
                   {
                       zoom(1.1, getWidth()/2, getHeight()/2);
                   }
                });
                timer.start();
            }
            public void mouseReleased(MouseEvent e) 
            {
                if (timer != null) timer.stop();
                timer = null;
            }
        });        
        
        

        
        
        this.addMouseListener(new MouseAdapter() 
        {
            public void mousePressed(MouseEvent e) 
            {
                setCursor(FlatGUI.lookDesign.getCursor("cursor.pressed"));
                viewportx = e.getX();
                viewporty = e.getY();
                worldx = (viewportx/scalex) - translatex;
                worldy = (viewporty/scaley) - translatey;
                double presx = (worldx/viewbox_sx) - viewbox_tx;
                double presy = (worldy/viewbox_sy) - viewbox_ty;
                updateSelected(e, presx, presy);

                
                if (SwingUtilities.isRightMouseButton(e) == true)
                {
                    showMenu(e.getX(), e.getY(), false);
                }
                else
                {
                    if(buttonMenu != null)
                    {
                        Rectangle rectangle = new Rectangle(4, getHeight() - buttonMenu.getHeight() - 8, buttonMenu.getWidth(), buttonMenu.getHeight());

                        if (rectangle.contains(e.getX(), e.getY()))
                        {
                            showMenu(e.getX(), e.getY(), true);
                            repaint();
                            return;
                        }
                    }
                }
                                
                repaint();
            }
            
            
            public void mouseReleased(MouseEvent e) 
            {      
                dragging = false;
                setCursor(FlatGUI.lookDesign.getCursor("cursor.hand"));
                repaint();
            }

            
            public void mouseClicked(MouseEvent e) 
            {
                if (e.getClickCount() == 2)
                {
                    // TODO : listSelectedDevices the selected devices
                    // Open window
                }
            }

        });        
        
        
        
        this.addMouseMotionListener(new MouseMotionAdapter() 
        {
            public void mouseMoved(MouseEvent e) 
            {
            }
            
            public void mouseDragged(MouseEvent e) 
            {
                try
                {
                    dragging = true;
                    worlddraggingx = (e.getX()/scalex) - translatex;
                    worlddraggingy = (e.getY()/scaley) - translatey;

                    if ((selectedObject == null) && (lockNavigation == false))
                    {
                        double tx = (e.getX() - viewportx)/scalex;
                        double ty = (e.getY() - viewporty)/scaley;
                        viewportx = e.getX();
                        viewporty = e.getY();
                        translatex = translatex + tx;
                        translatey = translatey + ty;
                    }
                }
                catch (Exception exception)
                {
                }

                repaint();
            }
        });                
        
        
        
        
        this.addMouseWheelListener(new MouseWheelListener()
        {
            public void mouseWheelMoved(MouseWheelEvent e)
            {
                float increment = (1 + ((float)-e.getWheelRotation()/10));
                Point mousePoint = MouseInfo.getPointerInfo().getLocation();
                Point panelPoint = getLocationOnScreen();
                double x = mousePoint.getX() - panelPoint.getX();
                double y = mousePoint.getY() - panelPoint.getY();
                zoom(increment, x, y);
            }
        });
        
        
    }
    
    
    // </editor-fold>  

    

    // <editor-fold defaultstate="collapsed" desc="Paint">
        
    
    public void paintMenu(Graphics2D g2)
    {
        int x = 4;
        int y = getHeight() - buttonMenu.getHeight() - 4;
        buttonMenu.setBounds(x, y, 32, 32);
        paintComponent(buttonMenu, g2);
    }
    
    
    public void paintPanTiltZoom(Graphics2D g2)
    {
        if (lockNavigation == true) return;
        
        int x = getWidth() - 16 - 10 - 48;
        int y = 12 + 10 + 24;
        buttonCenter.setBounds(x, y, 32, 32);
        paintComponent(buttonCenter, g2);

        x = getWidth() - 16 - 10 - 48;
        y = 12;
        buttonTop.setBounds(x, y, 32, 32);
        paintComponent(buttonTop, g2);
        
        x = getWidth() - 16 - 20 - 72;
        y = 12 + 10 + 24;
        buttonLeft.setBounds(x, y, 32, 32);
        paintComponent(buttonLeft, g2);

        x = getWidth() - 16 - 10 - 48;
        y = 12 + 20 + 48;
        buttonBottom.setBounds(x, y, 32, 32);
        paintComponent(buttonBottom, g2);

        x = getWidth() - 16 - 24;
        y = 12 + 10 + 24;
        buttonRight.setBounds(x, y, 32, 32);
        paintComponent(buttonRight, g2);
        
        x = getWidth() - 16 - 24;
        y = 12 + 20 + 64;
        buttonMinus.setBounds(x, y, 32, 32);
        paintComponent(buttonMinus, g2);
        
        x = getWidth() - 16 - 20 - 72;
        y = 12 + 20 + 64;
        buttonPlus.setBounds(x, y, 32, 32);
        paintComponent(buttonPlus, g2);
        
    }

    
    
    public void paintComponent(Component component, Graphics2D g2)
    {
        try
        {
            Point mousePoint = MouseInfo.getPointerInfo().getLocation();
            Point panelPoint = getLocationOnScreen();
            double mousex = mousePoint.getX() - panelPoint.getX();
            double mousey = mousePoint.getY() - panelPoint.getY();

            Rectangle bounds = component.getBounds();

            g2.translate(bounds.x, bounds.y);

            
            if (bounds.contains(mousex, mousey) == true)
            {
                g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f));
            }
            else
            {
                g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.4f));
            }
            
            component.paint(g2);
            g2.translate(-bounds.x, -bounds.y);
        }
        catch (Exception e)
        {
        }
    }
    
    

    
    protected void showMenu(int x, int y, boolean autopos)
    {
        FlatPopupMenu popupMenu = new FlatPopupMenu();
        
        double presx = (((x/scalex) - translatex)/viewbox_sx) - viewbox_tx;
        double presy = (((y/scaley) - translatey)/viewbox_sy) - viewbox_ty;
        
        
        {
            String identifier = getSelected(presx, presy);
            
            if (identifier != null)
            {
                // TODO : Device idenfitifier popup selection
                return;
            }
        }
        
        
        
        if (showButtonNavigation == true)
        {
            FlatMenu menuNavigation = new FlatMenu();
            {
                menuNavigation.setText(Shared.getMessage("Navigation"));
                menuNavigation.setIcon(Resources.getResourceURL(Icons.EARTH_24x24));
                {
                    FlatMenuItemCheck item = new FlatMenuItemCheck();
                    item.setText(Shared.getMessage("Lock navigation"));
                    item.setStayOpen(true);
                    item.setIcon(Resources.getResourceURL(Icons.EARTH_LOCK_24x24));
                    item.setSelected(lockNavigation == true);
                    item.addActionListener(new ActionListener()
                    {
                        public void actionPerformed(ActionEvent e)
                        {
                            lockNavigation = ((FlatMenuItemCheck)e.getSource()).isSelected();
                        }
                    });
                    menuNavigation.add(item);
                }
                {
                    FlatMenuItemCheck item = new FlatMenuItemCheck();
                    item.setText(Shared.getMessage("Fit to page"));
                    item.setStayOpen(true);
                    item.setIcon(Resources.getResourceURL(Icons.ADJUST_PAGE_24x24));
                    item.setSelected(fitToPage == true);
                    item.addActionListener(new ActionListener()
                    {
                        public void actionPerformed(ActionEvent e)
                        {
                            FlatMenuItemCheck item = (FlatMenuItemCheck)e.getSource();
                            fitToPage = item.isSelected();
                            fit();
                        }
                    });
                    menuNavigation.add(item);
                }
            }
            
            popupMenu.add(menuNavigation);
        }
        
        
        if (showButtonLayers == true)
        {
            FlatMenu menuLayers = new FlatMenu();
            {
                menuLayers.setText(Shared.getMessage("Layers"));
                menuLayers.setIcon(Resources.getResourceURL(Icons.LAYERS_24x24));

                for (int i=0; i<diagram.getRoot().getNumChildren(); i++)
                {
                    try
                    {
                        SVGElement child = diagram.getRoot().getChild(i);
                        String layer = child.getPresAbsolute("art.layer").getStringValue();
                        double minZoom = getAttributeDouble(diagram, layer, "art.minzoom");
                        double maxZoom = getAttributeDouble(diagram, layer, "art.maxzoom");
                        boolean showButtonLayer = ((minZoom == 0) && (maxZoom == 0)) || (minZoom > maxZoom) || ((scalex >= minZoom) && (scalex <= maxZoom));

                        if (showButtonLayer == true)
                        {
                            FlatMenuItemCheck item = new FlatMenuItemCheck();
                            {
                                item.setName(layer);
                                item.setText(Shared.getMessage(layer));
                                item.setStayOpen(true);
                                String display = getAttributeString(child, "art.display");
                                item.setSelected(display.equalsIgnoreCase("inline") == true);

                                item.addActionListener(new ActionListener()
                                {
                                    public void actionPerformed(ActionEvent e)
                                    {
                                        try
                                        {
                                            SVGElement element = ArticScalableVectorGraphics.getLayer(diagram, ((FlatMenuItemCheck)e.getSource()).getName());

                                            if (item.isSelected() == false)
                                            {
                                                // SVG Salamander bug. We can to change all objects recursively.
                                                setAttribute(element, "display", AnimationElement.AT_AUTO, "none", 99999);
                                                element.setAttribute("art.display", AnimationElement.AT_AUTO, "none");
                                            }
                                            else
                                            {
                                                // SVG Salamander bug. We can to change all objects recursively.
                                                setAttribute(element, "display", AnimationElement.AT_AUTO, "inline", 99999);
                                                element.setAttribute("art.display", AnimationElement.AT_AUTO, "inline");
                                            }

                                            repaint();
                                        }
                                        catch (Exception exception)
                                        {
                                        }
                                    }
                                });

                                menuLayers.add(item);
                            }
                        }
                    }
                    catch (Exception e)
                    {
                    }
                }
            }
            
            popupMenu.add(menuLayers);
        }

        
        if (showButtonDevices == true)
        {
            FlatMenu menuDevices = new FlatMenu();
            {
                menuDevices.setText(Shared.getMessage("Devices"));
                menuDevices.setIcon(Resources.getResourceURL(Icons.SHAPES_GEOMETRICAL_24x24));
            }
            popupMenu.add(menuDevices);
        }

        popupMenu.pack();
        
        if (autopos == true)
        {
            popupMenu.show(this, buttonMenu.getX(), buttonMenu.getY() - (int)popupMenu.getPreferredSize().getHeight() - popupMenu.getHeight());
        }
        else
        {
            popupMenu.show(this, x, y);
        }
    }
   
    
    
    

    // </editor-fold>  
        
    

    
    
    private Point2D windowToScreen (double x, double y)
    {
        double wx = (x/scalex) - translatex;
        double wy = (y/scaley) - translatey;
        Point2D resultado = new Point2D.Double(wx, wy);
        return resultado;
    }
    
    
    
    

    
    public void addSelected (String identifier)
    {
        try
        {
            for (SVGElement element : lelement)
            {
                if (getAttributeString(element, "display").equalsIgnoreCase("inline") == true)
                {
                    if (listSelectedDevices.contains(element) == false)
                    {
                        listSelectedDevices.add(element);
                    }
                }
            }
        }        
        catch (Exception e)
        {
        }
    }

    
        
    
    public void setSelected (String identifier)
    {
        try
        {
            listSelectedDevices.clear();
            
            for (SVGElement element : lelement)
            {
                if (getAttributeString(element, "art.device").equalsIgnoreCase(identifier))
                {
                    if (getAttributeString(element, "display").equalsIgnoreCase("inline") == true)
                    {
                        Shape shape = getBoundingBox(element);
                        double x = shape.getBounds2D().getCenterX();
                        double y = shape.getBounds2D().getCenterY();
                        x = (x + viewbox_tx) * viewbox_sx;
                        y = (y + viewbox_ty) * viewbox_sy;
                        //x = (x + translatex) * scalex;
                        //y = (y + translatey) * scaley;
                        
                        translatex = -x + ((getWidth()/2) / scalex);
                        translatey = -y + ((getHeight()/2) / scaley);

                        
                        listSelectedDevices.add(element);
                        repaint();
                        return;
                    }
                }
            }
        }        
        catch (Exception e)
        {
        }
    }

    
    
    
    private void updateSelected(MouseEvent event, double x, double y)
    {
        try
        {
            if ((event == null) || (event.isShiftDown() == false))
            {
                listSelectedDevices.clear();
            }
            
            for (SVGElement element : lelement)
            {
                if (getAttributeString(element, "display").equalsIgnoreCase("inline") == true)
                {
                    Shape shape = getBoundingBox(element);

                    if (shape.contains(x, y) == true)
                    {
                        listSelectedDevices.add(element);
                    }
                }
            }
        }        
        catch (Exception e)
        {
        }
    }
    

    
    

    private String getSelected(double x, double y)
    {
        try
        {
            for (SVGElement element : lelement)
            {
                if (getAttributeString(element, "display").equalsIgnoreCase("inline") == true)
                {
                    Shape shape = getBoundingBox(element);

                    if (shape.contains(x, y) == true)
                    {
                        return getAttributeString(element, "art.device");
                    }
                }
            }
        }        
        catch (Exception e)
        {
        }
        
        return null;
    }
    
    
    
    
    protected void fit()
    {
        if (lockNavigation == true) return;
        
        try
        {
            if (fitToPage == false)
            {
                Rectangle2D view = diagram.getViewRect();
                double ratiox = getWidth() / view.getWidth();
                double ratioy = getHeight() / view.getHeight();
                double ratio = Math.min(ratiox, ratioy);
                translatex = -view.getX() + (getWidth() - (view.getWidth() * ratio))/2;
                translatey = -view.getY() + (getHeight() - (view.getHeight() * ratio))/2;
                translatex = translatex / ratio;
                translatey = translatey / ratio;
                scalex = ratio;
                scaley = ratio;
            }
            else
            {
                Rectangle2D view = diagram.getViewRect();
                translatex = -view.getX();
                translatey = -view.getY();
                scalex = getWidth() / view.getWidth();
                scaley = getHeight() / view.getHeight();
            }
            
            refreshLayers();
            repaint();
        }
        catch (Exception e)
        {
        }
    }

    
    
    private void zoom(double increment, double x, double y)
    {
        try
        {
            if (lockNavigation == true) return;

            if ((scalex * increment) < 0.10) return;
            if ((scaley * increment) < 0.10) return;

            Point2D O = windowToScreen(0, 0);
            Point2D P = windowToScreen(x, y);

            // Ponemos el punto del mouse en el (0,0)

            double tx = P.getX() - O.getX();
            double ty = P.getY() - O.getY();
            translatex = translatex - tx;
            translatey = translatey - ty;

            // Ampliamos

            scalex = scalex * increment;
            scaley = scaley * increment;

            // Devolvemos el punto del mouse al punto de pantalla original

            translatex = translatex + (tx / increment);
            translatey = translatey + (ty / increment);

            refreshLayers();

        }
        catch (Exception exception)
        {
        }
        
        repaint();
    }
                
    
    
    
    
    
    
    
    private void refreshLayers()
    {
        for (int i=0; i<diagram.getRoot().getNumChildren(); i++)
        {
            try
            {
                SVGElement element = diagram.getRoot().getChild(i);
                String layer = element.getPresAbsolute("art.layer").getStringValue();
                String display = element.getPresAbsolute("art.display").getStringValue();
                double minZoom = getAttributeDouble(diagram, layer, "art.minzoom");
                double maxZoom = getAttributeDouble(diagram, layer, "art.maxzoom");
                boolean showscale = ((minZoom == 0) && (maxZoom == 0)) || (minZoom > maxZoom) || ((scalex >= minZoom) && (scalex <= maxZoom));

                if (showscale == true)
                {                    
                    setAttribute(element, "display", AnimationElement.AT_AUTO, display, 99999);
                }
                else
                {
                    setAttribute(element, "display", AnimationElement.AT_AUTO, "none", 99999);
                }
            }
            catch (Exception e)
            {
            }
        }         
    }
    
    
    
    
    

    private FlatButton createButtonMap(String icon)
    {
        FlatButton button = new FlatButton();
        button.setIcon(Resources.getResourceURL(icon));
        button.setPreferredSize(new Dimension(button.getStringWidth(), 0));
        button.setHorizontalAlignment(SwingConstants.CENTER);
        button.setHorizontalTextPosition(SwingConstants.CENTER);
        button.getLook().focus = false;
        button.getLook().borderRollover = false;
        button.getLook().borderSelected = false;
        button.getLook().colorBackgroundSelected = null;
        button.getLook().colorBackgroundRollover = null;
        button.revalidate();
        return button;
    }
    
        
    
    


    
}