groupchatparticipantlist.java.svn-base

来自「开源项目openfire的完整源程序」· SVN-BASE 代码 · 共 891 行 · 第 1/3 页

/**
 * $Revision: $
 * $Date: $
 *
 * Copyright (C) 2006 Jive Software. All rights reserved.
 *
 * This software is published under the terms of the GNU Lesser Public License (LGPL),
 * a copy of which is included in this distribution.
 */

package org.jivesoftware.spark.ui.conferences;

import org.jdesktop.swingx.JXList;
import org.jivesoftware.resource.Res;
import org.jivesoftware.resource.SparkRes;
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.packet.XMPPError;
import org.jivesoftware.smack.util.StringUtils;
import org.jivesoftware.smackx.ServiceDiscoveryManager;
import org.jivesoftware.smackx.muc.Affiliate;
import org.jivesoftware.smackx.muc.InvitationRejectionListener;
import org.jivesoftware.smackx.muc.MultiUserChat;
import org.jivesoftware.smackx.muc.Occupant;
import org.jivesoftware.smackx.muc.UserStatusListener;
import org.jivesoftware.smackx.packet.DiscoverInfo;
import org.jivesoftware.spark.ChatManager;
import org.jivesoftware.spark.PresenceManager;
import org.jivesoftware.spark.SparkManager;
import org.jivesoftware.spark.UserManager;
import org.jivesoftware.spark.component.ImageTitlePanel;
import org.jivesoftware.spark.ui.ChatRoom;
import org.jivesoftware.spark.ui.ChatRoomListener;
import org.jivesoftware.spark.ui.ChatRoomNotFoundException;
import org.jivesoftware.spark.ui.rooms.ChatRoomImpl;
import org.jivesoftware.spark.ui.rooms.GroupChatRoom;
import org.jivesoftware.spark.util.ModelUtil;
import org.jivesoftware.spark.util.log.Log;

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.DefaultListModel;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.ListCellRenderer;
import javax.swing.SwingUtilities;

/**
 * The <code>RoomInfo</code> class is used to display all room information, such as agents and room information.
 */
public final class GroupChatParticipantList extends JPanel implements ChatRoomListener {
    private GroupChatRoom groupChatRoom;
    private final ImageTitlePanel agentInfoPanel;
    private ChatManager chatManager;
    private MultiUserChat chat;

    private final Map<String, String> userMap = new HashMap<String, String>();

    private UserManager userManager = SparkManager.getUserManager();

    private DefaultListModel model = new DefaultListModel();

    private JXList participantsList;

    private PacketListener listener = null;

    private Map<String, String> invitees = new HashMap<String, String>();

    private boolean allowNicknameChange = true;

    private DiscoverInfo roomInformation;

    private List<JLabel> users = new ArrayList<JLabel>();

    /**
     * Creates a new RoomInfo instance using the specified ChatRoom.  The RoomInfo
     * component is responsible for monitoring all activity in the ChatRoom.
     */
    public GroupChatParticipantList() {
        setLayout(new GridBagLayout());
        chatManager = SparkManager.getChatManager();

        agentInfoPanel = new ImageTitlePanel(Res.getString("message.participants.in.room"));
        participantsList = new JXList(model);
        participantsList.setCellRenderer(new ParticipantRenderer());

        // Set the room to track
        this.setOpaque(false);
        this.setBackground(Color.white);

        // Respond to Double-Click in Agent List to start a chat
        participantsList.addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent evt) {
                if (evt.getClickCount() == 2) {
                    String selectedUser = getSelectedUser();
                    startChat(groupChatRoom, (String)userMap.get(selectedUser));
                }
            }

            public void mouseReleased(final MouseEvent evt) {
                if (evt.isPopupTrigger()) {
                    checkPopup(evt);
                }
            }

