bschatwinmanager.java

一款即时通讯软件

package edu.ou.kmi.buddyspace.gui;

/*
 * BSChatWinManager.java
 *
 * Project: BuddySpace
 * (C) Copyright Knowledge Media Institute 2002
 *
 *
 * Created on 24 October 2002, 10:18
 */

import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;

import org.jabber.jabberbeans.*;
import org.jabber.jabberbeans.util.*;
import org.jabber.jabberbeans.Extension.*;

import edu.ou.kmi.buddyspace.core.*;
import edu.ou.kmi.buddyspace.utils.*;

/**
 * <code>BSChatWinManager</code> is manager of all chat windows. It holds
 * hashtable of open windows and process message redirection into right windows.
 * It relies on <code>BSMessengerBean</code> and <code>BSPresenceBean</code>.
 *
 * @author  Jiri Komzak, Knowledge Media Institute, Open University, United Kingdom
 */
public class BSChatWinManager extends AlertsWinManager
                              implements RosterListener, BSPresenceListener {

    private BSMessengerBean messenger = null;
    private BSPresenceBean presenceBean = null;
    private BSRosterBean rosterBean = null;
    //private Icon chatIcon = null;
    private Image chatImage = null;
    private Image chatNewMsgImage = null;
    protected BSMainFrame mainFrame = null;

    /** Constructor */
    public BSChatWinManager(JTabbedPane tabbedPane, BSMainFrame mainFrame,
                           BSMessengerBean messenger, BSPresenceBean presenceBean) {

        super(tabbedPane);
        this.mainFrame = mainFrame;

        //chatIcon = new ImageIcon(ClassLoader.getSystemResource("images/chat.gif"));
        //chatImage = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource("images/chat.gif"));
        //chatNewMsgImage = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource("images/chat-new.gif"));
        chatImage = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource("images/chat.gif"));
        chatNewMsgImage = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource("images/alert_chat.gif"));
        setMessenger(messenger);
        setPresenceBean(presenceBean);
    }

    /** Sets used <code>BSMessengerBean</code> */
    public void setMessenger(BSMessengerBean messenger) {
        /*if (this.messenger != null)
            this.messenger.removeMessageListener(this);*/
        this.messenger = messenger;
        /*if (messenger != null)
            messenger.addMessageListener(this);*/
    }

    /** Sets used <code>BSPresenceBean</code> */
    public void setPresenceBean(BSPresenceBean presenceBean) {
        if (this.presenceBean != null)
            this.presenceBean.removePresenceListener(this);
        this.presenceBean = presenceBean;
        if (presenceBean != null)
            presenceBean.addPresenceListener(this);
    }

    /** Sets used <code>BSRosterBean</code> */
    public void setRosterBean(BSRosterBean rosterBean) {
        if (this.rosterBean != null)
            this.rosterBean.removeRosterListener(this);
        this.rosterBean = rosterBean;
        if (rosterBean != null)
            rosterBean.addRosterListener(this);
    }

    /**
     * Returns if jid has more than one online resource.
     */
    private boolean hasMoreResources(JID jid) {
        if (presenceBean == null || jid == null)
            return false;

        Enumeration e = presenceBean.getAllPresences(jid);
        if (e.hasMoreElements()) {
            e.nextElement();
            // if jid has two or more online presences, returns true
            if (e.hasMoreElements()) return true;
        }
        return false;

    }

    /**
     * Opens chat window if not exist already.
     * @param nick nickname used for title of window and inside the window
     * @param local nickname of local user
     * @param select if true the window is selected
     * @param forceResource if true force opening of window for specified resource
     * @param showResource if true shows resource in title of window (hack for conferencing)
     */
    public void openChatWindow(JID jid, String nick, String local,
                               boolean select, boolean forceResource,
                               boolean showResource) {
        // returns when null params
        if (messenger == null || tabbedPane == null) return;

        // gets existing window for jid with resource
        //String message;
        Message message;
        //String str = BSPresenceBean.getJIDHashString(jid, true);
        String id = jid.normalize();
        //BSChatWindow win = (BSChatWindow) getWindow(str);
        BSChatWindow win = (BSChatWindow) getWindow(id);
        // if doesn't exist and doesn't have to force resource
        if (win == null && !forceResource) {
            // gets window for jid without resource
            //String str2 = BSPresenceBean.getJIDHashString(jid, false);
            String id2 = jid.getSimpleJID().normalize();
            //win = (BSChatWindow) getWindow(str2);
            win = (BSChatWindow) getWindow(id2);
        }
        if (win == null) {
            // if doesn't have to leave resource and doesn't have more resources
            if (!forceResource && !hasMoreResources(jid)) {
                //jid = new JID(jid.getUsername(), jid.getServer(), null);
                jid = jid.getSimpleJID();
                //str = BSPresenceBean.getJIDHashString(jid, false);
                id = jid.normalize();
            }
            // creates a new chat window for JID
            String resource = jid.getResource();
            if (resource != null && !resource.equals("") && showResource)
                nick = nick + "/" + resource;
            boolean dock = mainFrame.isDockingWindows();
            win = new BSChatWindow(mainFrame, this, jid, nick, chatImage, nick,
                                                    local, dock, showResource);
            addWindow(win, dock);
            showWindow(win, true, select);
        }

        if (select) {
            selectWindow(win);
            if (win.isDocked())
                mainFrame.toFront();
        }

        JID usedJID = win.getJID();
        boolean newMsgs = false;

        Enumeration msgsEnum = messenger.getMessagePackets(usedJID, "chat");
        while (msgsEnum.hasMoreElements()) {
            message = (Message) msgsEnum.nextElement();
            messenger.deleteMessagePacket(message);
            win.addReceivedMessage(message);
            newMsgs = true;
        }
        msgsEnum = messenger.getMessagePackets(usedJID, "");
        while (msgsEnum.hasMoreElements()) {
            message = (Message) msgsEnum.nextElement();
            messenger.deleteMessagePacket(message);
            win.addReceivedMessage(message);
            newMsgs = true;
        }
        msgsEnum = messenger.getMessagePackets(usedJID, "headline");
        while (msgsEnum.hasMoreElements()) {
            message = (Message) msgsEnum.nextElement();
            messenger.deleteMessagePacket(message);
            win.addReceivedMessage(message);
            newMsgs = true;
        }

       String from = jid.toString().toLowerCase();
       if (!from.startsWith(BSMainFrame.buddyFinderBotJID))
       {
           updateNewMessageFlags(win, newMsgs);
       }

        // groupchat hack
        if (!showResource) {
            // changes the crazy room/resource id to nick
            int index = tabbedPane.indexOfComponent(win);
            if (index != -1) tabbedPane.setTitleAt(index, nick);
            win.setNick(nick);
        }
    }


    /** Updates newMessage flags */
    public void updateNewMessageFlags(AlertsDockableWindow win, boolean newMsg) {
        boolean select = mainFrame.isAutoPopping();
        if (newMsg && select) {
            selectWindow(win);
            if (win.isDocked())
                mainFrame.toFront();
        }

        super.updateNewMessageFlags(win, newMsg);

        mainFrame.setNewMessage();
    }


    /** Sends message */
    public void sendMessage(JID jid, String body, String thread) {
        //messenger.sendMessage(jid, body, null, "chat");
        messenger.sendChatMessage(jid, body, thread);
    }


    /** Sends message */
    public void sendMessage(Message message) {
        //messenger.sendMessage(jid, body, null, "chat");
        messenger.sendMessage(message);
    }


    /** Sends url inside message **/
    public Message sendURL(JID jid, String thread, String url, String urlDesc) {
        return messenger.sendURLMessage(jid, "chat", null, urlDesc + ": " + url,
                                        thread, url, urlDesc);
    }

    /**
     * <code>BSPresenceListener</code> function.
     * Calls presenceChanged for JID's window.
     */
    public void presenceChanged(BSPresenceInfo pi) {
        JID jid;
        if (presenceBean == null || pi == null || (jid = pi.getJID()) == null)
            return;

        //String str = BSPresenceBean.getJIDHashString(jid, true);
        String id = jid.normalize();
        //BSChatWindow win = (BSChatWindow) openWindows.get(str);
        BSChatWindow win = (BSChatWindow) openWindows.get(id);
        if (win != null)
            win.presenceChanged(pi);

        //str = BSPresenceBean.getJIDHashString(jid, false);
        id = jid.getSimpleJID().normalize();
        //win = (BSChatWindow) openWindows.get(str);
        win = (BSChatWindow) openWindows.get(id);
        if (win != null) {
            win.presenceChanged(pi);
        }
    }

    /** <code>BSPresenceListener</code> function. Empty implementation. */
    public void presencesCleared() {
        Enumeration wins = openWindows.elements();
        while(wins.hasMoreElements()) {
            BSChatWindow w = (BSChatWindow) wins.nextElement();
            w.presenceChanged(new BSPresenceInfo(w.getJID(), false, null, null));
        }
    }

    /** <code>BSPresenceListener</code> function. Empty implementation. */
    public void subscriptionApproved(JID jid) { }
    /** <code>BSPresenceListener</code> function. Empty implementation. */
    public void subscriptionRequested(JID jid) { }


    protected Image getWinImage(AlertsDockableWindow win, boolean newMsg) {
        if (newMsg)
            return chatNewMsgImage;
        else
            return chatImage;
    }


    /** Opens windows specified in vector. */
    public void openTheWindows(Vector openWindows, BSRosterBean rosterBean, boolean connected) {
        if (openWindows == null) return;
        if (!connected) return;

        Enumeration owEnum = openWindows.elements();
        while (owEnum.hasMoreElements()) {
            BSOpenWindows.BSOpenWindow ow = (BSOpenWindows.BSOpenWindow) owEnum.nextElement();
            if ("chat".equals(ow.namespace) && ow.jid != null) {
                // opens the window
                String nick = null;
                if (rosterBean != null)
                    nick = rosterBean.getFriendlyName(ow.jid);
                if (nick == null || nick.equals(""))
                    //nick = BSPresenceBean.getJidWithoutRes(ow.jid).toString();
                    nick = ow.jid.toSimpleString();
                openChatWindow(ow.jid, nick, BSMainFrame.username, true, true, true);
                // sets its size and position
                BSOpenWindows.adjustWindowToScreen(ow);
                //String jidStr = BSPresenceBean.getJIDHashString(ow.jid, true);
                String id = ow.jid.normalize();
                //BSChatWindow win = (BSChatWindow) getWindow(jidStr);
                BSChatWindow win = (BSChatWindow) getWindow(id);
                if (win != null) {
                    win.setFrameSize(ow.width, ow.height);
                    win.setFrameLocation(ow.x, ow.y);
                    setWindowDocked(win, ow.docked);
                }
            } //if
        } //while
    }


    /** Add its open windows into the vector (for opening when starting next time). */
    public void addOpenWindows(Vector openWindows, boolean connected) {
        if (openWindows == null) return;
        if (!connected) return;

        Enumeration owEnum = this.openWindows.elements();
        while (owEnum.hasMoreElements()) {
            BSChatWindow win = (BSChatWindow) owEnum.nextElement();
            JID jid = win.getJID();
            if (jid != null) {
                BSOpenWindows.BSOpenWindow ow = new BSOpenWindows.BSOpenWindow(jid,
                                        "chat",
                                        win.getFrameX(), win.getFrameY(),
                                        win.getFrameWidth(), win.getFrameHeight(),
                                        win.isDocked());
                openWindows.add(ow);
            }
        } //while
    }

    /** Roster listener function - refreshes nicks of windows */
    public void changedRoster(Roster r) {
        refreshWindowNicks();
    }

    /** Roster listener function - refreshes nicks of windows */
    public void replacedRoster(Roster r) {
        refreshWindowNicks();
    }


    /** Refreshes nicks of windows accoding to current roster */
    public void refreshWindowNicks() {
        Enumeration wins = openWindows.elements();
        while(wins.hasMoreElements()) {
            BSChatWindow w = (BSChatWindow) wins.nextElement();
            JID jid = w.getJID();
            String nick = rosterBean.getFriendlyName(jid);
            String resource = jid.getResource();
            if (w.isShowResource() && resource != null && !"".equals(resource))
                nick += "/" + resource;
            w.setNick(nick);
            setWindowTitle(w, nick);
        }
    }

}