path: root/src/net/java/sip/communicator/impl/gui/main/chat/ChatWindowManager.java

/*
 * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client.
 *
 * Distributable under LGPL license.
 * See terms of license at gnu.org.
 */
package net.java.sip.communicator.impl.gui.main.chat;

import java.util.*;

import javax.swing.*;

import net.java.sip.communicator.impl.gui.*;
import net.java.sip.communicator.impl.gui.customcontrols.*;
import net.java.sip.communicator.impl.gui.main.chat.conference.*;
import net.java.sip.communicator.impl.gui.main.chatroomslist.*;
import net.java.sip.communicator.impl.gui.main.contactlist.*;
import net.java.sip.communicator.impl.gui.utils.*;
import net.java.sip.communicator.service.contactlist.*;
import net.java.sip.communicator.service.protocol.*;

/**
 * Manages chat windows and panels.
 *
 * @author Yana Stamcheva
 */
public class ChatWindowManager
{
    private final java.util.List<ChatPanel> chatPanels =
        new ArrayList<ChatPanel>();

    private final Object syncChat = new Object();

    /**
     * Opens a the specified chatPanel and brings it to the front if so
     * specified.
     *
     * @param chatPanel the chat panel that we will be opening
     * @param setSelected specifies whether we should bring the chat to front
     * after creating it.
     */
    public void openChat(final ChatPanel chatPanel, final boolean setSelected)
    {
        if(!SwingUtilities.isEventDispatchThread())
        {
            SwingUtilities.invokeLater(new Runnable()
            {
                public void run()
                {
                    openChat(chatPanel, setSelected);
                }
            });
            return;
        }

        synchronized (syncChat)
        {
            ChatWindow chatWindow = chatPanel.getChatWindow();

            boolean isChatVisible = chatPanel.isShown();

            if(!isChatVisible)
                chatWindow.addChat(chatPanel);

            if(chatWindow.isVisible())
            {
                if(chatWindow.getExtendedState() != JFrame.ICONIFIED)
                {
                    if(ConfigurationManager.isAutoPopupNewMessage()
                        || setSelected)
                        chatWindow.toFront();
                }
                else
                {
                    if(setSelected)
                    {
                        chatWindow.setExtendedState(JFrame.NORMAL);
                        chatWindow.toFront();
                    }

                    if(!chatWindow.getTitle().startsWith("*"))
                        chatWindow.setTitle(
                            "*" + chatWindow.getTitle());
                }

                if(setSelected)
                {
                    chatWindow.setCurrentChatPanel(chatPanel);
                }
                else if(!chatWindow.getCurrentChatPanel().equals(chatPanel)
                    && chatWindow.getChatTabCount() > 0)
                {
                    chatPanel.getChatWindow().highlightTab(chatPanel);

                    chatPanel.setCaretToEnd();
                }
            }
            else
            {
                chatWindow.setVisible(true);

                chatWindow.setCurrentChatPanel(chatPanel);

                chatPanel.setCaretToEnd();
            }
        }
    }

    /**
     * Returns TRUE if there is an opened <tt>ChatPanel</tt> for the given
     * <tt>MetaContact</tt>.
     * @param metaContact the <tt>MetaContact</tt>, for which the chat is about
     * @return TRUE if there is an opened <tt>ChatPanel</tt> for the given
     * <tt>MetaContact</tt>
     */
    public boolean isChatOpenedForContact(MetaContact metaContact)
    {
        synchronized (syncChat)
        {
            ChatSession chatSession = findChatSessionForDescriptor(metaContact);

            return (chatSession != null
                && getChat(chatSession).isShown());
        }
    }

