package jmri.jmrit.display.panelEditor;

import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.lang.reflect.InvocationTargetException;
import java.util.*;

import javax.swing.AbstractAction;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JTextField;

import jmri.*;
import jmri.configurexml.ConfigXmlManager;
import jmri.configurexml.XmlAdapter;
import jmri.jmrit.catalog.ImageIndexEditor;
import jmri.jmrit.display.*;
import jmri.util.JmriJFrame;
import jmri.util.gui.GuiLafPreferencesManager;
import jmri.util.swing.JmriColorChooser;
import jmri.util.swing.JmriJOptionPane;
import jmri.util.swing.JmriMouseEvent;

import org.jdom2.Element;

/**
 * Provides a simple editor for adding jmri.jmrit.display items to a captive
 * JFrame.
 * <p>
 * GUI is structured as a band of common parameters across the top, then a
 * series of things you can add.
 * <p>
 * All created objects are put specific levels depending on their type (higher
 * levels are in front):
 * <ul>
 *   <li>BKG background
 *   <li>ICONS icons and other drawing symbols
 *   <li>LABELS text labels
 *   <li>TURNOUTS turnouts and other variable track items
 *   <li>SENSORS sensors and other independently modified objects
 * </ul>
 * <p>
 * The "contents" List keeps track of all the objects added to the target frame
 * for later manipulation.
 * <p>
 * If you close the Editor window, the target is left alone and the editor
 * window is just hidden, not disposed. If you close the target, the editor and
 * target are removed, and dispose is run. To make this logic work, the
 * PanelEditor is descended from a JFrame, not a JPanel. That way it can control
 * its own visibility.
 * <p>
 * The title of the target and the editor panel are kept consistent via the
 * {#setTitle} method.
 *
 * @author Bob Jacobsen Copyright (c) 2002, 2003, 2007
 * @author Dennis Miller 2004
 * @author Howard G. Penny Copyright (c) 2005
 * @author Matthew Harris Copyright (c) 2009
 * @author Pete Cressman Copyright (c) 2009, 2010
 */
public class PanelEditor extends Editor implements ItemListener {

    private static final String SENSOR = "Sensor";
    private static final String SIGNAL_HEAD = "SignalHead";
    private static final String SIGNAL_MAST = "SignalMast";
    private static final String MEMORY = "Memory";
    private static final String RIGHT_TURNOUT = "RightTurnout";
    private static final String LEFT_TURNOUT = "LeftTurnout";
    private static final String SLIP_TO_EDITOR = "SlipTOEditor";
    private static final String BLOCK_LABEL = "BlockLabel";
    private static final String REPORTER = "Reporter";
    private static final String LIGHT = "Light";
    private static final String BACKGROUND = "Background";
    private static final String MULTI_SENSOR = "MultiSensor";
    private static final String RPSREPORTER = "RPSreporter";
    private static final String FAST_CLOCK = "FastClock";
    private static final String GLOBAL_VARIABLE = "GlobalVariable";
    private static final String LOGIXNG_TABLE = "LogixNGTable";
    private static final String ICON = "Icon";
    private static final String AUDIO = "Audio";
    private static final String LOGIXNG = "LogixNG";
    private final JTextField nextX = new JTextField("0", 4);
    private final JTextField nextY = new JTextField("0", 4);

    private final JCheckBox editableBox = new JCheckBox(Bundle.getMessage("CheckBoxEditable"));
    private final JCheckBox positionableBox = new JCheckBox(Bundle.getMessage("CheckBoxPositionable"));
    private final JCheckBox controllingBox = new JCheckBox(Bundle.getMessage("CheckBoxControlling"));
    //private JCheckBox showCoordinatesBox = new JCheckBox(Bundle.getMessage("CheckBoxShowCoordinates"));
    private final JCheckBox showTooltipBox = new JCheckBox(Bundle.getMessage("CheckBoxShowTooltips"));
    private final JCheckBox hiddenBox = new JCheckBox(Bundle.getMessage("CheckBoxHidden"));
    private final JCheckBox menuBox = new JCheckBox(Bundle.getMessage("CheckBoxMenuBar"));
    private final JLabel scrollableLabel = new JLabel(Bundle.getMessage("ComboBoxScrollable"));
    private final JComboBox<String> scrollableComboBox = new JComboBox<>();
    private JCheckBoxMenuItem disableLocoMarkerPopupMenuItem;

    private final JButton labelAdd = new JButton(Bundle.getMessage("ButtonAddText"));
    private final JTextField nextLabel = new JTextField(10);

    private JComboBox<ComboBoxItem> _addIconBox;

    public PanelEditor() {
    }

    public PanelEditor(String name) {
        super(name, false, true);
        init(name);
    }

