bsconfwinmanager.java

一款即时通讯软件

package edu.ou.kmi.buddyspace.plugins.conference.gui;

/*
 * BSConfWinManager.java
 *
 * Project: BuddySpace
 * (C) Copyright Knowledge Media Institute 2002
 *
 *
 * Created on 30 October 2002, 15:13
 */

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

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.conference.*;
import edu.ou.kmi.buddyspace.plugins.conference.core.*;

/**
 * <code>BSConfWinManager</code> manages conference room windows.
 * It listens to events and forwards them to particular windows.
 * It relies on <code>BSConfBeanInterface</code>.
 *
 * @author  Jiri Komzak, Knowledge Media Institute, Open University, United Kingdom
 */
public class BSConfWinManager extends AlertsWinManager
                              implements BSConfListener {

    protected BSConfBeanInterface confBean = null;
    protected BSRosterBean rosterBean = null;
    protected BSPresenceBean presenceBean = null;

    protected BSMainFrame mainFrame = null;

    protected Image confImage = null;
    protected Image alertConfImage = null;

    protected int lastId = 0;

    /** Constructor */
    public BSConfWinManager(BSMainFrame mainFrame, JTabbedPane tabbedPane) {
        super(tabbedPane);
        this.mainFrame = mainFrame;
        //confImage = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource("images/conf.gif"));
        confImage = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource("images/conference.gif"));
        alertConfImage = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource("images/alert_conference.gif"));
    }

    /** Constructor */
    public BSConfWinManager(BSMainFrame mainFrame, JTabbedPane tabbedPane,
                     BSConfBeanInterface confBean, BSRosterBean rosterBean) {
        this(mainFrame, tabbedPane);
        setConfBean(confBean);
        setRosterBean(rosterBean);
    }

    /** Sets conference bean */
    public void setConfBean(BSConfBeanInterface confBean) {
        if (this.confBean != null)
            this.confBean.removeConfListener(this);
        this.confBean = confBean;
        if (confBean != null)
            confBean.addConfListener(this);
    }

    /** Sets roster bean */
    public void setRosterBean(BSRosterBean rosterBean) {
        /*if (this.rosterBean != null)
            this.rosterBean.removeRosterListener(this);*/
        this.rosterBean = rosterBean;
        /*if (rosterBean != null)
            rosterBean.addRosterListener(this);*/
    }

    /** Sets presence bean */
    public void setPresenceBean(BSPresenceBean presenceBean) {
        this.presenceBean = presenceBean;
    }

    /** Selects window for given room */
    public void selectRoom(JID roomJID) {
        if (roomJID == null) return;

        //String hashJID = BSPresenceBean.getJIDHashString(roomJID, false);
        String key = roomJID.getSimpleJID().normalize();
        //BSConfWindow win = (BSConfWindow) openWindows.get(hashJID);
        //BSConfWindow win = (BSConfWindow) getWindow(hashJID);
        //DockableWindow win = getWindow(hashJID);
        DockableWindow win = getWindow(key);
        if (win == null) return;

        //tabbedPane.setSelectedComponent(win);
        selectWindow(win);
    }

    /** Changes nickname in given room */
    public void changeNick(JID roomJID) {
        if (roomJID == null) return;

        String key = roomJID.getSimpleJID().normalize();
        DockableWindow win = getWindow(key);
        if (win == null) return;

        selectWindow(win);
        ((BSConfWindow)win).changeNick();
    }

    /** Opens new window for room */
    public void joinRoom(String roomName, String server, String nick) {
        if (roomName == null || server == null || nick == null) return;

        JID roomJID = new JID(roomName, server, null);
        //String hashJID = BSPresenceBean.getJIDHashString(roomJID, false);
        String key = roomJID.getSimpleJID().normalize();
        //BSConfWindow win = (BSConfWindow) openWindows.get(hashJID);
        //BSConfWindow win = (BSConfWindow) getWindow(hashJID);
        //DockableWindow win = getWindow(hashJID);
        DockableWindow win = getWindow(key);

        if (win != null && win instanceof BSConfWindow) {
            selectRoom(roomJID);
            ((BSConfWindow)win).errorWM(roomJID, "", "already in room");
            return;
        }

        boolean dock = mainFrame.isDockingWindows();
        /*win = new BSConfWindow(mainFrame, this, hashJID, confImage, roomName,
                                                server, nick, confBean, dock);*/
        win = new BSConfWindow(mainFrame, this, key, confImage, roomName,
                                                server, nick, confBean, dock);
        // *** start joining ***

        //win.setPresenceBean(presenceBean);
        addWindow(win, dock);
        showWindow(win, true, true);
        selectWindow(win);
    }

    /** Returns elements of main roster */
    public Enumeration getRoster() {
        if (rosterBean != null)
            return rosterBean.entries();
        else {
            return new Vector().elements();
        }
    }

    /**
     * Calles when invitation received.
     * Displays confirmation dialog and joins the room.
     */
    public void invitation(JID fromAddress, JID roomJID, String subject, String body) {
        String fromNick = null;
        if (rosterBean != null)
            fromNick = rosterBean.getFriendlyName(fromAddress);
        if (fromNick == null && fromAddress != null)
            fromNick = fromAddress.toString();
        Object[] options = {"Yes", "No"};
        int result = JOptionPane.showOptionDialog(mainFrame,
                        "<" + fromNick + "> invites you to join chat.\n" +
                        "S: " + subject + "\n" +
                        "B: " + body + "\n\n" +
                        "Do you want to join room \"" + roomJID.toString() + "\"?",
                        "Join chat?",
                        JOptionPane.YES_NO_OPTION,
                        JOptionPane.QUESTION_MESSAGE,
                        null, options, options[0]);
        if (result == 0) {
            String username = mainFrame.username;
            //joinRoom(roomJID.getUsername(), roomJID.getServer(), username);
            BSConfJoinDialog dlg = new BSConfJoinDialog(mainFrame, this,
                                       roomJID.getServer(), roomJID.getUsername(),
                                       username, true);
            dlg.setVisible(true);
        }
    }

    /**
     * Opens window for composing invitation for specified <code>jidList</code> and
     * <code>groupList</code>. As recipients it takes all specified jids
     * and adds to them all jids in specified groups.
     * @param jidList <code>Enumeration</code> of JIDs of recipients
     * @param groupList <code>Enumeration</code> of Strings of recipient groups
     */
    public BSConfInvitationWin composeInvitation(JID confJID, Enumeration jidList, Enumeration groupList) {
        // returns when null params
        if (confBean == null || rosterBean == null || tabbedPane == null || confJID == null)
            return null;

        Vector recipients = new Vector();
        while (jidList != null && jidList.hasMoreElements()) {
            recipients.add(jidList.nextElement());
        }
        while (groupList != null && groupList.hasMoreElements()) {
            Enumeration jidEnum = rosterBean.getJIDsInGroup((String)groupList.nextElement());
            while (jidEnum.hasMoreElements())
                recipients.add(jidEnum.nextElement());
        }

        // creates new compose invitation window
        String idStr = Integer.toString(++lastId);
        boolean dock = mainFrame.isDockingWindows();
        String winTitle = "Invitation into chatroom " + confJID.toString();
        BSConfInvitationWin win = new BSConfInvitationWin(mainFrame, mainFrame, this, idStr, winTitle, confJID, confImage, confBean, rosterBean, presenceBean, dock);
        addWindow(win, dock);
        showWindow(win, true, true);
        win.addRecipients(recipients.elements());

        selectWindow(win);
        return win;
    }

    /** Opens private chat window (calls to the main window to do it). */
    public void openChatWindow(JID jid, boolean select, boolean forceResource) {
        String nick = confBean.getNick(jid);
        mainFrame.openChatWindow(jid, select, forceResource, nick);
    }

    /** Closes all chatroom windows. */
    /*public void closeAllWindows() {
        Enumeration enum = openWindows.elements();
        while (enum.hasMoreElements()) {
            BSConfWindow win = (BSConfWindow) enum.nextElement();
            closeTab(win);
        }
    }*/

    /** Empty */
    public void groupMessage(JID fromAddress, String nick, String body) { }
    /** Empty */
    public void presenceChanged(JID fromAddress, String nick, BSPresenceInfo pi) { }
    /** Empty */
    public void privateMessage(JID fromAddress, String nick, String body) { }
    /** Empty */
    public void roomMessage(JID roomJID, String body) { }
    /** Empty */
    public void stateChanged(JID roomJID, int state) { }
    /** Empty  */
    public void setMyJID(JID roomJID, JID myJID) { }

    /** Called when error occures. */
    public void error(JID roomJID, String errCode, String errMsg) {
        selectRoom(roomJID);
        //DockableWindow win = (roomJID != null)? getWindow(roomJID.toString()) : null;
        DockableWindow win = (roomJID != null)? getWindow(roomJID.getSimpleJID().normalize()) : null;
        if (win != null && win instanceof BSConfWindow)
            ((BSConfWindow)win).errorWM(roomJID, errCode, errMsg);
        else
            JOptionPane.showMessageDialog(mainFrame,
                        "Error " + errCode + ": " + errMsg + "!",
                        "Error",
                        JOptionPane.ERROR_MESSAGE);
    }


    /** 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();
        if (newMsg)
            mainFrame.playAlertSound();
    }


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


    public boolean addBookmark(JID jid) {
        if (mainFrame == null || jid == null) return false;
        return mainFrame.addBookmark(jid, "jabber:iq:conference",
                                     "Conference room " + jid.getUsername());
    }


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

        Enumeration owEnum = openWindows.elements();
        while (owEnum.hasMoreElements()) {
            BSOpenWindows.BSOpenWindow ow = (BSOpenWindows.BSOpenWindow) owEnum.nextElement();
            if ("jabber:iq:conference".equals(ow.namespace) && ow.jid != null) {
                // opens the room
                joinRoom(ow.jid.getUsername(), ow.jid.getServer(), BSMainFrame.username);
                // sets its size and location
                BSOpenWindows.adjustWindowToScreen(ow);
                //String hashJID = BSPresenceBean.getJIDHashString(ow.jid, false);
                String key = ow.jid.getSimpleJID().normalize();
                //DockableWindow win = (DockableWindow) getWindow(hashJID);
                DockableWindow win = (DockableWindow) getWindow(key);
                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()) {
            BSConfWindow win = (BSConfWindow) owEnum.nextElement();
            JID jid = win.getRoomJID();
            if (jid != null) {
                BSOpenWindows.BSOpenWindow ow = new BSOpenWindows.BSOpenWindow(jid,
                                        "jabber:iq:conference",
                                        win.getFrameX(), win.getFrameY(),
                                        win.getFrameWidth(), win.getFrameHeight(),
                                        win.isDocked());
                openWindows.add(ow);
            }
        } //while
    }

}