    /**
     * Returns TRUE if there is an opened <tt>ChatPanel</tt> for the given
     * <tt>ChatRoom</tt>.
     * @param chatRoomWrapper the <tt>ChatRoomWrapper</tt>, for which the chat
     * is about
     * @return TRUE if there is an opened <tt>ChatPanel</tt> for the given
     * <tt>ChatRoom</tt>
     */
    public boolean isChatOpenedForChatRoom(ChatRoomWrapper chatRoomWrapper)
    {
        synchronized (syncChat)
        {
            ChatSession chatSession
                = findChatSessionForDescriptor(chatRoomWrapper);

            return (chatSession != null
                && getChat(chatSession).isShown());
        }
    }

    /**
     * Returns TRUE if there is an opened <tt>ChatPanel</tt> for the given
     * <tt>ChatRoom</tt>.
     * @param chatRoom the <tt>ChatRoom</tt>, for which the chat is about
     * @return TRUE if there is an opened <tt>ChatPanel</tt> for the given
     * <tt>ChatRoom</tt>
     */
    public boolean isChatOpenedForChatRoom(ChatRoom chatRoom)
    {
        synchronized (syncChat)
        {
            for (ChatPanel chatPanel : chatPanels)
            {
                ChatSession chatSession = chatPanel.getChatSession();

                Object descriptor = chatSession.getDescriptor();

                if(descriptor instanceof ChatRoomWrapper)
                {
                    ChatRoomWrapper chatRoomWrapper
                        = (ChatRoomWrapper) descriptor;

                    if(chatRoomWrapper.getChatRoomID().equals(chatRoom.getIdentifier())
                        && getChat(chatSession).isShown())
                    {
                        return true;
                    }
                }
            }

            return false;
        }
    }

    /**
     * Closes the given chat panel.
     *
     * @param chatPanel the chat panel to close
     */
    public void closeChat(ChatPanel chatPanel)
    {
        synchronized (syncChat)
        {
            if(containsChat(chatPanel))
            {
                ChatWindow chatWindow = chatPanel.getChatWindow();

                if (!chatPanel.isWriteAreaEmpty())
                {
                    SIPCommMsgTextArea msgText = new SIPCommMsgTextArea(
                        GuiActivator.getResources().getI18NString(
                            "service.gui.NON_EMPTY_CHAT_WINDOW_CLOSE"));

                    int answer = JOptionPane.showConfirmDialog(
                        chatWindow,
                        msgText,
                        GuiActivator.getResources().getI18NString(
                            "service.gui.WARNING"),
                        JOptionPane.OK_CANCEL_OPTION,
                        JOptionPane.WARNING_MESSAGE);

                    if (answer == JOptionPane.OK_OPTION)
                    {
                        closeChatPanel(chatPanel);
                    }
                }
                else if (System.currentTimeMillis() - chatWindow
                    .getLastIncomingMsgTimestamp(chatPanel) < 2 * 1000)
                {
                    SIPCommMsgTextArea msgText
                        = new SIPCommMsgTextArea(GuiActivator.getResources()
                            .getI18NString(
                                "service.gui.CLOSE_CHAT_AFTER_NEW_MESSAGE"));

                    int answer = JOptionPane.showConfirmDialog(
                        chatWindow,
                        msgText,
                        GuiActivator.getResources()
                            .getI18NString("service.gui.WARNING"),
                        JOptionPane.OK_CANCEL_OPTION,
                        JOptionPane.WARNING_MESSAGE);

                    if (answer == JOptionPane.OK_OPTION)
                        closeChatPanel(chatPanel);
                }
                else {
                    closeChatPanel(chatPanel);
                }
            }
        }
    }