    @Override
    protected void init(String name) {
        java.awt.Container contentPane = this.getContentPane();
        contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));
        // common items
        JPanel common = new JPanel();
        common.setLayout(new FlowLayout());
        common.add(new JLabel(" x:"));
        common.add(nextX);
        common.add(new JLabel(" y:"));
        common.add(nextY);
        contentPane.add(common);
        setAllEditable(true);
        setShowHidden(true);
        super.setTargetPanel(null, makeFrame(name));
        super.setTargetPanelSize(400, 300);
        super.setDefaultToolTip(new ToolTip(null, 0, 0, new Font("SansSerif", Font.PLAIN, 12),
                Color.black, new Color(215, 225, 255), Color.black, null));
        // set scrollbar initial state
        setScroll(SCROLL_BOTH);

        // add menu - not using PanelMenu, because it now
        // has other stuff in it?
        JMenuBar menuBar = new JMenuBar();
        JMenu fileMenu = new JMenu(Bundle.getMessage("MenuFile"));
        menuBar.add(fileMenu);
        fileMenu.add(new jmri.jmrit.display.NewPanelAction(Bundle.getMessage("MenuItemNew")));
        fileMenu.add(new jmri.configurexml.StoreXmlUserAction(Bundle.getMessage("FileMenuItemStore")));
        JMenuItem storeIndexItem = new JMenuItem(Bundle.getMessage("MIStoreImageIndex"));
        fileMenu.add(storeIndexItem);
        storeIndexItem.addActionListener(event -> InstanceManager.getDefault(CatalogTreeManager.class).storeImageIndex());
        JMenuItem editItem = new JMenuItem(Bundle.getMessage("editIndexMenu"));
        editItem.addActionListener(e -> {
            ImageIndexEditor ii = InstanceManager.getDefault(ImageIndexEditor.class);
            ii.pack();
            ii.setVisible(true);
        });
        fileMenu.add(editItem);

        editItem = new JMenuItem(Bundle.getMessage("CPEView"));
        fileMenu.add(editItem);
        editItem.addActionListener(event -> changeView("jmri.jmrit.display.controlPanelEditor.ControlPanelEditor"));

        fileMenu.addSeparator();
        JMenuItem deleteItem = new JMenuItem(Bundle.getMessage("DeletePanel"));
        fileMenu.add(deleteItem);
        deleteItem.addActionListener(event -> {
            if (deletePanel()) {
                getTargetFrame().dispose();
                dispose();
            }
        });

        setJMenuBar(menuBar);
        addHelpMenu("package.jmri.jmrit.display.PanelEditor", true);

        // allow renaming the panel
        {
            JPanel namep = new JPanel();
            namep.setLayout(new FlowLayout());
            JButton b = new JButton(Bundle.getMessage("renamePanelMenu", "..."));
            b.addActionListener(new ActionListener() {
                PanelEditor editor;

                @Override
                public void actionPerformed(ActionEvent e) {
                    JFrame frame = getTargetFrame();
                    String oldName = frame.getTitle();
                    // prompt for name
                    String newName = JmriJOptionPane.showInputDialog(null, Bundle.getMessage("PromptNewName"), oldName);
                    if ((newName == null) || (oldName.equals(newName))) {
                        return;  // cancelled
                    }
                    if (InstanceManager.getDefault(EditorManager.class).contains(newName)) {
                        JmriJOptionPane.showMessageDialog(null, Bundle.getMessage("CanNotRename"), Bundle.getMessage("PanelExist"),
                                JmriJOptionPane.ERROR_MESSAGE);
                        return;
                    }
                    frame.setTitle(newName);
                    editor.setTitle();
                }

                ActionListener init(PanelEditor e) {
                    editor = e;
                    return this;
                }
            }.init(this));
            namep.add(b);
            this.getContentPane().add(namep);
        }
        // add a text label
        {
            JPanel panel = new JPanel();
            panel.setLayout(new FlowLayout());
            panel.add(labelAdd);
            labelAdd.setEnabled(false);
            labelAdd.setToolTipText(Bundle.getMessage("ToolTipWillActivate"));
            panel.add(nextLabel);
            labelAdd.addActionListener(new ActionListener() {
                PanelEditor editor;

                @Override
                public void actionPerformed(ActionEvent a) {
                    editor.addLabel(nextLabel.getText());
                }

                ActionListener init(PanelEditor e) {
                    editor = e;
                    return this;
                }
            }.init(this));
            nextLabel.addKeyListener(new KeyAdapter() {
                @Override
                public void keyReleased(KeyEvent a) {
                    if (nextLabel.getText().equals("")) {
                        labelAdd.setEnabled(false);
                        labelAdd.setToolTipText(Bundle.getMessage("ToolTipWillActivate"));
                    } else {
                        labelAdd.setEnabled(true);
                        labelAdd.setToolTipText(null);
                    }
                }
            });
            this.getContentPane().add(panel);
        }

        // Selection of the type of entity for the icon to represent is done from a combobox
        _addIconBox = new JComboBox<>();
        _addIconBox.setMinimumSize(new Dimension(75, 75));
        _addIconBox.setMaximumSize(new Dimension(200, 200));
        _addIconBox.addItem(new ComboBoxItem(RIGHT_TURNOUT));
        _addIconBox.addItem(new ComboBoxItem(LEFT_TURNOUT));
        _addIconBox.addItem(new ComboBoxItem(SLIP_TO_EDITOR));
        _addIconBox.addItem(new ComboBoxItem(SENSOR)); // NOI18N
        _addIconBox.addItem(new ComboBoxItem(SIGNAL_HEAD));
        _addIconBox.addItem(new ComboBoxItem(SIGNAL_MAST));
        _addIconBox.addItem(new ComboBoxItem(MEMORY));
        _addIconBox.addItem(new ComboBoxItem(BLOCK_LABEL));
        _addIconBox.addItem(new ComboBoxItem(REPORTER));
        _addIconBox.addItem(new ComboBoxItem(LIGHT));
        _addIconBox.addItem(new ComboBoxItem(BACKGROUND));
        _addIconBox.addItem(new ComboBoxItem(MULTI_SENSOR));
        _addIconBox.addItem(new ComboBoxItem(RPSREPORTER));
        _addIconBox.addItem(new ComboBoxItem(FAST_CLOCK));
        _addIconBox.addItem(new ComboBoxItem(GLOBAL_VARIABLE));
        _addIconBox.addItem(new ComboBoxItem(LOGIXNG_TABLE));
        _addIconBox.addItem(new ComboBoxItem(AUDIO));
        _addIconBox.addItem(new ComboBoxItem(LOGIXNG));
        _addIconBox.addItem(new ComboBoxItem(ICON));

        for (var positionableFactory : ServiceLoader.load(PositionableFactory.class)) {
            _addIconBox.addItem(new ComboBoxItem(
                    positionableFactory.getIdentifier(),
                    positionableFactory.getDescription()));
        }

        _addIconBox.setSelectedIndex(-1);
        _addIconBox.addItemListener(this);  // must be AFTER no selection is set
        JPanel p1 = new JPanel();
        p1.setLayout(new BoxLayout(p1, BoxLayout.Y_AXIS));
        JPanel p2 = new JPanel();
        p2.setLayout(new FlowLayout());
        p2.add(new JLabel(Bundle.getMessage("selectTypeIcon")));
        p1.add(p2);
        p1.add(_addIconBox);
        contentPane.add(p1);

        // edit, position, control controls
        {
            // edit mode item
            contentPane.add(editableBox);
            editableBox.addActionListener(event -> {
                setAllEditable(editableBox.isSelected());
                hiddenCheckBoxListener();
            });
            editableBox.setSelected(isEditable());
            // positionable item
            contentPane.add(positionableBox);
            positionableBox.addActionListener(event -> setAllPositionable(positionableBox.isSelected()));
            positionableBox.setSelected(allPositionable());
            // controlable item
            contentPane.add(controllingBox);
            controllingBox.addActionListener(event -> setAllControlling(controllingBox.isSelected()));
            controllingBox.setSelected(allControlling());
            // hidden item
            contentPane.add(hiddenBox);
            hiddenCheckBoxListener();
            hiddenBox.setSelected(showHidden());

            /*
             contentPane.add(showCoordinatesBox);
             showCoordinatesBox.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
             setShowCoordinates(showCoordinatesBox.isSelected());
             }
             });
             showCoordinatesBox.setSelected(showCoordinates());
             */
            contentPane.add(showTooltipBox);
            showTooltipBox.addActionListener(e -> setAllShowToolTip(showTooltipBox.isSelected()));
            showTooltipBox.setSelected(showToolTip());

            contentPane.add(menuBox);
            menuBox.addActionListener(e -> setPanelMenuVisible(menuBox.isSelected()));
            menuBox.setSelected(true);

            // Show/Hide Scroll Bars
            JPanel scrollPanel = new JPanel();
            scrollPanel.setLayout(new FlowLayout());
            scrollableLabel.setLabelFor(scrollableComboBox);
            scrollPanel.add(scrollableLabel);
            scrollPanel.add(scrollableComboBox);
            contentPane.add(scrollPanel);
            scrollableComboBox.addItem(Bundle.getMessage("ScrollNone"));
            scrollableComboBox.addItem(Bundle.getMessage("ScrollBoth"));
            scrollableComboBox.addItem(Bundle.getMessage("ScrollHorizontal"));
            scrollableComboBox.addItem(Bundle.getMessage("ScrollVertical"));
            scrollableComboBox.setSelectedIndex(SCROLL_BOTH);
            scrollableComboBox.addActionListener(e -> setScroll(scrollableComboBox.getSelectedIndex()));
        }

        // register the resulting panel for later configuration
        ConfigureManager cm = InstanceManager.getNullableDefault(jmri.ConfigureManager.class);
        if (cm != null) {
            cm.registerUser(this);
        }

        // when this window closes, set contents of target uneditable
        addWindowListener(new java.awt.event.WindowAdapter() {

            HashMap<String, JFrameItem> iconAdderFrames;

            @Override
            public void windowClosing(java.awt.event.WindowEvent e) {
                for (JFrameItem frame : iconAdderFrames.values()) {
                    frame.dispose();
                }
            }

            WindowAdapter init(HashMap<String, JFrameItem> f) {
                iconAdderFrames = f;
                return this;
            }
        }.init(_iconEditorFrame));

        // and don't destroy the window
        setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
        // move this editor panel off the panel's position
        getTargetFrame().setLocationRelativeTo(this);
        getTargetFrame().pack();
        getTargetFrame().setVisible(true);
        log.debug("PanelEditor ctor done.");
    }  // end ctor

    /**
     * Initializes the hiddencheckbox and its listener. This has been taken out
     * of the init, as checkbox is enable/disabled by the editableBox.
     */
    private void hiddenCheckBoxListener() {
        setShowHidden(hiddenBox.isSelected());
        if (editableBox.isSelected()) {
            hiddenBox.setEnabled(false);
//            hiddenBox.setSelected(true);
        } else {
            hiddenBox.setEnabled(true);
            hiddenBox.addActionListener(event -> setShowHidden(hiddenBox.isSelected()));
        }

    }

    /**
     * After construction, initialize all the widgets to their saved config
     * settings.
     */
    @Override
    public void initView() {
        editableBox.setSelected(isEditable());
        positionableBox.setSelected(allPositionable());
        controllingBox.setSelected(allControlling());
        //showCoordinatesBox.setSelected(showCoordinates());
        showTooltipBox.setSelected(showToolTip());
        hiddenBox.setSelected(showHidden());
        menuBox.setSelected(getTargetFrame().getJMenuBar().isVisible());
    }

    static class ComboBoxItem {

        private final String name;
        private final String description;

        protected ComboBoxItem(String n) {
            name = n;
            // I18N split Bundle name
            // use NamedBeanBundle property for basic beans like "Turnout" I18N
            String bundleName;
            if (SENSOR.equals(name)) {
                bundleName = "BeanNameSensor";
            } else if (SIGNAL_HEAD.equals(name)) {
                bundleName = "BeanNameSignalHead";
            } else if (SIGNAL_MAST.equals(name)) {
                bundleName = "BeanNameSignalMast";
            } else if (MEMORY.equals(name)) {
                bundleName = "BeanNameMemory";
            } else if (REPORTER.equals(name)) {
                bundleName = "BeanNameReporter";
            } else if (LIGHT.equals(name)) {
                bundleName = "BeanNameLight";
            } else if (GLOBAL_VARIABLE.equals(name)) {
                bundleName = "BeanNameGlobalVariable";
            } else if (LOGIXNG_TABLE.equals(name)) {
                bundleName = "BeanNameLogixNGTable";
            } else if (AUDIO.equals(name)) {
                bundleName = "BeanNameAudio";
            } else {
                bundleName = name;
            }
            description = Bundle.getMessage(bundleName); // use NamedBeanBundle property for basic beans like "Turnout" I18N
        }

        protected ComboBoxItem(String n, String descr) {
            name = n;
            description = descr;
        }

        protected String getName() {
            return name;
        }

        @Override
        public String toString() {
            return description;
        }
    }

    /*
     * itemListener for JComboBox.
     */
    @Override
    public void itemStateChanged(ItemEvent e) {
        if (e.getStateChange() == ItemEvent.SELECTED) {
            ComboBoxItem item = (ComboBoxItem) e.getItem();
            String name = item.getName();
            JFrameItem frame = super.getIconFrame(name);
            if (frame != null) {
                frame.getEditor().reset();
                frame.setVisible(true);
            } else {
                if (name.equals(FAST_CLOCK)) {
                    addClock();
                } else if (name.equals(RPSREPORTER)) {
                    addRpsReporter();
                } else {
                    PositionableFactory positionableFactory = null;
                    for (var pf : ServiceLoader.load(PositionableFactory.class)) {
                        if (name.equals(pf.getIdentifier())) {
                            positionableFactory = pf;
                        }
                    }
                    if (positionableFactory != null) {
                        positionableFactory.addPositionable(this, null);
                    } else {
                        log.error("Unable to open Icon Editor \"{}\"", item.getName());
                    }
                }
            }
            _addIconBox.setSelectedIndex(-1);
        }
    }

    /**
     * Handle close of editor window.
     * <p>
     * Overload/override method in JmriJFrame parent, which by default is
     * permanently closing the window. Here, we just want to make it invisible,
     * so we don't dispose it (yet).
     */
    @Override
    @SuppressFBWarnings(value = "OVERRIDING_METHODS_MUST_INVOKE_SUPER",
            justification = "Don't want to close window yet")
    public void windowClosing(java.awt.event.WindowEvent e) {
        setVisible(false);
    }

    /**
     * Create sequence of panels, etc, for layout: JFrame contains its
     * ContentPane which contains a JPanel with BoxLayout (p1) which contains a
     * JScollPane (js) which contains the targetPane.
     * @param name the frame name.
     * @return the frame.
     */
    public JmriJFrame makeFrame(String name) {
        JmriJFrame targetFrame = new JmriJFrameWithPermissions(name);
        targetFrame.setVisible(false);

        JMenuBar menuBar = new JMenuBar();
        JMenu editMenu = new JMenu(Bundle.getMessage("MenuEdit"));
        menuBar.add(editMenu);
        editMenu.add(new AbstractAction(Bundle.getMessage("OpenEditor")) {
            @Override
            public void actionPerformed(ActionEvent e) {
                setVisible(true);
            }
        });
        editMenu.addSeparator();
        editMenu.add(new AbstractAction(Bundle.getMessage("DeletePanel")) {
            @Override
            public void actionPerformed(ActionEvent e) {
                if (deletePanel()) {
                    dispose();
                }
            }
        });
        targetFrame.setJMenuBar(menuBar);
        // add maker menu
        JMenu markerMenu = new JMenu(Bundle.getMessage("MenuMarker"));
        menuBar.add(markerMenu);
        markerMenu.add(new AbstractAction(Bundle.getMessage("AddLoco")) {
            @Override
            public void actionPerformed(ActionEvent e) {
                locoMarkerFromInput();
            }
        });
        markerMenu.add(new AbstractAction(Bundle.getMessage("AddLocoRoster")) {
            @Override
            public void actionPerformed(ActionEvent e) {
                locoMarkerFromRoster();
            }
        });
        markerMenu.add(new AbstractAction(Bundle.getMessage("RemoveMarkers")) {
            @Override
            public void actionPerformed(ActionEvent e) {
                removeMarkers();
            }
        });
        InstanceManager.getOptionalDefault(UserPreferencesManager.class).ifPresent(prefsMgr -> {
            markerMenu.addSeparator();
            disableLocoMarkerPopupMenuItem = new JCheckBoxMenuItem(
                    new AbstractAction(Bundle.getMessage("DisableLocoMarkerPopup")) {
                        @Override
                        public void actionPerformed(ActionEvent e) {
                            enableDisableLocoMarkerPopups();
                        }
            });
            disableLocoMarkerPopupMenuItem.setSelected(isLocoMarkerPopupDisabled());
            markerMenu.add(disableLocoMarkerPopupMenuItem);
        });

        JMenu warrantMenu = jmri.jmrit.logix.WarrantTableAction.getDefault().makeWarrantMenu(isEditable());
        if (warrantMenu != null) {
            menuBar.add(warrantMenu);
        }

        targetFrame.addHelpMenu("package.jmri.jmrit.display.PanelTarget", true);
        return targetFrame;
    }

    private void enableDisableLocoMarkerPopups() {
        if (disableLocoMarkerPopupMenuItem != null) {
            boolean selected = disableLocoMarkerPopupMenuItem.isSelected();
            setLocoMarkerPopupDisabled(selected);
        }
    }

    /*
     ************* implementation of Abstract Editor methods **********
     */

    /**
     * The target window has been requested to close, don't delete it at this
     * time. Deletion must be accomplished via the Delete this panel menu item.
     */
    @Override
    protected void targetWindowClosingEvent(java.awt.event.WindowEvent e) {
        targetWindowClosing();
    }

    /**
     * Called from TargetPanel's paint method for additional drawing by editor
     * view
     */
    @Override
    protected void paintTargetPanel(Graphics g) {
        /*Graphics2D g2 = (Graphics2D)g;
         drawPositionableLabelBorder(g2);*/
    }

    /**
     * Set an object's location when it is created.
     */
    @Override
    public void setNextLocation(Positionable obj) {
        int x = Integer.parseInt(nextX.getText());
        int y = Integer.parseInt(nextY.getText());
        obj.setLocation(x, y);
    }

    /**
     * Create popup for a Positionable object. Popup items common to all
     * positionable objects are done before and after the items that pertain
     * only to specific Positionable types.
     *
     * @param p           the item containing or requiring the context menu
     * @param event       the event triggering the menu
     * @param selections  the list of all Positionables at this position
     */
    protected void showPopUp(Positionable p, JmriMouseEvent event, List<Positionable> selections) {
        if (!((JComponent) p).isVisible()) {
            return;     // component must be showing on the screen to determine its location
        }
        JPopupMenu popup = new JPopupMenu();
        PositionablePopupUtil util = p.getPopupUtility();
        if (p.isEditable()) {
            // items for all Positionables
            if (p.doViemMenu()) {
                popup.add(p.getNameString());
                setPositionableMenu(p, popup);
                if (p.isPositionable()) {
                    setShowCoordinatesMenu(p, popup);
                    setShowAlignmentMenu(p, popup);
                }
                setDisplayLevelMenu(p, popup);
                setHiddenMenu(p, popup);
                setEmptyHiddenMenu(p, popup);
                setValueEditDisabledMenu(p, popup);
                setEditIdMenu(p, popup);
                setEditClassesMenu(p, popup);
                popup.addSeparator();
                setLogixNGPositionableMenu(p, popup);
                popup.addSeparator();
            }

            // Positionable items with defaults or using overrides
            boolean popupSet = false;
            popupSet = p.setRotateOrthogonalMenu(popup);
            popupSet |= p.setRotateMenu(popup);
            popupSet |= p.setScaleMenu(popup);
            if (popupSet) {
                popup.addSeparator();
            }
            popupSet = p.setEditIconMenu(popup);
            if (popupSet) {
                popup.addSeparator();
            }
            popupSet = p.setTextEditMenu(popup);
            if (util != null) {
                util.setFixedTextMenu(popup);
                util.setTextMarginMenu(popup);
                util.setTextBorderMenu(popup);
                util.setTextFontMenu(popup);
                util.setBackgroundMenu(popup);
                util.setTextJustificationMenu(popup);
                util.setTextOrientationMenu(popup);
                util.copyItem(popup);
                popup.addSeparator();
                util.propertyUtil(popup);
                util.setAdditionalEditPopUpMenu(popup);
                popupSet = true;
            }
            if (popupSet) {
                popup.addSeparator();
            }
            p.setDisableControlMenu(popup);

            // for Positionables with unique item settings
            p.showPopUp(popup);

            setShowToolTipMenu(p, popup);
            setRemoveMenu(p, popup);
        } else {
            p.showPopUp(popup);
            if (util != null) {
                util.setAdditionalViewPopUpMenu(popup);
            }
        }

        if (selections.size() > 1) {
            boolean found = false;
            JMenu iconsBelowMenu = new JMenu(Bundle.getMessage("MenuItemIconsBelow"));
            for (int i=0; i < selections.size(); i++) {
                Positionable pos = selections.get(i);
                if (found) {
                    iconsBelowMenu.add(new AbstractAction(Bundle.getMessage(
                            "PositionableTypeAndName", pos.getTypeString(), pos.getNameString())) {
                        @Override
                        public void actionPerformed(ActionEvent e) {
                            showPopUp(pos, event, new ArrayList<>());
                        }
                    });
                } else {
                    if (p == pos) found = true;
                }
            }
            popup.addSeparator();
            popup.add(iconsBelowMenu);
        }

        popup.show((Component) p, p.getWidth() / 2, p.getHeight() / 2);
    }

    /**
     * ***************************************************
     */
    private boolean delayedPopupTrigger;

    @Override
    public void mousePressed(JmriMouseEvent event) {
        setToolTip(null); // ends tooltip if displayed
        if (log.isDebugEnabled()) {
            log.debug("mousePressed at ({},{}) _dragging= {}", event.getX(), event.getY(), _dragging);
        }
        _anchorX = event.getX();
        _anchorY = event.getY();
        _lastX = _anchorX;
        _lastY = _anchorY;
        List<Positionable> selections = getSelectedItems(event);
        if (_dragging) {
            return;
        }
        if (selections.size() > 0) {
            if (event.isShiftDown() && selections.size() > 1) {
                _currentSelection = selections.get(1);
            } else {
                _currentSelection = selections.get(0);
            }
            if (event.isPopupTrigger()) {
                log.debug("mousePressed calls showPopUp");
                if (event.isMetaDown() || event.isAltDown()) {
                    // if requesting a popup and it might conflict with moving, delay the request to mouseReleased
                    delayedPopupTrigger = true;
                } else {
                    // no possible conflict with moving, display the popup now
                    if (_selectionGroup != null) {
                        //Will show the copy option only
                        showMultiSelectPopUp(event, _currentSelection);
                    } else {
                        showPopUp(_currentSelection, event, selections);
                    }
                }
            } else if (!event.isControlDown()) {
                _currentSelection.doMousePressed(event);
                if (_multiItemCopyGroup != null && !_multiItemCopyGroup.contains(_currentSelection)) {
                    _multiItemCopyGroup = null;
                }
                // _selectionGroup = null;
            }
        } else {
            if (event.isPopupTrigger()) {
                if (event.isMetaDown() || event.isAltDown()) {
                    // if requesting a popup and it might conflict with moving, delay the request to mouseReleased
                    delayedPopupTrigger = true;
                } else {
                    if (_multiItemCopyGroup != null) {
                        pasteItemPopUp(event);
                    } else if (_selectionGroup != null) {
                        showMultiSelectPopUp(event, _currentSelection);
                    } else {
                        backgroundPopUp(event);
                        _currentSelection = null;
                    }
                }
            } else {
                _currentSelection = null;
            }
        }
        // if ((event.isControlDown() || _selectionGroup!=null) && _currentSelection!=null){
        if ((event.isControlDown()) || event.isMetaDown() || event.isAltDown()) {
            //Don't want to do anything, just want to catch it, so that the next two else ifs are not
            //executed
        } else if ((_currentSelection == null && _multiItemCopyGroup == null)
                || (_selectRect != null && !_selectRect.contains(_anchorX, _anchorY))) {
            _selectRect = new Rectangle(_anchorX, _anchorY, 0, 0);
            _selectionGroup = null;
        } else {
            _selectRect = null;
            _selectionGroup = null;
        }
        _targetPanel.repaint(); // needed for ToolTip
    }

    @Override
    public void mouseReleased(JmriMouseEvent event) {
        setToolTip(null); // ends tooltip if displayed
        if (log.isDebugEnabled()) {
            // in if statement to avoid inline conditional unless logging
            log.debug("mouseReleased at ({},{}) dragging= {} selectRect is {}", event.getX(), event.getY(), _dragging,
                    _selectRect == null ? "null" : "not null");
        }
        List<Positionable> selections = getSelectedItems(event);

        if (_dragging) {
            mouseDragged(event);
        }
        if (selections.size() > 0) {
            if (event.isShiftDown() && selections.size() > 1) {
                _currentSelection = selections.get(1);
            } else {
                _currentSelection = selections.get(0);
            }
            if (_multiItemCopyGroup != null && !_multiItemCopyGroup.contains(_currentSelection)) {
                _multiItemCopyGroup = null;
            }
        } else {
            if ((event.isPopupTrigger() || delayedPopupTrigger) && !_dragging) {
                if (_multiItemCopyGroup != null) {
                    pasteItemPopUp(event);
                } else {
                    backgroundPopUp(event);
                    _currentSelection = null;
                }
            } else {
                _currentSelection = null;

            }
        }
        /*if (event.isControlDown() && _currentSelection!=null && !event.isPopupTrigger()){
         amendSelectionGroup(_currentSelection, event);*/
        if ((event.isPopupTrigger() || delayedPopupTrigger) && _currentSelection != null && !_dragging) {
            if (_selectionGroup != null) {
                //Will show the copy option only
                showMultiSelectPopUp(event, _currentSelection);

            } else {
                showPopUp(_currentSelection, event, selections);
            }
        } else {
            if (_currentSelection != null && !_dragging && !event.isControlDown()) {
                _currentSelection.doMouseReleased(event);
            }
            if (allPositionable() && _selectRect != null) {
                if (_selectionGroup == null && _dragging) {
                    makeSelectionGroup(event);
                }
            }
        }
        delayedPopupTrigger = false;
        _dragging = false;
        _selectRect = null;

        // if not sending MouseClicked, do it here
        if (InstanceManager.getDefault(GuiLafPreferencesManager.class).isNonStandardMouseEvent()) {
            mouseClicked(event);
        }
        _targetPanel.repaint(); // needed for ToolTip
    }

    @Override
    public void mouseDragged(JmriMouseEvent event) {
        setToolTip(null); // ends tooltip if displayed
        if ((event.isPopupTrigger()) || (!event.isMetaDown() && !event.isAltDown())) {
            if (_currentSelection != null) {
                List<Positionable> selections = getSelectedItems(event);
                if (selections.size() > 0) {
                    if (selections.get(0) != _currentSelection) {
                        _currentSelection.doMouseReleased(event);
                    } else {
                        _currentSelection.doMouseDragged(event);
                    }
                } else {
                    _currentSelection.doMouseReleased(event);
                }
            }
            return;
        }
        moveIt:
        if (_currentSelection != null && getFlag(OPTION_POSITION, _currentSelection.isPositionable())) {
            int deltaX = event.getX() - _lastX;
            int deltaY = event.getY() - _lastY;
            int minX = getItemX(_currentSelection, deltaX);
            int minY = getItemY(_currentSelection, deltaY);
            if (_selectionGroup != null && _selectionGroup.contains(_currentSelection)) {
                for (Positionable comp : _selectionGroup) {
                    minX = Math.min(getItemX(comp, deltaX), minX);
                    minY = Math.min(getItemY(comp, deltaY), minY);
                }
            }
            if (minX < 0 || minY < 0) {
                break moveIt;
            }
            if (_selectionGroup != null && _selectionGroup.contains(_currentSelection)) {
                for (Positionable comp : _selectionGroup) {
                    moveItem(comp, deltaX, deltaY);
                }
                _highlightcomponent = null;
            } else {
                moveItem(_currentSelection, deltaX, deltaY);
                _highlightcomponent = new Rectangle(_currentSelection.getX(), _currentSelection.getY(),
                        _currentSelection.maxWidth(), _currentSelection.maxHeight());
            }
        } else {
            if (allPositionable() && _selectionGroup == null) {
                drawSelectRect(event.getX(), event.getY());
            }
        }
        _dragging = true;
        _lastX = event.getX();
        _lastY = event.getY();
        _targetPanel.repaint(); // needed for ToolTip
    }

    @Override
    public void mouseMoved(JmriMouseEvent event) {
        // log.debug("mouseMoved at ({},{})", event.getX(), event.getY());
        if (_dragging || event.isPopupTrigger()) {
            return;
        }

        List<Positionable> selections = getSelectedItems(event);
        Positionable selection = null;
        if (selections.size() > 0) {
            if (event.isShiftDown() && selections.size() > 1) {
                selection = selections.get(1);
            } else {
                selection = selections.get(0);
            }
        }
        if (isEditable() && selection != null && selection.getDisplayLevel() > BKG) {
            _highlightcomponent = new Rectangle(selection.getX(), selection.getY(), selection.maxWidth(), selection.maxHeight());
            _targetPanel.repaint();
        } else {
            _highlightcomponent = null;
            _targetPanel.repaint();
        }
        if (selection != null && selection.getDisplayLevel() > BKG && selection.showToolTip()) {
            showToolTip(selection, event);
            //selection.highlightlabel(true);
            _targetPanel.repaint();
        } else {
            setToolTip(null);
            _highlightcomponent = null;
            _targetPanel.repaint();
        }
    }

    @Override
    public void mouseClicked(JmriMouseEvent event) {
        setToolTip(null); // ends tooltip if displayed
        if (log.isDebugEnabled()) {
            log.debug("mouseClicked at ({},{}) dragging= {} selectRect is {}",
                    event.getX(), event.getY(), _dragging, (_selectRect == null ? "null" : "not null"));
        }
        List<Positionable> selections = getSelectedItems(event);

        if (selections.size() > 0) {
            if (event.isShiftDown() && selections.size() > 1) {
                _currentSelection = selections.get(1);
            } else {
                _currentSelection = selections.get(0);
            }
        } else {
            _currentSelection = null;
            if (event.isPopupTrigger()) {
                if (_multiItemCopyGroup == null) {
                    pasteItemPopUp(event);
                } else {
                    backgroundPopUp(event);
                }
            }
        }
        if (event.isPopupTrigger() && _currentSelection != null && !_dragging) {
            if (_selectionGroup != null) {
                showMultiSelectPopUp(event, _currentSelection);
            } else {
                showPopUp(_currentSelection, event, selections);
            }
            // _selectionGroup = null; // Show popup only works for a single item

        } else {
            if (_currentSelection != null && !_dragging && !event.isControlDown()) {
                _currentSelection.doMouseClicked(event);
            }
        }
        _targetPanel.repaint(); // needed for ToolTip
        if (event.isControlDown() && _currentSelection != null && !event.isPopupTrigger()) {
            amendSelectionGroup(_currentSelection);
        }
    }

    @Override
    public void mouseEntered(JmriMouseEvent event) {
    }

    @Override
    public void mouseExited(JmriMouseEvent event) {
        setToolTip(null);
        _targetPanel.repaint();  // needed for ToolTip
    }

    protected ArrayList<Positionable> _multiItemCopyGroup = null;  // items gathered inside fence

    @Override
    protected void copyItem(Positionable p) {
        _multiItemCopyGroup = new ArrayList<>();
        _multiItemCopyGroup.add(p);
    }

    protected void pasteItemPopUp(final JmriMouseEvent event) {
        if (!isEditable()) {
            return;
        }
        if (_multiItemCopyGroup == null) {
            return;
        }
        JPopupMenu popup = new JPopupMenu();
        JMenuItem edit = new JMenuItem(Bundle.getMessage("MenuItemPaste"));
        edit.addActionListener(e -> pasteItem(event));
        setBackgroundMenu(popup);
        showAddItemPopUp(event, popup);
        popup.add(edit);
        popup.show(event.getComponent(), event.getX(), event.getY());
    }

    protected void backgroundPopUp(JmriMouseEvent event) {
        if (!isEditable()) {
            return;
        }
        JPopupMenu popup = new JPopupMenu();
        setBackgroundMenu(popup);
        showAddItemPopUp(event, popup);
        popup.show(event.getComponent(), event.getX(), event.getY());
    }

    protected void showMultiSelectPopUp(final JmriMouseEvent event, Positionable p) {
        JPopupMenu popup = new JPopupMenu();
        JMenuItem copy = new JMenuItem(Bundle.getMessage("MenuItemCopy")); // changed "edit" to "copy"
        if (p.isPositionable()) {
            setShowAlignmentMenu(p, popup);
        }
        copy.addActionListener(e -> {
            _multiItemCopyGroup = new ArrayList<>();
            // must make a copy or pasteItem() will hang
            if (_selectionGroup != null) {
                _multiItemCopyGroup.addAll(_selectionGroup);
            }
        });

        setMultiItemsPositionableMenu(popup); // adding Lock Position for all
        // selected items

        setRemoveMenu(p, popup);
        //showAddItemPopUp(event, popup); // no need to Add when group selected
        popup.add(copy);
        popup.show(event.getComponent(), event.getX(), event.getY());
    }

    protected void showAddItemPopUp(final JmriMouseEvent event, JPopupMenu popup) {
        if (!isEditable()) {
            return;
        }
        JMenu _add = new JMenu(Bundle.getMessage("MenuItemAddItem"));
        // for items in the following list, I18N is picked up later on
        addItemPopUp(new ComboBoxItem(RIGHT_TURNOUT), _add);
        addItemPopUp(new ComboBoxItem(LEFT_TURNOUT), _add);
        addItemPopUp(new ComboBoxItem(SLIP_TO_EDITOR), _add);
        addItemPopUp(new ComboBoxItem(SENSOR), _add);
        addItemPopUp(new ComboBoxItem(SIGNAL_HEAD), _add);
        addItemPopUp(new ComboBoxItem(SIGNAL_MAST), _add);
        addItemPopUp(new ComboBoxItem(MEMORY), _add);
        addItemPopUp(new ComboBoxItem(BLOCK_LABEL), _add);
        addItemPopUp(new ComboBoxItem(REPORTER), _add);
        addItemPopUp(new ComboBoxItem(LIGHT), _add);
        addItemPopUp(new ComboBoxItem(BACKGROUND), _add);
        addItemPopUp(new ComboBoxItem(MULTI_SENSOR), _add);
        addItemPopUp(new ComboBoxItem(RPSREPORTER), _add);
        addItemPopUp(new ComboBoxItem(FAST_CLOCK), _add);
        addItemPopUp(new ComboBoxItem(GLOBAL_VARIABLE), _add);
        addItemPopUp(new ComboBoxItem(LOGIXNG_TABLE), _add);
        addItemPopUp(new ComboBoxItem(AUDIO), _add);
        addItemPopUp(new ComboBoxItem(LOGIXNG), _add);
        addItemPopUp(new ComboBoxItem(ICON), _add);
        addItemPopUp(new ComboBoxItem("Text"), _add);

        for (var positionableFactory : ServiceLoader.load(PositionableFactory.class)) {
            addItemPopUp(new ComboBoxItem(
                    positionableFactory.getIdentifier(),
                    positionableFactory.getDescription()),
                    _add,
                    (ActionEvent e) -> {
                        addItemViaMouseClick = true;
                        positionableFactory.addPositionable(this, null);
                    });
        }

        popup.add(_add);
    }

    void addItemPopUp(final ComboBoxItem item, JMenu menu) {
        addItemPopUp(item, menu, null);
    }

    void addItemPopUp(final ComboBoxItem item, JMenu menu, ActionListener a) {

        if (a == null) {
            a = new ActionListener() {
                //final String desiredName = name;
                @Override
                public void actionPerformed(ActionEvent e) {
                    addItemViaMouseClick = true;
                    getIconFrame(item.getName());
                }

                ActionListener init(ComboBoxItem i) {
                    return this;
                }
            }.init(item);
        }
        JMenuItem addto = new JMenuItem(item.toString());
        addto.addActionListener(a);
        menu.add(addto);
    }

    protected boolean addItemViaMouseClick = false;

    @Override
    public void putItem(Positionable l) throws Positionable.DuplicateIdException {
        putItem(l, false);
    }

    @Override
    public void putItem(Positionable l, boolean factoryPositionable)
            throws Positionable.DuplicateIdException {

        super.putItem(l, factoryPositionable);

        /*This allows us to catch any new items that are being pasted into the panel
         and add them to the selection group, so that the user can instantly move them around*/
        //!!!
        if (pasteItemFlag) {
            amendSelectionGroup(l);
            return;
        }
        if (addItemViaMouseClick) {
            addItemViaMouseClick = false;
            l.setLocation(_lastX, _lastY);
        }
    }

    private void amendSelectionGroup(Positionable p) {
        if (p == null) {
            return;
        }
        if (_selectionGroup == null) {
            _selectionGroup = new ArrayList<>();
        }
        boolean removed = false;
        for (int i = 0; i < _selectionGroup.size(); i++) {
            if (_selectionGroup.get(i) == p) {
                _selectionGroup.remove(i);
                removed = true;
                break;
            }
        }
        if (!removed) {
            _selectionGroup.add(p);
        } else if (_selectionGroup.isEmpty()) {
            _selectionGroup = null;
        }
        _targetPanel.repaint();
    }

    protected boolean pasteItemFlag = false;

    protected void pasteItem(JmriMouseEvent e) {
        pasteItemFlag = true;
        XmlAdapter adapter;
        String className;
        int x;
        int y;
        int xOrig;
        int yOrig;
        if (_multiItemCopyGroup != null) {
            JComponent copied;
            int xoffset;
            int yoffset;
            x = _multiItemCopyGroup.get(0).getX();
            y = _multiItemCopyGroup.get(0).getY();
            xoffset = e.getX() - x;
            yoffset = e.getY() - y;
            /*We make a copy of the selected items and work off of that copy
             as amendments are made to the multiItemCopyGroup during this process
             which can result in a loop*/
            ArrayList<Positionable> _copyOfMultiItemCopyGroup = new ArrayList<>(_multiItemCopyGroup);
            Collections.copy(_copyOfMultiItemCopyGroup, _multiItemCopyGroup);
            for (Positionable comp : _copyOfMultiItemCopyGroup) {
                copied = (JComponent) comp;
                xOrig = copied.getX();
                yOrig = copied.getY();
                x = xOrig + xoffset;
                y = yOrig + yoffset;
                if (x < 0) {
                    x = 1;
                }
                if (y < 0) {
                    y = 1;
                }
                className = ConfigXmlManager.adapterName(copied);
                copied.setLocation(x, y);
                try {
                    adapter = (XmlAdapter) Class.forName(className).getDeclaredConstructor().newInstance();
                    Element el = adapter.store(copied);
                    adapter.load(el, this);
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException
                    | jmri.configurexml.JmriConfigureXmlException
                    | RuntimeException ex) {
                        log.debug("Could not paste.", ex);
                }
                /*We remove the original item from the list, so we end up with
                 just the new items selected and allow the items to be moved around */
                amendSelectionGroup(comp);
                copied.setLocation(xOrig, yOrig);
            }
            _selectionGroup = null;
        }
        pasteItemFlag = false;
        _targetPanel.repaint();
    }

    /**
     * Add an action to remove the Positionable item.
     */
    @Override
    public void setRemoveMenu(Positionable p, JPopupMenu popup) {
        popup.add(new AbstractAction(Bundle.getMessage("Remove")) {
            Positionable comp;

            @Override
            public void actionPerformed(ActionEvent e) {
                if (_selectionGroup == null) {
                    comp.remove();
                } else {
                    removeMultiItems();
                }
            }

            AbstractAction init(Positionable pos) {
                comp = pos;
                return this;
            }
        }.init(p));
    }

    private void removeMultiItems() {
        boolean itemsInCopy = false;
        if (_selectionGroup == _multiItemCopyGroup) {
            itemsInCopy = true;
        }
        for (Positionable comp : _selectionGroup) {
            comp.remove();
        }
        //As we have removed all the items from the panel we can remove the group.
        _selectionGroup = null;
        //If the items in the selection group and copy group are the same we need to
        //clear the copy group as the originals no longer exist.
        if (itemsInCopy) {
            _multiItemCopyGroup = null;
        }
    }

    // This adds a single CheckBox in the PopupMenu to set or clear all the selected
    // items "Lock Position" or Positionable setting, when clicked, all the items in
    // the selection will be changed accordingly.
    private void setMultiItemsPositionableMenu(JPopupMenu popup) {
        // This would do great with a "greyed" CheckBox if the multiple items have different states.
        // Then selecting the true or false state would force all to change to true or false

        JCheckBoxMenuItem lockItem = new JCheckBoxMenuItem(Bundle.getMessage("LockPosition"));
        boolean allSetToMove = false;  // used to decide the state of the checkbox shown
        int trues = 0;                 // used to see if all items have the same setting

        int size = _selectionGroup.size();

        for (Positionable comp : _selectionGroup) {
            if (!comp.isPositionable()) {
                allSetToMove = true;
                trues++;
            }

            lockItem.setSelected(allSetToMove);

            lockItem.addActionListener(new ActionListener() {
                Positionable comp;
                JCheckBoxMenuItem checkBox;

                @Override
                public void actionPerformed(ActionEvent e) {
                    comp.setPositionable(!checkBox.isSelected());
                    setSelectionsPositionable(!checkBox.isSelected(), comp);
                }

                ActionListener init(Positionable pos, JCheckBoxMenuItem cb) {
                    comp = pos;
                    checkBox = cb;
                    return this;
                }
            }.init(comp, lockItem));
        }

        // Add "~" to the Text when all items do not have the same setting,
        // until we get a "greyed" CheckBox ;) - GJM
        if ((trues != size) && (trues != 0)) {
            lockItem.setText("~ " + lockItem.getText());
            // uncheck box if all not the same
            lockItem.setSelected(false);
        }
        popup.add(lockItem);
    }

    public void setBackgroundMenu(JPopupMenu popup) {
        // Panel background, not text background
        JMenuItem edit = new JMenuItem(Bundle.getMessage("FontBackgroundColor"));
        edit.addActionListener((ActionEvent event) -> {
            Color desiredColor = JmriColorChooser.showDialog(this,
                                 Bundle.getMessage("FontBackgroundColor"),
                                 getBackgroundColor());
            if (desiredColor!=null ) {
               setBackgroundColor(desiredColor);
           }
        });
        popup.add(edit);
    }

    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(PanelEditor.class);

}