javax.swing.text

Class GapContent

Contents
  • All Implemented Interfaces:
    Serializable, AbstractDocument.Content

    public class GapContent
extends Object
implements AbstractDocument.Content, Serializable
    An implementation of the AbstractDocument.Content interface implemented using a gapped buffer similar to that used by emacs. The underlying storage is a array of unicode characters with a gap somewhere. The gap is moved to the location of changes to take advantage of common behavior where most changes are in the same location. Changes that occur at a gap boundary are generally cheap and moving the gap is generally cheaper than moving the array contents directly to accomodate the change.

    The positions tracking change are also generally cheap to maintain. The Position implementations (marks) store the array index and can easily calculate the sequential position from the current gap location. Changes only require update to the the marks between the old and new gap boundaries when the gap is moved, so generally updating the marks is pretty cheap. The marks are stored sorted so they can be located quickly with a binary search. This increases the cost of adding a mark, and decreases the cost of keeping the mark updated.

    • Constructor Detail

      • GapContent

        public GapContent()
        Creates a new GapContent object. Initial size defaults to 10.

      • GapContent

        public GapContent(int initialLength)
        Creates a new GapContent object, with the initial size specified. The initial size will not be allowed to go below 2, to give room for the implied break and the gap.
        Parameters:
        initialLength - the initial size

    • Method Detail

      • allocateArray

        protected Object allocateArray(int len)
        Allocate an array to store items of the type appropriate (which is determined by the subclass).

      • getArrayLength

        protected int getArrayLength()
        Get the length of the allocated array.

      • shiftEnd

        protected void shiftEnd(int newSize)
        Make the gap bigger, moving any necessary data and updating the appropriate marks

      • shiftGap

        protected void shiftGap(int newGapStart)
        Move the start of the gap to a new location, without changing the size of the gap. This moves the data in the array and updates the marks accordingly.

      • resetMarksAtZero

        protected void resetMarksAtZero()
        Resets all the marks that have an offset of 0 to have an index of zero as well.

      • shiftGapStartDown

        protected void shiftGapStartDown(int newGapStart)
        Adjust the gap end downward. This doesn't move any data, but it does update any marks affected by the boundary change. All marks from the old gap start down to the new gap start are squeezed to the end of the gap (their location has been removed).

      • shiftGapEndUp

        protected void shiftGapEndUp(int newGapEnd)
        Adjust the gap end upward. This doesn't move any data, but it does update any marks affected by the boundary change. All marks from the old gap end up to the new gap end are squeezed to the end of the gap (their location has been removed).

      • getPositionsInRange

        protected Vector getPositionsInRange(Vector v,
                         int offset,
                         int length)
        Returns a Vector containing instances of UndoPosRef for the Positions in the range offset to offset + length. If v is not null the matching Positions are placed in there. The vector with the resulting Positions are returned.
        Parameters:
        v - the Vector to use, with a new one created on null
        offset - the starting offset >= 0
        length - the length >= 0
        Returns:
        the set of instances

      • updateUndoPositions

        protected void updateUndoPositions(Vector positions,
                       int offset,
                       int length)
        Resets the location for all the UndoPosRef instances in positions.

        This is meant for internal usage, and is generally not of interest to subclasses.

        Parameters:
        positions - the UndoPosRef instances to reset

      • getArray

        protected final Object getArray()
        Access to the array. The actual type of the array is known only by the subclass.

      • getGapStart

        protected final int getGapStart()
        Access to the start of the gap.

      • getGapEnd

        protected final int getGapEnd()
        Access to the end of the gap.

      • replace

        protected void replace(int position,
           int rmSize,
           Object addItems,
           int addSize)
        Replace the given logical position in the storage with the given new items. This will move the gap to the area being changed if the gap is not currently located at the change location.
        Parameters:
        position - the location to make the replacement. This is not the location in the underlying storage array, but the location in the contiguous space being modeled.
        rmSize - the number of items to remove
        addItems - the new items to place in storage.

Document created the 11/06/2005, last modified the 04/03/2020
Source of the printed document:https://www.gaudry.be/en/java-api-rf-javax/swing/text/GapContent.html

The infobrol is a personal site whose content is my sole responsibility. The text is available under CreativeCommons license (BY-NC-SA). More info on the terms of use and the author.

References

  1. View the html document Language of the document:fr Manuel PHP : https://docs.oracle.com

These references and links indicate documents consulted during the writing of this page, or which may provide additional information, but the authors of these sources can not be held responsible for the content of this page.
The author This site is solely responsible for the way in which the various concepts, and the freedoms that are taken with the reference works, are presented here. Remember that you must cross multiple source information to reduce the risk of errors.

Contents Haut