    /**
     * Closes the chat window. Removes all contained chats and invokes
     * setVisible(false) to the window.
     */
    public void closeWindow(ChatWindow chatWindow)
    {
        synchronized (syncChat)
        {
            ChatPanel chatPanel = chatWindow.getCurrentChatPanel();

            if (!chatPanel.isWriteAreaEmpty())
            {
                SIPCommMsgTextArea msgText = new SIPCommMsgTextArea(
                    GuiActivator.getResources().getI18NString(
                        "service.gui.NON_EMPTY_CHAT_WINDOW_CLOSE"));
                int answer = JOptionPane.showConfirmDialog(
                    chatWindow,
                    msgText,
                    GuiActivator.getResources()
                        .getI18NString("service.gui.WARNING"),
                    JOptionPane.OK_CANCEL_OPTION,
                    JOptionPane.WARNING_MESSAGE);

                if (answer == JOptionPane.OK_OPTION)
                {
                    this.disposeChatWindow(chatWindow);
                }
            }
            else if (System.currentTimeMillis() - chatWindow
                .getLastIncomingMsgTimestamp(chatPanel) < 2 * 1000)
            {
                SIPCommMsgTextArea msgText = new SIPCommMsgTextArea(
                    GuiActivator.getResources()
                    .getI18NString("service.gui.CLOSE_CHAT_AFTER_NEW_MESSAGE"));

                int answer = JOptionPane.showConfirmDialog(
                    chatWindow,
                    msgText,
                    GuiActivator.getResources()
                        .getI18NString("service.gui.WARNING"),
                    JOptionPane.OK_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE);

                if (answer == JOptionPane.OK_OPTION)
                {
                    this.disposeChatWindow(chatWindow);
                }
            }
            else
            {
                this.disposeChatWindow(chatWindow);
            }
        }
    }

    /**
     * Returns the chat panel corresponding to the given meta contact
     *
     * @param metaContact the meta contact.
     * @return the chat panel corresponding to the given meta contact
     */
    public ChatPanel getContactChat(MetaContact metaContact)
    {
        synchronized (syncChat)
        {
            ChatSession chatSession = findChatSessionForDescriptor(metaContact);

            if(chatSession != null)
            {
                return getChat(chatSession);
            }
            else
            {
                return createChat(metaContact);
            }
        }
    }

    /**
     * Returns the chat panel corresponding to the given meta contact
     *
     * @param metaContact the meta contact.
     * @param protocolContact the protocol specific contact
     * @return the chat panel corresponding to the given meta contact
     */
    public ChatPanel getContactChat(MetaContact metaContact,
                                    Contact protocolContact)
    {
        synchronized (syncChat)
        {
            ChatSession chatSession = findChatSessionForDescriptor(metaContact);

            if(chatSession != null)
            {
                return getChat(chatSession);
            }
            else
                return createChat(metaContact, protocolContact);
        }
    }

    /**
     * Returns the chat panel corresponding to the given meta contact
     *
     * @param metaContact the meta contact.
     * @param protocolContact the protocol specific contact
     * @param escapedMessageID the message ID of the message that should be
     * excluded from the history when the last one is loaded in the chat
     * @return the chat panel corresponding to the given meta contact
     */
    public ChatPanel getContactChat(MetaContact metaContact,
                                    Contact protocolContact,
                                    String escapedMessageID)
    {
        synchronized (syncChat)
        {
            ChatSession chatSession = findChatSessionForDescriptor(metaContact);

            if(chatSession != null)
            {
                return getChat(chatSession);
            }
            else
                return createChat(  metaContact,
                                    protocolContact,
                                    escapedMessageID);
        }
    }

    /**
     * Returns the currently selected <tt>ChatPanel</tt>.
     * @return the currently selected <tt>ChatPanel</tt>
     */
    public ChatPanel getSelectedChat()
    {
        ChatPanel selectedChat = null;

        Iterator<ChatPanel> chatPanelsIter = chatPanels.iterator();

        synchronized (syncChat)
        {
            if (ConfigurationManager.isMultiChatWindowEnabled())
            {
                if (chatPanelsIter.hasNext())
                {
                    ChatPanel firstChatPanel = chatPanelsIter.next();

                    selectedChat
                        = firstChatPanel.getChatWindow().getCurrentChatPanel();
                }
            }
            else
            {
                while (chatPanelsIter.hasNext())
                {
                    ChatPanel chatPanel = chatPanelsIter.next();

                    if (chatPanel.getChatWindow().isFocusOwner())
                        selectedChat = chatPanel;
                }
            }

            return selectedChat;
        }
    }

