Smack 1.5.1 + SMACK-73. Branch generated to include TLS support in HEAD.

git-svn-id: http://svn.igniterealtime.org/svn/repos/smack/trunk@2716 b35dd754-fafc-0310-a699-88a17e54d16e

CopyOftrunk/source/org/jivesoftware/smackx/debugger/EnhancedDebugger.java

@@ -0,0 +1,858 @@
+/**
+ * $RCSfile$
+ * $Revision$
+ * $Date$
+ *
+ * Copyright 2003-2004 Jive Software.
+ *
+ * All rights reserved. Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jivesoftware.smackx.debugger;
+
+import java.awt.*;
+import java.awt.datatransfer.*;
+import java.awt.event.*;
+import java.io.*;
+import java.net.*;
+import java.text.*;
+import java.util.Date;
+
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.table.*;
+import javax.xml.transform.*;
+import javax.xml.transform.stream.*;
+
+import org.jivesoftware.smack.*;
+import org.jivesoftware.smack.debugger.*;
+import org.jivesoftware.smack.packet.*;
+import org.jivesoftware.smack.util.*;
+
+/**
+ * The EnhancedDebugger is a debugger that allows to debug sent, received and interpreted messages 
+ * but also provides the ability to send ad-hoc messages composed by the user.<p>
+ * 
+ * A new EnhancedDebugger will be created for each connection to debug. All the EnhancedDebuggers 
+ * will be shown in the same debug window provided by the class EnhancedDebuggerWindow.
+ * 
+ * @author Gaston Dombiak
+ */
+public class EnhancedDebugger implements SmackDebugger {
+
+    private static final String NEWLINE = "\n";
+
+    private static ImageIcon packetReceivedIcon;
+    private static ImageIcon packetSentIcon;
+    private static ImageIcon presencePacketIcon;
+    private static ImageIcon iqPacketIcon;
+    private static ImageIcon messagePacketIcon;
+    private static ImageIcon unknownPacketTypeIcon;
+
+    {
+        URL url;
+        // Load the image icons 
+        url =
+            Thread.currentThread().getContextClassLoader().getResource("images/nav_left_blue.png");
+        if (url != null) {
+            packetReceivedIcon = new ImageIcon(url);
+        }
+        url =
+            Thread.currentThread().getContextClassLoader().getResource("images/nav_right_red.png");
+        if (url != null) {
+            packetSentIcon = new ImageIcon(url);
+        }
+        url =
+            Thread.currentThread().getContextClassLoader().getResource("images/photo_portrait.png");
+        if (url != null) {
+            presencePacketIcon = new ImageIcon(url);
+        }
+        url =
+            Thread.currentThread().getContextClassLoader().getResource(
+                "images/question_and_answer.png");
+        if (url != null) {
+            iqPacketIcon = new ImageIcon(url);
+        }
+        url = Thread.currentThread().getContextClassLoader().getResource("images/message.png");
+        if (url != null) {
+            messagePacketIcon = new ImageIcon(url);
+        }
+        url = Thread.currentThread().getContextClassLoader().getResource("images/unknown.png");
+        if (url != null) {
+            unknownPacketTypeIcon = new ImageIcon(url);
+        }
+    }
+
+    private DefaultTableModel messagesTable = null;
+    private JTextArea messageTextArea = null;
+    private JFormattedTextField userField = null;
+    private JFormattedTextField statusField = null;
+
+    private XMPPConnection connection = null;
+
+    private PacketListener packetReaderListener = null;
+    private PacketListener packetWriterListener = null;
+    private ConnectionListener connListener = null;
+
+    private Writer writer;
+    private Reader reader;
+    private ReaderListener readerListener;
+    private WriterListener writerListener;
+
+    private Date creationTime = new Date();
+
+    // Statistics variables
+    private DefaultTableModel statisticsTable = null;
+    private int sentPackets = 0;
+    private int receivedPackets = 0;
+    private int sentIQPackets = 0;
+    private int receivedIQPackets = 0;
+    private int sentMessagePackets = 0;
+    private int receivedMessagePackets = 0;
+    private int sentPresencePackets = 0;
+    private int receivedPresencePackets = 0;
+    private int sentOtherPackets = 0;
+    private int receivedOtherPackets = 0;
+
+    JTabbedPane tabbedPane;
+
+    public EnhancedDebugger(XMPPConnection connection, Writer writer, Reader reader) {
+        this.connection = connection;
+        this.writer = writer;
+        this.reader = reader;
+        createDebug();
+        EnhancedDebuggerWindow.addDebugger(this);
+    }
+
+    /**
+     * Creates the debug process, which is a GUI window that displays XML traffic.
+     */
+    private void createDebug() {
+        // We'll arrange the UI into six tabs. The first tab contains all data, the second
+        // client generated XML, the third server generated XML, the fourth allows to send 
+        // ad-hoc messages and the fifth contains connection information.
+        tabbedPane = new JTabbedPane();
+
+        // Add the All Packets, Sent, Received and Interpreted panels
+        addBasicPanels();
+
+        // Add the panel to send ad-hoc messages
+        addAdhocPacketPanel();
+
+        // Add the connection information panel
+        addInformationPanel();
+
+        // Create a thread that will listen for all incoming packets and write them to
+        // the GUI. This is what we call "interpreted" packet data, since it's the packet
+        // data as Smack sees it and not as it's coming in as raw XML.
+        packetReaderListener = new PacketListener() {
+            SimpleDateFormat dateFormatter = new SimpleDateFormat("hh:mm:ss aaa");
+            public void processPacket(Packet packet) {
+                addReadPacketToTable(dateFormatter, packet);
+            }
+        };
+
+        // Create a thread that will listen for all outgoing packets and write them to
+        // the GUI.
+        packetWriterListener = new PacketListener() {
+            SimpleDateFormat dateFormatter = new SimpleDateFormat("hh:mm:ss aaa");
+            public void processPacket(Packet packet) {
+                addSentPacketToTable(dateFormatter, packet);
+            }
+        };
+
+        // Create a thread that will listen for any connection closed event
+        connListener = new ConnectionListener() {
+            public void connectionClosed() {
+                statusField.setValue("Closed");
+                EnhancedDebuggerWindow.connectionClosed(EnhancedDebugger.this);
+            }
+
+            public void connectionClosedOnError(Exception e) {
+                statusField.setValue("Closed due to an exception");
+                EnhancedDebuggerWindow.connectionClosedOnError(EnhancedDebugger.this, e);
+            }
+        };
+    }
+
+    private void addBasicPanels() {
+        JPanel allPane = new JPanel();
+        allPane.setLayout(new GridLayout(2, 1));
+        tabbedPane.add("All Packets", allPane);
+        tabbedPane.setToolTipTextAt(0, "Sent and received packets processed by Smack");
+
+        messagesTable =
+            new DefaultTableModel(
+                new Object[] { "Hide", "Timestamp", "", "", "Message", "Id", "Type", "To", "From" },
+                0) {
+            public boolean isCellEditable(int rowIndex, int mColIndex) {
+                return false;
+            }
+            public Class getColumnClass(int columnIndex) {
+                if (columnIndex == 2 || columnIndex == 3) {
+                    return Icon.class;
+                }
+                return super.getColumnClass(columnIndex);
+            }
+
+        };
+        JTable table = new JTable(messagesTable);
+        // Allow only single a selection
+        table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+        // Hide the first column 
+        table.getColumnModel().getColumn(0).setMaxWidth(0);
+        table.getColumnModel().getColumn(0).setMinWidth(0);
+        table.getTableHeader().getColumnModel().getColumn(0).setMaxWidth(0);
+        table.getTableHeader().getColumnModel().getColumn(0).setMinWidth(0);
+        // Set the column "timestamp" size
+        table.getColumnModel().getColumn(1).setMaxWidth(300);
+        table.getColumnModel().getColumn(1).setPreferredWidth(70);
+        // Set the column "direction" icon size
+        table.getColumnModel().getColumn(2).setMaxWidth(50);
+        table.getColumnModel().getColumn(2).setPreferredWidth(30);
+        // Set the column "packet type" icon size
+        table.getColumnModel().getColumn(3).setMaxWidth(50);
+        table.getColumnModel().getColumn(3).setPreferredWidth(30);
+        // Set the column "Id" size
+        table.getColumnModel().getColumn(5).setMaxWidth(100);
+        table.getColumnModel().getColumn(5).setPreferredWidth(55);
+        // Set the column "type" size
+        table.getColumnModel().getColumn(6).setMaxWidth(200);
+        table.getColumnModel().getColumn(6).setPreferredWidth(50);
+        // Set the column "to" size
+        table.getColumnModel().getColumn(7).setMaxWidth(300);
+        table.getColumnModel().getColumn(7).setPreferredWidth(90);
+        // Set the column "from" size
+        table.getColumnModel().getColumn(8).setMaxWidth(300);
+        table.getColumnModel().getColumn(8).setPreferredWidth(90);
+        // Create a table listener that listen for row selection events
+        SelectionListener selectionListener = new SelectionListener(table);
+        table.getSelectionModel().addListSelectionListener(selectionListener);
+        table.getColumnModel().getSelectionModel().addListSelectionListener(selectionListener);
+        allPane.add(new JScrollPane(table));
+        messageTextArea = new JTextArea();
+        messageTextArea.setEditable(false);
+        // Add pop-up menu.
+        JPopupMenu menu = new JPopupMenu();
+        JMenuItem menuItem1 = new JMenuItem("Copy");
+        menuItem1.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                // Get the clipboard
+                Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+                // Set the sent text as the new content of the clipboard
+                clipboard.setContents(new StringSelection(messageTextArea.getText()), null);
+            }
+        });
+        menu.add(menuItem1);
+        // Add listener to the text area so the popup menu can come up.
+        messageTextArea.addMouseListener(new PopupListener(menu));
+        allPane.add(new JScrollPane(messageTextArea));
+
+        // Create UI elements for client generated XML traffic.
+        final JTextArea sentText = new JTextArea();
+        sentText.setEditable(false);
+        sentText.setForeground(new Color(112, 3, 3));
+        tabbedPane.add("Raw Sent Packets", new JScrollPane(sentText));
+        tabbedPane.setToolTipTextAt(1, "Raw text of the sent packets");
+
+        // Add pop-up menu.
+        menu = new JPopupMenu();
+        menuItem1 = new JMenuItem("Copy");
+        menuItem1.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                // Get the clipboard
+                Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+                // Set the sent text as the new content of the clipboard
+                clipboard.setContents(new StringSelection(sentText.getText()), null);
+            }
+        });
+
+        JMenuItem menuItem2 = new JMenuItem("Clear");
+        menuItem2.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                sentText.setText("");
+            }
+        });
+
+        // Add listener to the text area so the popup menu can come up.
+        sentText.addMouseListener(new PopupListener(menu));
+        menu.add(menuItem1);
+        menu.add(menuItem2);
+
+        // Create UI elements for server generated XML traffic.
+        final JTextArea receivedText = new JTextArea();
+        receivedText.setEditable(false);
+        receivedText.setForeground(new Color(6, 76, 133));
+        tabbedPane.add("Raw Received Packets", new JScrollPane(receivedText));
+        tabbedPane.setToolTipTextAt(
+            2,
+            "Raw text of the received packets before Smack process them");
+
+        // Add pop-up menu.
+        menu = new JPopupMenu();
+        menuItem1 = new JMenuItem("Copy");
+        menuItem1.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                // Get the clipboard
+                Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+                // Set the sent text as the new content of the clipboard
+                clipboard.setContents(new StringSelection(receivedText.getText()), null);
+            }
+        });
+
+        menuItem2 = new JMenuItem("Clear");
+        menuItem2.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                receivedText.setText("");
+            }
+        });
+
+        // Add listener to the text area so the popup menu can come up.
+        receivedText.addMouseListener(new PopupListener(menu));
+        menu.add(menuItem1);
+        menu.add(menuItem2);
+
+        // Create a special Reader that wraps the main Reader and logs data to the GUI.
+        ObservableReader debugReader = new ObservableReader(reader);
+        readerListener = new ReaderListener() {
+                    public void read(String str) {
+                        int index = str.lastIndexOf(">");
+                        if (index != -1) {
+                            receivedText.append(str.substring(0, index + 1));
+                            receivedText.append(NEWLINE);
+                            if (str.length() > index) {
+                                receivedText.append(str.substring(index + 1));
+                            }
+                        }
+                        else {
+                            receivedText.append(str);
+                        }
+                    }
+                };
+        debugReader.addReaderListener(readerListener);
+
+        // Create a special Writer that wraps the main Writer and logs data to the GUI.
+        ObservableWriter debugWriter = new ObservableWriter(writer);
+        writerListener = new WriterListener() {
+                    public void write(String str) {
+                        sentText.append(str);
+                        if (str.endsWith(">")) {
+                            sentText.append(NEWLINE);
+                        }
+                    }
+                };
+        debugWriter.addWriterListener(writerListener);
+
+        // Assign the reader/writer objects to use the debug versions. The packet reader
+        // and writer will use the debug versions when they are created.
+        reader = debugReader;
+        writer = debugWriter;
+
+    }
+
+    private void addAdhocPacketPanel() {
+        // Create UI elements for sending ad-hoc messages.
+        final JTextArea adhocMessages = new JTextArea();
+        adhocMessages.setEditable(true);
+        adhocMessages.setForeground(new Color(1, 94, 35));
+        tabbedPane.add("Ad-hoc message", new JScrollPane(adhocMessages));
+        tabbedPane.setToolTipTextAt(3, "Panel that allows you to send adhoc packets");
+
+        // Add pop-up menu.
+        JPopupMenu menu = new JPopupMenu();
+        JMenuItem menuItem = new JMenuItem("Message");
+        menuItem.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                adhocMessages.setText(
+                    "<message to=\"\" id=\""
+                        + StringUtils.randomString(5)
+                        + "-X\"><body></body></message>");
+            }
+        });
+        menu.add(menuItem);
+
+        menuItem = new JMenuItem("IQ Get");
+        menuItem.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                adhocMessages.setText(
+                    "<iq type=\"get\" to=\"\" id=\""
+                        + StringUtils.randomString(5)
+                        + "-X\"><query xmlns=\"\"></query></iq>");
+            }
+        });
+        menu.add(menuItem);
+
+        menuItem = new JMenuItem("IQ Set");
+        menuItem.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                adhocMessages.setText(
+                    "<iq type=\"set\" to=\"\" id=\""
+                        + StringUtils.randomString(5)
+                        + "-X\"><query xmlns=\"\"></query></iq>");
+            }
+        });
+        menu.add(menuItem);
+
+        menuItem = new JMenuItem("Presence");
+        menuItem.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                adhocMessages.setText(
+                    "<presence to=\"\" id=\"" + StringUtils.randomString(5) + "-X\"/>");
+            }
+        });
+        menu.add(menuItem);
+        menu.addSeparator();
+
+        menuItem = new JMenuItem("Send");
+        menuItem.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                if (!"".equals(adhocMessages.getText())) {
+                    AdHocPacket packetToSend = new AdHocPacket(adhocMessages.getText());
+                    connection.sendPacket(packetToSend);
+                }
+            }
+        });
+        menu.add(menuItem);
+
+        menuItem = new JMenuItem("Clear");
+        menuItem.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                adhocMessages.setText(null);
+            }
+        });
+        menu.add(menuItem);
+
+        // Add listener to the text area so the popup menu can come up.
+        adhocMessages.addMouseListener(new PopupListener(menu));
+    }
+
+    private void addInformationPanel() {
+        // Create UI elements for connection information.
+        JPanel informationPanel = new JPanel();
+        informationPanel.setLayout(new BorderLayout());
+
+        // Add the Host information
+        JPanel connPanel = new JPanel();
+        connPanel.setLayout(new GridBagLayout());
+        connPanel.setBorder(BorderFactory.createTitledBorder("Connection information"));
+
+        JLabel label = new JLabel("Host: ");
+        label.setMinimumSize(new java.awt.Dimension(150, 14));
+        label.setMaximumSize(new java.awt.Dimension(150, 14));
+        connPanel.add(
+            label,
+            new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0, 21, 0, new Insets(0, 0, 0, 0), 0, 0));
+        JFormattedTextField field = new JFormattedTextField(connection.getHost());
+        field.setMinimumSize(new java.awt.Dimension(150, 20));
+        field.setMaximumSize(new java.awt.Dimension(150, 20));
+        field.setEditable(false);
+        field.setBorder(null);
+        connPanel.add(
+            field,
+            new GridBagConstraints(1, 0, 1, 1, 1.0, 0.0, 10, 2, new Insets(0, 0, 0, 0), 0, 0));
+
+        // Add the Port information
+        label = new JLabel("Port: ");
+        label.setMinimumSize(new java.awt.Dimension(150, 14));
+        label.setMaximumSize(new java.awt.Dimension(150, 14));
+        connPanel.add(
+            label,
+            new GridBagConstraints(0, 1, 1, 1, 0.0, 0.0, 21, 0, new Insets(0, 0, 0, 0), 0, 0));
+        field = new JFormattedTextField(new Integer(connection.getPort()));
+        field.setMinimumSize(new java.awt.Dimension(150, 20));
+        field.setMaximumSize(new java.awt.Dimension(150, 20));
+        field.setEditable(false);
+        field.setBorder(null);
+        connPanel.add(
+            field,
+            new GridBagConstraints(1, 1, 1, 1, 0.0, 0.0, 10, 2, new Insets(0, 0, 0, 0), 0, 0));
+
+        // Add the connection's User information
+        label = new JLabel("User: ");
+        label.setMinimumSize(new java.awt.Dimension(150, 14));
+        label.setMaximumSize(new java.awt.Dimension(150, 14));
+        connPanel.add(
+            label,
+            new GridBagConstraints(0, 2, 1, 1, 0.0, 0.0, 21, 0, new Insets(0, 0, 0, 0), 0, 0));
+        userField = new JFormattedTextField();
+        userField.setMinimumSize(new java.awt.Dimension(150, 20));
+        userField.setMaximumSize(new java.awt.Dimension(150, 20));
+        userField.setEditable(false);
+        userField.setBorder(null);
+        connPanel.add(
+            userField,
+            new GridBagConstraints(1, 2, 1, 1, 0.0, 0.0, 10, 2, new Insets(0, 0, 0, 0), 0, 0));
+
+        // Add the connection's creationTime information
+        label = new JLabel("Creation time: ");
+        label.setMinimumSize(new java.awt.Dimension(150, 14));
+        label.setMaximumSize(new java.awt.Dimension(150, 14));
+        connPanel.add(
+            label,
+            new GridBagConstraints(0, 3, 1, 1, 0.0, 0.0, 21, 0, new Insets(0, 0, 0, 0), 0, 0));
+        field = new JFormattedTextField(new SimpleDateFormat("yyyy.MM.dd hh:mm:ss aaa"));
+        field.setMinimumSize(new java.awt.Dimension(150, 20));
+        field.setMaximumSize(new java.awt.Dimension(150, 20));
+        field.setValue(creationTime);
+        field.setEditable(false);
+        field.setBorder(null);
+        connPanel.add(
+            field,
+            new GridBagConstraints(1, 3, 1, 1, 0.0, 0.0, 10, 2, new Insets(0, 0, 0, 0), 0, 0));
+
+        // Add the connection's creationTime information
+        label = new JLabel("Status: ");
+        label.setMinimumSize(new java.awt.Dimension(150, 14));
+        label.setMaximumSize(new java.awt.Dimension(150, 14));
+        connPanel.add(
+            label,
+            new GridBagConstraints(0, 4, 1, 1, 0.0, 0.0, 21, 0, new Insets(0, 0, 0, 0), 0, 0));
+        statusField = new JFormattedTextField();
+        statusField.setMinimumSize(new java.awt.Dimension(150, 20));
+        statusField.setMaximumSize(new java.awt.Dimension(150, 20));
+        statusField.setValue("Active");
+        statusField.setEditable(false);
+        statusField.setBorder(null);
+        connPanel.add(
+            statusField,
+            new GridBagConstraints(1, 4, 1, 1, 0.0, 0.0, 10, 2, new Insets(0, 0, 0, 0), 0, 0));
+        // Add the connection panel to the information panel
+        informationPanel.add(connPanel, BorderLayout.NORTH);
+
+        // Add the Number of sent packets information
+        JPanel packetsPanel = new JPanel();
+        packetsPanel.setLayout(new GridLayout(1, 1));
+        packetsPanel.setBorder(BorderFactory.createTitledBorder("Transmitted Packets"));
+
+        statisticsTable =
+            new DefaultTableModel(new Object[][] { { "IQ", new Integer(0), new Integer(0)}, {
+                "Message", new Integer(0), new Integer(0)
+                }, {
+                "Presence", new Integer(0), new Integer(0)
+                }, {
+                "Other", new Integer(0), new Integer(0)
+                }, {
+                "Total", new Integer(0), new Integer(0)
+                }
+        }, new Object[] { "Type", "Received", "Sent" }) {
+            public boolean isCellEditable(int rowIndex, int mColIndex) {
+                return false;
+            }
+        };
+        JTable table = new JTable(statisticsTable);
+        // Allow only single a selection
+        table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+        packetsPanel.add(new JScrollPane(table));
+
+        // Add the packets panel to the information panel
+        informationPanel.add(packetsPanel, BorderLayout.CENTER);
+
+        tabbedPane.add("Information", new JScrollPane(informationPanel));
+        tabbedPane.setToolTipTextAt(4, "Information and statistics about the debugged connection");
+    }
+
+    public void userHasLogged(String user) {
+        userField.setText(user);
+        EnhancedDebuggerWindow.userHasLogged(this, user);
+        // Add the connection listener to the connection so that the debugger can be notified
+        // whenever the connection is closed.
+        connection.addConnectionListener(connListener);
+    }
+
+    public Reader getReader() {
+        return reader;
+    }
+
+    public Writer getWriter() {
+        return writer;
+    }
+
+    public PacketListener getReaderListener() {
+        return packetReaderListener;
+    }
+
+    public PacketListener getWriterListener() {
+        return packetWriterListener;
+    }
+
+    /**
+     * Updates the statistics table
+     */
+    private void updateStatistics() {
+        statisticsTable.setValueAt(new Integer(receivedIQPackets), 0, 1);
+        statisticsTable.setValueAt(new Integer(sentIQPackets), 0, 2);
+
+        statisticsTable.setValueAt(new Integer(receivedMessagePackets), 1, 1);
+        statisticsTable.setValueAt(new Integer(sentMessagePackets), 1, 2);
+
+        statisticsTable.setValueAt(new Integer(receivedPresencePackets), 2, 1);
+        statisticsTable.setValueAt(new Integer(sentPresencePackets), 2, 2);
+
+        statisticsTable.setValueAt(new Integer(receivedOtherPackets), 3, 1);
+        statisticsTable.setValueAt(new Integer(sentOtherPackets), 3, 2);
+
+        statisticsTable.setValueAt(new Integer(receivedPackets), 4, 1);
+        statisticsTable.setValueAt(new Integer(sentPackets), 4, 2);
+    }
+
+    /**
+     * Adds the received packet detail to the messages table.
+     * 
+     * @param dateFormatter the SimpleDateFormat to use to format Dates
+     * @param packet the read packet to add to the table
+     */
+    private void addReadPacketToTable(SimpleDateFormat dateFormatter, Packet packet) {
+        String messageType = null;
+        String from = packet.getFrom();
+        String type = "";
+        Icon packetTypeIcon;
+        receivedPackets++;
+        if (packet instanceof IQ) {
+            packetTypeIcon = iqPacketIcon;
+            messageType = "IQ Received (class=" + packet.getClass().getName() + ")";
+            type = ((IQ) packet).getType().toString();
+            receivedIQPackets++;
+        }
+        else if (packet instanceof Message) {
+            packetTypeIcon = messagePacketIcon;
+            messageType = "Message Received";
+            type = ((Message) packet).getType().toString();
+            receivedMessagePackets++;
+        }
+        else if (packet instanceof Presence) {
+            packetTypeIcon = presencePacketIcon;
+            messageType = "Presence Received";
+            type = ((Presence) packet).getType().toString();
+            receivedPresencePackets++;
+        }
+        else {
+            packetTypeIcon = unknownPacketTypeIcon;
+            messageType = packet.getClass().getName() + " Received";
+            receivedOtherPackets++;
+        }
+
+        messagesTable.addRow(
+            new Object[] {
+                formatXML(packet.toXML()),
+                dateFormatter.format(new Date()),
+                packetReceivedIcon,
+                packetTypeIcon,
+                messageType,
+                packet.getPacketID(),
+                type,
+                "",
+                from });
+        // Update the statistics table
+        updateStatistics();
+    }
+
+    /**
+     * Adds the sent packet detail to the messages table.
+     * 
+     * @param dateFormatter the SimpleDateFormat to use to format Dates
+     * @param packet the sent packet to add to the table
+     */
+    private void addSentPacketToTable(SimpleDateFormat dateFormatter, Packet packet) {
+        String messageType = null;
+        String to = packet.getTo();
+        String type = "";
+        Icon packetTypeIcon;
+        sentPackets++;
+        if (packet instanceof IQ) {
+            packetTypeIcon = iqPacketIcon;
+            messageType = "IQ Sent (class=" + packet.getClass().getName() + ")";
+            type = ((IQ) packet).getType().toString();
+            sentIQPackets++;
+        }
+        else if (packet instanceof Message) {
+            packetTypeIcon = messagePacketIcon;
+            messageType = "Message Sent";
+            type = ((Message) packet).getType().toString();
+            sentMessagePackets++;
+        }
+        else if (packet instanceof Presence) {
+            packetTypeIcon = presencePacketIcon;
+            messageType = "Presence Sent";
+            type = ((Presence) packet).getType().toString();
+            sentPresencePackets++;
+        }
+        else {
+            packetTypeIcon = unknownPacketTypeIcon;
+            messageType = packet.getClass().getName() + " Sent";
+            sentOtherPackets++;
+        }
+
+        messagesTable.addRow(
+            new Object[] {
+                formatXML(packet.toXML()),
+                dateFormatter.format(new Date()),
+                packetSentIcon,
+                packetTypeIcon,
+                messageType,
+                packet.getPacketID(),
+                type,
+                to,
+                "" });
+
+        // Update the statistics table
+        updateStatistics();
+    }
+
+    private String formatXML(String str) {
+        try {
+            // Use a Transformer for output
+            TransformerFactory tFactory = TransformerFactory.newInstance();
+            // Surround this setting in a try/catch for compatibility with Java 1.4. This setting is required
+            // for Java 1.5
+            try {
+                tFactory.setAttribute("indent-number", new Integer(2));
+            }
+            catch (IllegalArgumentException e) {}
+            Transformer transformer = tFactory.newTransformer();
+            transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
+            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
+
+            // Transform the requested string into a nice formatted XML string
+            StreamSource source = new StreamSource(new StringReader(str));
+            StringWriter sw = new StringWriter();
+            StreamResult result = new StreamResult(sw);
+            transformer.transform(source, result);
+            return sw.toString();
+
+        }
+        catch (TransformerConfigurationException tce) {
+            // Error generated by the parser
+            System.out.println("\n** Transformer Factory error");
+            System.out.println("   " + tce.getMessage());
+
+            // Use the contained exception, if any
+            Throwable x = tce;
+            if (tce.getException() != null)
+                x = tce.getException();
+            x.printStackTrace();
+
+        }
+        catch (TransformerException te) {
+            // Error generated by the parser
+            System.out.println("\n** Transformation error");
+            System.out.println("   " + te.getMessage());
+
+            // Use the contained exception, if any
+            Throwable x = te;
+            if (te.getException() != null)
+                x = te.getException();
+            x.printStackTrace();
+
+        }
+        return str;
+    }
+    
+    /**
+     * Returns true if the debugger's connection with the server is up and running.
+     *
+     * @return true if the connection with the server is active.
+     */
+    boolean isConnectionActive() {
+        return connection.isConnected();
+    }
+
+    /**
+     * Stops debugging the connection. Removes any listener on the connection.
+     *
+     */
+    void cancel() {
+        connection.removeConnectionListener(connListener);
+        connection.removePacketListener(packetReaderListener);
+        connection.removePacketWriterListener(packetWriterListener);
+        ((ObservableReader)reader).removeReaderListener(readerListener);
+        ((ObservableWriter)writer).removeWriterListener(writerListener);
+        messagesTable = null;
+    }
+
+    /**
+     * An ad-hoc packet is like any regular packet but with the exception that it's intention is 
+     * to be used only <b>to send packets</b>.<p>
+     * 
+     * The whole text to send must be passed to the constructor. This implies that the client of 
+     * this class is responsible for sending a valid text to the constructor. 
+     * 
+     */
+    private class AdHocPacket extends Packet {
+
+        private String text;
+
+        /**
+         * Create a new AdHocPacket with the text to send. The passed text must be a valid text to 
+         * send to the server, no validation will be done on the passed text.
+         * 
+         * @param text the whole text of the packet to send 
+         */
+        public AdHocPacket(String text) {
+            this.text = text;
+        }
+
+        public String toXML() {
+            return text;
+        }
+
+    }
+
+    /**
+     * Listens for debug window popup dialog events.
+     */
+    private class PopupListener extends MouseAdapter {
+        JPopupMenu popup;
+
+        PopupListener(JPopupMenu popupMenu) {
+            popup = popupMenu;
+        }
+
+        public void mousePressed(MouseEvent e) {
+            maybeShowPopup(e);
+        }
+
+        public void mouseReleased(MouseEvent e) {
+            maybeShowPopup(e);
+        }
+
+        private void maybeShowPopup(MouseEvent e) {
+            if (e.isPopupTrigger()) {
+                popup.show(e.getComponent(), e.getX(), e.getY());
+            }
+        }
+    }
+
+    private class SelectionListener implements ListSelectionListener {
+        JTable table;
+
+        // It is necessary to keep the table since it is not possible
+        // to determine the table from the event's source
+        SelectionListener(JTable table) {
+            this.table = table;
+        }
+        public void valueChanged(ListSelectionEvent e) {
+            if (table.getSelectedRow() == -1) {
+                // Clear the messageTextArea since there is none packet selected 
+                messageTextArea.setText(null);
+            }
+            else {
+                // Set the detail of the packet in the messageTextArea 
+                messageTextArea.setText(
+                    (String) table.getModel().getValueAt(table.getSelectedRow(), 0));
+                // Scroll up to the top
+                messageTextArea.setCaretPosition(0);
+            }
+        }
+    }
+}

