bsmapbean.java

一款即时通讯软件

            XMLFileIO.saveTag(map, filename);
        } catch (IOException e) {}
    }

    /** Saves map into file with given name. Changes the map ID to match
     * the filename. */
    public boolean saveMap(String originID, String mapID,
                           String newOriginID, String newMapID) {

        if (mapID == null || originID == null || newMapID == null)
            return false;

        // gets the map tag
        String completeID = new String(originID + "/" + mapID);
        MapTag map = (MapTag) maps.get(completeID);
        if (map == null) return false;

        // gets the filename and creates path for it
        String newCompleteID = new String(newOriginID + "/" + newMapID);
        String filename = new String(mapPath + "/" + newCompleteID);
        File parentFile = new File(filename).getAbsoluteFile().getParentFile();
        if (parentFile != null)
            parentFile.mkdirs();

        // sets new ID and origin and re-inserts the map under the new IDs
        map.setID(newMapID);
        maps.remove(completeID);
        maps.put(newCompleteID, map);

        try {
            XMLFileIO.saveTag(map, filename);
        } catch (IOException e) {
            return false;
        }

        return true;
    }

    /**
     * Connects references to maps to MapTags if exist otherwise downloads maps.
     */
    protected void processMap(MapTag map, String originID) {
        Enumeration layers = map.layers();
        while (layers.hasMoreElements()) {
            LayerTag layer = (LayerTag) layers.nextElement();
            String src = layer.getSrc();

            // loads all referenced maps
            if (src != null) {
                MapTag refdMap = (MapTag) maps.get(src);

                // if map not in memory
                if (refdMap == null) {
                    refdMap = loadMapTag(src, originID);
                }

                // otherwise downloads it
                if (refdMap == null) {
                }

                // sets the referenced map (possibly null)
                layer.setSrcMap(refdMap);

                // processes also loaded map
                if (refdMap != null) {
                    processMap(refdMap, originID);
                }

            } //loads referenced map

        } //while
    }

    /** Sends map and OOB for necessary files inside a message
     * and uploads the files on web server.
     */
    public boolean sendMap(String mapID, String originID, JID jid, String subject, String body) {
        if (mapID == null || originID == null || jid == null ||
            msgBean == null || msgBean.getConnection() == null)
            return false;

        MessageBuilder msgBuilder = new MessageBuilder();

        if (!addMapIntoMessage(msgBuilder, mapID, originID, true))
            return false;

        msgBuilder.setSubject(subject);
        msgBuilder.setBody(body);
        msgBuilder.setToAddress(jid);

        try {
            msgBean.getConnection().send(msgBuilder.build());
        } catch (InstantiationException e) {
            return false;
        }
        return true;
    }

    /** Adds map and OOB for necessary files into the message
     * and uploads the files on web server.
     */
    private boolean addMapIntoMessage(MessageBuilder msgBuilder, String mapID,
                                      String originID, boolean mainMap) {

        String completeMapPath = new String(mapPath + "/" + originID);
        String completeID = new String(originID + "/" + mapID);

        MapTag map = (MapTag) maps.get(completeID);
        if (map == null) return false;

        OOBBuilder oobBuilder = new OOBBuilder();

        // first goes through the mapTag and looks for map images
        // all images are uploaded and OOB is added
        Enumeration layers = map.layers();
        while (layers.hasMoreElements()) {
            LayerTag l = (LayerTag) layers.nextElement();
            ImgTag img = l.getImg();
            if (img != null) {
                File imgFile = new File(completeMapPath + "/" + img.getSrc());
                String urlStr = new String("http://" + fileServer + ":" +
                                fileServerPort + fileServerPath + "/" + img.getSrc());
                URL url;
                try {
                    url = new URL(urlStr);
                    URLFileTransfer.uploadURL(imgFile, url, proxy, proxyPort);
                } catch (MalformedURLException e) {
                    break;
                } catch (IOException e) {
                    break;
                }
                oobBuilder.reset();
                oobBuilder.setIQ(false);
                oobBuilder.setURL(urlStr);
                oobBuilder.setDescription(img.getSrc());
                msgBuilder.addExtension(oobBuilder.build());
            }
            MapTag insetMap = l.getSrcMap();
            if (insetMap != null && recursiveMapsSend) {
                addMapIntoMessage(msgBuilder, insetMap.getID(), originID, false);
            }
        }

        msgBuilder.addExtension(map);

        return true;
    }

    /** Copies all necessary files for given map into specified dir. */
    public boolean copyFilesForMap(MapTag map, String sourceOriginID,
                                               String destOriginID) {

        if (map == null) return true;

        String sourcePath = new String(mapPath + "/" + sourceOriginID);
        String destPath = new String(mapPath + "/" + destOriginID);

        // for all layers
        Enumeration layers = map.layers();
        while (layers.hasMoreElements()) {
            LayerTag l = (LayerTag) layers.nextElement();
            // copies images
            ImgTag img = l.getImg();
            if (img != null) {
                if (!FileCopier.copyFile(new File(sourcePath + "/" + img.getSrc()),
                                         new File(destPath + "/" + img.getSrc())))
                    return false;
            }
            // for nested maps
            MapTag insetMap = l.getSrcMap();
            if (insetMap != null) {
                // copies map files
                if (!FileCopier.copyFile(new File(sourcePath + "/" + insetMap.getID()),
                                         new File(destPath + "/" + insetMap.getID())))
                    return false;
                // and all necessary files referenced
                if (!copyFilesForMap(insetMap, sourceOriginID, destOriginID))
                    return false;
            }
        }

        return true;
    }

    /** Loads map */
    public void loadMap(String mapID, String originID) {
        MapTag newMap = loadMapTag(mapID, originID);
        if (newMap == null) return;
        // pridat do hashtable
        String completeID = originID + "/" + mapID;
        maps.put(completeID, newMap);
        processMap(newMap, originID);
        // zavolat manager, at to zobrazi
        fireMapReceived(newMap, originID);
    }

    /** Load map tag from disk */
    private MapTag loadMapTag(String mapID, String originID) {
        MapTag result = loadMapImpl(mapID,  originID);
        if (result == null)
            JOptionPane.showMessageDialog(null, "Cannot load map " + mapID,
                                      "Error", JOptionPane.ERROR_MESSAGE);
        return result;
    }

    /** Implementation of load map tag from disk */
    private MapTag loadMapImpl(String mapID, String originID) {
        String completeID = new String(originID + "/" + mapID);
        String filename = new String(mapPath + "/" + completeID);
        try {
            XMLFileIO mapLoader = new XMLFileIO();
            XMLData d = mapLoader.readFile(filename);
            if (d == null)
                return null;
            if (d instanceof MapTag) {
                maps.put(completeID, d);
                return (MapTag) d;
            }
            else
                return null;
        }
        catch (IOException e) {return null;}
    }

    /** Returns <code>MapTag</code> either from cache or loaded from disk */
    public MapTag getMap(String originID, String mapID) {
        String completeID = new String(originID + "/" + mapID);

        MapTag map = (MapTag) maps.get(completeID);
        if (map != null) return map;

        map = loadMapImpl(mapID, originID);
        if (map != null) processMap(map, originID);
        return map;
    }

    /**
     * Invoked when a message packet send failes.
     */
    public void sendFailed(PacketEvent pe) {
        //BSCore.logEvent(name, "error: message send failed");
    }

    /**
     * Invoked when a message packet is sent.
     */
    public void sentPacket(PacketEvent pe) {
    }

    // *** map listeners ***

    /**
     * Adds <code>MapListener</code> from listeners notified when
     * map arrives.
     *
     * @see #removeMapListener
     * @see #removeAllMapListeners
     * @see #fireMapReceived
     */
    public void addMapListener(BSMapListener listener) {
        //assert listener != null : listener;
        if (listener == null) return;
        if (!mapListeners.contains(listener)) {
            mapListeners.addElement(listener);
        }
    }

    /**
     * Removes <code>MapListener</code> from listeners notified when
     * map arrives.
     *
     * @see #addMapListener
     * @see #removeAllMapListeners
     * @see #fireMapReceived
     */
    public void removeMapListener(BSMapListener listener) {
        //assert listener != null : listener;
        if (listener == null) return;
        mapListeners.removeElement(listener);
    }

    /**
     * Removes all listeners notified when map arrives.
     * This can be used before to free dependencies and allow dispose of
     * all objects.
     *
     * @see #addMapListener
     * @see #removeMapListener
     * @see #fireMapReceived
     */
    public void removeAllMapListeners() {
        mapListeners.clear();
    }

    /**
     * Notifies map listeners that
     * <code>map</code> was received.
     *
     * @see #addMapListener
     * @see #removeMapListener
     * @see #removeAllMapListeners
     */
    protected void fireMapReceived(MapTag map, String originID) {
        for (Enumeration e = mapListeners.elements(); e.hasMoreElements(); ) {
            BSMapListener listener = (BSMapListener) e.nextElement();
            listener.mapReceived(map, originID);
        }
    }

}