Source code: org/gjt/sp/jedit/Buffer.java

   /*
    * Buffer.java - jEdit buffer
    * :tabSize=8:indentSize=8:noTabs=false:
    * :folding=explicit:collapseFolds=1:
    *
    * Copyright (C) 1998, 2003 Slava Pestov
    * Portions copyright (C) 1999, 2000 mike dillon
    *
    * 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 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.
   */
  
  package org.gjt.sp.jedit;
  
  //{{{ Imports
  import gnu.regexp.*;
  import javax.swing.*;
  import javax.swing.text.*;
  import java.awt.Toolkit;
  import java.io.File;
  import java.io.IOException;
  import java.net.Socket;
  import java.util.*;
  import org.gjt.sp.jedit.browser.VFSBrowser;
  import org.gjt.sp.jedit.buffer.*;
  import org.gjt.sp.jedit.io.*;
  import org.gjt.sp.jedit.msg.*;
  import org.gjt.sp.jedit.search.RESearchMatcher;
  import org.gjt.sp.jedit.syntax.*;
  import org.gjt.sp.jedit.textarea.*;
  import org.gjt.sp.util.*;
  //}}}
  
  /**
   * A <code>Buffer</code> represents the contents of an open text
   * file as it is maintained in the computer's memory (as opposed to
   * how it may be stored on a disk).<p>
   *
   * In a BeanShell script, you can obtain the current buffer instance from the
   * <code>buffer</code> variable.<p>
   *
   * This class does not have a public constructor.
   * Buffers can be opened and closed using methods in the <code>jEdit</code>
   * class.<p>
   *
   * This class is partially thread-safe, however you must pay attention to two
   * very important guidelines:
   * <ul>
   * <li>Changes to a buffer can only be made from the AWT thread.
   * <li>When accessing the buffer from another thread, you must
   * grab a read lock if you plan on performing more than one call, to ensure that
   * the buffer contents are not changed by the AWT thread for the duration of the
   * lock. Only methods whose descriptions specify thread safety can be invoked
   * from other threads.
   * </ul>
   *
   * @author Slava Pestov
   * @version $Id: Buffer.java,v 1.208 2003/11/22 20:32:28 spestov Exp $
   */
  public class Buffer
  {
    //{{{ Some constants
    /**
     * Line separator property.
     */
    public static final String LINESEP = "lineSeparator";
  
    /**
     * Backed up property.
     * @since jEdit 3.2pre2
     */
    public static final String BACKED_UP = "Buffer__backedUp";
  
    /**
     * Caret info properties.
     * @since jEdit 3.2pre1
     */
    public static final String CARET = "Buffer__caret";
    public static final String SELECTION = "Buffer__selection";
  
    /**
     * This should be a physical line number, so that the scroll
     * position is preserved correctly across reloads (which will
     * affect virtual line numbers, due to fold being reset)
     */
    public static final String SCROLL_VERT = "Buffer__scrollVert";
    public static final String SCROLL_HORIZ = "Buffer__scrollHoriz";
  
   /**
    * Character encoding used when loading and saving.
    * @since jEdit 3.2pre4
    */
   public static final String ENCODING = "encoding";
 
   /**
    * Should jEdit try to set the encoding based on a UTF8, UTF16 or
    * XML signature at the beginning of the file?
    */
   public static final String ENCODING_AUTODETECT = "encodingAutodetect";
 
   /**
    * This property is set to 'true' if the file has a trailing newline.
    * @since jEdit 4.0pre1
    */
   public static final String TRAILING_EOL = "trailingEOL";
 
   /**
    * This property is set to 'true' if the file should be GZipped.
    * @since jEdit 4.0pre4
    */
   public static final String GZIPPED = "gzipped";
   //}}}
 
   //{{{ Input/output methods
 
   //{{{ reload() method
   /**
    * Reloads the buffer from disk, asking for confirmation if the buffer
    * has unsaved changes.
    * @param view The view
    * @since jEdit 2.7pre2
    */
   public void reload(View view)
   {
     if(getFlag(DIRTY))
     {
       String[] args = { name };
       int result = GUIUtilities.confirm(view,"changedreload",
         args,JOptionPane.YES_NO_OPTION,
         JOptionPane.WARNING_MESSAGE);
       if(result != JOptionPane.YES_OPTION)
         return;
     }
 
     view.getEditPane().saveCaretInfo();
     load(view,true);
   } //}}}
 
   //{{{ load() method
   /**
    * Loads the buffer from disk, even if it is loaded already.
    * @param view The view
    * @param reload If true, user will not be asked to recover autosave
    * file, if any
    *
    * @since 2.5pre1
    */
   public boolean load(final View view, final boolean reload)
   {
     if(isPerformingIO())
     {
       GUIUtilities.error(view,"buffer-multiple-io",null);
       return false;
     }
 
     setBooleanProperty(BufferIORequest.ERROR_OCCURRED,false);
 
     setFlag(LOADING,true);
 
     // view text areas temporarily blank out while a buffer is
     // being loaded, to indicate to the user that there is no
     // data available yet.
     if(!getFlag(TEMPORARY))
       EditBus.send(new BufferUpdate(this,view,BufferUpdate.LOAD_STARTED));
 
     final boolean loadAutosave;
 
     if(reload || !getFlag(NEW_FILE))
     {
       if(file != null)
         modTime = file.lastModified();
 
       // Only on initial load
       if(!reload && autosaveFile != null && autosaveFile.exists())
         loadAutosave = recoverAutosave(view);
       else
       {
         if(autosaveFile != null)
           autosaveFile.delete();
         loadAutosave = false;
       }
 
       if(!loadAutosave)
       {
         VFS vfs = VFSManager.getVFSForPath(path);
 
         if(!checkFileForLoad(view,vfs,path))
         {
           setFlag(LOADING,false);
           return false;
         }
 
         // have to check again since above might set
         // NEW_FILE flag
         if(reload || !getFlag(NEW_FILE))
         {
           if(!vfs.load(view,this,path))
           {
             setFlag(LOADING,false);
             return false;
           }
         }
       }
     }
     else
       loadAutosave = false;
 
     //{{{ Do some stuff once loading is finished
     Runnable runnable = new Runnable()
     {
       public void run()
       {
         String newPath = getStringProperty(
           BufferIORequest.NEW_PATH);
         Segment seg = (Segment)getProperty(
           BufferIORequest.LOAD_DATA);
         IntegerArray endOffsets = (IntegerArray)
           getProperty(BufferIORequest.END_OFFSETS);
 
         if(seg == null)
           seg = new Segment(new char[1024],0,0);
         if(endOffsets == null)
         {
           endOffsets = new IntegerArray();
           endOffsets.add(1);
         }
 
         try
         {
           writeLock();
 
           // For `reload' command
           firePreContentRemoved(0,0,getLineCount()
             - 1,getLength());
 
           contentMgr.remove(0,getLength());
           lineMgr.contentRemoved(0,0,getLineCount()
             - 1,getLength());
           positionMgr.contentRemoved(0,getLength());
           fireContentRemoved(0,0,getLineCount()
             - 1,getLength());
 
           // theoretically a segment could
           // have seg.offset != 0 but
           // SegmentBuffer never does that
           contentMgr._setContent(seg.array,seg.count);
 
           lineMgr._contentInserted(endOffsets);
           positionMgr.contentInserted(0,seg.count);
 
           fireContentInserted(0,0,
             endOffsets.getSize() - 1,
             seg.count - 1);
         }
         finally
         {
           writeUnlock();
         }
 
         unsetProperty(BufferIORequest.LOAD_DATA);
         unsetProperty(BufferIORequest.END_OFFSETS);
         unsetProperty(BufferIORequest.NEW_PATH);
 
         undoMgr.clear();
         undoMgr.setLimit(jEdit.getIntegerProperty(
           "buffer.undoCount",100));
 
         if(!getFlag(TEMPORARY))
           finishLoading();
 
         setFlag(LOADING,false);
 
         // if reloading a file, clear dirty flag
         if(reload)
           setDirty(false);
 
         if(!loadAutosave && newPath != null)
           setPath(newPath);
 
         // if loadAutosave is false, we loaded an
         // autosave file, so we set 'dirty' to true
 
         // note that we don't use setDirty(),
         // because a) that would send an unnecessary
         // message, b) it would also set the
         // AUTOSAVE_DIRTY flag, which will make
         // the autosave thread write out a
         // redundant autosave file
         if(loadAutosave)
           setFlag(DIRTY,true);
 
         // send some EditBus messages
         if(!getFlag(TEMPORARY))
         {
           EditBus.send(new BufferUpdate(Buffer.this,
             view,BufferUpdate.LOADED));
           //EditBus.send(new BufferUpdate(Buffer.this,
           //  view,BufferUpdate.MARKERS_CHANGED));
         }
       }
     }; //}}}
 
     if(getFlag(TEMPORARY))
       runnable.run();
     else
       VFSManager.runInAWTThread(runnable);
 
     return true;
   } //}}}
 
   //{{{ insertFile() method
   /**
    * Loads a file from disk, and inserts it into this buffer.
    * @param view The view
    *
    * @since 4.0pre1
    */
   public boolean insertFile(final View view, String path)
   {
     if(isPerformingIO())
     {
       GUIUtilities.error(view,"buffer-multiple-io",null);
       return false;
     }
 
     setBooleanProperty(BufferIORequest.ERROR_OCCURRED,false);
 
     path = MiscUtilities.constructPath(this.path,path);
 
     Buffer buffer = jEdit.getBuffer(path);
     if(buffer != null)
     {
       view.getTextArea().setSelectedText(
         buffer.getText(0,buffer.getLength()));
       return true;
     }
 
     VFS vfs = VFSManager.getVFSForPath(path);
 
     // this returns false if initial sanity
     // checks (if the file is a directory, etc)
     // fail
     return vfs.insert(view,this,path);
   } //}}}
 
   //{{{ autosave() method
   /**
    * Autosaves this buffer.
    */
   public void autosave()
   {
     if(autosaveFile == null || !getFlag(AUTOSAVE_DIRTY)
       || !getFlag(DIRTY)
       || getFlag(LOADING)
       || getFlag(IO))
       return;
 
     setFlag(AUTOSAVE_DIRTY,false);
 
     VFSManager.runInWorkThread(new BufferIORequest(
       BufferIORequest.AUTOSAVE,null,this,null,
       VFSManager.getFileVFS(),autosaveFile.getPath()));
   } //}}}
 
   //{{{ saveAs() method
   /**
    * Prompts the user for a file to save this buffer to.
    * @param view The view
    * @param rename True if the buffer's path should be changed, false
    * if only a copy should be saved to the specified filename
    * @since jEdit 2.6pre5
    */
   public boolean saveAs(View view, boolean rename)
   {
     String[] files = GUIUtilities.showVFSFileDialog(view,path,
       VFSBrowser.SAVE_DIALOG,false);
 
     // files[] should have length 1, since the dialog type is
     // SAVE_DIALOG
     if(files == null)
       return false;
 
     return save(view,files[0],rename);
   } //}}}
 
   //{{{ save() method
   /**
    * Saves this buffer to the specified path name, or the current path
    * name if it's null.
    * @param view The view
    * @param path The path name to save the buffer to, or null to use
    * the existing path
    */
   public boolean save(View view, String path)
   {
     return save(view,path,true);
   } //}}}
 
   //{{{ save() method
   /**
    * Saves this buffer to the specified path name, or the current path
    * name if it's null.
    * @param view The view
    * @param path The path name to save the buffer to, or null to use
    * the existing path
    * @param rename True if the buffer's path should be changed, false
    * if only a copy should be saved to the specified filename
    * @since jEdit 2.6pre5
    */
   public boolean save(final View view, String path, final boolean rename)
   {
     if(isPerformingIO())
     {
       GUIUtilities.error(view,"buffer-multiple-io",null);
       return false;
     }
 
     setBooleanProperty(BufferIORequest.ERROR_OCCURRED,false);
 
     if(path == null && getFlag(NEW_FILE))
       return saveAs(view,rename);
 
     if(path == null && file != null)
     {
       long newModTime = file.lastModified();
 
       if(newModTime != modTime
         && jEdit.getBooleanProperty("view.checkModStatus"))
       {
         Object[] args = { this.path };
         int result = GUIUtilities.confirm(view,
           "filechanged-save",args,
           JOptionPane.YES_NO_OPTION,
           JOptionPane.WARNING_MESSAGE);
         if(result != JOptionPane.YES_OPTION)
           return false;
       }
     }
 
     setFlag(IO,true);
     EditBus.send(new BufferUpdate(this,view,BufferUpdate.SAVING));
 
     final String oldPath = this.path;
     final String oldSymlinkPath = this.symlinkPath;
     final String newPath = (path == null ? this.path : path);
 
     VFS vfs = VFSManager.getVFSForPath(newPath);
 
     if(!checkFileForSave(view,vfs,newPath))
     {
       setFlag(IO,false);
       return false;
     }
 
     if(!vfs.save(view,this,newPath))
     {
       setFlag(IO,false);
       return false;
     }
 
     // Once save is complete, do a few other things
     VFSManager.runInAWTThread(new Runnable()
     {
       public void run()
       {
         setFlag(IO,false);
         finishSaving(view,oldPath,oldSymlinkPath,
           newPath,rename,getBooleanProperty(
           BufferIORequest.ERROR_OCCURRED));
       }
     });
 
     return true;
   } //}}}
 
   //{{{ checkFileStatus() method
   public static final int FILE_NOT_CHANGED = 0;
   public static final int FILE_CHANGED = 1;
   public static final int FILE_DELETED = 2;
   /**
    * Check if the buffer has changed on disk.
    * @return One of <code>NOT_CHANGED</code>, <code>CHANGED</code>, or
    * <code>DELETED</code>.
    *
    * @since jEdit 4.2pre1
    */
   public int checkFileStatus(View view)
   {
     // - don't do these checks while a save is in progress,
     // because for a moment newModTime will be greater than
     // oldModTime, due to the multithreading
     // - only supported on local file system
     if(!getFlag(IO) && !getFlag(LOADING) && file != null
       && !getFlag(NEW_FILE))
     {
       boolean newReadOnly = (file.exists() && !file.canWrite());
       if(newReadOnly != getFlag(READ_ONLY))
       {
         setFlag(READ_ONLY,newReadOnly);
         EditBus.send(new BufferUpdate(this,null,
           BufferUpdate.DIRTY_CHANGED));
       }
 
       long oldModTime = modTime;
       long newModTime = file.lastModified();
 
       if(newModTime != oldModTime)
       {
         modTime = newModTime;
 
         if(!file.exists())
         {
           setFlag(NEW_FILE,true);
           setDirty(true);
           return FILE_DELETED;
         }
         else
         {
           return FILE_CHANGED;
         }
       }
     }
 
     return FILE_NOT_CHANGED;
   } //}}}
 
   //}}}
 
   //{{{ Getters/setter methods for various buffer meta-data
 
   //{{{ getLastModified() method
   /**
    * Returns the last time jEdit modified the file on disk.
    * This method is thread-safe.
    */
   public long getLastModified()
   {
     return modTime;
   } //}}}
 
   //{{{ setLastModified() method
   /**
    * Sets the last time jEdit modified the file on disk.
    * @param modTime The new modification time
    */
   public void setLastModified(long modTime)
   {
     this.modTime = modTime;
   } //}}}
 
   //{{{ getVFS() method
   /**
    * Returns the virtual filesystem responsible for loading and
    * saving this buffer. This method is thread-safe.
    */
   public VFS getVFS()
   {
     return VFSManager.getVFSForPath(path);
   } //}}}
 
   //{{{ getAutosaveFile() method
   /**
    * Returns the autosave file for this buffer. This may be null if
    * the file is non-local.
    */
   public File getAutosaveFile()
   {
     return autosaveFile;
   } //}}}
 
   //{{{ getName() method
   /**
    * Returns the name of this buffer. This method is thread-safe.
    */
   public String getName()
   {
     return name;
   } //}}}
 
   //{{{ getPath() method
   /**
    * Returns the path name of this buffer. This method is thread-safe.
    */
   public String getPath()
   {
     return path;
   } //}}}
 
   //{{{ getSymlinkPath() method
   /**
    * If this file is a symbolic link, returns the link destination.
    * Otherwise returns the file's path. This method is thread-safe.
    * @since jEdit 4.2pre1
    */
   public String getSymlinkPath()
   {
     return symlinkPath;
   } //}}}
 
   //{{{ getDirectory() method
   /**
    * Returns the directory containing this buffer.
    * @since jEdit 4.1pre11
    */
   public String getDirectory()
   {
     return directory;
   } //}}}
 
   //{{{ isClosed() method
   /**
    * Returns true if this buffer has been closed with
    * {@link org.gjt.sp.jedit.jEdit#closeBuffer(View,Buffer)}.
    * This method is thread-safe.
    */
   public boolean isClosed()
   {
     return getFlag(CLOSED);
   } //}}}
 
   //{{{ isLoaded() method
   /**
    * Returns true if the buffer is loaded. This method is thread-safe.
    */
   public boolean isLoaded()
   {
     return !getFlag(LOADING);
   } //}}}
 
   //{{{ isPerformingIO() method
   /**
    * Returns true if the buffer is currently performing I/O.
    * This method is thread-safe.
    * @since jEdit 2.7pre1
    */
   public boolean isPerformingIO()
   {
     return getFlag(LOADING) || getFlag(IO);
   } //}}}
 
   //{{{ isNewFile() method
   /**
    * Returns whether this buffer lacks a corresponding version on disk.
    * This method is thread-safe.
    */
   public boolean isNewFile()
   {
     return getFlag(NEW_FILE);
   } //}}}
 
   //{{{ setNewFile() method
   /**
    * Sets the new file flag.
    * @param newFile The new file flag
    */
   public void setNewFile(boolean newFile)
   {
     setFlag(NEW_FILE,newFile);
     if(!newFile)
       setFlag(UNTITLED,false);
   } //}}}
 
   //{{{ isUntitled() method
   /**
    * Returns true if this file is 'untitled'. This method is thread-safe.
    */
   public boolean isUntitled()
   {
     return getFlag(UNTITLED);
   } //}}}
 
   //{{{ isDirty() method
   /**
    * Returns whether there have been unsaved changes to this buffer.
    * This method is thread-safe.
    */
   public boolean isDirty()
   {
     return getFlag(DIRTY);
   } //}}}
 
   //{{{ isReadOnly() method
   /**
    * Returns true if this file is read only, false otherwise.
    * This method is thread-safe.
    */
   public boolean isReadOnly()
   {
     return getFlag(READ_ONLY) || getFlag(READ_ONLY_OVERRIDE);
   } //}}}
 
   //{{{ isEditable() method
   /**
    * Returns true if this file is editable, false otherwise. A file may
    * become uneditable if it is read only, or if I/O is in progress.
    * This method is thread-safe.
    * @since jEdit 2.7pre1
    */
   public boolean isEditable()
   {
     return !(getFlag(READ_ONLY) || getFlag(READ_ONLY_OVERRIDE)
       || getFlag(IO) || getFlag(LOADING));
   } //}}}
 
   //{{{ setReadOnly() method
   /**
    * Sets the read only flag.
    * @param readOnly The read only flag
    */
   public void setReadOnly(boolean readOnly)
   {
     setFlag(READ_ONLY_OVERRIDE,readOnly);
   } //}}}
 
   //{{{ setDirty() method
   /**
    * Sets the 'dirty' (changed since last save) flag of this buffer.
    */
   public void setDirty(boolean d)
   {
     boolean old_d = getFlag(DIRTY);
     boolean editable = isEditable();
 
     if(d)
     {
       if(editable)
       {
         setFlag(DIRTY,true);
         setFlag(AUTOSAVE_DIRTY,true);
       }
     }
     else
     {
       setFlag(DIRTY,false);
       setFlag(AUTOSAVE_DIRTY,false);
 
       if(autosaveFile != null)
         autosaveFile.delete();
 
       // fixes dirty flag not being reset on
       // save/insert/undo/redo/undo
       if(!getFlag(UNDO_IN_PROGRESS))
       {
         // this ensures that undo can clear the dirty flag properly
         // when all edits up to a save are undone
         undoMgr.bufferSaved();
       }
     }
 
     if(d != old_d && editable)
     {
       EditBus.send(new BufferUpdate(this,null,
         BufferUpdate.DIRTY_CHANGED));
     }
   } //}}}
 
   //{{{ isTemporary() method
   /**
    * Returns if this is a temporary buffer. This method is thread-safe.
    * @see jEdit#openTemporary(View,String,String,boolean)
    * @see jEdit#commitTemporary(Buffer)
    * @since jEdit 2.2pre7
    */
   public boolean isTemporary()
   {
     return getFlag(TEMPORARY);
   } //}}}
 
   //{{{ getIcon() method
   /**
    * Returns this buffer's icon.
    * @since jEdit 2.6pre6
    */
   public Icon getIcon()
   {
     if(getFlag(DIRTY))
       return GUIUtilities.DIRTY_BUFFER_ICON;
     else if(getFlag(READ_ONLY) || getFlag(READ_ONLY_OVERRIDE))
       return GUIUtilities.READ_ONLY_BUFFER_ICON;
     else if(getFlag(NEW_FILE))
       return GUIUtilities.NEW_BUFFER_ICON;
     else
       return GUIUtilities.NORMAL_BUFFER_ICON;
   } //}}}
 
   //}}}
 
   //{{{ Thread safety
 
   //{{{ readLock() method
   /**
    * The buffer is guaranteed not to change between calls to
    * {@link #readLock()} and {@link #readUnlock()}.
    */
   public void readLock()
   {
     lock.readLock();
   } //}}}
 
   //{{{ readUnlock() method
   /**
    * The buffer is guaranteed not to change between calls to
    * {@link #readLock()} and {@link #readUnlock()}.
    */
   public void readUnlock()
   {
     lock.readUnlock();
   } //}}}
 
   //{{{ writeLock() method
   /**
    * Attempting to obtain read lock will block between calls to
    * {@link #writeLock()} and {@link #writeUnlock()}.
    */
   public void writeLock()
   {
     lock.writeLock();
   } //}}}
 
   //{{{ writeUnlock() method
   /**
    * Attempting to obtain read lock will block between calls to
    * {@link #writeLock()} and {@link #writeUnlock()}.
    */
   public void writeUnlock()
   {
     lock.writeUnlock();
   } //}}}
 
   //}}}
 
   //{{{ Line offset methods
 
   //{{{ getLength() method
   /**
    * Returns the number of characters in the buffer. This method is thread-safe.
    */
   public int getLength()
   {
     // no need to lock since this just returns a value and that's it
     return contentMgr.getLength();
   } //}}}
 
   //{{{ getLineCount() method
   /**
    * Returns the number of physical lines in the buffer.
    * This method is thread-safe.
    * @since jEdit 3.1pre1
    */
   public int getLineCount()
   {
     // no need to lock since this just returns a value and that's it
     return lineMgr.getLineCount();
   } //}}}
 
   //{{{ getLineOfOffset() method
   /**
    * Returns the line containing the specified offset.
    * This method is thread-safe.
    * @param offset The offset
    * @since jEdit 4.0pre1
    */
   public int getLineOfOffset(int offset)
   {
     try
     {
       readLock();
 
       if(offset < 0 || offset > getLength())
         throw new ArrayIndexOutOfBoundsException(offset);
 
       return lineMgr.getLineOfOffset(offset);
     }
     finally
     {
       readUnlock();
     }
   } //}}}
 
   //{{{ getLineStartOffset() method
   /**
    * Returns the start offset of the specified line.
    * This method is thread-safe.
    * @param line The line
    * @return The start offset of the specified line
    * @since jEdit 4.0pre1
    */
   public int getLineStartOffset(int line)
   {
     try
     {
       readLock();
 
       if(line < 0 || line >= lineMgr.getLineCount())
         throw new ArrayIndexOutOfBoundsException(line);
       else if(line == 0)
         return 0;
 
       return lineMgr.getLineEndOffset(line - 1);
     }
     finally
     {
       readUnlock();
     }
   } //}}}
 
   //{{{ getLineEndOffset() method
   /**
    * Returns the end offset of the specified line.
    * This method is thread-safe.
    * @param line The line
    * @return The end offset of the specified line
    * invalid.
    * @since jEdit 4.0pre1
    */
   public int getLineEndOffset(int line)
   {
     try
     {
       readLock();
 
       if(line < 0 || line >= lineMgr.getLineCount())
         throw new ArrayIndexOutOfBoundsException(line);
 
       return lineMgr.getLineEndOffset(line);
     }
     finally
     {
       readUnlock();
     }
   } //}}}
 
   //{{{ getLineLength() method
   /**
    * Returns the length of the specified line.
    * This method is thread-safe.
    * @param line The line
    * @since jEdit 4.0pre1
    */
   public int getLineLength(int line)
   {
     try
     {
       readLock();
 
       return getLineEndOffset(line)
         - getLineStartOffset(line) - 1;
     }
     finally
     {
       readUnlock();
     }
   } //}}}
 
   //{{{ invalidateCachedScreenLineCounts() method
   /**
    * Invalidates all cached screen line count information.
    * @since jEdit 4.2pre7.
    */
   public void invalidateCachedScreenLineCounts()
   {
     lineMgr.invalidateScreenLineCounts();
   } //}}}
 
   //}}}
 
   //{{{ Text getters and setters
 
   //{{{ getLineText() method
   /**
    * Returns the text on the specified line.
    * This method is thread-safe.
    * @param line The line
    * @return The text, or null if the line is invalid
    * @since jEdit 4.0pre1
    */
   public String getLineText(int line)
   {
     if(line < 0 || line >= lineMgr.getLineCount())
       throw new ArrayIndexOutOfBoundsException(line);
 
     try
     {
       readLock();
 
       int start = (line == 0 ? 0
         : lineMgr.getLineEndOffset(line - 1));
       int end = lineMgr.getLineEndOffset(line);

      return getText(start,end - start - 1);
    }
    finally
    {
      readUnlock();
    }
  } //}}}

  //{{{ getLineText() method
  /**
   * Returns the specified line in a <code>Segment</code>.<p>
   *
   * Using a <classname>Segment</classname> is generally more
   * efficient than using a <classname>String</classname> because it
   * results in less memory allocation and array copying.<p>
   *
   * This method is thread-safe.
   *
   * @param line The line
   * @since jEdit 4.0pre1
   */
  public void getLineText(int line, Segment segment)
  {
    if(line < 0 || line >= lineMgr.getLineCount())
      throw new ArrayIndexOutOfBoundsException(line);

    try
    {
      readLock();

      int start = (line == 0 ? 0
        : lineMgr.getLineEndOffset(line - 1));
      int end = lineMgr.getLineEndOffset(line);

      getText(start,end - start - 1,segment);
    }
    finally
    {
      readUnlock();
    }
  } //}}}

  //{{{ getText() method
  /**
   * Returns the specified text range. This method is thread-safe.
   * @param start The start offset
   * @param length The number of characters to get
   */
  public String getText(int start, int length)
  {
    try
    {
      readLock();

      if(start < 0 || length < 0
        || start + length > contentMgr.getLength())
        throw new ArrayIndexOutOfBoundsException(start + ":" + length);

      return contentMgr.getText(start,length);
    }
    finally
    {
      readUnlock();
    }
  } //}}}

  //{{{ getText() method
  /**
   * Returns the specified text range in a <code>Segment</code>.<p>
   *
   * Using a <classname>Segment</classname> is generally more
   * efficient than using a <classname>String</classname> because it
   * results in less memory allocation and array copying.<p>
   *
   * This method is thread-safe.
   *
   * @param start The start offset
   * @param length The number of characters to get
   * @param seg The segment to copy the text to
   */
  public void getText(int start, int length, Segment seg)
  {
    try
    {
      readLock();

      if(start < 0 || length < 0
        || start + length > contentMgr.getLength())
        throw new ArrayIndexOutOfBoundsException(start + ":" + length);

      contentMgr.getText(start,length,seg);
    }
    finally
    {
      readUnlock();
    }
  } //}}}

  //{{{ insert() method
  /**
   * Inserts a string into the buffer.
   * @param offset The offset
   * @param str The string
   * @since jEdit 4.0pre1
   */
  public void insert(int offset, String str)
  {
    if(str == null)
      return;

    int len = str.length();

    if(len == 0)
      return;

    if(isReadOnly())
      throw new RuntimeException("buffer read-only");

    try
    {
      writeLock();

      if(offset < 0 || offset > contentMgr.getLength())
        throw new ArrayIndexOutOfBoundsException(offset);

      contentMgr.insert(offset,str);

      integerArray.clear();

      for(int i = 0; i < len; i++)
      {
        if(str.charAt(i) == '\n')
          integerArray.add(i + 1);
      }

      if(!getFlag(UNDO_IN_PROGRESS))
      {
        undoMgr.contentInserted(offset,len,str,
          !getFlag(DIRTY));
      }

      contentInserted(offset,len,integerArray);
    }
    finally
    {
      writeUnlock();
    }
  } //}}}

  //{{{ insert() method
  /**
   * Inserts a string into the buffer.
   * @param offset The offset
   * @param seg The segment
   * @since jEdit 4.0pre1
   */
  public void insert(int offset, Segment seg)
  {
    if(seg.count == 0)
      return;

    if(isReadOnly())
      throw new RuntimeException("buffer read-only");

    try
    {
      writeLock();

      if(offset < 0 || offset > contentMgr.getLength())
        throw new ArrayIndexOutOfBoundsException(offset);

      contentMgr.insert(offset,seg);

      integerArray.clear();

      for(int i = 0; i < seg.count; i++)
      {
        if(seg.array[seg.offset + i] == '\n')
          integerArray.add(i + 1);
      }

      if(!getFlag(UNDO_IN_PROGRESS))
      {
        undoMgr.contentInserted(offset,seg.count,
          seg.toString(),!getFlag(DIRTY));
      }

      contentInserted(offset,seg.count,integerArray);
    }
    finally
    {
      writeUnlock();
    }
  } //}}}

  //{{{ remove() method
  /**
   * Removes the specified rang efrom the buffer.
   * @param offset The start offset
   * @param length The number of characters to remove
   */
  public void remove(int offset, int length)
  {
    if(length == 0)
      return;

    if(isReadOnly())
      throw new RuntimeException("buffer read-only");

    try
    {
      setFlag(TRANSACTION,true);
      writeLock();

      if(offset < 0 || length < 0
        || offset + length > contentMgr.getLength())
        throw new ArrayIndexOutOfBoundsException(offset + ":" + length);

      int startLine = lineMgr.getLineOfOffset(offset);
      int endLine = lineMgr.getLineOfOffset(offset + length);

      int numLines = endLine - startLine;

      if(!getFlag(UNDO_IN_PROGRESS) && !getFlag(LOADING))
      {
        undoMgr.contentRemoved(offset,length,
          getText(offset,length),
          !getFlag(DIRTY));
      }

      firePreContentRemoved(startLine,offset,numLines,length);

      contentMgr.remove(offset,length);
      lineMgr.contentRemoved(startLine,offset,numLines,length);
      positionMgr.contentRemoved(offset,length);

      fireContentRemoved(startLine,offset,numLines,length);

      /* otherwise it will be delivered later */
      if(!getFlag(UNDO_IN_PROGRESS) && !insideCompoundEdit())
        fireTransactionComplete();

      setDirty(true);
    }
    finally
    {
      setFlag(TRANSACTION,false);
      writeUnlock();
    }
  } //}}}

  //}}}

  //{{{ Undo

  //{{{ undo() method
  /**
   * Undoes the most recent edit.
   *
   * @since jEdit 4.0pre1
   */
  public void undo(JEditTextArea textArea)
  {
    if(undoMgr == null)
      return;

    if(!isEditable())
    {
      textArea.getToolkit().beep();
      return;
    }

    try
    {
      writeLock();

      setFlag(UNDO_IN_PROGRESS,true);
      int caret = undoMgr.undo();

      if(caret == -1)
        textArea.getToolkit().beep();
      else
        textArea.setCaretPosition(caret);

      fireTransactionComplete();
    }
    finally
    {
      setFlag(UNDO_IN_PROGRESS,false);

      writeUnlock();
    }
  } //}}}

  //{{{ redo() method
  /**
   * Redoes the most recently undone edit.
   *
   * @since jEdit 2.7pre2
   */
  public void redo(JEditTextArea textArea)
  {
    if(undoMgr == null)
      return;

    if(!isEditable())
    {
      Toolkit.getDefaultToolkit().beep();
      return;
    }

    try
    {
      writeLock();

      setFlag(UNDO_IN_PROGRESS,true);
      int caret = undoMgr.redo();
      if(caret == -1)
        textArea.getToolkit().beep();
      else
        textArea.setCaretPosition(caret);

      fireTransactionComplete();
    }
    finally
    {
      setFlag(UNDO_IN_PROGRESS,false);

      writeUnlock();
    }
  } //}}}

  //{{{ isTransactionInProgress() method
  /**
   * Returns if an undo or compound edit is currently in progress. If this
   * method returns true, then eventually a
   * {@link org.gjt.sp.jedit.buffer.BufferChangeListener#transactionComplete(Buffer)}
   * buffer event will get fired.
   * @since jEdit 4.0pre6
   */
  public boolean isTransactionInProgress()
  {
    return getFlag(TRANSACTION)
      || getFlag(UNDO_IN_PROGRESS)
      || insideCompoundEdit();
  } //}}}

  //{{{ beginCompoundEdit() method
  /**
   * Starts a compound edit. All edits from now on until
   * {@link #endCompoundEdit()} are called will be merged
   * into one. This can be used to make a complex operation
   * undoable in one step. Nested calls to
   * {@link #beginCompoundEdit()} behave as expected,
   * requiring the same number of {@link #endCompoundEdit()}
   * calls to end the edit.
   * @see #endCompoundEdit()
   */
  public void beginCompoundEdit()
  {
    // Why?
    //if(getFlag(TEMPORARY))
    //  return;

    try
    {
      writeLock();

      undoMgr.beginCompoundEdit();
    }
    finally
    {
      writeUnlock();
    }
  } //}}}

  //{{{ endCompoundEdit() method
  /**
   * Ends a compound edit. All edits performed since
   * {@link #beginCompoundEdit()} was called can now
   * be undone in one step by calling {@link #undo(JEditTextArea)}.
   * @see #beginCompoundEdit()
   */
  public void endCompoundEdit()
  {
    // Why?
    //if(getFlag(TEMPORARY))
    //  return;

    try
    {
      writeLock();

      undoMgr.endCompoundEdit();

      if(!insideCompoundEdit())
        fireTransactionComplete();
    }
    finally
    {
      writeUnlock();
    }
  }//}}}

  //{{{ insideCompoundEdit() method
  /**
   * Returns if a compound edit is currently active.
   * @since jEdit 3.1pre1
   */
  public boolean insideCompoundEdit()
  {
    return undoMgr.insideCompoundEdit();
  } //}}}

  //}}}

  //{{{ Buffer events
  public static final int NORMAL_PRIORITY = 0;
  public static final int HIGH_PRIORITY = 1;
  static class Listener
  {
    BufferChangeListener listener;
    int priority;

    Listener(BufferChangeListener listener, int priority)
    {
      this.listener = listener;
      this.priority = priority;
    }
  }

  //{{{ addBufferChangeListener() method
  /**
   * Adds a buffer change listener.
   * @param listener The listener
   * @param priority Listeners with HIGH_PRIORITY get the event before
   * listeners with NORMAL_PRIORITY
   * @since jEdit 4.2pre2
   */
  public void addBufferChangeListener(BufferChangeListener listener,
    int priority)
  {
    Listener l = new Listener(listener,priority);
    for(int i = 0; i < bufferListeners.size(); i++)
    {
      Listener _l = (Listener)bufferListeners.get(i);
      if(_l.priority < priority)
      {
        bufferListeners.insertElementAt(l,i);
        return;
      }
    }
    bufferListeners.addElement(l);
  } //}}}

  //{{{ addBufferChangeListener() method
  /**
   * Adds a buffer change listener.
   * @param listener The listener
   * @since jEdit 4.0pre1
   */
  public void addBufferChangeListener(BufferChangeListener listener)
  {
    addBufferChangeListener(listener,NORMAL_PRIORITY);
  } //}}}

  //{{{ removeBufferChangeListener() method
  /**
   * Removes a buffer change listener.
   * @param listener The listener
   * @since jEdit 4.0pre1
   */
  public void removeBufferChangeListener(BufferChangeListener listener)
  {
    for(int i = 0; i < bufferListeners.size(); i++)
    {
      if(((Listener)bufferListeners.get(i)).listener == listener)
      {
        bufferListeners.removeElementAt(i);
        return;
      }
    }
  } //}}}

  //{{{ getBufferChangeListeners() method
  /**
   * Returns an array of registered buffer change listeners.
   * @param listener The listener
   * @since jEdit 4.1pre3
   */
  public BufferChangeListener[] getBufferChangeListeners()
  {
    BufferChangeListener[] returnValue
      = new BufferChangeListener[
      bufferListeners.size()];
    for(int i = 0; i < returnValue.length; i++)
    {
      returnValue[i] = ((Listener)bufferListeners.get(i))
        .listener;
    }
    return returnValue;
  } //}}}

  //}}}

  //{{{ Property methods

  //{{{ propertiesChanged() method
  /**
   * Reloads settings from the properties. This should be called
   * after the <code>syntax</code> or <code>folding</code>
   * buffer-local properties are changed.
   */
  public void propertiesChanged()
  {
    String folding = getStringProperty("folding");
    FoldHandler handler = FoldHandler.getFoldHandler(folding);

    if(handler != null)
    {
      setFoldHandler(handler);
    }
    else
    {
      if (folding != null)
        Log.log(Log.WARNING, this, path + ": invalid 'folding' property: " + folding); 
      setFoldHandler(new DummyFoldHandler());
    }

    EditBus.send(new BufferUpdate(this,null,BufferUpdate.PROPERTIES_CHANGED));
  } //}}}

  //{{{ getTabSize() method
  /**
   * Returns the tab size used in this buffer. This is equivalent
   * to calling <code>getProperty("tabSize")</code>.
   * This method is thread-safe.
   */
  public int getTabSize()
  {
    return getIntegerProperty("tabSize",8);
  } //}}}

  //{{{ getIndentSize() method
  /**
   * Returns the indent size used in this buffer. This is equivalent
   * to calling <code>getProperty("indentSize")</code>.
   * This method is thread-safe.
   * @since jEdit 2.7pre1
   */
  public int getIndentSize()
  {
    return getIntegerProperty("indentSize",8);
  } //}}}

  //{{{ getProperty() method
  /**
   * Returns the value of a buffer-local property.<p>
   *
   * Using this method is generally discouraged, because it returns an
   * <code>Object</code> which must be cast to another type
   * in order to be useful, and this can cause problems if the object
   * is of a different type than what the caller expects.<p>
   *
   * The following methods should be used instead:
   * <ul>
   * <li>{@link #getStringProperty(String)}</li>
   * <li>{@link #getBooleanProperty(String)}</li>
   * <li>{@link #getIntegerProperty(String,int)}</li>
   * <li>{@link #getRegexpProperty(String,int,gnu.regexp.RESyntax)}</li>
   * </ul>
   *
   * This method is thread-safe.
   *
   * @param name The property name. For backwards compatibility, this
   * is an <code>Object</code>, not a <code>String</code>.
   */
  public Object getProperty(Object name)
  {
    synchronized(propertyLock)
    {
      // First try the buffer-local properties
      PropValue o = (PropValue)properties.get(name);
      if(o != null)
        return o.value;

      // For backwards compatibility
      if(!(name instanceof String))
        return null;

      // Now try mode.<mode>.<property>
      if(mode != null)
      {
        Object retVal = mode.getProperty((String)name);
        if(retVal == null)
          return null;

        properties.put(name,new PropValue(retVal,true));
        return retVal;
      }
      else
      {
        // Now try buffer.<property>
        String value = jEdit.getProperty("buffer." + name);
        if(value == null)
          return null;

        // Try returning it as an integer first
        Object retVal;
        try
        {
          retVal = new Integer(value);
        }
        catch(NumberFormatException nf)
        {
          retVal = value;
        }
        properties.put(name,new PropValue(retVal,true));
        return retVal;
      }
    }
  } //}}}

  //{{{ setProperty() method
  /**
   * Sets the value of a buffer-local property.
   * @param name The property name
   * @param value The property value
   * @since jEdit 4.0pre1
   */
  public void setProperty(String name, Object value)
  {
    if(value == null)
      properties.remove(name);
    else
    {
      PropValue test = (PropValue)properties.get(name);
      if(test == null)
        properties.put(name,new PropValue(value,false));
      else if(test.value.equals(value))
      {
        // do nothing
      }
      else
      {
        test.value = value;
        test.defaultValue = false;
      }
    }
  } //}}}

  //{{{ unsetProperty() method
  /**
   * Clears the value of a buffer-local property.
   * @param name The property name
   * @since jEdit 4.0pre1
   */
  public void unsetProperty(String name)
  {
    properties.remove(name);
  } //}}}

  //{{{ getStringProperty() method
  /**
   * Returns the value of a string property. This method is thread-safe.
   * @param name The property name
   * @since jEdit 4.0pre1
   */
  public String getStringProperty(String name)
  {
    Object obj = getProperty(name);
    if(obj != null)