    /**
     * Returns the chat panel corresponding to the given chat room wrapper.
     *
     * @param chatRoomWrapper the chat room wrapper, corresponding to the chat
     * room for which the chat panel is about
     * @return the chat panel corresponding to the given chat room
     */
    public ChatPanel getMultiChat(ChatRoomWrapper chatRoomWrapper)
    {
        synchronized (syncChat)
        {
            ChatSession chatSession
                = findChatSessionForDescriptor(chatRoomWrapper);

            if(chatSession != null)
            {
                return getChat(chatSession);
            }
            else
                return createChat(chatRoomWrapper);
            }
        }

    /**
     * Returns the chat panel corresponding to the given chat room.
     *
     * @param chatRoom the chat room, for which the chat panel is about
     * @return the chat panel corresponding to the given chat room
     */
    public ChatPanel getMultiChat(ChatRoom chatRoom)
    {
        return getMultiChat(chatRoom, null);
    }

    /**
     * Returns the chat panel corresponding to the given chat room.
     *
     * @param chatRoom the chat room, for which the chat panel is about
     * @param escapedMessageID the message ID of the message that should be
     * excluded from the history when the last one is loaded in the chat
     * @return the chat panel corresponding to the given chat room
     */
    public ChatPanel getMultiChat(  ChatRoom chatRoom,
                                    String escapedMessageID)
    {
        synchronized (syncChat)
        {
            ChatRoomList chatRoomList = GuiActivator.getUIService()
                .getConferenceChatManager().getChatRoomList();

            // Search in the chat room's list for a chat room that correspond
            // to the given one.
            ChatRoomWrapper chatRoomWrapper
                = chatRoomList.findChatRoomWrapperFromChatRoom(chatRoom);

            if (chatRoomWrapper == null)
            {
                ChatRoomProviderWrapper parentProvider
                    = chatRoomList.findServerWrapperFromProvider(
                        chatRoom.getParentProvider());

                chatRoomWrapper = new ChatRoomWrapper(parentProvider, chatRoom);

                chatRoomList.addChatRoom(chatRoomWrapper);
            }

            ChatSession chatSession
                = findChatSessionForDescriptor(chatRoomWrapper);

            if (chatSession != null)
            {
                return getChat(chatSession);
            }

            return createChat(chatRoomWrapper, escapedMessageID);
        }
    }

    /**
     * Closes the selected chat tab or the window if there are no tabs.
     *
     * @param chatPanel the chat panel to close.
     */
    private void closeChatPanel(ChatPanel chatPanel)
    {
        ChatWindow chatWindow = chatPanel.getChatWindow();

        chatWindow.removeChat(chatPanel);

        if (chatWindow.getChatCount() == 0)
            disposeChatWindow(chatWindow);

        boolean isChatPanelContained;
        synchronized (chatPanels)
        {
            isChatPanelContained = chatPanels.remove(chatPanel);
        }

        if (isChatPanelContained)
            chatPanel.dispose();
    }

