conferenceroombrowser.java

来自「开源项目openfire的完整源程序」· Java 代码 · 共 726 行 · 第 1/2 页

/**
 * $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.jivesoftware.resource.Res;
import org.jivesoftware.resource.SparkRes;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.util.StringUtils;
import org.jivesoftware.smackx.Form;
import org.jivesoftware.smackx.bookmark.BookmarkedConference;
import org.jivesoftware.smackx.muc.HostedRoom;
import org.jivesoftware.smackx.muc.MultiUserChat;
import org.jivesoftware.smackx.muc.RoomInfo;
import org.jivesoftware.spark.ChatManager;
import org.jivesoftware.spark.SparkManager;
import org.jivesoftware.spark.component.JiveTreeNode;
import org.jivesoftware.spark.component.RolloverButton;
import org.jivesoftware.spark.component.Table;
import org.jivesoftware.spark.component.TitlePanel;
import org.jivesoftware.spark.component.Tree;
import org.jivesoftware.spark.ui.ChatRoomNotFoundException;
import org.jivesoftware.spark.ui.rooms.GroupChatRoom;
import org.jivesoftware.spark.util.ResourceUtils;
import org.jivesoftware.spark.util.SwingWorker;
import org.jivesoftware.spark.util.log.Log;
import org.jivesoftware.sparkimpl.settings.local.LocalPreferences;
import org.jivesoftware.sparkimpl.settings.local.SettingsManager;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

/**
 * A UI that handles all Group Rooms contained in an XMPP Messenger server.  This handles
 * creation and joining of rooms for group chat discussions as well as the listing
 * of the creation times, number of occupants in a room, and the room name itself.
 */
public class ConferenceRoomBrowser extends JPanel implements ActionListener {
    private final RoomList roomsTable;
    private final RolloverButton createButton = new RolloverButton("", SparkRes.getImageIcon(SparkRes.SMALL_USER1_NEW));
    private final RolloverButton joinRoomButton = new RolloverButton("", SparkRes.getImageIcon(SparkRes.DOOR_IMAGE));
    private final RolloverButton refreshButton = new RolloverButton("", SparkRes.getImageIcon(SparkRes.REFRESH_IMAGE));
    private final RolloverButton addRoomButton = new RolloverButton("", SparkRes.getImageIcon(SparkRes.ADD_BOOKMARK_ICON));

    private ChatManager chatManager;

    private JDialog dlg;

    private BookmarksUI conferences;
    private String serviceName;

    private boolean partialDiscovery = false;

