Member Avatar for kartheepanmirra
kartheepanmirra 0 Newbie Poster

There is a java based chat client called as SparkCLIENT which is widely used as a messenger.THE SERVER WHICH SUPPORTS THIS CLIENT IS OPENFIRE SERVER.The technology involved in the communication of messages between the client and the server is xmpp protocol.This is the technology being used in GTALK client.

The client should be able to open same chat window for the same user as many number of times.when the individual messages are been sent the client on the other side should be getting the messages with the correspongin window.Please help me out.

/**
 * $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;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.StringTokenizer;

import javax.swing.AbstractAction;
import javax.swing.Icon;
import javax.swing.JComponent;
//dhanashri added one 
import javax.swing.JFrame;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JTextPane;
import javax.swing.KeyStroke;
import javax.swing.UIManager;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.Element;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument;

import org.jivesoftware.resource.Res;
import org.jivesoftware.spark.SparkManager;
import org.jivesoftware.spark.plugin.ContextMenuListener;
import org.jivesoftware.spark.util.BrowserLauncher;
import org.jivesoftware.spark.util.ModelUtil;
import org.jivesoftware.spark.util.log.Log;
//dhanashri added one line down
import org.jivesoftware.sparkimpl.plugin.emoticons.Emoticon;
import org.jivesoftware.sparkimpl.plugin.emoticons.EmoticonManager;
import org.jivesoftware.sparkimpl.settings.local.LocalPreferences;
import org.jivesoftware.sparkimpl.settings.local.SettingsManager;

/**
 * The ChatArea class handles proper chat text formatting such as url handling. Use ChatArea for proper
 * formatting of bold, italics, underlined and urls.
 */
public class ChatArea extends JTextPane implements MouseListener, MouseMotionListener, ActionListener {
	private static final long serialVersionUID = -2155445968040220072L;

	/**
     * The SimpleAttributeSet used within this instance of JTextPane.
     */
    public final SimpleAttributeSet styles = new SimpleAttributeSet();

    /**
     * The default Hand cursor.
     */
    public static final Cursor HAND_CURSOR = new Cursor(Cursor.HAND_CURSOR);

    /**
     * The default Text Cursor.
     */
    public static final Cursor DEFAULT_CURSOR = new Cursor(Cursor.DEFAULT_CURSOR);

    /**
     * The currently selected Font Family to use.
     */
    private String fontFamily;

    /**
     * The currently selected Font Size to use.
     */
    private int fontSize;

    private List<ContextMenuListener> contextMenuListener = new ArrayList<ContextMenuListener>();

    private JPopupMenu popup;


    private JMenuItem cutMenu;
    private JMenuItem copyMenu;
    private JMenuItem pasteMenu;
    private JMenuItem selectAll;

    private List<LinkInterceptor> interceptors = new ArrayList<LinkInterceptor>();

    private EmoticonManager emoticonManager;

    protected Boolean forceEmoticons = false;
    
    private Boolean emoticonsAvailable = true;

    /**
     * ChatArea Constructor.
     */
    public ChatArea() {
        emoticonManager = EmoticonManager.getInstance();
        
        Collection<String> emoticonPacks = null; 
        emoticonPacks = emoticonManager.getEmoticonPacks();
        
        if(emoticonPacks == null) {
        	emoticonsAvailable = false;
        }

        // Set Default Font
        final LocalPreferences pref = SettingsManager.getLocalPreferences();
        int fs = pref.getChatRoomFontSize();
        fontSize = fs;
        setFontSize(fs);


        cutMenu = new JMenuItem(Res.getString("action.cut"));
        cutMenu.addActionListener(this);

        copyMenu = new JMenuItem(Res.getString("action.copy"));
        copyMenu.addActionListener(this);

        pasteMenu = new JMenuItem(Res.getString("action.paste"));
        pasteMenu.addActionListener(this);

        selectAll = new JMenuItem(Res.getString("action.select.all"));
        selectAll.addActionListener(this);

        // Set Default Font
        setFont(new Font("Dialog", Font.PLAIN, 12));


        getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("Ctrl x"), "cut");

        getActionMap().put("cut", new AbstractAction("cut") {
			private static final long serialVersionUID = 9117190151545566922L;

			public void actionPerformed(ActionEvent evt) {
                cutAction();
            }
        });

        getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("Ctrl c"), "copy");

        getActionMap().put("copy", new AbstractAction("copy") {
			private static final long serialVersionUID = 4949716854440264528L;

			public void actionPerformed(ActionEvent evt) {
                SparkManager.setClipboard(getSelectedText());
            }
        });

        getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(KeyStroke.getKeyStroke("Ctrl v"), "paste");

        getActionMap().put("paste", new AbstractAction("paste") {
			private static final long serialVersionUID = -8767763580660683678L;

			public void actionPerformed(ActionEvent evt) {
                pasteAction();
            }
        });

    }

    /**
     * Set the current text of the ChatArea.
     *
     * @param message inserts the text directly into the ChatArea
     */
    public void setText(String message) {
        // By default, use the hand cursor for link selection
        // and scrolling.
        setCursor(HAND_CURSOR);

        // Make sure the message is not null.
        //  message = message.trim();
        // Why?
//        message = message.replaceAll("/\"", "");
        if (ModelUtil.hasLength(message)) {
            try {
                insert(message);
            }
            catch (BadLocationException e) {
                Log.error(e);
            }
        }
    }

    /**
     * Clear the current document. This will remove all text and element
     * attributes such as bold, italics, and underlining. Note that the font family  and
     * font size will be persisted.
     */
    public void clear() {
        super.setText("");
        if (fontFamily != null) {
            setFont(fontFamily);
        }

        if (fontSize != 0) {
            setFontSize(fontSize);
        }

        StyleConstants.setUnderline(styles, false);
        StyleConstants.setBold(styles, false);
        StyleConstants.setItalic(styles, false);
        setCharacterAttributes(styles, false);
    }


    /**
     * Does the actual insertion of text, adhering to the styles
     * specified during message creation in either the thin or thick client.
     *
     * @param text - the text to insert.
     * @throws BadLocationException if location is not available to insert into.
     */
    public void insert(String text) throws BadLocationException {
        boolean bold = false;
        boolean italic = false;
        boolean underlined = false;
		System.out.println("text to be displayed"+text);
		try{text=text.substring(0,text.lastIndexOf("<windowID>"));}catch(Exception e){}
		

        final StringTokenizer tokenizer = new StringTokenizer(text, " \n \t,", true);
        while (tokenizer.hasMoreTokens()) {
            String textFound = tokenizer.nextToken();
            if ((textFound.startsWith("http://") || textFound.startsWith("ftp://")
                    || textFound.startsWith("https://") || textFound.startsWith("www.")) &&
                    textFound.indexOf(".") > 1) {
                insertLink(textFound);
            }
            else if ( textFound.startsWith("\\\\")  || (textFound.indexOf("://") > 0 && textFound.indexOf(".") < 1) ) {
                insertAddress(textFound);
            }     
            else if (!insertImage(textFound)) {
                insertText(textFound);
            }
        }

        // By default, always have decorations off.
        StyleConstants.setBold(styles, bold);
        StyleConstants.setItalic(styles, italic);
        StyleConstants.setUnderline(styles, underlined);
    }

    /**
     * Inserts text into the current document.
     *
     * @param text the text to insert
     * @throws BadLocationException if the location is not available for insertion.
     */
    public void insertText(String text) throws BadLocationException {
        final Document doc = getDocument();
        styles.removeAttribute("link");
        doc.insertString(doc.getLength(), text, styles);
    }

    /**
     * Inserts text into the current document.
     *
     * @param text  the text to insert
     * @param color the color of the text
     * @throws BadLocationException if the location is not available for insertion.
     */
    public void insertText(String text, Color color) throws BadLocationException {
        final Document doc = getDocument();
        StyleConstants.setForeground(styles, color);
        doc.insertString(doc.getLength(), text, styles);
    }

    /**
     * Inserts a link into the current document.
     *
     * @param link - the link to insert( ex. http://www.javasoft.com )
     * @throws BadLocationException if the location is not available for insertion.
     */
    public void insertLink(String link) throws BadLocationException {
        final Document doc = getDocument();
        styles.addAttribute("link", link);

        StyleConstants.setForeground(styles, (Color)UIManager.get("Link.foreground"));
        StyleConstants.setUnderline(styles, true);
        doc.insertString(doc.getLength(), link, styles);
        StyleConstants.setUnderline(styles, false);
        StyleConstants.setForeground(styles, (Color)UIManager.get("TextPane.foreground"));
        styles.removeAttribute("link");
        setCharacterAttributes(styles, false);

    }
    
     /**
     * Inserts a network address into the current document. 
     *
     * @param address - the address to insert( ex. \superpc\etc\file\ OR http://localhost/ )
     * @throws BadLocationException if the location is not available for insertion.
     */
    public void insertAddress(String address) throws B
