bsmapeditview.java

一款即时通讯软件

package edu.ou.kmi.buddyspace.plugins.maps.editor;

/*
 * BSMapEditView.java
 *
 * Project: BuddySpace
 * (C) Copyright Knowledge Media Institute 2002
 *
 *
 * Created on 19 August 2002, 9:54
 */

import java.util.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;
import java.awt.event.*;
//import org.netbeans.lib.awtextra.*;

import org.jabber.jabberbeans.util.*;

import edu.ou.kmi.buddyspace.core.*;
import edu.ou.kmi.buddyspace.gui.*;
import edu.ou.kmi.buddyspace.utils.*;
import edu.ou.kmi.buddyspace.plugins.maps.xml.*;
import edu.ou.kmi.buddyspace.plugins.maps.gui.*;

/**
 * <code>BSMapEditView</code> is view of map represented by a <code>MapTag</code>.
 *
 * @author  Jiri Komzak, Knowledge Media Institute, Open University, United Kingdom
 */
public class BSMapEditView extends JScrollPane
                           implements MouseInputListener, ActionListener {
    
    private BSRosterBean rosterBean = null;
    
    private BSMapEditWindow mapPanel = null;
    
    private JPanel helpPanel = null;
    private JLayeredPane mainPanel = null;
    private int layerNum = Integer.MAX_VALUE;
    
    private ImageIcon lurkerIcon = null;
    private ImageIcon clusterIcon = null;
    
    private int w = 10, h = 10;   // icons width and height
    
    private JPopupMenu jidPopupMenu;
    private JMenuItem deleteMenuItem;
    private JMenuItem addMenuItem;
    private JMenuItem jidMenuItem;
    private JPopupMenu clusterPopupMenu;
    private JMenuItem setClusterNameMenuItem;
    private JMenuItem deleteClusterMenuItem;
    private JPopupMenu imgPopupMenu;
    private JMenuItem changeMenuItem;
    private JPopupMenu layerPopupMenu;
    private JMenuItem resizeMenuItem;
    private JMenuItem deleteLayerMenuItem;
    private JMenuItem addLayerMenuItem;
    private JMenuItem layerMenuItem;
    private JMenuItem infoMenuItem;
    
    private String originID = null;
    private String mapID = null;
    private MapTag map = null;
    
    private String mapPath;
    
    private Object selectedComponent = null;
    private LayerTag selectedMapLayer = null;
    private int posInSelectedX;
    private int posInSelectedY;
    
    private boolean refreshOnRelease = false;
    
    private Hashtable layersComponents = new Hashtable();
    
    /** Constructor */
    public BSMapEditView(BSMapEditWindow mapPanel, MapTag map, String mapID, String originID,
                         String mapPath, BSRosterBean rosterBean) {
        super();
        
        this.mapPanel = mapPanel;
        this.mapPath = mapPath;
        
        this.rosterBean = rosterBean;
        
        lurkerIcon = new ImageIcon(ClassLoader.getSystemResource("images/map_lurker.gif"));
        clusterIcon = new ImageIcon(ClassLoader.getSystemResource("images/map_cluster.gif"));
        
        jidPopupMenu = new JPopupMenu();
        clusterPopupMenu = new JPopupMenu();
        deleteMenuItem = new JMenuItem("Delete buddy");
        deleteMenuItem.addActionListener(this);
        addMenuItem = new JMenuItem("Add buddy");
        addMenuItem.addActionListener(this);
        jidMenuItem = new JMenuItem("Set JID");
        jidMenuItem.addActionListener(this);
        deleteClusterMenuItem = new JMenuItem("Delete cluster");
        deleteClusterMenuItem.addActionListener(this);
        setClusterNameMenuItem = new JMenuItem("Set cluster name");
        setClusterNameMenuItem.addActionListener(this);
        imgPopupMenu = new JPopupMenu();
        changeMenuItem = new JMenuItem("Change image");
        changeMenuItem.addActionListener(this);
        layerPopupMenu = new JPopupMenu();
        resizeMenuItem = new JMenuItem("Resize inset");
        resizeMenuItem.addActionListener(this);
        layerMenuItem = new JMenuItem("Set layer properties");
        layerMenuItem.addActionListener(this);
        addLayerMenuItem = new JMenuItem("Add layer");
        addLayerMenuItem.addActionListener(this);
        deleteLayerMenuItem = new JMenuItem("Delete layer");
        deleteLayerMenuItem.addActionListener(this);
        infoMenuItem = new JMenuItem("Info");
    
        this.mapID = mapID;
        this.originID = originID;
        this.map = map;
        
        helpPanel = new JPanel();
        //helpPanel.setLayout(new BorderLayout());
        mainPanel = new JLayeredPane();
        mainPanel.setDoubleBuffered(true);
        mainPanel.setBorder(new LineBorder(Color.black, 1));
        //mainPanel.setLayout(null);
        
        layersComponents.clear();
        addMap(map, 0, 0, 1, true, null);
        
        /*Insets insets = mainPanel.getInsets();
        JLabel lblnnn = new JLabel("nazdarek");
        mainPanel.add(lblnnn, new Integer(Integer.MAX_VALUE));
        lblnnn.setBounds(50 + insets.left, 50 + insets.top, 30, 30);*/
        
        setSelectedLayer(null);
        
        helpPanel.add(mainPanel);
        //helpPanel.add(mainPanel, BorderLayout.CENTER);
        setViewportView(helpPanel);
    }
    
    /** Returns map id */
    public String getMapID() {
        return mapID;
    }
    
    /** Returns origin id */
    public String getOriginID() {
        return originID;
    }
    
    public void setMapID(String mapID) {
        this.mapID = mapID;
    }
    
    public void setOriginID(String originID) {
        this.originID = originID;
    }
    
    
    // *** map view construction functions ***
    
    /** Adds <code>map</code> into the view.
     * This is used for inserting insets during the view construction.
     */
    protected void addMap(MapTag map, int offsetX, int offsetY, float scale, 
                          boolean editable, LayerTag topLevelLayer) {
        Enumeration layers;
        
        // creates temp vector
        Vector tmpLayers = new Vector();
        layers = map.layers();
        while (layers.hasMoreElements()) {
            tmpLayers.add(layers.nextElement());
        }
        
        // goes through all layers and inserts them according to their priority
        int lastPriority = Integer.MAX_VALUE;
        int curPriority = getNextHighestPriority(tmpLayers, lastPriority);
        while (curPriority != -1) {
            Vector tmp2Layers = (Vector) tmpLayers.clone();
            layers = tmp2Layers.elements();
            while (layers.hasMoreElements()) {
                LayerTag l = (LayerTag) layers.nextElement();
                if (l.getPriorityInt() == curPriority) {
                    if (editable) {
                        topLevelLayer = l;
                        layersComponents.put(l, new Vector());
                    }
                    addLayer(l, offsetX, offsetY, scale, editable, topLevelLayer);
                    tmpLayers.remove(l);
                }
            }
            lastPriority = curPriority;
            curPriority = getNextHighestPriority(tmpLayers, lastPriority);
        }
        
        invalidate();
        repaint();
    }
    
    /**
     * Returns the highest priority in vector lower than lastPriority.
     */
    protected int getNextHighestPriority(Vector layersVector, int lastPriority) {
        int newPriority = -1;
        Enumeration layers = layersVector.elements();
        while (layers.hasMoreElements()) {
            int priority = ((LayerTag) layers.nextElement()).getPriorityInt();
            if (priority < lastPriority && priority > newPriority)
                newPriority = priority;
        }
        return newPriority;
    }
    
    /** Adds <code>layer</code> into the view.
     *  This is used during the view construction.
     */
    protected void addLayer(LayerTag layer, int offsetX, int offsetY, float scale, 
                            boolean editable, LayerTag topLevelLayer) {
        
        Insets insets = mainPanel.getInsets();
        
        // sets the new scale and offset inside the layer
        float newScale = scale * layer.getScaleFloat();
        int newOffsetX = Math.round(offsetX + layer.getOffsetXInt() * scale);
        int newOffsetY = Math.round(offsetY + layer.getOffsetYInt() * scale);
        
        // adds all the items
        Enumeration items = layer.getItems();
        while (items.hasMoreElements()) {
            Object o = items.nextElement();
            // if it's item
            if (o instanceof ItemTag) {
                ItemTag i = (ItemTag) o;
                JID jid = i.getJID();
                if (jid == null) break;
                String nick = null;
                if (rosterBean != null) nick = rosterBean.getFriendlyName(jid);
                if (rosterBean == null || nick == null) nick = "?";
                BSMapEditJIDLabel jidLabel = new BSMapEditJIDLabel(jid, nick, lurkerIcon, (ItemTag)o, topLevelLayer, editable);
                ((Vector)layersComponents.get(topLevelLayer)).add(jidLabel);
                jidLabel.setOpaque(false);
                if (lurkerIcon != null) {
                    w = lurkerIcon.getIconWidth();
                    h = lurkerIcon.getIconHeight();
                }
                int x = Math.round(i.getLonFloat()*newScale + newOffsetX - w/2);
                int y = Math.round(i.getLatFloat()*newScale + newOffsetY - h/2);
                //mainPanel.add(jidLabel, new AbsoluteConstraints(x, y, w, h));
                //mainPanel.add(jidLabel, JLayeredPane.DEFAULT_LAYER, layerNum);
                mainPanel.add(jidLabel, new Integer(layerNum));
                jidLabel.setBounds(x + insets.left, y + insets.top, w, h);
                jidLabel.addMouseListener(this);
                jidLabel.addMouseMotionListener(this);
            }
            // else if it's cluster
            else if (o instanceof ClusterTag) {
                ClusterTag c = (ClusterTag) o;
                //BSClusterLabel clusterLabel = new BSClusterLabel(c, clusterIcon);
                BSMapEditClusterLabel clusterLabel = new BSMapEditClusterLabel(c, clusterIcon, topLevelLayer, editable);
                ((Vector)layersComponents.get(topLevelLayer)).add(clusterLabel);
                clusterLabel.setOpaque(false);
                if (clusterIcon != null) {
                    w = clusterIcon.getIconWidth();
                    h = clusterIcon.getIconHeight();
                }
                int x = Math.round(c.getLonFloat()*newScale + newOffsetX - w/2);
                int y = Math.round(c.getLatFloat()*newScale + newOffsetY - h/2);
                //mainPanel.add(jidLabel, new AbsoluteConstraints(x, y, w, h));
                //mainPanel.add(clusterLabel, JLayeredPane.DEFAULT_LAYER, layerNum);
                mainPanel.add(clusterLabel, new Integer(layerNum));
                clusterLabel.setBounds(x + insets.left, y + insets.top, w, h);
                clusterLabel.addMouseListener(this);
                clusterLabel.addMouseMotionListener(this);
            }
        }
        layerNum--;
        
        String completeMapPath = new String(mapPath + "/" + originID);
        // loads image of map
        ImgTag imgTag = layer.getImg();
        if (imgTag != null) {
            //Image image = getImage(ClassLoader.getSystemResource("images/" + imgTag.getSrc()));
            /*Image image = Toolkit.getDefaultToolkit().getImage(
                            ClassLoader.getSystemResource(completeMapPath + "/" + imgTag.getSrc()));*/
            Image image = Toolkit.getDefaultToolkit().getImage(completeMapPath + "/" + imgTag.getSrc());
            BSMapEditImagePanel imgPanel = new BSMapEditImagePanel(
                                    image, newScale, mainPanel, 
                                    imgTag.getWidthInt(), imgTag.getHeightInt(),
                                    imgTag, topLevelLayer, editable);
            ((Vector)layersComponents.get(topLevelLayer)).add(imgPanel);
            //mainPanel.add(imgPanel, JLayeredPane.DEFAULT_LAYER, layerNum);
            mainPanel.add(imgPanel, new Integer(layerNum));
            imgPanel.addMouseListener(this);
            imgPanel.addMouseMotionListener(this);
            imgPanel.setBounds(newOffsetX + insets.left, newOffsetY + insets.top,
                               imgPanel.getWidth(), imgPanel.getHeight());
            imgPanel.maybeResizeParent();
        }
        layerNum--;
        
        // loads map given in layer's src attribute (when the map is only referenced)
        MapTag map = layer.getSrcMap();
        if (map != null) {
            addMap(map, newOffsetX, newOffsetY, newScale, false, topLevelLayer);