bsmsgwinmanager.java

一款即时通讯软件

package edu.ou.kmi.buddyspace.gui;

/*
 * BSMsgWinManager.java
 *
 * Project: BuddySpace
 * (C) Copyright Knowledge Media Institute 2002
 *
 *
 * Created on 14 November 2002, 9:50
 */

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

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

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

/**
 * <code>BSMsgWinManager</code> is manager of plain message and headline windows
 * as well as compose message windows. It holds
 * hashtable of open windows and process message redirection into right windows.
 * It relies on <code>BSMessengerBean</code> and <code>BSRosterBean</code>.
 *
 * @author  Jiri Komzak, Knowledge Media Institute, Open University, United Kingdom
 */
public class BSMsgWinManager extends WinManager
                              implements /*BSMessageListener,*/ ChangeListener {
                                            
    private BSMessengerBean msgBean = null;
    private BSRosterBean rosterBean = null;
    private BSPresenceBean presenceBean = null;
    private Image msgImage = null;
    private Image msgAlertImage = null;
    protected BSMainFrame mainFrame = null;
    
    private final int MSGS_WIN_ID = 0;
    private final int HEADLINES_WIN_ID = 1;
    private final int DEBUG_WIN_ID = 2;
    private final int STATUS_WIN_ID = 3;
    private int lastId = STATUS_WIN_ID;
    
    /** Constructor */
    public BSMsgWinManager(JTabbedPane tabbedPane, BSMainFrame mainFrame,
                           BSMessengerBean msgBean, BSRosterBean rosterBean) {
                               
        super(tabbedPane);
        
        this.mainFrame = mainFrame;
        //msgImage = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource("images/message-small.gif"));
        msgImage = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource("images/messages.gif"));
        msgAlertImage = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource("images/alert_messages.gif"));
        setMsgBean(msgBean);
        setRosterBean(rosterBean);
        setTabbedPane(tabbedPane);
        if (tabbedPane != null)
            tabbedPane.addChangeListener(this);
        
        //showMessagesWindow(true, false);
    }
    
    /** Sets used <code>BSMessengerBean</code> */
    public void setMsgBean(BSMessengerBean msgBean) {
        /*if (this.msgBean != null)
            this.msgBean.removeMessageListener(this);*/
        this.msgBean = msgBean;
        /*if (msgBean != null)
            msgBean.addMessageListener(this);*/
    }
    
    /** Sets used <code>BSRosterBean</code> */
    public void setRosterBean(BSRosterBean rosterBean) {
        /*if (this.rosterBean != null)
            this.rosterBean.removePresenceListener(this);*/
        this.rosterBean = rosterBean;
        /*if (rosterBean != null)
            rosterBean.addPresenceListener(this);*/
    }
    
    /** Sets used <code>BSPresenceBean</code> */
    public void setPresenceBean(BSPresenceBean presenceBean) {
        this.presenceBean = presenceBean;
    }
    
    /**
     * Opens compose message window 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 BSComposeMsgWin composeMessage(Enumeration jidList, Enumeration groupList) {
        // returns when null params
        if (msgBean == null || rosterBean == null || tabbedPane == 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 window
        String idStr = Integer.toString(++lastId);
        boolean dock = mainFrame.isDockingWindows();
        BSComposeMsgWin win = new BSComposeMsgWin(mainFrame, this, idStr, "Compose", msgImage, 
                                                  rosterBean, presenceBean, dock);
        addWindow(win, dock);
        showWindow(win, true, true);
        win.addRecipients(recipients.elements());
            
        selectWindow(win);
        return win;
    }
    
    /**
     * Shows/hides window with list of received messages.
     */
    public void showMessagesWindow(boolean show, boolean select, boolean docked) {
        mainFrame.setShowMessages(show);
        
        String idStr = Integer.toString(MSGS_WIN_ID);
        BSMessagesWindow win = (BSMessagesWindow) getWindow(idStr);
            
        // if show
        if (show) {
            // if not open
            if (win == null) {
                win = new BSMessagesWindow(mainFrame, this, idStr, 
                                           "Messages", msgImage, docked);
                addWindow(win, docked);
                win.setMessengerBean(msgBean);
            }
            
            showWindow(win, show, select);
            
            if (select) {
                selectWindow(win);
            }
        
        }
        // if hide
        else
            if (win != null) showWindow(win, show, select);
    }
    
    /**
     * Shows/hides debug window.
     */
    public void showDebugWindow(boolean show, boolean select, BSCore core, boolean docked) {
        mainFrame.setShowDebug(show);
        
        String idStr = Integer.toString(DEBUG_WIN_ID);
        BSDebugWin win = (BSDebugWin) getWindow(idStr);
            
        // if show
        if (show) {
            // if not open
            if (win == null) {
                win = new BSDebugWin(mainFrame, this, idStr, 
                                           "Debug", null, core, docked);
                addWindow(win, docked);
            }
            
            showWindow(win, show, select);
            
            if (select) {
                selectWindow(win);
            }
        }
        // if hide
        else
            if (win != null) showWindow(win, show, select);
    }
    
    /**
     * Shows/hides status window.
     */
    public void showStatusWindow(boolean show, boolean select, BSCore core, boolean docked) {
        mainFrame.setShowStatus(show);
        
        String idStr = Integer.toString(STATUS_WIN_ID);
        BSStatusWin win = (BSStatusWin) getWindow(idStr);
            
        // if show
        if (show) {
            // if not open
            if (win == null) {
                win = new BSStatusWin(mainFrame, this, idStr, 
                                           "Status", null, core, docked);
                addWindow(win, docked);
            }
            
            showWindow(win, show, select);
            
            if (select) {
                selectWindow(win);
            }
        }
        // if hide
        else
            if (win != null) showWindow(win, show, select);
    }
    
    /**
     * Shows/hides window with list of received headlines.
     */
    public void showHeadlinesWindow(boolean show) {
    }
    
    /**
     * Adds the message into messages window and possibly selects it.
     */
    public void addMessage(Message msg, boolean select) {
        
        // stores msg to history
        if (msg != null) {
            JID jid = msg.getFromAddress();
            if (jid != null)
                /*History.storeMessage(new JID(BSMainFrame.username, BSMainFrame.server, null),
                                      jid, jid.getUsername(), msg.getSubject(), msg.getBody());*/
                History.storeIncomingMessage(msg, jid.getUsername());
        }
        
        boolean docked = mainFrame.isDockingWindows();
        showMessagesWindow(true, select, docked);
        
        String idStr = Integer.toString(MSGS_WIN_ID);
        BSMessagesWindow win = (BSMessagesWindow) getWindow(idStr);
        if (win == null) return;
        
        win.addMessage(msg);
        
        //mainFrame.setNewMessage();
    }
    
    /** Updates newMessage flags */
    public void updateNewMessageFlags() {
        
        String idStr = Integer.toString(MSGS_WIN_ID);
        BSMessagesWindow win = (BSMessagesWindow) getWindow(idStr);
        if (win == null) return;
        
        win.setIcon(win.isNewMessage()? msgAlertImage : msgImage);
        
        // if window is docked
        if (win.isDocked()) {
            int index = tabbedPane.indexOfComponent(win);
            // if window is selected
            if (tabbedPane.getSelectedIndex() == index) {
                tabbedPane.setForegroundAt(index, null);
                tabbedPane.setIconAt(index, new ImageIcon(msgImage));
            }
            // else window is not selected
            else {
                if (win.isNewMessage() && index != -1) {
                    tabbedPane.setForegroundAt(index, new Color(255,0,0));
                    tabbedPane.setIconAt(index, new ImageIcon(msgAlertImage));
                }
            }
        }
        // else window is not docked
        else {
            // window is selected
            //if (win.isSelected())
        }
    }
    
    
    /** Sends message */
    public boolean sendMessage(Enumeration jidList, String body, String subject) {
        if (msgBean == null) return false;
        
        while (jidList.hasMoreElements()) {
            JID jid = (JID)jidList.nextElement();
            msgBean.sendMessage(jid, body, subject);
            // stores msg to history
            History.storeMessage(new JID(BSMainFrame.username, BSMainFrame.server, null),
                                 jid, BSMainFrame.username, subject, body);
        }
        
        return true;
    }
    
    /** Closes all windows */
    public void closeAllWindows() {
        super.closeAllWindows();
    }
    
    /** Returns friendly name of JID */
    public String getFriendlyName(JID jid) {
        if (rosterBean != null)
            return rosterBean.getFriendlyName(jid);
        else
            return (jid != null)? jid.toString() : null;
    }
    
    /** Called from windows to let this know that messages was read */
    public void setNewMessage() {
        updateNewMessageFlags();
        mainFrame.setNewMessage();
    }
    
    /** Returns if there are some new unread messages */
    public boolean isNewMessage() {
        String idStr = Integer.toString(MSGS_WIN_ID);
        BSMessagesWindow win = (BSMessagesWindow) getWindow(idStr);
        return (win == null)? false : win.isNewMessage();
    }
    
    /** 
     * <code>ChangeListener</code> function.
     * Cancel highlighting when highlighted selected.
     */
    public void stateChanged(ChangeEvent evt) {
        Object src = evt.getSource();
        if (src == tabbedPane) {
            updateNewMessageFlags();
        }
    }
    
}