/*
   Wotonomy: OpenStep design patterns for pure Java applications.
   Copyright (C) 2000 Michael Powers
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, see http://www.gnu.org
  */
  
  package net.wotonomy.ui.swing.util;
  
  import java.awt.BorderLayout;
  import java.awt.Dimension;
  import java.awt.Insets;
  import java.awt.Toolkit;
  import java.awt.datatransfer.Clipboard;
  import java.awt.datatransfer.StringSelection;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.KeyEvent;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.PrintStream;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.StringTokenizer;
  
  import javax.swing.JComponent;
  import javax.swing.JFrame;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.JTable;
  import javax.swing.KeyStroke;
  import javax.swing.border.EmptyBorder;
  import javax.swing.event.TableModelListener;
  import javax.swing.table.TableModel;
  
  import net.wotonomy.ui.swing.components.MultiLineLabel;
  
  /***
  * The StackTraceInspector displays a JFrame containing
  * stack trace information for a Throwable.  <br><br>
  *
  * There are also a few static methods for obtaining
  * information about the current stack, which is useful
  * for determining who's calling you at runtime.
  *
  * @author michael@mpowers.net
  * @version $Revision: 904 $
  */
  
  public class StackTraceInspector
      implements TableModel, MouseListener, ActionListener
  {
      protected JTable table = null;
      protected List tableModelListeners = null;
      protected List methodNames = new ArrayList();
  
      // key command to copy contents to clipboard
      static public final String COPY = "COPY";
  
  /***
  * Displays the current stack trace at the time
  * of instantiation in a table on a frame.
  */
      public StackTraceInspector()
      {
          initLayout( parseStackTrace( new RuntimeException() ), null );
      }
  
  /***
  * Displays the current stack trace at the time
  * of instantiation in a table on a frame
  * annotated with the specified message.
  */
      public StackTraceInspector( String aMessage )
      {
          initLayout( parseStackTrace( new RuntimeException() ), aMessage );
      }
  
  /***
  * Displays the stack trace for the given throwable
  * in a table on a frame.
  * @param aThrowable A Throwable whose stack will be examined.
  */
      public StackTraceInspector( Throwable aThrowable )
      {
         initLayout( parseStackTrace( aThrowable ),
 			aThrowable.getClass() + ": " + aThrowable.getMessage() );
     }
 
 /***
 * Simply displays the list items in a dialog.
 * Presumably (but not necessarily) called from
 * the other constructors.  (I guess if you just
 * want a frame with strings in table, you can
 * call this.)
 * @param aStringList A List containing Strings.
 */
     public StackTraceInspector( List aStringList )
     {
         initLayout( aStringList, null );
     }
 
     protected void initLayout( List items, String message )
     {
         methodNames = new ArrayList( items );
         table = new JTable( this ); // this class is the table model
         table.addMouseListener( this ); // listen for double-clicks
 
         // set up keyboard events for cut-copy: Ctrl-C, Ctrl-X
         table.registerKeyboardAction( this, COPY,
             KeyStroke.getKeyStroke( KeyEvent.VK_C, 
             Toolkit.getDefaultToolkit().getMenuShortcutKeyMask() ),
             JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT );
         table.registerKeyboardAction( this, COPY,
             KeyStroke.getKeyStroke( KeyEvent.VK_X, 
             Toolkit.getDefaultToolkit().getMenuShortcutKeyMask() ),
             JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT );
 
         JPanel panel = new JPanel();
         panel.setBorder( new EmptyBorder( new Insets( 10, 10, 10, 10 ) ) );
         panel.setLayout( new BorderLayout( 10, 10 ) );
 		
 		if ( message != null )
 		{
 			panel.add( new MultiLineLabel( message ), BorderLayout.NORTH );	
 		}
 
         JScrollPane scrollPane = new JScrollPane( table );
         scrollPane.setPreferredSize( new Dimension( 325, 350 ) );
         panel.add( scrollPane, BorderLayout.CENTER );
 
         JFrame window = new JFrame();
         window.setTitle( "Stack Trace Inspector" );
         window.getContentPane().add( panel );
 
         window.pack();
         WindowUtilities.cascade( window );
         window.show();
     }
 
     // interface TableModel
 
     public int getRowCount()
     {
         return methodNames.size();
     }
 
     public int getColumnCount()
     {
         return 1;
     }
 
     public String getColumnName(int columnIndex)
     {
         switch ( columnIndex )
         {
             case 0:
                 return "Methods";
             case 1:
                 return "Property";
         }
         System.out.println( "StackTraceInspector.getColumnName: unknown column: " + columnIndex );
         return "";
     }
 
     public Class getColumnClass(int columnIndex)
     {
         switch ( columnIndex )
         {
             case 0:
                 return String.class;
             case 1:
                 return String.class;
         }
         System.out.println( "StackTraceInspector.getColumnClass: unknown column: " + columnIndex );
         return Object.class;
     }
 
     public boolean isCellEditable(int rowIndex,
                               int columnIndex)
     {
         return false;
     }
 
     public Object getValueAt(int rowIndex,
                          int columnIndex)
     {
         return methodNames.get( rowIndex );
     }
 
     public void setValueAt(Object aValue,
                        int rowIndex,
                        int columnIndex)
     {
     }
 
     public void addTableModelListener(TableModelListener l)
     {
         if ( tableModelListeners == null )
         {
             tableModelListeners = new ArrayList();
         }
         tableModelListeners.add( l );
     }
 
     public void removeTableModelListener(TableModelListener l)
     {
         if ( tableModelListeners != null )
         {
             tableModelListeners.remove( l );
         }
     }
 
     // interface MouseListener
 
     /***
     * Double click to call invokeFileFromString.
     */
 
     public void mouseClicked(MouseEvent e)
     {
         if ( e.getSource() == table )
         {
             if ( e.getClickCount() > 1 )
             {
                 int row = table.rowAtPoint( e.getPoint() );
                 int col = table.columnAtPoint( e.getPoint() );
 
                 if ( ( row == -1 ) || ( col != 0 ) ) return;
 
                 invokeFileFromString( methodNames.get( row ).toString() );
             }
         }
     }
 
     public void mouseReleased(MouseEvent e) {}
     public void mousePressed(MouseEvent e) {}
     public void mouseEntered(MouseEvent e) {}
     public void mouseExited(MouseEvent e) {}
 
 
     // interface ActionEventListener - for listening to key commands
 
     public void actionPerformed(ActionEvent evt)
     {
         if ( COPY.equals( evt.getActionCommand() ) )
         {
             copyToClipboard();
             return;
         }
     }
 
 /***
 * Copies the contents of the table to the clipboard as a tab-delimited string.
 */
     public void copyToClipboard()
     {
         Toolkit toolkit = Toolkit.getDefaultToolkit();
         Clipboard clipboard = toolkit.getSystemClipboard();
         StringSelection selection =
             new StringSelection( getSelectedStackString() );
         clipboard.setContents( selection, selection );
     }
 
 /***
 * Converts the selected contents of the table to a string.
 * @return A String containing the text contents of the table.
 */
     public String getSelectedStackString()
     {
         StringBuffer result = new StringBuffer(64);
 
         TableModel model = table.getModel();
 
         Object o;
         int[] selectedRows = table.getSelectedRows();
         for ( int i = 0; i < selectedRows.length; i++ )
         {
             o = model.getValueAt( selectedRows[i], 0 );
             if ( o == null ) o = "";
             result.append( o );
             result.append( '\n' );
         }
 
         return result.toString();
     }
 
 
     // static methods
 
 /***
 * Obtains a list of strings representing the stack trace
 * associated with this throwable starting with the most recent call.
 * @param aThrowable A Throwable whose stack trace is parsed.
 * @return a List containing the method names as Strings.
 */
     static public List parseStackTrace( Throwable aThrowable )
     {
         String trace = null;
 
         // create new stream
         ByteArrayOutputStream os = new ByteArrayOutputStream( 256 );
         PrintStream newErr = new PrintStream( os );
         aThrowable.printStackTrace( newErr ); // prints to System.err
 
         // convert to string
         trace = os.toString();
 
         List result = new ArrayList();
 
         // populate list with parsed trace, starting from top
         String token;
         StringTokenizer tokens = new StringTokenizer( trace, "\n" );
         tokens.nextToken(); // strip off description of throwable
         while ( tokens.hasMoreTokens() )
         {
             token = tokens.nextToken();
             if ( token.indexOf( StackTraceInspector.class.getName() ) == -1 )
             { // add only those methods not from this class
 
                 // strip whitespace, "at  " from front, and \r from end
                 token.trim();
                 token = token.substring( 4, token.length() - 1 );
 
                 result.add( token );
             }
         }
 
         return result;
     }
 
 /***
 * Convenience method that obtains a String representing
 * the caller's caller.
 * @return a String representing a method in stack trace format.
 */
     static public String getMyCaller()
     {
         List trace = parseStackTrace( new RuntimeException() );
         if ( trace.size() > 1 )
         {
             return trace.get( 1 ).toString();
         }
 
         return null;
     }
 
 /***
 * Prints a stack trace up to the first method whose fully
 * qualified class name begins with "java" to System.out.
 */
     static public void printShortStackTrace()
     {
         String s;
         Iterator i = parseStackTrace( new RuntimeException() ).iterator();
         while ( i.hasNext() )
         {
             System.out.println( "  " + ( s = i.next().toString() ) );
             if ( s.startsWith( "java" ) ) break;
         }
     }
 
     protected void invokeFileFromString( String aString )
     {
         // strip off parentheses, if any
         int openParam = aString.indexOf( "(" );
         if ( openParam != -1 )
         {
             aString = aString.substring( 0, openParam );
         }
 
         // separate class name from method name
         int lastDot = aString.lastIndexOf( "." );
         if ( lastDot == -1 ) return;
         String className = aString.substring( 0, lastDot );
         String methodName = aString.substring( lastDot + 1 );
 
         // convert "."s to file separator characters
         StringBuffer buf = new StringBuffer();
         StringTokenizer tokens = new StringTokenizer( className, "." );
         while ( true )
         {
             buf.append( tokens.nextToken() );
             if ( ! tokens.hasMoreTokens() ) break;
             buf.append( File.separator );
         }
         String path = buf.toString();
         java.net.URL url = ClassLoader.getSystemResource( path + ".java" );
         if ( url == null ) return; // do nothing
 
         String name = url.getFile();
 
         // try to launch the document
         try
         {
             // NOTE: This is Windows-dependent!
             String args[] = new String[] {
                 "cmd", "/c", "\"start \"\" \"" + name.substring(1) + "\"\"" };
                 // this translates to: cmd /c "start "" "path""
                 // apparently an array is more reliable for calling exec().
                 // all the extra quotes are to handle paths with spaces.
                 // trims off the first "/" before the drive letter.
                 // needed a dummy title for the console or it wouldn't work.
             Runtime.getRuntime().exec( args );
         }
         catch ( Exception exc )
         {
             System.out.println( "DocumentLinkPanel.invokeDocument: " + exc );
         }
         return;
     }
 
 }
 
 /*
  * $Log$
  * Revision 1.2  2006/02/18 23:19:05  cgruber
  * Update imports and maven dependencies.
  *
  * Revision 1.1  2006/02/16 13:22:22  cgruber
  * Check in all sources in eclipse-friendly maven-enabled packages.
  *
  * Revision 1.5  2003/08/06 23:07:53  chochos
  * general code cleanup (mostly, removing unused imports)
  *
  * Revision 1.4  2002/11/16 16:33:31  mpowers
  * Now using platform-specific accelerator key for shortcuts.
  *
  * Revision 1.3  2001/07/18 21:53:33  mpowers
  * Added a string argument for display as a message.
  *
  * Revision 1.2  2001/07/17 14:01:43  mpowers
  * Added short stack trace method.
  *
  * Revision 1.1.1.1  2000/12/21 15:51:34  mpowers
  * Contributing wotonomy.
  *
  * Revision 1.5  2000/12/20 16:25:45  michael
  * Added log to all files.
  *
  *
  */