    /**
     * Creates a chat for the given meta contact. If the most connected proto
     * contact of the meta contact is offline choose the proto contact that
     * supports offline messaging.
     *
     * @param metaContact the meta contact for the chat
     *
     * @return the newly created ChatPanel
     */
    private ChatPanel createChat(MetaContact metaContact)
    {
        Contact defaultContact = metaContact.getDefaultContact();

        ProtocolProviderService defaultProvider
            = defaultContact.getProtocolProvider();

        OperationSetBasicInstantMessaging
            defaultIM = (OperationSetBasicInstantMessaging)
                defaultProvider.getOperationSet(
                        OperationSetBasicInstantMessaging.class);

        ProtocolProviderService protoContactProvider;
        OperationSetBasicInstantMessaging protoContactIM;

        if (defaultContact.getPresenceStatus().getStatus() < 1
                && (!defaultIM.isOfflineMessagingSupported()
                        || !defaultProvider.isRegistered()))
        {
            Iterator<Contact> protoContacts = metaContact.getContacts();

            while(protoContacts.hasNext())
            {
                Contact contact = protoContacts.next();

                protoContactProvider = contact.getProtocolProvider();

                protoContactIM = (OperationSetBasicInstantMessaging)
                    protoContactProvider.getOperationSet(
                        OperationSetBasicInstantMessaging.class);

                if(protoContactIM.isOfflineMessagingSupported()
                        && protoContactProvider.isRegistered())
                {
                    defaultContact = contact;
                }
            }
        }

        return createChat(metaContact, defaultContact);
    }


    /**
     * Creates a <tt>ChatPanel</tt> for the given contact and saves it in the
     * list ot created <tt>ChatPanel</tt>s.
     *
     * @param contact The MetaContact for this chat.
     * @param protocolContact The protocol contact.
     * @return The <code>ChatPanel</code> newly created.
     */
    private ChatPanel createChat(MetaContact contact,
                                            Contact protocolContact)
    {
        return createChat(contact, protocolContact, null);
    }

    /**
     * Creates a <tt>ChatPanel</tt> for the given contact and saves it in the
     * list ot created <tt>ChatPanel</tt>s.
     *
     * @param metaContact The MetaContact for this chat.
     * @param protocolContact The protocol contact.
     * @param escapedMessageID the message ID of the message that should be
     * excluded from the history when the last one is loaded in the chat.
     * @return The <code>ChatPanel</code> newly created.
     */
    private ChatPanel createChat(   MetaContact metaContact,
                                    Contact protocolContact,
                                    String escapedMessageID)
    {
        ChatWindow chatWindow;

        if(ConfigurationManager.isMultiChatWindowEnabled())
        {
            Iterator<ChatPanel> chatPanelsIter = chatPanels.iterator();

            // If we're in a tabbed window we're looking for the chat window
            // through one of the already created chats.
            if(chatPanelsIter.hasNext())
            {
                chatWindow = chatPanelsIter.next().getChatWindow();
            }
            else
            {
                chatWindow = new ChatWindow();

                GuiActivator.getUIService()
                    .registerExportedWindow(chatWindow);
            }
        }
        else
        {
            chatWindow = new ChatWindow();
        }

        ChatPanel chatPanel = new ChatPanel(chatWindow);

        MetaContactChatSession chatSession
            = new MetaContactChatSession(   chatPanel,
                                            metaContact,
                                            protocolContact);

        chatPanel.setChatSession(chatSession);

        synchronized (chatPanels)
        {
            this.chatPanels.add(chatPanel);
        }

        if (ConfigurationManager.isHistoryShown())
        {
            if(escapedMessageID != null)
                chatPanel.loadHistory(escapedMessageID);
            else
                chatPanel.loadHistory();
        }

        return chatPanel;
    }

    /**
     * Creates a <tt>ChatPanel</tt> for the given <tt>ChatRoom</tt> and saves it
     * in the list of created <tt>ChatPanel</tt>s.
     *
     * @param chatRoomWrapper the <tt>ChatRoom</tt>, for which the chat will be created
     * @return The <code>ChatPanel</code> newly created.
     */
    private ChatPanel createChat( ChatRoomWrapper chatRoomWrapper)
    {
        return createChat(chatRoomWrapper, null);
    }