CopyOftrunk/source/org/jivesoftware/smackx/debugger/EnhancedDebuggerWindow.java

@@ -0,0 +1,348 @@
+/**
+ * $RCSfile$
+ * $Revision$
+ * $Date$
+ *
+ * Copyright 2003-2004 Jive Software.
+ *
+ * All rights reserved. Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jivesoftware.smackx.debugger;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.net.*;
+import java.util.*;
+
+import javax.swing.*;
+
+import org.jivesoftware.smack.SmackConfiguration;
+import org.jivesoftware.smack.provider.ProviderManager;
+
+/**
+ * The EnhancedDebuggerWindow is the main debug window that will show all the EnhancedDebuggers. 
+ * For each connection to debug there will be an EnhancedDebugger that will be shown in the 
+ * EnhancedDebuggerWindow.<p>
+ * 
+ * This class also provides information about Smack like for example the Smack version and the
+ * installed providers. 
+ * 
+ * @author Gaston Dombiak
+ */
+class EnhancedDebuggerWindow {
+
+    private static EnhancedDebuggerWindow instance;
+
+    private static ImageIcon connectionCreatedIcon;
+    private static ImageIcon connectionActiveIcon;
+    private static ImageIcon connectionClosedIcon;
+    private static ImageIcon connectionClosedOnErrorIcon;
+    
+    {
+        URL url;
+        
+        url =
+            Thread.currentThread().getContextClassLoader().getResource(
+                "images/trafficlight_off.png");
+        if (url != null) {
+            connectionCreatedIcon = new ImageIcon(url);
+        }
+        url =
+            Thread.currentThread().getContextClassLoader().getResource(
+                "images/trafficlight_green.png");
+        if (url != null) {
+            connectionActiveIcon = new ImageIcon(url);
+        }
+        url =
+            Thread.currentThread().getContextClassLoader().getResource(
+                "images/trafficlight_red.png");
+        if (url != null) {
+            connectionClosedIcon = new ImageIcon(url);
+        }
+        url = Thread.currentThread().getContextClassLoader().getResource("images/warning.png");
+        if (url != null) {
+            connectionClosedOnErrorIcon = new ImageIcon(url);
+        }
+
+    }
+
+    private JFrame frame = null;
+    private JTabbedPane tabbedPane = null;
+    private java.util.List debuggers = new ArrayList();
+
+    private EnhancedDebuggerWindow() {
+    }
+
+    /**
+     * Returns the unique EnhancedDebuggerWindow instance available in the system. 
+     * 
+     * @return the unique EnhancedDebuggerWindow instance 
+     */
+    private static EnhancedDebuggerWindow getInstance() {
+        if (instance == null) {
+            instance = new EnhancedDebuggerWindow();
+        }
+        return instance;
+    }
+
+    /**
+     * Adds the new specified debugger to the list of debuggers to show in the main window.
+     * 
+     * @param debugger the new debugger to show in the debug window
+     */
+    synchronized static void addDebugger(EnhancedDebugger debugger) {
+        getInstance().showNewDebugger(debugger);
+    }
+
+    /**
+     * Shows the new debugger in the debug window. 
+     * 
+     * @param debugger the new debugger to show
+     */
+    private void showNewDebugger(EnhancedDebugger debugger) {
+        if (frame == null) {
+            createDebug();
+        }
+        debugger.tabbedPane.setName("Connection_" + tabbedPane.getComponentCount());
+        tabbedPane.add(debugger.tabbedPane, tabbedPane.getComponentCount() - 1);
+        tabbedPane.setIconAt(tabbedPane.indexOfComponent(debugger.tabbedPane), connectionCreatedIcon);
+        frame.setTitle(
+            "Smack Debug Window -- Total connections: " + (tabbedPane.getComponentCount() - 1));
+        // Keep the added debugger for later access
+        debuggers.add(debugger);
+    }
+
+    /**
+     * Notification that a user has logged in to the server. A new title will be set 
+     * to the tab of the given debugger. 
+     * 
+     * @param debugger the debugger whose connection logged in to the server
+     * @param user the user@host/resource that has just logged in
+     */
+    synchronized static void userHasLogged(EnhancedDebugger debugger, String user) {
+        int index = getInstance().tabbedPane.indexOfComponent(debugger.tabbedPane);
+        getInstance().tabbedPane.setTitleAt(
+            index,
+            user);
+        getInstance().tabbedPane.setIconAt(
+            index,
+            connectionActiveIcon);
+    }
+
+    /**
+     * Notification that the connection was properly closed.
+     *
+     * @param debugger the debugger whose connection was properly closed.
+     */
+    synchronized static void connectionClosed(EnhancedDebugger debugger) {
+        getInstance().tabbedPane.setIconAt(
+            getInstance().tabbedPane.indexOfComponent(debugger.tabbedPane),
+            connectionClosedIcon);
+    }
+
+    /**
+     * Notification that the connection was closed due to an exception.
+     *
+     * @param debugger the debugger whose connection was closed due to an exception.
+     * @param e the exception.
+     */
+    synchronized static void connectionClosedOnError(EnhancedDebugger debugger, Exception e) {
+        int index = getInstance().tabbedPane.indexOfComponent(debugger.tabbedPane);
+        getInstance().tabbedPane.setToolTipTextAt(
+            index,
+            "Connection closed due to the exception: " + e.getMessage());
+        getInstance().tabbedPane.setIconAt(
+            index,
+            connectionClosedOnErrorIcon);
+    }
+
+    /**
+     * Creates the main debug window that provides information about Smack and also shows
+     * a tab panel for each connection that is being debugged. 
+     */
+    private void createDebug() {
+
+        frame = new JFrame("Smack Debug Window");
+
+        // Add listener for window closing event 
+        frame.addWindowListener(new WindowAdapter() {
+            public void windowClosing(WindowEvent evt) {
+                rootWindowClosing(evt);
+            }
+        });
+
+        // We'll arrange the UI into tabs. The last tab contains Smack's information.
+        // All the connection debugger tabs will be shown before the Smack info tab. 
+        tabbedPane = new JTabbedPane();
+
+        // Create the Smack info panel 
+        JPanel informationPanel = new JPanel();
+        informationPanel.setLayout(new BoxLayout(informationPanel, BoxLayout.Y_AXIS));
+
+        // Add the Smack version label
+        JPanel versionPanel = new JPanel();
+        versionPanel.setLayout(new BoxLayout(versionPanel, BoxLayout.X_AXIS));
+        versionPanel.setMaximumSize(new Dimension(2000, 31));
+        versionPanel.add(new JLabel(" Smack version: "));
+        JFormattedTextField field = new JFormattedTextField(SmackConfiguration.getVersion());
+        field.setEditable(false);
+        field.setBorder(null);
+        versionPanel.add(field);
+        informationPanel.add(versionPanel);
+
+        // Add the list of installed IQ Providers
+        JPanel iqProvidersPanel = new JPanel();
+        iqProvidersPanel.setLayout(new GridLayout(1, 1));
+        iqProvidersPanel.setBorder(BorderFactory.createTitledBorder("Installed IQ Providers"));
+        Vector providers = new Vector();
+        for (Iterator it = ProviderManager.getIQProviders(); it.hasNext();) {
+            Object provider = it.next();
+            if (provider.getClass() == Class.class) {
+                providers.add(((Class) provider).getName());
+            }
+            else {
+                providers.add(provider.getClass().getName());
+            }
+        }
+        // Sort the collection of providers
+        Collections.sort(providers);
+        JList list = new JList(providers);
+        iqProvidersPanel.add(new JScrollPane(list));
+        informationPanel.add(iqProvidersPanel);
+
+        // Add the list of installed Extension Providers
+        JPanel extensionProvidersPanel = new JPanel();
+        extensionProvidersPanel.setLayout(new GridLayout(1, 1));
+        extensionProvidersPanel.setBorder(BorderFactory.createTitledBorder("Installed Extension Providers"));
+        providers = new Vector();
+        for (Iterator it = ProviderManager.getExtensionProviders(); it.hasNext();) {
+            Object provider = it.next();
+            if (provider.getClass() == Class.class) {
+                providers.add(((Class) provider).getName());
+            }
+            else {
+                providers.add(provider.getClass().getName());
+            }
+        }
+        // Sort the collection of providers
+        Collections.sort(providers);
+        list = new JList(providers);
+        extensionProvidersPanel.add(new JScrollPane(list));
+        informationPanel.add(extensionProvidersPanel);
+
+        tabbedPane.add("Smack Info", informationPanel);
+
+        // Add pop-up menu.
+        JPopupMenu menu = new JPopupMenu();
+        // Add a menu item that allows to close the current selected tab
+        JMenuItem menuItem = new JMenuItem("Close");
+        menuItem.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                // Remove the selected tab pane if it's not the Smack info pane
+                if (tabbedPane.getSelectedIndex() < tabbedPane.getComponentCount() - 1) {
+                    int index = tabbedPane.getSelectedIndex();
+                    // Notify to the debugger to stop debugging
+                    EnhancedDebugger debugger = (EnhancedDebugger)debuggers.get(index);
+                    debugger.cancel();
+                    // Remove the debugger from the root window
+                    tabbedPane.remove(debugger.tabbedPane);
+                    debuggers.remove(debugger);
+                    // Update the root window title
+                    frame.setTitle(
+                        "Smack Debug Window -- Total connections: "
+                            + (tabbedPane.getComponentCount() - 1));
+                }
+            }
+        });
+        menu.add(menuItem);
+        // Add a menu item that allows to close all the tabs that have their connections closed
+        menuItem = new JMenuItem("Close All Not Active");
+        menuItem.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                ArrayList debuggersToRemove = new ArrayList();
+                // Remove all the debuggers of which their connections are no longer valid
+                for (int index=0; index < tabbedPane.getComponentCount()-1; index++) {
+                    EnhancedDebugger debugger = (EnhancedDebugger)debuggers.get(index);
+                    if (!debugger.isConnectionActive()) {
+                        // Notify to the debugger to stop debugging
+                        debugger.cancel();
+                        debuggersToRemove.add(debugger);
+                    }
+                }
+                for (Iterator it=debuggersToRemove.iterator(); it.hasNext();) {
+                    EnhancedDebugger debugger = (EnhancedDebugger)it.next();
+                    // Remove the debugger from the root window
+                    tabbedPane.remove(debugger.tabbedPane);
+                    debuggers.remove(debugger);
+                }
+                // Update the root window title
+                frame.setTitle(
+                    "Smack Debug Window -- Total connections: "
+                        + (tabbedPane.getComponentCount() - 1));
+            }
+        });
+        menu.add(menuItem);
+        // Add listener to the text area so the popup menu can come up.
+        tabbedPane.addMouseListener(new PopupListener(menu));
+
+        frame.getContentPane().add(tabbedPane);
+
+        frame.setSize(650, 400);
+        frame.setVisible(true);
+
+    }
+
+    /**
+     * Notification that the root window is closing. Stop listening for received and 
+     * transmitted packets in all the debugged connections.
+     * 
+     * @param evt the event that indicates that the root window is closing 
+     */
+    public void rootWindowClosing(WindowEvent evt) {
+        // Notify to all the debuggers to stop debugging
+        for (Iterator it = debuggers.iterator(); it.hasNext();) {
+            EnhancedDebugger debugger = (EnhancedDebugger)it.next();
+            debugger.cancel();
+        }
+        // Release any reference to the debuggers
+        debuggers.removeAll(debuggers);
+        // Release the default instance
+        instance = null;
+    }
+
+    /**
+     * Listens for debug window popup dialog events.
+     */
+    private class PopupListener extends MouseAdapter {
+        JPopupMenu popup;
+
+        PopupListener(JPopupMenu popupMenu) {
+            popup = popupMenu;
+        }
+
+        public void mousePressed(MouseEvent e) {
+            maybeShowPopup(e);
+        }
+
+        public void mouseReleased(MouseEvent e) {
+            maybeShowPopup(e);
+        }
+
+        private void maybeShowPopup(MouseEvent e) {
+            if (e.isPopupTrigger()) {
+                popup.show(e.getComponent(), e.getX(), e.getY());
+            }
+        }
+    }
+}

CopyOftrunk/source/org/jivesoftware/smackx/debugger/package.html

@@ -0,0 +1 @@
+<body>Smack optional Debuggers.</body>