bsmapeditview.java

一款即时通讯软件

        }
        
        // changes buddy (JID)
        else if (src == jidMenuItem) {
            /*JID j = chatMenuItem.getJID();
            if (j != null)
                mapPanel.sendSubscriptionRequest(j);*/
        }
        
        // changes image source file
        else if (src == changeMenuItem) {
            mapPanel.setImg();
        }
        
        // changes layer properties
        else if (src == layerMenuItem) {
            mapPanel.setLayer();
        }
        
        // adds layer
        else if (src == addLayerMenuItem) {
            mapPanel.addLayer();
        }
        
        // deletes layer
        else if (src == deleteLayerMenuItem) {
            mapPanel.deleteLayer();
        }
        
        // a resource must be specified !!!
        /*else if (src == sendFileMenuItem) {
            JID j = chatMenuItem.getJID();
            if (j != null)
                mapPanel.sendFile(j);
        }*/
    }
    
    public Enumeration getLayers() {
        if (map != null)
            return map.layers();
        else return new Vector().elements();
    }
    
    public boolean isSelectedLayerEditable() {
        return selectedMapLayer != null && selectedMapLayer.getSrc() == null;
    }
    
    public void addBuddy(JID jid) {
        
        if (selectedComponent == null || selectedMapLayer == null) {
            JOptionPane.showMessageDialog(null, "No layer selected", 
                       "Add buddy error", 
                       JOptionPane.ERROR_MESSAGE);
            return;
        }
            
        if (selectedMapLayer.getSrc() != null) {
            JOptionPane.showMessageDialog(null, "Cannot change referenced map", 
                                          "Add buddy error", 
                                          JOptionPane.ERROR_MESSAGE);
            return;
        }
        
        ItemTagBuilder itemBuilder = new ItemTagBuilder();
        itemBuilder.setJID(jid);
        ItemTag newItem;
        try { newItem = new ItemTag(itemBuilder); }
        catch (InstantiationException e) { return; }

        if (selectedComponent instanceof BSMapEditImagePanel) {
            float scale = selectedMapLayer.getScaleFloat();
            float lon, lat;
            if (scale != 0) {
                lon = posInSelectedX / scale;
                lat = posInSelectedY / scale;
            }
            else {
                lon = lurkerIcon.getIconWidth()/2;
                lat = lurkerIcon.getIconHeight()/2;
            }
            newItem.setLon(lon);
            newItem.setLat(lat);
            selectedMapLayer.addItem(newItem);
        }
        else if (selectedComponent instanceof BSMapEditClusterLabel) {
            // gets the cluster
            BSMapEditClusterLabel label = (BSMapEditClusterLabel) selectedComponent;
            ClusterTag cluster = label.getTag();
            // sets coordinates for the new one
            newItem.setLon(cluster.getLonFloat());
            newItem.setLat(cluster.getLatFloat());
            // adds item into the cluster
            cluster.addItem(newItem);
        }
        else if (selectedComponent instanceof BSMapEditJIDLabel) {
            // gets the old item
            BSMapEditJIDLabel label = (BSMapEditJIDLabel) selectedComponent;
            ItemTag oldItem = label.getTag();
            // sets coordinates for the new one
            newItem.setLon(oldItem.getLonFloat());
            newItem.setLat(oldItem.getLatFloat());
            // creates new cluster
            ClusterTagBuilder clusterBuilder = new ClusterTagBuilder();
            clusterBuilder.setSize(Integer.toString(0));
            clusterBuilder.setLon(oldItem.getLon());
            clusterBuilder.setLat(oldItem.getLat());
            clusterBuilder.addItem(newItem);
            clusterBuilder.addItem(oldItem);
            ClusterTag clusterTag;
            try { clusterTag = new ClusterTag(clusterBuilder); }
            catch (InstantiationException e) { return; }
            // removes the old item from the layer
            selectedMapLayer.removeItem(oldItem);
            // adds cluster into the layer
            selectedMapLayer.addCluster(clusterTag);
        }

        reloadMap();
    }
    
    
    public void setClusterName(String name) {
        
        if (selectedComponent == null) {
            JOptionPane.showMessageDialog(null, "No cluster selected", 
                       "Set cluster name error", 
                       JOptionPane.ERROR_MESSAGE);
            return;
        }
        
        if (selectedComponent instanceof BSMapEditClusterLabel) {
            BSMapEditClusterLabel label = (BSMapEditClusterLabel) selectedComponent;
            ClusterTag tag = label.getTag();
            if (tag == null) 
                return;
            tag.setName(name);
        }
        reloadMap();
    }
    
    
    public void setSelectedLayer(String layerName) {
        Enumeration layersEnum = getLayers();
        if (layerName == null) {
            if (layersEnum.hasMoreElements()) {
                if (selectedMapLayer != null)
                    selectLayerComponents(selectedMapLayer, false);
                selectedMapLayer = (LayerTag) layersEnum.nextElement();
                if (selectedMapLayer != null)
                    mapPanel.setSelectedLayer(selectedMapLayer.getID());
                selectLayerComponents(selectedMapLayer, true);
            }
            else
                selectedMapLayer = null;
        }
        else {
            if (selectedMapLayer != null)
                selectLayerComponents(selectedMapLayer, false);
            selectedMapLayer = null;
            while (layersEnum.hasMoreElements()) {
                LayerTag curLayer = (LayerTag)layersEnum.nextElement();
                String curLayerName = curLayer.getID();
                if (layerName.equals(curLayerName)) {
                    selectedMapLayer = curLayer;
                    mapPanel.setSelectedLayer(layerName);
                    selectLayerComponents(selectedMapLayer, true);
                    break;
                }
            }
        }
    }
    
    public void selectLayerComponents(LayerTag layer, boolean select) {
        if (layer == null) return;
        Vector comps = (Vector) layersComponents.get(layer);
        if (comps == null) return;
        Enumeration compsEnum = comps.elements();
        while (compsEnum.hasMoreElements()) {
            Object o = compsEnum.nextElement();
            if (o instanceof BSMapEditJIDLabel) ((BSMapEditJIDLabel)o).setAsSelected(select);
            else if (o instanceof BSMapEditClusterLabel) ((BSMapEditClusterLabel)o).setAsSelected(select);
            else if (o instanceof BSMapEditImagePanel) ((BSMapEditImagePanel)o).setAsSelected(select);
        }
    }
    
    public void reloadMap() {
        selectedComponent = null;
        mainPanel.removeAll();
        layersComponents.clear();
        this.addMap(map, 0, 0, 1, true, null);
    }
    
    public void refresh() {
        reloadMap();
        revalidate();
        repaint();
        mainPanel.revalidate();
        mainPanel.repaint();
    }
    
    public String getMapPath() {
        return mapPath;
    }
    
    public void setImg(String imgSrc, String imgWidth, String imgHeight) {
        if (selectedMapLayer == null)
            JOptionPane.showMessageDialog(null, "No layer selected", 
                       "Set bitmap error", 
                       JOptionPane.ERROR_MESSAGE);
        else if (selectedMapLayer.getSrc() != null)
            JOptionPane.showMessageDialog(null, "Cannot change referenced map", 
                       "Set bitmap error", 
                       JOptionPane.ERROR_MESSAGE);
        else {
            //String imgPath = new String(mapPath + "/" + originID + "/" + imgSrc);
            //Icon tmpIcon = new ImageIcon(imgPath);
            ImgTag imgTag = selectedMapLayer.getImg();
            if (imgTag == null) {
                ImgTagBuilder imgBuilder = new ImgTagBuilder();
                try { imgTag = new ImgTag(imgBuilder); }
                catch (InstantiationException e) { return; }
            }
            imgTag.setSrc(imgSrc);
            //imgTag.setWidth(imgWidth);
            //imgTag.setHeight(imgHeight);
            imgTag.setWidth(Integer.toString(0));
            imgTag.setHeight(Integer.toString(0));
            //imgTag.setWidth(Integer.toString(tmpIcon.getIconWidth()));
            //imgTag.setHeight(Integer.toString(tmpIcon.getIconHeight()));
            selectedMapLayer.setImg(imgTag);
            refresh();
        }
    }
    
    public LayerTag getSelectedLayer() {
        return selectedMapLayer;
    }
    
    public void setLayerProperties(int offsetX, int offsetY, float scale, int priority) {
        if (selectedMapLayer != null && isTopLevelLayer(selectedMapLayer)) {
            selectedMapLayer.setOffsetX(Integer.toString(offsetX));
            selectedMapLayer.setOffsetY(Integer.toString(offsetY));
            selectedMapLayer.setScale(Float.toString(scale));
            selectedMapLayer.setPriority(Integer.toString(priority));
            refresh();
        }
    }
    
    public void deleteLayer() {
        if (selectedMapLayer != null && isTopLevelLayer(selectedMapLayer)) {
            map.deleteLayer(selectedMapLayer);
            refresh();
        }
    }
    
    public boolean isTopLevelLayer(LayerTag layer) {
        if (map == null) return false;
        Enumeration layersEnum = map.layers();
        while(layersEnum.hasMoreElements())
            if (layersEnum.nextElement() == layer)
                return true;
        return false;
    }
    
    public void addMap(MapTag newMapTag) {
        if (map == null || newMapTag == null) return;
        LayerTagBuilder lb = new LayerTagBuilder();
        lb.setSrc(newMapTag.getID());
        lb.setOffsetX(Integer.toString(0));
        lb.setOffsetY(Integer.toString(0));
        lb.setPriority(Integer.toString(10));
        lb.setScale(Float.toString(1));
        lb.setID("inset_" + newMapTag.getID());
        LayerTag layer;
        try {
            layer = new LayerTag(lb);
        } catch(InstantiationException e) { return; }
        layer.setSrcMap(newMapTag);
        map.addLayer(layer);
        refresh();
    }
    
    public void addLayerWithImg(String imgSrc, String imgWidth, String imgHeight) {
        if (map == null) return;
        LayerTagBuilder lb = new LayerTagBuilder();
        //lb.setSrc(newMapTag.getID());
        lb.setOffsetX(Integer.toString(0));
        lb.setOffsetY(Integer.toString(0));
        lb.setPriority(Integer.toString(10));
        lb.setScale(Float.toString(1));
        Enumeration layerEnum = map.layers();
        int i;
        for (i=1; layerEnum.hasMoreElements(); i++)
            layerEnum.nextElement();
        lb.setID("inset_" + Integer.toString(i));
        LayerTag layer;
        try {
            layer = new LayerTag(lb);
        } catch(InstantiationException e) { return; }
        map.addLayer(layer);
        
        selectedMapLayer = layer;
        setImg(imgSrc, imgWidth, imgHeight);
        
        refresh();
    }
    
}