    /**
     * Creates a new instance of ConferenceRooms.
     *
     * @param conferences the conference ui.
     * @param serviceName the name of the conference service.
     *                    //TODO This needs to be refactored.
     */
    public ConferenceRoomBrowser(BookmarksUI conferences, final String serviceName) {

        this.setLayout(new BorderLayout());

        this.conferences = conferences;
        this.serviceName = serviceName;

        // Add Toolbar
        final JPanel toolbar = new JPanel(new FlowLayout(FlowLayout.LEFT));
        toolbar.add(joinRoomButton);
        toolbar.add(addRoomButton);
        toolbar.add(createButton);
        toolbar.add(refreshButton);

        this.add(toolbar, BorderLayout.NORTH);
        createButton.addActionListener(this);
        joinRoomButton.addActionListener(this);
        refreshButton.addActionListener(this);

        ResourceUtils.resButton(createButton, Res.getString("button.create.room"));
        ResourceUtils.resButton(joinRoomButton, Res.getString("button.join.room"));
        ResourceUtils.resButton(refreshButton, Res.getString("button.refresh"));
        ResourceUtils.resButton(addRoomButton, Res.getString("button.bookmark.room"));

        refreshButton.setToolTipText(Res.getString("message.update.room.list"));
        joinRoomButton.setToolTipText(Res.getString("message.join.conference.room"));
        createButton.setToolTipText(Res.getString("message.create.or.join.room"));

        // Add Group Chat Table
        roomsTable = new RoomList();

        final JScrollPane pane = new JScrollPane(roomsTable);
        pane.setBackground(Color.white);
        pane.setForeground(Color.white);
        this.setBackground(Color.white);
        this.setForeground(Color.white);
        pane.getViewport().setBackground(Color.white);
        this.add(pane, BorderLayout.CENTER);

        chatManager = SparkManager.getChatManager();

        joinRoomButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent actionEvent) {
                joinSelectedRoom();
            }
        });

        addRoomButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent actionEvent) {
                bookmarkRoom(serviceName);
            }
        });

        refreshButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent actionEvent) {
                refreshRoomList(serviceName);
            }
        });

        joinRoomButton.setEnabled(false);
        addRoomButton.setEnabled(false);

        addTableListener();
    }

    private void refreshRoomList(final String serviceName) {
        roomsTable.clearTable();
        SwingWorker worker = new SwingWorker() {
            Collection result;

            public Object construct() {
                result = getRoomsAndInfo(serviceName);
                return result;
            }

            public void finished() {
                try {


                    Iterator rooms = result.iterator();
                    while (rooms.hasNext()) {
                        RoomObject obj = (RoomObject)rooms.next();
                        addRoomToTable(obj.getRoomJID(), obj.getRoomName(), obj.getNumberOfOccupants());
                    }
                }
                catch (Exception e) {
                    Log.error("Unable to retrieve room list and info.", e);
                }
            }
        };

        worker.start();


    }

    private Collection getRoomsAndInfo(final String serviceName) {
        List roomList = new ArrayList();
        boolean stillSearchForOccupants = true;
        try {
            Collection result = getRoomList(serviceName);
            try {
                Iterator rooms = result.iterator();
                while (rooms.hasNext()) {
                    HostedRoom hostedRoom = (HostedRoom)rooms.next();
                    String roomName = hostedRoom.getName();
                    String roomJID = hostedRoom.getJid();
                    int numberOfOccupants = -1;
                    if (stillSearchForOccupants) {
                        RoomInfo roomInfo = null;
                        try {
                            roomInfo = MultiUserChat.getRoomInfo(SparkManager.getConnection(), roomJID);
                        }
                        catch (Exception e) {
                        }

                        if (roomInfo != null) {
                            numberOfOccupants = roomInfo.getOccupantsCount();
                            if (numberOfOccupants == -1) {
                                stillSearchForOccupants = false;
                            }
                        }
                        else {
                            stillSearchForOccupants = false;
                        }
                    }

                    RoomObject obj = new RoomObject();
                    obj.setRoomJID(roomJID);
                    obj.setRoomName(roomName);
                    obj.setNumberOfOccupants(numberOfOccupants);
                    roomList.add(obj);
                }
            }
            catch (Exception e) {
                Log.error("Error setting up GroupChatTable", e);
            }
        }
        catch (Exception e) {
            System.err.println(e);
        }
        return roomList;
    }

    private void bookmarkRoom(String serviceName) {
        int selectedRow = roomsTable.getSelectedRow();
        if (-1 == selectedRow) {
            JOptionPane.showMessageDialog(dlg, Res.getString("message.select.add.room.to.add"), Res.getString("title.group.chat"), JOptionPane.INFORMATION_MESSAGE);
            return;
        }

        final String roomJID = (String)roomsTable.getValueAt(selectedRow, 2) + "@" + serviceName;
        final String roomName = (String)roomsTable.getValueAt(selectedRow, 1);

        // Check to see what type of room this is.
        try {
            final RoomInfo roomInfo = MultiUserChat.getRoomInfo(SparkManager.getConnection(), roomJID);
            if (!roomInfo.isPersistent()) {
                JOptionPane.showMessageDialog(dlg, Res.getString("message.bookmark.temporary.room.error"), Res.getString("title.error"), JOptionPane.ERROR_MESSAGE);
                return;
            }
        }
        catch (Exception e) {
            // Do not return
        }

        Tree serviceTree = conferences.getTree();
        JiveTreeNode rootNode = (JiveTreeNode)serviceTree.getModel().getRoot();

        TreePath rootPath = serviceTree.findByName(serviceTree, new String[]{rootNode.toString(), serviceName});


        boolean isBookmarked = isBookmarked(roomJID);


        if (!isBookmarked) {
            JiveTreeNode node = (JiveTreeNode)serviceTree.getLastSelectedPathComponent();
            if (node == null) {
                TreePath path = serviceTree.findByName(serviceTree, new String[]{rootNode.toString(), ConferenceServices.getDefaultServiceName()});
                node = (JiveTreeNode)path.getLastPathComponent();
            }
            JiveTreeNode roomNode = new JiveTreeNode(roomName, false, SparkRes.getImageIcon(SparkRes.BOOKMARK_ICON));
            roomNode.setAssociatedObject(roomJID);
            node.add(roomNode);
            final DefaultTreeModel model = (DefaultTreeModel)serviceTree.getModel();
            model.nodeStructureChanged(node);
            serviceTree.expandPath(rootPath);
            roomsTable.getTableModel().setValueAt(new JLabel(SparkRes.getImageIcon(SparkRes.BOOKMARK_ICON)), selectedRow, 0);
            addBookmarkUI(false);

            conferences.addBookmark(roomName, roomJID, false);
        }
        else {
            // Remove bookmark
            TreePath path = serviceTree.findByName(serviceTree, new String[]{rootNode.toString(), serviceName, roomName});
            JiveTreeNode node = (JiveTreeNode)path.getLastPathComponent();
            final DefaultTreeModel model = (DefaultTreeModel)serviceTree.getModel();
            model.removeNodeFromParent(node);
            roomsTable.getTableModel().setValueAt(new JLabel(SparkRes.getImageIcon(SparkRes.BLANK_IMAGE)), selectedRow, 0);
            addBookmarkUI(true);

            String jid = (String)node.getAssociatedObject();
            conferences.removeBookmark(jid);
        }
    }

    private void joinSelectedRoom() {
        int selectedRow = roomsTable.getSelectedRow();
        if (-1 == selectedRow) {
            JOptionPane.showMessageDialog(dlg, Res.getString("message.select.room.to.join"), Res.getString("title.group.chat"), JOptionPane.INFORMATION_MESSAGE);
            return;
        }
        enterRoom();
    }

    private void addTableListener() {
        roomsTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
            public void valueChanged(ListSelectionEvent e) {
                if (e.getValueIsAdjusting()) return;

                int selectedRow = roomsTable.getSelectedRow();
                if (selectedRow != -1) {
                    joinRoomButton.setEnabled(true);

                    String roomName = (String)roomsTable.getValueAt(selectedRow, 1);
                    String roomJID = (String)roomsTable.getValueAt(selectedRow, 2) + "@" + serviceName;
                    addRoomButton.setEnabled(true);
                    if (isBookmarked(roomJID)) {
                        addBookmarkUI(false);
                    }
                    else {
                        addBookmarkUI(true);
                    }
                }
                else {
                    joinRoomButton.setEnabled(false);
                    addRoomButton.setEnabled(false);
                    addBookmarkUI(true);
                }
            }
        });
    }

    /**
     * Displays the ConferenceRoomBrowser.
     */
    public void invoke() {
        SwingWorker worker = new SwingWorker() {
            Collection rooms;

            public Object construct() {
                try {
                    rooms = getRoomList(serviceName);
                }
                catch (Exception e) {
                    Log.error("Unable to retrieve list of rooms.", e);
                }

                return "OK";
            }

            public void finished() {
                if (rooms == null) {
                    JOptionPane.showMessageDialog(conferences, Res.getString("message.conference.info.error"), Res.getString("title.error"), JOptionPane.ERROR_MESSAGE);
                    if (dlg != null) {