    /**
     * Creates a <tt>ChatPanel</tt> for the given <tt>ChatRoom</tt> and saves it
     * in the list of created <tt>ChatPanel</tt>s.
     *
     * @param chatRoomWrapper the <tt>ChatRoom</tt>, for which the chat will be created
     * @param escapedMessageID the message ID of the message that should be
     * excluded from the history when the last one is loaded in the chat.
     * @return The <code>ChatPanel</code> newly created.
     */
    private ChatPanel createChat( ChatRoomWrapper chatRoomWrapper,
                                            String escapedMessageID)
    {
        ChatWindow chatWindow;

        if(ConfigurationManager.isMultiChatWindowEnabled())
        {
            Iterator<ChatPanel> chatPanelsIter = chatPanels.iterator();

            // If we're in a tabbed window we're looking for the chat window
            // through one of the already created chats.
            if(chatPanelsIter.hasNext())
            {
                chatWindow = chatPanelsIter.next().getChatWindow();
            }
            else
            {
                chatWindow = new ChatWindow();

                GuiActivator.getUIService()
                    .registerExportedWindow(chatWindow);
            }
        }
        else
        {
            chatWindow = new ChatWindow();
        }

        ChatPanel chatPanel = new ChatPanel(chatWindow);

        ConferenceChatSession chatSession
            = new ConferenceChatSession(chatPanel,
                                        chatRoomWrapper);

        chatPanel.setChatSession(chatSession);

        synchronized (chatPanels)
        {
            this.chatPanels.add(chatPanel);
        }

        if (ConfigurationManager.isHistoryShown())
        {
            if(escapedMessageID != null)
                chatPanel.loadHistory(escapedMessageID);
            else
                chatPanel.loadHistory();
        }

        return chatPanel;
    }

    /**
     * Finds the chat session corresponding to the given chat descriptor.
     * 
     * @param descriptor The chat descriptor.
     * @return The chat session corresponding to the given chat descriptor.
     */
    private ChatSession findChatSessionForDescriptor(Object descriptor)
    {
        for (ChatPanel chatPanel : chatPanels)
        {
            ChatSession chatSession = chatPanel.getChatSession();

            if (chatSession.getDescriptor().equals(descriptor))
                return chatSession;
        }

        return null;
    }

    /**
     * Returns TRUE if this chat window contains the given chatPanel,
     * FALSE otherwise.
     *
     * @param chatPanel the chat panel that we're looking for.
     * @return TRUE if this chat window contains the given chatPanel,
     * FALSE otherwise
     */
    private boolean containsChat(ChatPanel chatPanel)
    {
        synchronized (chatPanels)
        {
            return chatPanels.contains(chatPanel);
        }
    }

    /**
     * Returns the <tt>ChatPanel</tt> corresponding to the given meta contact.
     * 
     * @param chatSession the key, which corresponds to the chat we are looking for. It
     * could be a <tt>MetaContact</tt> in the case of single user chat and
     * a <tt>ChatRoom</tt> in the case of a multi user chat
     * @return the <tt>ChatPanel</tt> corresponding to the given meta contact
     */
    private ChatPanel getChat(ChatSession chatSession)
    {
        for (ChatPanel chatPanel : chatPanels)
        {
            if (chatSession.equals(chatPanel.getChatSession()))
                return chatPanel;
        }

        return null;
    }

    /**
     * Disposes the chat window.
     */
    private void disposeChatWindow(ChatWindow chatWindow)
    {
        for (ChatPanel chatPanel : chatPanels)
            chatPanel.dispose();

        synchronized (chatPanels)
        {
            chatPanels.clear();
        }

        if (chatWindow.getChatCount() > 0)
            chatWindow.removeAllChats();

        /*
         * The ChatWindow should seize to exist so we don't want any strong
         * references to it i.e. it cannot be exported anymore.
         */
        GuiActivator.getUIService().unregisterExportedWindow(chatWindow);
        chatWindow.dispose();

        ContactList clist
            = GuiActivator.getUIService().getMainFrame()
                .getContactListPanel().getContactList();

        // Remove the envelope from the all active contacts in the contact list.
        clist.removeAllActiveContacts();
    }
}