/**
 * $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;

import org.jivesoftware.resource.Res;
import org.jivesoftware.resource.SparkRes;
import org.jivesoftware.smack.ConnectionListener;
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.spark.ChatAreaSendField;
import org.jivesoftware.spark.SparkManager;
import org.jivesoftware.spark.component.BackgroundPanel;
import org.jivesoftware.spark.component.RolloverButton;
import org.jivesoftware.spark.plugin.ContextMenuListener;
import org.jivesoftware.spark.util.GraphicUtils;
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.BorderFactory;
import javax.swing.Icon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.JSeparator;
import javax.swing.JSplitPane;
import javax.swing.KeyStroke;
import javax.swing.UIManager;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;

import java.awt.Color;
import java.awt.Component;
import java.awt.FlowLayout;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
//dhanashri added one line down
import javax.swing.Timer;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * The base implementation of all ChatRoom conversations. You would implement this class to have most types of Chat.
 */
public abstract class ChatRoom extends BackgroundPanel implements ActionListener, PacketListener, DocumentListener, ConnectionListener, FocusListener, ContextMenuListener {
	private static final long serialVersionUID = 7981019929515888299L;
	private final JPanel chatPanel;
    private final JSplitPane splitPane;
    private JSplitPane verticalSplit;

    private final JLabel notificationLabel;
    private final TranscriptWindow transcriptWindow;
    private final ChatAreaSendField chatAreaButton;
    private final ChatToolBar toolbar;
    private final JScrollPane textScroller;
    private final JPanel bottomPanel;
    private final JPanel editorBar;
    private JPanel chatWindowPanel;

    private int unreadMessageCount;

    private boolean mousePressed;

    private List<ChatRoomClosingListener> closingListeners = new CopyOnWriteArrayList<ChatRoomClosingListener>();


    private ChatRoomTransferHandler transferHandler;

    private final List<String> packetIDList;
    private final List<MessageListener> messageListeners;
    private List<Message> transcript;
    private List<FileDropListener> fileDropListeners;

    private MouseAdapter transcriptWindowMouseListener;

    private KeyAdapter chatEditorKeyListener;
	private int windowID=0;

    private ChatRoom chatroom = this;
    private Timer timer;
    /**
     * Initializes the base layout and base background color.
     */
    public ChatRoom() {
        chatPanel = new JPanel(new GridBagLayout());
        transcriptWindow = new TranscriptWindow();
        splitPane = new JSplitPane();
        packetIDList = new ArrayList<String>();
        notificationLabel = new JLabel();
        toolbar = new ChatToolBar();
        bottomPanel = new JPanel();

        messageListeners = new ArrayList<MessageListener>();
        transcript = new ArrayList<Message>();
        editorBar = new JPanel(new FlowLayout(FlowLayout.LEFT, 1, 1));
        fileDropListeners = new ArrayList<FileDropListener>();

        transcriptWindowMouseListener = new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                getChatInputEditor().requestFocus();
            }

            public void mouseReleased(MouseEvent e) {
                mousePressed = false;
                if (transcriptWindow.getSelectedText() == null) {
                    getChatInputEditor().requestFocus();
                }
            }