            public void mousePressed(final MouseEvent evt) {
                if (evt.isPopupTrigger()) {
                    checkPopup(evt);
                }
            }
        });


        JScrollPane scroller = new JScrollPane(participantsList);

        // Speed up scrolling. It was way too slow.
        scroller.getVerticalScrollBar().setBlockIncrement(50);
        scroller.getVerticalScrollBar().setUnitIncrement(20);
        scroller.setBackground(Color.white);
        scroller.getViewport().setBackground(Color.white);

        add(scroller, new GridBagConstraints(0, 0, 1, 1, 1.0, 1.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
    }

    public void setChatRoom(final ChatRoom chatRoom) {
        this.groupChatRoom = (GroupChatRoom)chatRoom;

        chatManager.addChatRoomListener(this);

        chat = groupChatRoom.getMultiUserChat();

        chat.addInvitationRejectionListener(new InvitationRejectionListener() {
            public void invitationDeclined(String jid, String message) {
                String nickname = userManager.getUserNicknameFromJID(jid);

                userHasLeft(chatRoom, nickname);

                chatRoom.getTranscriptWindow().insertNotificationMessage(nickname + " has rejected the invitation.", ChatManager.NOTIFICATION_COLOR);
            }
        });


        listener = new PacketListener() {
            public void processPacket(final Packet packet) {
                SwingUtilities.invokeLater(new Runnable() {
                    public void run() {
                        Presence p = (Presence)packet;
                        if (p.getError() != null) {
                            if (p.getError().getCondition().equals(XMPPError.Condition.conflict.toString())) {
                                return;
                            }
                        }
                        final String userid = p.getFrom();

                        String nickname = StringUtils.parseResource(userid);
                        userMap.put(nickname, userid);

                        if (p.getType() == Presence.Type.available) {
                            addParticipant(userid, p);
                            agentInfoPanel.setVisible(true);
                        }
                        else {
                            removeUser(nickname);
                        }
                    }
                });

            }
        };

        chat.addParticipantListener(listener);

        ServiceDiscoveryManager disco = ServiceDiscoveryManager.getInstanceFor(SparkManager.getConnection());
        try {
            roomInformation = disco.discoverInfo(chat.getRoom());
        }
        catch (XMPPException e) {
            Log.debug("Unable to retrieve room informatino for " + chat.getRoom());
        }
    }

    public void chatRoomOpened(ChatRoom room) {
        if (room != groupChatRoom) {
            return;
        }


        chat.addUserStatusListener(new UserStatusListener() {
            public void kicked(String actor, String reason) {

            }

            public void voiceGranted() {

            }

            public void voiceRevoked() {

            }

            public void banned(String actor, String reason) {

            }

            public void membershipGranted() {

            }

            public void membershipRevoked() {

            }

            public void moderatorGranted() {

            }

            public void moderatorRevoked() {

            }

            public void ownershipGranted() {
            }

            public void ownershipRevoked() {

            }

            public void adminGranted() {

            }

            public void adminRevoked() {

            }
        });
    }

    public void chatRoomLeft(ChatRoom room) {
        if (this.groupChatRoom == room) {
            chatManager.removeChatRoomListener(this);
            agentInfoPanel.setVisible(false);
        }
    }

    public void chatRoomClosed(ChatRoom room) {
        if (this.groupChatRoom == room) {
            chatManager.removeChatRoomListener(this);
            chat.removeParticipantListener(listener);
        }
    }

    public void chatRoomActivated(ChatRoom room) {
    }


    public void userHasJoined(ChatRoom room, String userid) {
    }

    public void addInvitee(String jid, String message) {
        // So the problem with this is that I have no idea what the users actual jid is in most cases.
        final UserManager userManager = SparkManager.getUserManager();

        String nickname = userManager.getUserNicknameFromJID(jid);

        groupChatRoom.getTranscriptWindow().insertNotificationMessage(nickname + " has been invited to join this room.", ChatManager.NOTIFICATION_COLOR);

        if (roomInformation != null && !roomInformation.containsFeature("muc_nonanonymous")) {
            return;