package org.devaki.nextobjects.ui.editor;
   /*
   
   nextobjects Copyright (C) 2001-2005 Emmanuel Florent
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2 of the License, or (at your
   option) any later version.
  
  This program 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 General Public License for more details.
  
  You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc., 59
  Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  
  */
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileReader;
  import java.io.IOException;
  import java.io.Reader;
  import java.util.Comparator;
  import java.util.HashSet;
  import java.util.Hashtable;
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  import java.util.SortedSet;
  import java.util.TreeSet;
  import java.util.Vector;
  import java.awt.Color;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.event.MouseEvent;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.JTextPane;
  import javax.swing.text.AbstractDocument;
  import javax.swing.text.AttributeSet;
  import javax.swing.text.BadLocationException;
  import javax.swing.text.DefaultStyledDocument;
  import javax.swing.text.SimpleAttributeSet;
  import javax.swing.text.StyleConstants;
  import javax.swing.event.MouseInputAdapter;
  import org.devaki.nextobjects.ui.editor.syntax.Lexer;
  import org.devaki.nextobjects.ui.editor.syntax.SqlLexer;
  import org.devaki.nextobjects.ui.editor.syntax.Token;
  import org.devaki.nextobjects.ui.menus.MenuFactory;
  public class SqlEditor extends JPanel
  {
      /***
       * The place where to draw text
       */
      private static JTextPane jTextPane;
      /***
      * the styled document that is the model for the textPane
      **/
      private static HighLightedDocument document;
      /***
       * A reader wrapped around the document so that the document can be fed into
       */
      private static DocumentReader documentReader;
      /*** 
      *The lexer that tells us what colors different words should be
      */
      private static Lexer syntaxLexer;
      /***
       *  A thread that handles the actual coloring
       */
      private static Colorer colorer;
      /***
       * A lock for modifying the document, or for actions that depend on the
      * document not being modified.
      */
      private Object fDoclock = new Object();
      /***
       * A hashtable containing the text styles.
       */
      private static Hashtable styles = new Hashtable();
      /***
       * This class contain the textpane of the SQL editor
       *
       */
      public SqlEditor()
      {
          //Initialization
          super(true);
          // Components
          // Text Panes
          document = new HighLightedDocument();
          SqlEditor.jTextPane = new JTextPane(document);
          
          jTextPane.addMouseListener(new MouseInputAdapter()
          {
              public void mousePressed(MouseEvent evt)
             {
                 if (evt.isPopupTrigger())
                 {
 					MenuFactory.getEditorPopupMenu().setTextpane(jTextPane);
                     MenuFactory.getEditorPopupMenu().show(evt.getComponent(), evt.getX(), evt.getY());
                 }
             }
         });
         colorer = new Colorer();
         colorer.start();
         this.initStyles();
         documentReader = new DocumentReader(document);
         syntaxLexer = new SqlLexer(documentReader);
         // Panels
         this.setLayout(new GridBagLayout());
         // Assembling components
         // Content panel
         this.add(
             new JScrollPane(jTextPane),
             new GridBagConstraints(
                 0,
                 0,
                 1,
                 1,
                 1.0,
                 1.0,
                 GridBagConstraints.CENTER,
                 GridBagConstraints.BOTH,
                 new Insets(3, 3, 3, 3),
                 0,
                 0));
     }
     /***
      * Edit the file given as paramater
      * @param pFile
      */
     public static void setFile(File pFile)
     {
         try
         {
             document.remove(0, document.getLength());
             BufferedReader reader = new BufferedReader(new FileReader(pFile));
             String tmp;
             while ((tmp = reader.readLine()) != null)
             {
                 document.insertString(document.getLength(), tmp + "\n", null);
             }
             reader.close();
         }
         catch (IOException ex)
         {
         }
         catch (BadLocationException ex)
         {
         }
     }
     /***
      * Description: Run the Syntax Highlighting as a separate thread.
      * Things that need to be colored are messaged to the
      * thread and put in a list.
      */
     private class Colorer extends Thread
     {
         /*** Initial places detected when the lexer has been initialized */
         private TreeSet fIniPositions =
             new TreeSet(new DocPositionComparator());
         /*** New places detected */
         private HashSet newPositions = new HashSet();
         /*** Vector that stores the communication between the two threads */
         private volatile Vector v = new Vector();
         /***  Changes that occured before the currently highlighting place */
         private volatile int change = 0;
         /*** The last position colored */
         private volatile int lastPosition = -1;
         /*** ?? */
         private volatile boolean asleep = false;
         /***  Synchronize 'this' object */
         private Object lock = new Object();
         /***  A simple wrapper representing something that needs to be colored */
         private class RecolorEvent
         {
             /*** position */
             public int position;
             /*** adjustement */
             public int adjustment;
             public RecolorEvent(int pPosition, int pAdjustment)
             {
                 this.position = pPosition;
                 this.adjustment = pAdjustment;
             }
         }
         /***
          * Tell the Syntax Highlighting thread to take another look at this section
          * of the document.  It will process this as a FIFO.
          * This method should be done inside a doclock.
          * @param position position
          * @param adjustment adjustement
          */
         public void color(int position, int adjustment)
         {
             if (position < lastPosition)
             {
                 if (lastPosition < position - adjustment)
                 {
                     change -= lastPosition - position;
                 }
                 else
                 {
                     change += adjustment;
                 }
             }
             synchronized (lock)
             {
                 v.add(new RecolorEvent(position, adjustment));
                 if (asleep)
                 {
                     this.interrupt();
                 }
             }
         }
         /***
          * The colorer runs forever and may sleep for long periods of time.
          * It should be interrupted every time there is something for it to do.
          */
         public void run()
         {
             int position = -1;
             int adjustment = 0;
             // if we just finish, we can't go to sleep until we ensure there is
             // nothing else for us to do.
             boolean tryAgain = false;
             for (;;)
             {
                 synchronized (lock)
                 {
                     if (v.size() > 0)
                     {
                         RecolorEvent re = (RecolorEvent) (v.elementAt(0));
                         v.removeElementAt(0);
                         position = re.position;
                         adjustment = re.adjustment;
                     }
                     else
                     {
                         tryAgain = false;
                         position = -1;
                         adjustment = 0;
                     }
                 }
                 if (position != -1)
                 {
                     SortedSet workingSet;
                     Iterator workingIt;
                     DocPosition startRequest = new DocPosition(position);
                     DocPosition endRequest =
                         new DocPosition(
                             position
                                 + ((adjustment >= 0) ? adjustment : -adjustment));
                     DocPosition dp;
                     DocPosition dpStart = null;
                     DocPosition dpEnd = null;
                     // find the starting position.
                     try
                     {
                         // all the good positions before
                         workingSet = fIniPositions.headSet(startRequest);
                         // the last of the stuff before
                         dpStart = ((DocPosition) workingSet.last());
                     }
                     catch (NoSuchElementException x)
                     {
                         // if there were no good positions before the requested start,
                         // we can always start at the very beginning.
                         dpStart = new DocPosition(0);
                     }
                     // if stuff was removed, take any removed positions off the list.
                     if (adjustment < 0)
                     {
                         workingSet =
                             fIniPositions.subSet(startRequest, endRequest);
                         workingIt = workingSet.iterator();
                         while (workingIt.hasNext())
                         {
                             workingIt.next();
                             workingIt.remove();
                         }
                     }
                     // adjust the positions of everything after the insertion/removal
                     workingSet = fIniPositions.tailSet(startRequest);
                     workingIt = workingSet.iterator();
                     while (workingIt.hasNext())
                     {
                         ((DocPosition) workingIt.next()).adjustPosition(
                             adjustment);
                     }
                     // now go through and highlight as much as needed
                     workingSet = fIniPositions.tailSet(dpStart);
                     workingIt = workingSet.iterator();
                     dp = null;
                     if (workingIt.hasNext())
                     {
                         dp = (DocPosition) workingIt.next();
                     }
                     try
                     {
                         Token t;
                         boolean done = false;
                         dpEnd = dpStart;
                         synchronized (fDoclock)
                         {
                             // we are playing some games with the lexer for efficiency.
                             // we could just create a new lexer each time here, but instead,
                             // we will just reset it so that it thinks it is starting at the
                             // beginning of the document but reporting a funny start position.
                             // Reseting the lexer causes the close() method on the reader
                             // to be called but because the close() method has no effect on the
                             // DocumentReader, we can do this.
                             syntaxLexer.reset(
                                 documentReader,
                                 0,
                                 dpStart.getPosition(),
                                 0);
                             // After the lexer has been set up, scroll the reader so that it
                             // is in the correct spot as well.
                             documentReader.seek(dpStart.getPosition());
                             // we will highlight tokens until we reach a good stopping place.
                             // the first obvious stopping place is the end of the document.
                             // the lexer will return null at the end of the document and wee
                             // need to stop there.
                             t = syntaxLexer.getNextToken();
                         }
                         newPositions.add(dpStart);
                         while (!done && t != null)
                         {
                             // this is the actual command that colors the stuff.
                             // Color stuff with the description of the style matched
                             // to the hash table that has been set up ahead of time.
                             synchronized (fDoclock)
                             {
                                 if (t.getCharEnd() <= document.getLength())
                                 {
                                     document.setCharacterAttributes(
                                         t.getCharBegin() + change,
                                         t.getCharEnd() - t.getCharBegin(),
                                         getStyle(t.getDescription()),
                                         true);
                                     // record the position of the last bit of text that we colored
                                     dpEnd = new DocPosition(t.getCharEnd());
                                 }
                                 lastPosition = (t.getCharEnd() + change);
                             }
                             // The other more complicated reason for doing no more highlighting
                             // is that all the colors are the same from here on out anyway.
                             // We can detect this by seeing if the place that the lexer returned
                             // to the initial state last time we highlighted is the same as the
                             // place that returned to the inital state this time.
                             // As long as that place is after the last changed text, everything
                             // from there on is fine already.
                             if (t.getState() == Token.INITIAL_STATE)
                             {
                                 //System.out.println(t);
                                 // look at all the positions from last time that are less than or
                                 // equal to the current position
                                 while (dp != null
                                     && dp.getPosition() <= t.getCharEnd())
                                 {
                                     if (dp.getPosition() == t.getCharEnd()
                                         && dp.getPosition()
                                             >= endRequest.getPosition())
                                     {
                                         // we have found a state that is the same
                                         done = true;
                                         dp = null;
                                     }
                                     else if (workingIt.hasNext())
                                     {
                                         // didn't find it, try again.
                                         dp = (DocPosition) workingIt.next();
                                     }
                                     else
                                     {
                                         // didn't find it, and there is no more info from last
                                         // time.  This means that we will just continue
                                         // until the end of the document.
                                         dp = null;
                                     }
                                 }
                                 // so that we can do this check next time, record all the
                                 // initial states from this time.
                                 newPositions.add(dpEnd);
                             }
                             synchronized (fDoclock)
                             {
                                 t = syntaxLexer.getNextToken();
                             }
                         }
                         // remove all the old initial positions from the place where
                         // we started doing the highlighting right up through the last
                         // bit of text we touched.
                         workingIt =
                             fIniPositions.subSet(dpStart, dpEnd).iterator();
                         while (workingIt.hasNext())
                         {
                             workingIt.next();
                             workingIt.remove();
                         }
                         // Remove all the positions that are after the end of the file.:
                         workingIt =
                             fIniPositions
                                 .tailSet(new DocPosition(document.getLength()))
                                 .iterator();
                         while (workingIt.hasNext())
                         {
                             workingIt.next();
                             workingIt.remove();
                         }
                         // and put the new initial positions that we have found on the list.
                         fIniPositions.addAll(newPositions);
                         newPositions.clear();
                     }
                     catch (IOException x)
                     {
                     }
                     synchronized (fDoclock)
                     {
                         lastPosition = -1;
                         change = 0;
                     }
                     // since we did something, we should check that there is
                     // nothing else to do before going back to sleep.
                     tryAgain = true;
                 }
                 asleep = true;
                 if (!tryAgain)
                 {
                     try
                     {
                         sleep(0xffffff);
                     }
                     catch (InterruptedException x)
                     {
                     }
                 }
                 asleep = false;
             }
         }
     }
     /***
      * Color a section of the document.
      * The actual coloring will start somewhere before the requested position
      * and continue as long as needed.
      * @param position the starting point for the coloring.
      * @param adjustment amount of text inserted or removed at the starting point.
      */
     public static void color(int position, int adjustment)
     {
         colorer.color(position, adjustment);
     }
     /***
      * retrieve the syle for the given type of text.
      * @param styleName the label for the type of text ("tag" for example)
      * or null if the styleName is not known.
      * @return the style
      */
     private static SimpleAttributeSet getStyle(String styleName)
     {
         return ((SimpleAttributeSet) styles.get(styleName));
     }
     /***
      * Create the styles and place them in the hash table.
      */
     private void initStyles()
     {
         SimpleAttributeSet style;
         style = new SimpleAttributeSet();
         StyleConstants.setFontFamily(style, "Monospaced");
         StyleConstants.setFontSize(style, 11);
         StyleConstants.setBackground(style, Color.white);
         StyleConstants.setForeground(style, Color.blue);
         StyleConstants.setBold(style, false);
         StyleConstants.setItalic(style, false);
         styles.put("reservedWord", style);
         style = new SimpleAttributeSet();
         StyleConstants.setFontFamily(style, "Monospaced");
         StyleConstants.setFontSize(style, 11);
         StyleConstants.setBackground(style, Color.white);
         StyleConstants.setForeground(style, Color.black);
         StyleConstants.setBold(style, false);
         StyleConstants.setItalic(style, false);
         styles.put("identifier", style);
         style = new SimpleAttributeSet();
         StyleConstants.setFontFamily(style, "Monospaced");
         StyleConstants.setFontSize(style, 11);
         StyleConstants.setBackground(style, Color.white);
         StyleConstants.setForeground(style, new Color(0xB03060)        /*Color.maroon*/
         );
         StyleConstants.setBold(style, false);
         StyleConstants.setItalic(style, false);
         styles.put("literal", style);
         style = new SimpleAttributeSet();
         StyleConstants.setFontFamily(style, "Monospaced");
         StyleConstants.setFontSize(style, 11);
         StyleConstants.setBackground(style, Color.white);
         StyleConstants.setForeground(style, new Color(0x000080) /*Color.navy*/
         );
         StyleConstants.setBold(style, false);
         StyleConstants.setItalic(style, false);
         styles.put("separator", style);
         style = new SimpleAttributeSet();
         StyleConstants.setFontFamily(style, "Monospaced");
         StyleConstants.setFontSize(style, 11);
         StyleConstants.setBackground(style, Color.white);
         StyleConstants.setForeground(style, Color.black);
         StyleConstants.setBold(style, true);
         StyleConstants.setItalic(style, false);
         styles.put("operator", style);
         style = new SimpleAttributeSet();
         StyleConstants.setFontFamily(style, "Monospaced");
         StyleConstants.setFontSize(style, 11);
         StyleConstants.setBackground(style, Color.white);
         StyleConstants.setForeground(style, Color.green.darker());
         StyleConstants.setBold(style, false);
         StyleConstants.setItalic(style, false);
         styles.put("comment", style);
         style = new SimpleAttributeSet();
         StyleConstants.setFontFamily(style, "Monospaced");
         StyleConstants.setFontSize(style, 11);
         StyleConstants.setBackground(style, Color.white);
         StyleConstants.setForeground(style, Color.black);
         StyleConstants.setBold(style, false);
         StyleConstants.setItalic(style, false);
         styles.put("whitespace", style);
         style = new SimpleAttributeSet();
         StyleConstants.setFontFamily(style, "Monospaced");
         StyleConstants.setFontSize(style, 12);
         StyleConstants.setBackground(style, Color.white);
         StyleConstants.setForeground(style, Color.red);
         StyleConstants.setBold(style, false);
         StyleConstants.setItalic(style, false);
         styles.put("error", style);
         style = new SimpleAttributeSet();
         StyleConstants.setFontFamily(style, "Monospaced");
         StyleConstants.setFontSize(style, 11);
         StyleConstants.setBackground(style, Color.white);
         StyleConstants.setForeground(style, Color.orange);
         StyleConstants.setBold(style, false);
         StyleConstants.setItalic(style, false);
         styles.put("unknown", style);
     }
     /***
      * Just like a DefaultStyledDocument but intercepts inserts and removes
      * to color them.
      */
     private class HighLightedDocument extends DefaultStyledDocument
     {
         public void insertString(int offs, String str, AttributeSet a)
             throws BadLocationException
         {
             synchronized (fDoclock)
             {
                 super.insertString(offs, str, a);
                 color(offs, str.length());
                 documentReader.update(offs, str.length());
             }
         }
         public void remove(int offs, int len) throws BadLocationException
         {
             synchronized (fDoclock)
             {
                 super.remove(offs, len);
                 color(offs, -len);
                 documentReader.update(offs, -len);
             }
         }
     }
 }
 /***
  * A wrapper for a position in a document appropriate for storing
  * in a collection.
  */
 class DocPosition
 {
     // The actual position
     private int position;
     /***
      * Get the position represented by this DocPosition
      * @return the position
      */
     int getPosition()
     {
         return position;
     }
     /***
      * Construct a DocPosition from the given offset into the document.
      * @param position The position this DocObject will represent
      */
     public DocPosition(int pPosition)
     {
         this.position = pPosition;
     }
     /***
      * Adjust this position.
      * @param adjustment amount to adjust this position.
      * @return the DocPosition, adjusted properly.
      */
     public DocPosition adjustPosition(int adjustment)
     {
         position += adjustment;
         return this;
     }
     /***
      * Two DocPositions are equal iff they have the same internal position.
      *  @param obj the object
      * @return if this DocPosition represents the same position as another.
      */
     public final boolean equals(final Object obj)
     {
         if (obj instanceof DocPosition)
         {
             DocPosition d = (DocPosition) (obj);
             return this.position == d.position;
         }
         else
         {
             return false;
         }
     }
     /***
      * A string representation useful for debugging.
      * @return A string representing the position.
      */
     public String toString()
     {
         return "" + position;
     }
 }
 /***
  * A comparator appropriate for use with Collections of
  * DocPositions.
  */
 class DocPositionComparator implements Comparator
 {
     /***
      * Comparator
      * @param object to compare
      * @return true for DocPositionComparators, false otherwise.
      */
     public boolean equals(Object obj)
     {
         return obj instanceof DocPositionComparator;
     }
     /***
      * Compare two DocPositions
      * @param o1 first DocPosition
      * @param o2 second DocPosition
      * @return negative,0 or positive
      */
     public int compare(final Object o1, final Object o2)
     {
         if (o1 instanceof DocPosition && o2 instanceof DocPosition)
         {
             DocPosition d1 = (DocPosition) (o1);
             DocPosition d2 = (DocPosition) (o2);
             return (d1.getPosition() - d2.getPosition());
         }
         else if (o1 instanceof DocPosition)
         {
             return -1;
         }
         else if (o2 instanceof DocPosition)
         {
             return 1;
         }
         else if (o1.hashCode() < o2.hashCode())
         {
             return -1;
         }
         else if (o2.hashCode() > o1.hashCode())
         {
             return 1;
         }
         else
         {
             return 0;
         }
     }
 }
 /***
  * A reader interface for an abstract document.  Since the syntax highlighting
  * packages only accept Stings and Readers, this must be used.
  * Since the close() method does nothing and a seek() method has been added,
  * this allows us to get some performance improvements through reuse.
  * It can be used even after the lexer explicitly closes it by seeking to the
  * place that we want to read next, and reseting the lexer.
  */
 class DocumentReader extends Reader
 {
     /*** Current position in the document */
     private long position = 0;
     /*** Saved position used in the mark and reset method */
     private long mark = -1;
     /*** The document that we are working with */
     private AbstractDocument document;
     /***
      * Alerting the reader
      * @param pPosition position
      * @param adjustment adjustement
      */
     public void update(int pPosition, int adjustment)
     {
         if (pPosition < this.position)
         {
             if (this.position < pPosition - adjustment)
             {
                 this.position = pPosition;
             }
             else
             {
                 this.position += adjustment;
             }
         }
     }
     /***
      * Construct a reader on the given document.
      * @param document the document to be read.
      */
     public DocumentReader(AbstractDocument pDocument)
     {
         this.document = pDocument;
     }
     /***
      * Has no effect.  This reader can be used even after it has been closed.
      */
     public void close()
     {
     }
     /***
      * Save a position for reset.
      * @param readAheadLimit ignored.
      */
     public void mark(int readAheadLimit)
     {
         mark = position;
     }
     /***
      * This reader support mark and reset.
      * @return true
      */
     public boolean markSupported()
     {
         return true;
     }
     /***
      * Read a single character.
      * @return the character or -1 if the end of the document has been reached.
      */
     public int read()
     {
         if (position < document.getLength())
         {
             try
             {
                 char c = document.getText((int) position, 1).charAt(0);
                 position++;
                 return c;
             }
             catch (BadLocationException x)
             {
                 return -1;
             }
         }
         else
         {
             return -1;
         }
     }
     /***
      * Read and fill the buffer.
      * @param cbuf the buffer to fill.
      * @return the number of characters read
      */
     public int read(char[] cbuf)
     {
         return read(cbuf, 0, cbuf.length);
     }
     /***
      * Read and fill the buffer.
      * @param cbuf the buffer to fill.
      * @param off offset into the buffer to begin the fill.
      * @param len maximum number of characters to put in the buffer.
      * @return the number of characters read
      */
     public int read(char[] cbuf, int off, int len)
     {
         if (position < document.getLength())
         {
             int length = len;
             if (position + length >= document.getLength())
             {
                 length = document.getLength() - (int) position;
             }
             if (off + length >= cbuf.length)
             {
                 length = cbuf.length - off;
             }
             try
             {
                 String s = document.getText((int) position, length);
                 position += length;
                 for (int i = 0; i < length; i++)
                 {
                     cbuf[off + i] = s.charAt(i);
                 }
                 return length;
             }
             catch (BadLocationException x)
             {
                 return -1;
             }
         }
         else
         {
             return -1;
         }
     }
     /***
      * @return true
      */
     public boolean ready()
     {
         return true;
     }
     /***
      * Reset this reader to the last mark, or the beginning of the document
      * if a mark has not been set.
      */
     public void reset()
     {
         if (mark == -1)
         {
             position = 0;
         }
         else
         {
             position = mark;
         }
         mark = -1;
     }
     /***
      * Skip characters of input.
      * @param n number of characters to skip.
      * @return the actual number of characters skipped.
      */
     public long skip(long n)
     {
         if (position + n <= document.getLength())
         {
             position += n;
             return n;
         }
         else
         {
             long oldPos = position;
             position = document.getLength();
             return (document.getLength() - oldPos);
         }
     }
     /***
      * Seek to the given position in the document
      * @param n the offset to which to seek.
      */
     public final void seek(final long n)
     {
         if (n <= document.getLength())
         {
             position = n;
         }
         else
         {
             position = document.getLength();
         }
     }
 }