            public void mousePressed(MouseEvent e) {
                mousePressed = true;
            }
        };

        transcriptWindow.addMouseListener(transcriptWindowMouseListener);

        chatAreaButton = new ChatAreaSendField(Res.getString("button.send"));
        /*{
            public Dimension getPreferredSize() {
                Dimension dim = super.getPreferredSize();

                int windowHeight = getChatRoom().getHeight();

                if (dim.getHeight() > windowHeight - 200) {
                    dim.height = windowHeight - 200;
                }

                return dim;
            }
        };
        */


        textScroller = new JScrollPane(transcriptWindow);

        textScroller.setBackground(transcriptWindow.getBackground());
        textScroller.getViewport().setBackground(Color.white);
        transcriptWindow.setBackground(Color.white);

        getChatInputEditor().setSelectedTextColor((Color)UIManager.get("ChatInput.SelectedTextColor"));
        getChatInputEditor().setSelectionColor((Color)UIManager.get("ChatInput.SelectionColor"));


        init();

        // Initally, set the right pane to null to keep it empty.
        getSplitPane().setRightComponent(null);

        notificationLabel.setIcon(SparkRes.getImageIcon(SparkRes.BLANK_IMAGE));


        getTranscriptWindow().addContextMenuListener(this);

        transferHandler = new ChatRoomTransferHandler(this);

        getTranscriptWindow().setTransferHandler(transferHandler);
        getChatInputEditor().setTransferHandler(transferHandler);

        add(toolbar, new GridBagConstraints(0, 0, 1, 1, 1.0, 0.0, GridBagConstraints.EAST, GridBagConstraints.HORIZONTAL, new Insets(0, 0, 0, 0), 0, 0));

        // Add Connection Listener
        SparkManager.getConnection().addConnectionListener(this);

        // Add Focus Listener
        addFocusListener(this);
    }

    // Setup base layout.
    private void init() {
        setLayout(new GridBagLayout());

        // Remove Default Beveled Borders
        splitPane.setBorder(null);
        splitPane.setOneTouchExpandable(false);

        // Add Vertical Split Pane
        verticalSplit = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
        add(verticalSplit, new GridBagConstraints(0, 1, 1, 1, 1.0, 1.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));

        verticalSplit.setBorder(null);
        verticalSplit.setOneTouchExpandable(false);

        verticalSplit.setTopComponent(splitPane);

        textScroller.setAutoscrolls(true);

        // Speed up scrolling. It was way too slow.
        textScroller.getVerticalScrollBar().setBlockIncrement(50);
        textScroller.getVerticalScrollBar().setUnitIncrement(20);

        chatWindowPanel = new JPanel();
        chatWindowPanel.setLayout(new GridBagLayout());
        chatWindowPanel.add(textScroller, new GridBagConstraints(0, 10, 1, 1, 1.0, 1.0, GridBagConstraints.WEST, GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0));
        chatWindowPanel.setOpaque(false);

        // Layout Components
        chatPanel.add(chatWindowPanel, new GridBagConstraints(0, 1, 1, 1, 1.0, 1.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0, 5, 0, 5), 0, 0));

        // Add Chat Panel to Split Pane
        splitPane.setLeftComponent(chatPanel);

        // Add edit buttons to Chat Room
        editorBar.setOpaque(false);
        chatPanel.setOpaque(false);


        editorBar.add(new JSeparator(JSeparator.VERTICAL));

        bottomPanel.setOpaque(false);
        splitPane.setOpaque(false);
        bottomPanel.setLayout(new GridBagLayout());
        bottomPanel.add(chatAreaButton, new GridBagConstraints(0, 1, 5, 1, 1.0, 1.0, GridBagConstraints.WEST, GridBagConstraints.BOTH, new Insets(0, 5, 5, 5), 0, 15));
        bottomPanel.add(editorBar, new GridBagConstraints(0, 0, 5, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(0, 5, 0, 5), 0, 0));

        // Set bottom panel border
        bottomPanel.setBorder(BorderFactory.createMatteBorder(0, 0, 1, 0, new Color(197, 213, 230)));
        verticalSplit.setOpaque(false);

        verticalSplit.setBottomComponent(bottomPanel);
        verticalSplit.setResizeWeight(1.0);
        verticalSplit.setDividerSize(2);

        // Add listener to send button
        chatAreaButton.getButton().addActionListener(this);

        // Add Key Listener to Send Field
        getChatInputEditor().getDocument().addDocumentListener(this);

        // Add Key Listener to Send Field
        chatEditorKeyListener = new KeyAdapter() {
            public void keyPressed(KeyEvent e) {
                checkForEnter(e);
            }
        };

        getChatInputEditor().addKeyListener(chatEditorKeyListener);

        getChatInputEditor().getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("ctrl F4"), "closeTheRoom");
        getChatInputEditor().getActionMap().put("closeTheRoom", new AbstractAction("closeTheRoom") {
			private static final long serialVersionUID = 1L;

			public void actionPerformed(ActionEvent evt) {
/**
 * $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.rooms;

import org.jivesoftware.resource.Res;
import org.jivesoftware.resource.SparkRes;
import org.jivesoftware.smack.Roster;
import org.jivesoftware.smack.RosterEntry;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.filter.AndFilter;
import org.jivesoftware.smack.filter.FromMatchesFilter;
import org.jivesoftware.smack.filter.OrFilter;
import org.jivesoftware.smack.filter.PacketFilter;
import org.jivesoftware.smack.filter.PacketTypeFilter;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.packet.StreamError;
import org.jivesoftware.smack.util.StringUtils;
import org.jivesoftware.smackx.MessageEventManager;
import org.jivesoftware.smackx.packet.MessageEvent;
import org.jivesoftware.spark.ChatManager;
import org.jivesoftware.spark.PresenceManager;
import org.jivesoftware.spark.SparkManager;
import org.jivesoftware.spark.ui.ChatRoom;
import org.jivesoftware.spark.ui.ChatRoomButton;
import org.jivesoftware.spark.ui.ContactItem;
import org.jivesoftware.spark.ui.ContactList;
import org.jivesoftware.spark.ui.MessageEventListener;
import org.jivesoftware.spark.ui.RosterDialog;
import org.jivesoftware.spark.ui.VCardPanel;
import org.jivesoftware.spark.util.ModelUtil;
import org.jivesoftware.spark.util.TaskEngine;
import org.jivesoftware.spark.util.log.Log;
import org.jivesoftware.sparkimpl.plugin.transcripts.ChatTranscript;
import org.jivesoftware.sparkimpl.plugin.transcripts.ChatTranscripts;
import org.jivesoftware.sparkimpl.plugin.transcripts.HistoryMessage;
import org.jivesoftware.sparkimpl.profile.VCardManager;
import org.jivesoftware.sparkimpl.settings.local.LocalPreferences;
import org.jivesoftware.sparkimpl.settings.local.SettingsManager;

import javax.swing.Icon;
//dhanashri added line down
import javax.swing.JComponent;
import javax.swing.SwingUtilities;
import javax.swing.event.DocumentEvent;
//dhanashri added two lines down
import org.jivesoftware.spark.component.tabbedPane.SparkTabbedPane;
import org.jivesoftware.spark.ui.ChatContainer;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.TimerTask;

import org.jivesoftware.spark.component.tabbedPane.SparkTabbedPane;

//dhanashri added line down
import javax.swing.JComponent;
import javax.swing.SwingUtilities;
import javax.swing.event.DocumentEvent;

import java.awt.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.TimerTask;


/**
 * This is the Person to Person implementation of <code>ChatRoom</code>
 * This room only allows for 1 to 1 conversations.
 */
public class ChatRoomImpl extends ChatRoom {

    private List<MessageEventListener> messageEventListeners = new ArrayList<MessageEventListener>();
    private String roomname;
    private Icon tabIcon;
    private String roomTitle;
    private String tabTitle;
    private String participantJID;
    private String participantNickname;

    private Presence presence;

    private boolean offlineSent;

    private Roster roster;

    private long lastTypedCharTime;
    private boolean sendNotification;

    private TimerTask typingTimerTask;
    private boolean sendTypingNotification;
    private String threadID;

    private long lastActivity;

    private boolean active;

 // Information button
    private ChatRoomButton infoButton;
	//dhanashri added one line down
	private ChatRoomButton externalizeButton;

    private ChatRoomButton addToRosterButton;
	//dhanashri added two lines down
	private ChatRoomImpl me;
    private ChatRoomButton internalizeButton;

	
	private static int windowID=0;
	private boolean setWindowID=false;
    /**
     * Constructs a 1-to-1 ChatRoom.
     *
     * @param participantJID      the participants jid to chat with.
     * @param participantNickname the nickname of the participant.
     * @param title               the title of the room.
     */
    public ChatRoomImpl(final String participantJID, String participantNickname, String title,int windowID) {
        this.active = true;
        this.participantJID = participantJID;
        this.participantNickname = participantNickname;

        // Loads the current history for this user.
        loadHistory();
		//The windowID of the room is initialised here
				if(!setWindowID){
									this.windowID=windowID;
									super.setWindowID(windowID);
								}
		setWindowID=true;
        // Register PacketListeners
        PacketFilter fromFilter = new FromMatchesFilter(participantJID);
        PacketFilter orFilter = new OrFilter(new PacketTypeFilter(Presence.class), new PacketTypeFilter(Message.class));
        PacketFilter andFilter = new AndFilter(orFilter, fromFilter);

        SparkManager.getConnection().addPacketListener(this, andFilter);

        // The roomname will be the participantJID
        this.roomname = participantJID;

        // Use the agents username as the Tab Title
        this.tabTitle = title;

        // The name of the room will be the node of the user jid + conversation.
        this.roomTitle = participantNickname;

        // Add RoomInfo
        this.getSplitPane().setRightComponent(null);
        getSplitPane().setDividerSize(0);


        presence = PresenceManager.getPresence(participantJID);

        roster = SparkManager.getConnection().getRoster();

        RosterEntry entry = roster.getEntry(participantJID);

        tabIcon = PresenceManager.getIconFromPresence(presence);

      // Create toolbar buttons.
        infoButton = new ChatRoomButton("", SparkRes.getImageIcon(SparkRes.PROFILE_IMAGE_24x24));
        infoButton.setToolTipText(Res.getString("message.view.information.about.this.user"));
		//dhanashri added two lines down
		externalizeButton = new ChatRoomButton("", SparkRes.getImageIcon("LEFT_ARROW_IMAGE"));
  
			externalizeButton.setToolTipText(Res.getString("message.externalize.tab"));
        // Create basic toolbar.
        getToolBar().addChatRoomButton(infoButton);
		//dhanashri add one line down
		getToolBar().addChatRoomButton(externalizeButton);
        // If the user is not in the roster, then allow user to add them.
        addToRosterButton = new ChatRoomButton("", SparkRes.getImageIcon(SparkRes.ADD_IMAGE_24x24));
        if (entry == null && !StringUtils.parseResource(participantJID).equals(participantNickname)) {
            addToRosterButton.setToolTipText(Res.getString("message.add.this.user.to.your.roster"));
            getToolBar().addChatRoomButton(addToRosterButton);

            addToRosterButton.addActionListener(this);
        }

        // Show VCard.
		//dhanashri added one line down
		externalizeButton.addActionListener(this);
        infoButton.addActionListener(this);

        // If this is a private chat from a group chat room, do not show toolbar.
        if (StringUtils.parseResource(participantJID).equals(participantNickname)) {
            getToolBar().setVisible(false);
        }

        typingTimerTask = new TimerTask() {
            public void run() {
                if (!sendTypingNotification) {
                    return;
                }
                long now = System.currentTimeMillis();
                if (now - lastTypedCharTime > 2000) {
                    if (!sendNotification) {
                        // send cancel
                        SparkManager.getMessageEventManager().sendCancelledNotification(getParticipantJID(), threadID);
                        sendNotification = true;
                    }
                }
            }
        };

        TaskEngine.getInstance().scheduleAtFixedRate(typingTimerTask, 2000, 2000);
        lastActivity = System.currentTimeMillis();
    }


    public void closeChatRoom() {
        // If already closed, don't bother.
        if (!active) {
            return;
        }

        super.closeChatRoom();

        // Remove info listener
        infoButton.removeActionListener(this);
        addToRosterButton.removeActionListener(this);

        // Send a cancel notification event on closing if listening.
        if (!sendNotification) {
            // send cancel
            SparkManager.getMessageEventManager().sendCancelledNotification(getParticipantJID(), threadID);

            sendNotification = true;
        }

        SparkManager.getChatManager().removeChat(this);

        SparkManager.getConnection().removePacketListener(this);
        if (typingTimerTask != null) {
            TaskEngine.getInstance().cancelScheduledTask(typingTimerTask);
            typingTimerTask = null;
        }
        active = false;
    }

    public void sendMessage() {
        String text = getChatInputEditor().getText();
        sendMessage(text);
    }

    public void sendMessage(String text) {
        final Message message = new Message();

        if (threadID == null) {
            threadID = StringUtils.randomString(6);
        }
        message.setThread(threadID);
		//message.setWindowID(windowID);
				message.setSubject("<windowID>"+getWindowID()+"</windowID>");
        // Set the body of the message using typedMessage
        message.setBody(text+"<windowID>"+getWindowID()+"</windowID>");

        // IF there is no body, just return and do nothing
        if (!ModelUtil.hasLength(text)) {
            return;
        }

        // Fire Message Filters
        SparkManager.getChatManager().filterOutgoingMessage(this, me
/**
 * $Revision: $
 * $Date: $
 *
 * Copyright (C) 2005-2008 Jive Software. All rights reserved.
 *
 * This software is published under the terms of the GNU Public License (GPL),
 * a copy of which is included in this distribution, or a commercial license
 * agreement with Jive.
 */

package org.jivesoftware.openfire.net;

import org.dom4j.Element;
import org.jivesoftware.openfire.Connection;
import org.jivesoftware.openfire.PacketRouter;
import org.jivesoftware.openfire.auth.UnauthorizedException;
import org.jivesoftware.openfire.session.LocalClientSession;
import org.jivesoftware.util.JiveGlobals;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmpp.packet.IQ;
import org.xmpp.packet.Message;
import org.xmpp.packet.Presence;
//KARTHEEPAN EDIT AUGUST 19TH 2009 5.20 P.M
import org.jivesoftware.openfire.OfflineMessageStore;
//KARTHEEPAN EDIT AUGUST 19TH 2009 5.20 P.M

/** Handler of XML stanzas sent by clients connected directly to the server. Received packet will
 * have their FROM attribute overriden to avoid spoofing.<p>
 *
 * By default the hostname specified in the stream header sent by clients will not be validated.
 * When validated the TO attribute of the stream header has to match the server name or a valid
 * subdomain. If the value of the 'to' attribute is not valid then a host-unknown error
 * will be returned. To enable the validation set the system property
 * <b>xmpp.client.validate.host</b> to true.
 *
 * @author Gaston Dombiak
 */
public class ClientStanzaHandler extends StanzaHandler {

    public ClientStanzaHandler(PacketRouter router, String serverName, Connection connection) {
        super(router, serverName, connection);
    }

    /**
     * Only packets of type Message, Presence and IQ can be processed by this class. Any other
     * type of packet is unknown and thus rejected generating the connection to be closed.
     *
     * @param doc the unknown DOM element that was received
     * @return always false.
     */
    boolean processUnknowPacket(Element doc) {
        return false;
    }

    String getNamespace() {
        return "jabber:client";
    }

    boolean validateHost() {
        return JiveGlobals.getBooleanProperty("xmpp.client.validate.host",false);
    }

    boolean validateJIDs() {
        return true;
    }

    boolean createSession(String namespace, String serverName, XmlPullParser xpp, Connection connection)
            throws XmlPullParserException {
        if ("jabber:client".equals(namespace)) {
            // The connected client is a regular client so create a ClientSession
            session = LocalClientSession.createSession(serverName, xpp, connection);
            return true;
        }
        return false;
    }

    protected void processIQ(IQ packet) throws UnauthorizedException {
        // Overwrite the FROM attribute to avoid spoofing
        packet.setFrom(session.getAddress());
        super.processIQ(packet);
    }

    protected void processPresence(Presence packet) throws UnauthorizedException {
        // Overwrite the FROM attribute to avoid spoofing

        packet.setFrom(session.getAddress());
		
        super.processPresence(packet);
    }

    protected void processMessage(Message packet) throws UnauthorizedException {
		
        // Overwrite the FROM attribute to avoid spoofing
        packet.setFrom(session.getAddress());
		super.processMessage(packet);
		//KARTHEEPAN EDIT AUGUST 19TH 2009 5.20 P.M
		OfflineMessageStore of=new OfflineMessageStore();
		try{
				
				String subject1="";
				String from="";String to="";String winID="";
			int windowID=0;
				subject1=packet.getSubject();
				String subject2=subject1.substring(0,subject1.lastIndexOf(":"));
				if(subject2.equals("delete"))
				{
					/*try{
						String admin=packet.getTo().toString();
						admin=admin.substring(0,admin.lastIndexOf("@"));
						of.deleteMessages(admin);
						//of.deleteMessages(session.getAddress().toString());
					}catch(Exception e){}*/
					//from=packet.getFrom().toString();
					
					from=subject1.substring(subject1.lastIndexOf(":")+1,subject1.lastIndexOf("%"));
					from=from.substring(0,from.lastIndexOf("@"));
					to=subject1.substring(subject1.lastIndexOf("%")+1);
					to=to.substring(0,to.lastIndexOf("@"));
					try{	
							winID=subject1.substring(subject1.lastIndexOf("#")+1);
							System.out.println("Subject value "+subject1+" winID "+winID);
							windowID=Integer.parseInt(winID);
					}catch(Exception e){
											System.out.println("error"+e);
									   }
					//of.deleteMessages(to);
					//of.deleteMessages(to,from);//august 19th 2009 kartheepan edit
					of.deleteMessages(to,from,windowID);//october 1st 2009 kartheepan edit
				}
				
				
		}catch(Exception e){System.out.println("Error in clientStanzaHandler"+e);}
		
		//KARTHEEPAN EDIT AUGUST 19TH 2009 5.20 P.M
    }

    void startTLS() throws Exception {
        Connection.ClientAuth policy;
        try {
            policy = Connection.ClientAuth.valueOf(JiveGlobals.getProperty("xmpp.client.cert.policy", "disabled"));
        } catch (IllegalArgumentException e) {
            policy = Connection.ClientAuth.disabled;
        }
        connection.startTLS(false, null, policy);
    }
}
package org.jivesoftware.spark;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import javax.swing.JViewport;
import java.awt.Rectangle;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.ListSelectionModel;
import javax.swing.WindowConstants;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.DefaultTableColumnModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableColumn;
import java.awt.Component;
import org.jivesoftware.spark.ui.ChatRoom;
import org.jivesoftware.spark.ui.ChatRoomNotFoundException;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.util.StringUtils;
import org.jivesoftware.resource.SparkRes;



import org.jivesoftware.resource.Default;

import javax.swing.JPanel;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.geom.AffineTransform;




/**
 * this class file contains all the elements to create a grid where individual messages are inserted into the grid.Also while onclicking the grid all the corresponding messages
 for the individual user are inserted into a chat ROOM
 */
public class DisplayMessage {
	
	//int count=0;
	private final JLabel titleLabel = new JLabel();//for title label
	private Icon tabIcon;//for tabIcon
 	private static DisplayMessage singleton;//the reference displayMessage to be returned to the workspace
	private Workspace workspace=null;//the workspace reference 
    private static final Object LOCK = new Object();//the object lock used for singleton instance creation for the displayMessage.java
    JFrame mainframe;//The JFrame for the offline messages grid to be displayed
	private JViewport viewport=null;
	JFrame frame;//Another JFrame for the offline messages

	JTable table;//The JTable reference for the grid creation for the offline messages

	JScrollPane tablePane, textFieldPane;//the JSCROLLPANE for the offline messages

	JTextArea messageField;//the JTextArea where the messages get displayed on click of the individual messages

	Vector dataCollection=new Vector();//the data collection where all the offline messages are stored

	private MyTableModel mytable=null;//the MyTableModel for the grid creation
	
	private MyCell mycell=null;//creating the reference for the inner class mycell
	

	private final String colhead[]={"From","Time","Date"};//the array colhead where the headings for the grid are stored
	int columns=0;//the column count
	private TableColumn tablecolumn[];//the table column reference created
	private DefaultTableColumnModel dtm=null;//the default table column model created
	
	
	Vector rowMessage;//the collection to store the individual grid message
	Vector rowFrom;//the collection to store the individual grid message fromID
	Vector windowIDS;//the collection to store the individual grid message
	String tip;
	int count=0;
	int selectedRow;//The variable storing the selected row id from the grid

	public DisplayMessage(final HashMap hm,ImageIcon titleImage) {//the counstructor with a collection as parameter
	
		columns=colhead.length;//the colhead length is assigned here
		rowMessage = new Vector();//the rowMessage collection earlier defined is insitialised
		//rowFrom = new HashMap();//the rowFrom collection earlier defined is insitialised
		rowFrom = new Vector();//the rowFrom collection earlier defined is insitialised
		windowIDS=new Vector();//the windowIDS collection earlier defined is insitialised

		frame = new JFrame("Offline Messages");//the frame for the offline messages
		try{
			//final Image TitleImage = Default.getImageIcon(Default.TRAY_IMAGE).getImage();
		//frame.setIconImage(Toolkit.getDefaultToolkit().getImage("icon_confused.gif"));
		frame.setIconImage(titleImage.getImage());
		}
		catch(Exception e){}
		tablecolumn=new TableColumn[columns];
		dtm=new DefaultTableColumnModel();
		mytable=new MyTableModel();
		mycell=new MyCell();//mycell.setBackground(Color.blue);
		//mycell.setIcon(titleImage);
		/*ImageIcon imageIcon;
		 imageIcon = new ImageIcon("icon_evil.gif");
		SetIcon(table, 1, imageIcon,"Home");
		SetIcon(table, 0, imageIcon,"Name");
		SetIcon(table, 1, imageIcon,"Home");
		*/

		//the columns are created for the grid in the following piece of code
		for(int i=0;i<columns;i++)
		{
			tablecolumn[i]=new TableColumn(i);
			tablecolumn[i].setCellRenderer(mycell);
			
		
				tablecolumn[i].setHeaderValue(colhead[i]);
			
			dtm.addColumn(tablecolumn[i]);
		}
		table = new JTable(mytable,dtm);
		constructString(hm);//the construct string method is invoked where the collection passed as parameter is passed on to the method for further processing
		tablePane = new JScrollPane(table);
		tablePane.getViewport().setForeground(Color.WHITE);
		//the messageFIELD area is defined
		messageField = new JTextArea(2, 30);
		messageField.setEditable(false);messageField.setCaretColor(Color.WHITE);
		//the messageFIELD area is defined
		
		//the JScrollPane is defined
		textFieldPane = new JScrollPane(messageField);
		tablePane.setPreferredSize(new Dimension(600, 130));
		tablePane.getViewport().setBackground(Color.WHITE);
		table.setRowSelectionAllowed(true);
		//the JScrollPane is defined

		// for creating tooltip text
		TableColumn column = table.getColumnModel().getColumn(0);
		DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
		tip = "Double click to reply";
		renderer.setToolTipText(tip);
		column.setCellRenderer(renderer);

		// for setting initial value
		messageField.setText((String) rowMessage.elementAt(0));
		
		
		
		
		table.setSelectionBackground(Color.lightGray);//table.setSelectionForeground(Color.black);
		table.setShowGrid(false);	//table.setGridColor(Color.blue);
		table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

		// for adding selection listener
		table.getSelectionModel().addListSelectionListener(
				new ListSelectionListener() {
					public void valueChanged(final ListSelectionEvent e) {
						// Ignore extra messages.

						if (e.getValueIsAdjusting()) {
							return;
						}
						ListSelectionModel lsm = (ListSelectionModel) e
								.getSource();

						if (lsm.isSelectionEmpty()) {
							// System.out.println("No rows are selected.");
						} else {

								/*	int windowID=22;String subject="";
									try{
											windowID=(Integer)windowIDS.elementAt(selectedRow);
										
									   }catch(Exception e1){windowID=44;subject=""+e1;}	
									*/


									selectedRow = lsm.getMinSelectionIndex();
									messageField.setText((String) rowMessage.elementAt(selectedRow));
									//messageField.setText((String) rowMessage.get((rowMessage.size()-1-selectedRow) + ""));


						}
					}
				});

		// for adding mouselistener
		table.addMouseListener(new MouseAdapter() {
			@Override
			public void mouseClicked(final MouseEvent e) {
				if (e.getSource().equals(table)) {
					if ((e.getClickCount() == 2)) {
						
						
						selectedRow = table.getSelectedRow();//the selected row id from the grid is assigned to the variable selectedRow
						//messageField.setText((String) rowMessage.get((rowMessage.size()-1-selectedRow) + ""));//the corresponding content is displayed in the messageField TEXT area on click of the grid
						//String from=(String) rowFrom.get((rowFrom.size()-1-selectedRow+count) + "");//the from addresse is got from the collection rowFrom based on the selected row in the grid
						
						
						int windowID=1000;
						String from="";String exep="";
									try{
						     				String content=(String) rowFrom.elementAt(selectedRow);//the from addresse is got from the collection rowFrom based on the selected row in the grid
											from=content;

											Integer winID=(Integer) windowIDS.elementAt(selectedRow);
											
											windowID=winID.intValue();
											//System.out.println("winddowIDS"+windowIDS.elementAt(selectedRow)+"winID"+winID+" windowID"+windowID+"selectedRow"+selectedRow+"rowFrom"+rowFrom+"windowIDS"+windowIDS);
											//exep=content;
											//windowID=1;
											//rowFrom.remove(selectedRow);
									   }catch(Exception e1){exep=""+e1;}	

										mytable.removeRow(selectedRow);//the selected row is removed from the grid
										rowFrom.remove(selectedRow);
										rowMessage.remove(selectedRow);
										//messageField.setText(selectedRow+"exep "+exep+"::from addresse"+from+"windowID"+windowID);
									try{
										int select=0; 
										if(selectedRow==0)select=1;
											else select=selectedRow-1;
													messageField.setText((String) rowMessage.elementAt(select));
										}catch(Exception e1){}
									 try {
											 //insertMessage(bareJID, message,windowID);
															 getChatRoom(from,windowID);//onclicking the individual grid the getChatRoom method is invoked to invoke the chat room
										 }
									   catch (ChatRoomNotFoundException e1) {
										   //Log.error("Could not find chat room.", e);
									 }
							
						tip = "Double click to reply <html><b>"
								+ table.getValueAt(table.getSelectedRow(),
										table.getSelectedColumn())
								+ "</b></htnl>";
						
					count++;
						
							
						}
					}//if
				}
			}
		);
		//JPanel panel = new JPanel();
		frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		frame.getContentPane().add("Center", tablePane);
		frame.getContentPane().add("South
/**
 * $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.sparkimpl.settings.local;

import org.jivesoftware.resource.Res;
import org.jivesoftware.resource.SparkRes;
import org.jivesoftware.spark.preference.Preference;

import javax.swing.Icon;
import javax.swing.JComponent;

/**
 * Represents the Local Preference inside the Preference Manager.
 */
public class LocalPreference implements Preference {
    private LocalPreferencePanel panel;
    private LocalPreferences preferences;
    private String errorMessage = "Error";

    /**
     * Initalize and load local preference.
     */
    public LocalPreference() {
        preferences = SettingsManager.getLocalPreferences();
    }

    public String getTitle() {
        return Res.getString("title.login.settings");
    }

    public String getListName() {
        return Res.getString("title.login");
    }

    public String getTooltip() {
        return Res.getString("title.login.settings");
    }

    public Icon getIcon() {
        return SparkRes.getImageIcon(SparkRes.LOGIN_KEY_IMAGE);
    }

    public void load() {
        preferences = SettingsManager.getLocalPreferences();
    }

    public void commit() {
        getData();

        SettingsManager.saveSettings();
    }

    public Object getData() {
        preferences = SettingsManager.getLocalPreferences();
        preferences.setAutoLogin(panel.getAutoLogin());
        preferences.setTimeOut(Integer.parseInt(panel.getTimeout()));
        preferences.setXmppPort(Integer.parseInt(panel.getPort()));
        preferences.setSavePassword(panel.isSavePassword());
        preferences.setIdleOn(panel.isIdleOn());
        preferences.setIdleTime(Integer.parseInt(panel.getIdleTime()));
        preferences.setStartedHidden(panel.startInSystemTray());
        preferences.setStartOnStartup(panel.startOnStartup());

        return preferences;
    }

    public String getErrorMessage() {
        return errorMessage;
    }

    public boolean isDataValid() {
        preferences.setTimeOut(Integer.parseInt(panel.getTimeout()));
        preferences.setXmppPort(Integer.parseInt(panel.getPort()));

        try {
            Integer.parseInt(panel.getTimeout());
            Integer.parseInt(panel.getPort());
            Integer.parseInt(panel.getIdleTime());
        }
        catch (Exception ex) {
            errorMessage = Res.getString("message.specify.valid.time.error");
            return false;
        }

        int timeOut = Integer.parseInt(panel.getTimeout());
        if (timeOut < 5) {
            errorMessage = Res.getString("message.timeout.error");
            return false;
        }

        return true;
    }

    public JComponent getGUI() {
        panel = new LocalPreferencePanel();

        return panel;
    }

    public String getNamespace() {
        return "LOGIN";
    }

    public void shutdown() {
        // Commit to file.
        SettingsManager.saveSettings();
    }

}
/**
 * $RCSfile$
 * $Revision: 2911 $
 * $Date: 2005-10-03 12:35:52 -0300 (Mon, 03 Oct 2005) $
 *
 * Copyright (C) 2004-2008 Jive Software. All rights reserved.
 *
 * This software is published under the terms of the GNU Public License (GPL),
 * a copy of which is included in this distribution, or a commercial license
 * agreement with Jive.
 */

package org.jivesoftware.openfire;

import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.jivesoftware.database.DbConnectionManager;
import org.jivesoftware.database.SequenceManager;
import org.jivesoftware.util.*;
import org.jivesoftware.util.cache.Cache;
import org.jivesoftware.util.cache.CacheFactory;
import org.jivesoftware.openfire.container.BasicModule;
import org.jivesoftware.openfire.event.UserEventDispatcher;
import org.jivesoftware.openfire.event.UserEventListener;
import org.jivesoftware.openfire.user.User;
import org.jivesoftware.openfire.user.UserManager;
import org.xmpp.packet.JID;
import org.xmpp.packet.Message;

import java.io.StringReader;
import java.sql.Connection;
import java.sql.Statement;//kartheepan include 6th october 7.10 p.m
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.*;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Represents the user's offline message storage. A message store holds messages that were
 * sent to the user while they were unavailable. The user can retrieve their messages by
 * setting their presence to "available". The messages will then be delivered normally.
 * Offline message storage is optional, in which case a null implementation is returned that
 * always throws UnauthorizedException when adding messages to the store.
 *
 * @author Iain Shigeoka
 */
public class OfflineMessageStore extends BasicModule implements UserEventListener {
    //KARTHEEPAN EDIT AUGUST 19TH,october 1st(update windowID) 2009 5.20 P.M
    private static final String INSERT_OFFLINE =
        "INSERT INTO ofOffline (username, messageID, creationDate, messageSize, stanza, sentFrom, windowID) " +
        "VALUES (?, ?, ?, ?, ?, ?, ?)";
	//KARTHEEPAN EDIT AUGUST 19TH,october 1st(update windowID) 2009 5.20 P.M
    private static final String LOAD_OFFLINE =
        "SELECT stanza, creationDate,windowID,sentFrom FROM ofOffline WHERE username=?";
    private static final String LOAD_OFFLINE_MESSAGE =
        "SELECT stanza FROM ofOffline WHERE username=? AND creationDate=?";
    private static final String SELECT_SIZE_OFFLINE =
        "SELECT SUM(messageSize) FROM ofOffline WHERE username=?";
    private static final String SELECT_SIZE_ALL_OFFLINE =
        "SELECT SUM(messageSize) FROM ofOffline";
    private static final String DELETE_OFFLINE =
        "DELETE FROM ofOffline WHERE username=?";

	//KARTHEEPAN EDIT AUGUST 19TH 2009 5.20 P.M
	private static final String DELETE_OFFLINE_SENTBY =
        "DELETE FROM ofOffline WHERE username=? AND sentFrom=?";
	//KARTHEEPAN EDIT AUGUST 19TH 2009 5.20 P.M
	
	//KARTHEEPAN EDIT OCTOBER 1ST 2009 5.20 P.M
	private static final String DELETE_OFFLINE_SENTBY_WINDOWID =
        "DELETE FROM ofOffline WHERE username=? AND sentFrom=? AND windowID=?";
	//KARTHEEPAN EDIT OCTOBER 1ST 2009 5.20 P.M
	
    private static final String DELETE_OFFLINE_MESSAGE =
        "DELETE FROM ofOffline WHERE username=? AND creationDate=?";

    private Cache<String, Integer> sizeCache;
    private FastDateFormat dateFormat;
    /**
     * Pattern to use for detecting invalid XML characters. Invalid XML characters will
     * be removed from the stored offline messages.
     */
    private Pattern pattern = Pattern.compile("&\\#[\\d]+;");

    /**
     * Returns the instance of <tt>OfflineMessageStore</tt> being used by the XMPPServer.
     *
     * @return the instance of <tt>OfflineMessageStore</tt> being used by the XMPPServer.
     */
    public static OfflineMessageStore getInstance() {
        return XMPPServer.getInstance().getOfflineMessageStore();
    }

    /**
     * Pool of SAX Readers. SAXReader is not thread safe so we need to have a pool of readers.
     */
    private BlockingQueue<SAXReader> xmlReaders = new LinkedBlockingQueue<SAXReader>();

    /**
     * Constructs a new offline message store.
     */
    public OfflineMessageStore() {
        super("Offline Message Store");
        dateFormat = FastDateFormat.getInstance(JiveConstants.XMPP_DELAY_DATETIME_FORMAT,
                TimeZone.getTimeZone("UTC"));
        sizeCache = CacheFactory.createCache("Offline Message Size");
    }

    /**
     * Adds a message to this message store. Messages will be stored and made
     * available for later delivery.
     *
     * @param message the message to store.
     */
    public void addMessage(Message message) {
        if (message == null) {
            return;
        }
        if (message.getBody() == null || message.getBody().length() == 0) {
        	// ignore empty bodied message (typically chat-state notifications).
        	return;
        }
        JID recipient = message.getTo();
		//KARTHEEPAN EDIT AUGUST 19TH 2009 5.20 P.M
		JID sentFrom= message.getFrom();
		String usernameFrom=sentFrom.getNode();
		//KARTHEEPAN EDIT AUGUST 19TH 2009 5.20 P.M

        String username = recipient.getNode();
        // If the username is null (such as when an anonymous user), don't store.
        if (username == null || !UserManager.getInstance().isRegisteredUser(recipient)) {
            return;
        }
        else
        if (!XMPPServer.getInstance().getServerInfo().getXMPPDomain().equals(recipient.getDomain())) {
            // Do not store messages sent to users of remote servers
            return;
        }

        long messageID = SequenceManager.nextID(JiveConstants.OFFLINE);
		
		//KARTHEEPAN EDIT OCTOBER 1ST 2009 4.36 P.M
		String subject="";
    	 subject=message.getSubject();
			try{
					subject=message.getSubject();//subject=subject.substring(0,body.indexOf("<windowID>"));
			   }catch(Exception e1){//body=e.getMessage();
				   					 subject=e1.getMessage();
								   }
		String parseWindowID="";
		int windowID1 = 0;
			try{
				
					parseWindowID=subject.substring(subject.lastIndexOf("<windowID>")+10,subject.lastIndexOf("</windowID>"));
		   		    windowID1=Integer.parseInt(parseWindowID);
			   }catch(Exception e1){windowID1=0;}
        //KARTHEEPAN EDIT OCTOBER 1ST 2009 4.36 P.M

        // Get the message in XML format.
        String msgXML = message.getElement().asXML();

        Connection con = null;
        PreparedStatement pstmt = null;
        try {
            con = DbConnectionManager.getConnection();
            pstmt = con.prepareStatement(INSERT_OFFLINE);
            pstmt.setString(1, username);
            pstmt.setLong(2, messageID);
            pstmt.setString(3, StringUtils.dateToMillis(new java.util.Date()));
            pstmt.setInt(4, msgXML.length());
            pstmt.setString(5, msgXML);
			//KARTHEEPAN EDIT AUGUST 19TH 2009 5.20 P.M
			pstmt.setString(6, usernameFrom);
			//KARTHEEPAN EDIT AUGUST 19TH 2009 5.20 P.M
			//KARTHEEPAN EDIT OCTOBER 1ST 2009 4.36 P.M
			//int set=100;
			pstmt.setInt(7, windowID1);
			//KARTHEEPAN EDIT OCTOBER 1ST 2009 4.36 P.M
            pstmt.executeUpdate();
        }

        catch (Exception e) {
            Log.error(LocaleUtils.getLocalizedString("admin.error"), e);
			System.out.println("error while inserting offline"+e);
        }
        finally {
            DbConnectionManager.closeConnection(pstmt, con);
        }

        // Update the cached size if it exists.
        if (sizeCache.containsKey(username)) {
            int size = sizeCache.get(username);
            size += msgXML.length();
            sizeCache.put(username, size);
        }
    }

    /**
     * Returns a Collection of all messages in the store for a user.
     * Messages may be deleted after being selected from the database depending on
     * the delete param.
     *
     * @param username the username of the user who's messages you'd like to receive.
     * @param delete true if the offline messages should be deleted.
     * @return An iterator of packets containing all offline messages.
     */
    public Collection<OfflineMessage> getMessages(String username, boolean delete) {
		System.out.println("inside method");
        List<OfflineMessage> messages = new ArrayList<OfflineMessage>();
        Connection con = null;
        PreparedStatement pstmt = null;
        SAXReader xmlReader = null;
        try {
            // Get a sax reader from the pool
            xmlReader = xmlReaders.take();
            con = DbConnectionManager.getConnection();
            pstmt = con.prepareStatement(LOAD_OFFLINE);
            pstmt.setString(1, username);
            ResultSet rs = pstmt.executeQuery();
			int compareID=0;
			boolean first=true;
            while (rs.next()) {
			System.out.println("inside while");
                String msgXML = rs.getString(1);//System.out.println("msgXML"+msgXML);
				//System.out.println(xmlReader.read(new StringReader(msgXML)).getRootElement());
				Date creationDate = new Date(Long.parseLong(rs.getString(2).trim()));
				int windowID=rs.getInt(3);
				String sentFrom=rs.getString(4);
				OfflineMessage message;
                try {
                    message = new OfflineMessage(creationDate,
                            xmlReader.read(new StringReader(msgXML)).getRootElement());
                } catch (DocumentException e) {
                    // Try again after removing invalid XML chars (e.g. &#12;)
                    Matcher matcher = pattern.matcher(msgXML);
                    if (matcher.find()) {
                        msgXML = matcher.replaceAll("");
                    }
                    message = new OfflineMessage(creationDate,
                            xmlReader.read(new StringReader(msgXML)).getRootElement());
/**
 * $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;

import org.jdesktop.swingx.calendar.DateUtils;
import org.jivesoftware.Spark;
import org.jivesoftware.resource.SparkRes;
import org.jivesoftware.resource.Res;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.util.StringUtils;
import org.jivesoftware.smackx.packet.DelayInformation;
import org.jivesoftware.spark.ChatManager;
import org.jivesoftware.spark.SparkManager;
import org.jivesoftware.spark.plugin.ContextMenuListener;
import org.jivesoftware.spark.util.ModelUtil;
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.JComponent;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.JPopupMenu;
import javax.swing.KeyStroke;
import javax.swing.UIManager;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.Style;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument;

import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.Toolkit;
import java.awt.datatransfer.StringSelection;
import java.awt.event.ActionEvent;
import java.awt.event.MouseEvent;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

/**
 * The <CODE>TranscriptWindow</CODE> class. Provides a default implementation
 * of a Chat Window. In general, extensions could override this class
 * to offer more support within the chat, but should not be necessary.
 */
public class TranscriptWindow extends ChatArea implements ContextMenuListener {

	private static final long serialVersionUID = -2168845249388070573L;
	private final SimpleDateFormat notificationDateFormatter;
    private final SimpleDateFormat messageDateFormatter;
    private final String notificationDateFormat = ((SimpleDateFormat)SimpleDateFormat.getDateInstance(SimpleDateFormat.FULL)).toPattern();
    private final String messageDateFormat = ((SimpleDateFormat)SimpleDateFormat.getTimeInstance(SimpleDateFormat.SHORT)).toPattern();

    private Date lastUpdated;

    /**
     * The default font used in the chat window for all messages.
     */
    private Font defaultFont;

    private Date lastPost;
    
    /**
     * Creates a default instance of <code>TranscriptWindow</code>.
     */
    public TranscriptWindow() {
        setEditable(false);

        // Set Default Font
        final LocalPreferences pref = SettingsManager.getLocalPreferences();
        int fontSize = pref.getChatRoomFontSize();
        defaultFont = new Font("Dialog", Font.PLAIN, fontSize);


        addMouseListener(this);
        addMouseMotionListener(this);
        setDragEnabled(true);
        addContextMenuListener(this);

        // Make sure ctrl-c works
        getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("Ctrl c"), "copy");

        getActionMap().put("copy", new AbstractAction("copy") {
			private static final long serialVersionUID = 1797491846835591379L;

			public void actionPerformed(ActionEvent evt) {
                StringSelection stringSelection = new StringSelection(getSelectedText());
                Toolkit.getDefaultToolkit().getSystemClipboard().setContents(stringSelection, null);
            }
        });

        notificationDateFormatter = new SimpleDateFormat(notificationDateFormat);
        messageDateFormatter = new SimpleDateFormat(messageDateFormat);
    }

    /**
     * Inserts a component into the transcript window.
     *
     * @param component the component to insert.
     */
    public void addComponent(Component component) {
        final StyledDocument doc = (StyledDocument)getDocument();

        // The image must first be wrapped in a style
        Style style = doc.addStyle("StyleName", null);


        StyleConstants.setComponent(style, component);

        // Insert the image at the end of the text
        try {
            doc.insertString(doc.getLength(), "ignored text", style);
            doc.insertString(doc.getLength(), "\n", null);
        }
        catch (BadLocationException e) {
            Log.error(e);
        }
    }

   /*
    * Create and insert a message from the current user.
    *
    * @param nickname   the nickname of the current user.
    * @param message    the message to insert.
    * @param foreground the color to use for the message foreground.
    */
    public void insertMessage(String nickname, Message message, Color foreground) {
        insertMessage(nickname, message, foreground, Color.white);
    }
   
    /**
     * Create and insert a message from the current user.
     *
     * @param nickname   the nickname of the current user.
     * @param message    the message to insert.
     * @param foreground the color to use for the message foreground.
     * @param background the color to use for the message background.
     */
    public void insertMessage(String nickname, Message message, Color foreground, Color background) {
        // Check interceptors.
        for (TranscriptWindowInterceptor interceptor : SparkManager.getChatManager().getTranscriptWindowInterceptors()) {
            boolean handled = interceptor.isMessageIntercepted(this, nickname, message);
            if (handled) {
                // Do nothing.
                return;
            }
        }

        String body = message.getBody();

        try {
            DelayInformation inf = (DelayInformation)message.getExtension("x", "jabber:x:delay");
            Date sentDate;
            if (inf != null) {
                sentDate = inf.getStamp();

                body = "(Offline) " + body;
            }
            else {
                sentDate = new Date();
            }
			//System.out.println("date"+sentDate);
			
            String date = getDate(sentDate);
			String dt=""+sentDate;
												 try{String subject=message.getSubject();
														dt=subject.substring(subject.lastIndexOf("<date>")+6,subject.lastIndexOf("</date>"));
															System.out.println("date"+dt);
															Date createDate=new Date(Long.parseLong(dt));
															date = getDate(createDate);
															System.out.println("date1"+createDate);
															//String value;

															 long lastPostTime = lastPost != null ? lastPost.getTime() : 0;
															 long lastPostStartOfDay = DateUtils.startOfDayInMillis(lastPostTime);
															 long newPostStartOfDay = DateUtils.startOfDayInMillis(createDate.getTime());

															 int diff = DateUtils.getDaysDiff(lastPostStartOfDay, newPostStartOfDay);
															  if (diff != 0) {
														  insertCustomText(notificationDateFormatter.format(createDate), true, true, Color.BLACK);
															 }

														  //value = "(" + messageDateFormatter.format(date) + ") ";
														  //value = value + userid + ": ";

														  lastPost = createDate;
														//message.setTo(to);
												    }catch(Exception e){System.out.println("Error fetching date in transcriptwindow	"+e);
													}	
													
            // Agent color is always blue
            StyleConstants.setBold(styles, false);
            StyleConstants.setForeground(styles, foreground);
            StyleConstants.setBackground(styles, background);
            final Document doc = getDocument();
            styles.removeAttribute("link");

            StyleConstants.setFontSize(styles, defaultFont.getSize());
            doc.insertString(doc.getLength(), date + nickname + ": ", styles);

            // Reset Styles for message
            StyleConstants.setBold(styles, false);

            StyleConstants.setForeground(styles, Color.black);
            setText(body);
            insertText("\n");
        }
        catch (BadLocationException e) {
            Log.error("Error message.", e);
        }
    }
 public void insertMessage(String nickname, Message message, Color foreground, Color background,String offline) {
        

        String body = message.getBody();
	System.out.println("1"+body);
        try {
            DelayInformation inf = (DelayInformation)message.getExtension("x", "jabber:x:delay");
            Date sentDate;
            if (inf != null) {
                sentDate = inf.getStamp();

                body = "(Offline) " + body;
            }
            else {
                sentDate = new Date();
            }
				
            String date = getDate(sentDate);
			System.out.println("2"+body+"date"+sentDate);
            // Agent color is always blue
            StyleConstants.setBold(styles, false);
            StyleConstants.setForeground(styles, foreground);
            StyleConstants.setBackground(styles, background);
            final Document doc = getDocument();
            styles.removeAttribute("link");
			System.out.println("3");
            StyleConstants.setFontSize(styles, defaultFont.getSize());
            doc.insertString(doc.getLength(), date + nickname + ": ", styles);
			System.out.println("4");
            // Reset Styles for message
            StyleConstants.setBold(styles, false);
			System.out.println("5");
            StyleConstants.setForeground(styles, Color.black);
			System.out.println("6");
            setText(body);
			System.out.println("7");
            insertText("\n");
			System.out.println("8");
        }
        catch (BadLocationException e) {
            Log.error("Error message.", e);
			
        }
    }
    /**
     * Inserts a full line using a prefix and message.
     *
     * @param prefix     the prefix to use. If null is used, then only the message will be inserted.
     * @param message    the message to insert.
     * @param foreground the fore
/**
 * $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;

import org.jivesoftware.MainWindow;
import org.jivesoftware.MainWindowListener;
import org.jivesoftware.Spark;
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.Roster;
import org.jivesoftware.smack.filter.PacketFilter;
import org.jivesoftware.smack.filter.PacketTypeFilter;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.util.StringUtils;
import org.jivesoftware.smackx.debugger.EnhancedDebuggerWindow;
import org.jivesoftware.smackx.packet.DelayInformation;
import org.jivesoftware.smackx.packet.VCard;
import org.jivesoftware.spark.component.tabbedPane.SparkTabbedPane;
import org.jivesoftware.spark.filetransfer.SparkTransferManager;
import org.jivesoftware.spark.search.SearchManager;
import org.jivesoftware.spark.ui.ChatContainer;
import org.jivesoftware.spark.ui.ChatRoom;
import org.jivesoftware.spark.ui.ChatRoomNotFoundException;
import org.jivesoftware.spark.ui.CommandPanel;
import org.jivesoftware.spark.ui.ContactItem;
import org.jivesoftware.spark.ui.ContactList;
import org.jivesoftware.spark.ui.conferences.ConferenceServices;
import org.jivesoftware.spark.ui.status.StatusBar;
import org.jivesoftware.spark.util.ModelUtil;
import org.jivesoftware.spark.util.TaskEngine;
import org.jivesoftware.spark.util.log.Log;
import org.jivesoftware.sparkimpl.plugin.alerts.BroadcastPlugin;
import org.jivesoftware.sparkimpl.plugin.bookmarks.BookmarkPlugin;
import org.jivesoftware.sparkimpl.plugin.gateways.GatewayPlugin;
import org.jivesoftware.sparkimpl.plugin.manager.Enterprise;
import org.jivesoftware.sparkimpl.plugin.transcripts.ChatTranscriptPlugin;


import java.awt.CardLayout;
import java.awt.Color;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.util.TimerTask;
import java.util.HashMap;
import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.TimeZone;
import javax.swing.AbstractAction;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
import javax.swing.KeyStroke;
import javax.swing.SwingUtilities;


/**
 * The inner Container for Spark. The Workspace is the container for all plugins into the Spark
 * install. Plugins would use this for the following:
 * <p/>
 * <ul>
 * <li>Add own tab to the main tabbed pane. ex.
 * <p/>
 * <p/>
 * Workspace workspace = SparkManager.getWorkspace();
 * JButton button = new JButton("HELLO SPARK USERS");
 * workspace.getWorkspacePane().addTab("MyPlugin", button);
 * </p>
 * <p/>
 * <li>Retrieve the ContactList.
 */
public class Workspace extends JPanel implements PacketListener {
	HashMap hm=new HashMap();//collection declaration kartheepan edit

	DisplayMessage displayMessage =null;//displayMessage instance creation for offline message grid display //kartheepan edit
    private SparkTabbedPane workspacePane;
    private StatusBar statusBox;
    private CommandPanel commandPanel;
    private ContactList contactList;
    private ConferenceServices conferences;
    private GatewayPlugin gatewayPlugin;
    private BookmarkPlugin bookmarkPlugin;
    private ChatTranscriptPlugin transcriptPlugin;
    private BroadcastPlugin broadcastPlugin;
	int count=0;
    private static Workspace singleton;
    private static final Object LOCK = new Object();

    private JPanel cardPanel;
    private CardLayout cardLayout;
	//private String compareFrom=null;//this variable is declared for comparing the fromAddress of subsequent offline messages.This variable is mainly used to avoid the subsequent insertion of the offline messages from the same user into the offline messages grid

    public static final String WORKSPACE_PANE = "WORKSPACE_PANE";


    /**
     * Returns the singleton instance of <CODE>Workspace</CODE>,
     * creating it if necessary.
     * <p/>
     *
     * @return the singleton instance of <Code>Workspace</CODE>
     */
    public static Workspace getInstance() {
        // Synchronize on LOCK to ensure that we don't end up creating
        // two singletons.
        synchronized (LOCK) {
            if (null == singleton) {
                Workspace controller = new Workspace();
                singleton = controller;
                return controller;
            }
        }
        return singleton;
    }


    /**
     * Creates the instance of the SupportChatWorkspace.
     */
    private Workspace() {
        final MainWindow mainWindow = SparkManager.getMainWindow();

        // Add MainWindow listener
        mainWindow.addMainWindowListener(new MainWindowListener() {
            public void shutdown() {
                final ChatContainer container = SparkManager.getChatManager().getChatContainer();
                // Close all Chats.
                for (ChatRoom chatRoom : container.getChatRooms()) {
                    // Leave ChatRoom
                    container.leaveChatRoom(chatRoom);
                }

                conferences.shutdown();
                gatewayPlugin.shutdown();
                bookmarkPlugin.shutdown();
                broadcastPlugin.shutdown();
            }

            public void mainWindowActivated() {

            }

            public void mainWindowDeactivated() {

            }
        });

        // Initialize workspace pane, defaulting the tabs to the bottom.
        workspacePane = new SparkTabbedPane(JTabbedPane.BOTTOM);
        workspacePane.setActiveButtonBold(true);

        // Add Panels.
        cardLayout = new CardLayout();
        cardPanel = new JPanel(cardLayout);
        cardPanel.setOpaque(false);
        cardPanel.add(WORKSPACE_PANE, this);

        statusBox = new StatusBar();
        commandPanel = new CommandPanel();

        // Build default workspace
        this.setLayout(new GridBagLayout());
        add(workspacePane, new GridBagConstraints(0, 9, 1, 1, 1.0, 1.0, GridBagConstraints.WEST, GridBagConstraints.BOTH, new Insets(0, 4, 4, 4), 0, 0));
        add(statusBox, new GridBagConstraints(0, 0, 1, 1, 1.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(2, 4, 4, 4), 0, 0));
        add(commandPanel, new GridBagConstraints(0, 5, 1, 1, 1.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(2, 4, 0, 4), 0, 0));


        this.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("F12"), "showDebugger");
        this.getActionMap().put("showDebugger", new AbstractAction("showDebugger") {
            public void actionPerformed(ActionEvent evt) {
                EnhancedDebuggerWindow window = EnhancedDebuggerWindow.getInstance();
                window.setVisible(true);
            }
        });

        // Set background
        setBackground(new Color(235, 239, 254));
    }

    /**
     * Builds the Workspace layout.
     */
    public void buildLayout() {
        new Enterprise();

        // Initialize Contact List
        contactList = new ContactList();
        conferences = new ConferenceServices();

        // Init contact list.
        contactList.initialize();

        // Load VCard information for status box
        statusBox.loadVCard();

        // Initialise TransferManager
        SparkTransferManager.getInstance();
    }

    /**
     * Starts the Loading of all Spark Plugins.
     */
    public void loadPlugins() {
        // Add presence and message listeners
        // we listen for these to force open a 1-1 peer chat window from other operators if
        // one isn't already open
        PacketFilter workspaceMessageFilter = new PacketTypeFilter(Message.class);

        // Add the packetListener to this instance
        SparkManager.getSessionManager().getConnection().addPacketListener(this, workspaceMessageFilter);

        // Make presence available to anonymous requests, if from anonymous user in the system.
        PacketListener workspacePresenceListener = new PacketListener() {
            public void processPacket(Packet packet) {
                Presence presence = (Presence)packet;
                if (presence.getProperty("anonymous") != null) {
                    boolean isAvailable = statusBox.getPresence().getMode() == Presence.Mode.available;
                    Presence reply = new Presence(Presence.Type.available);
                    if (!isAvailable) {
                        reply.setType(Presence.Type.unavailable);
                    }
                    reply.setTo(presence.getFrom());
                    SparkManager.getSessionManager().getConnection().sendPacket(reply);
                }
            }
        };

        SparkManager.getSessionManager().getConnection().addPacketListener(workspacePresenceListener, new PacketTypeFilter(Presence.class));

        // Send Available status
        final Presence presence = SparkManager.getWorkspace().getStatusBar().getPresence();
        SparkManager.getSessionManager().changePresence(presence);

        // Until we have better plugin management, will init after presence updates.
        gatewayPlugin = new GatewayPlugin();
        gatewayPlugin.initialize();

        // Load all non-presence related items.
        conferences.loadConferenceBookmarks();
        SearchManager.getInstance();
        transcriptPlugin = new ChatTranscriptPlugin();

        // Load Broadcast Plugin
        broadcastPlugin = new BroadcastPlugin();
        broadcastPlugin.initialize();

        // Load BookmarkPlugin
        bookmarkPlugin = new BookmarkPlugin();
        bookmarkPlugin.initialize();

        // Schedule loading of the plugins after two seconds.
        TaskEngine.getInstance().schedul
  • 1 Contributor
  • 0 Replies
  • 71 Views
Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.