src/com/ibm/richtext/styledtext/StandardTabRuler.java - external/github.com/unicode-org/icu - Git at Google

 /*
  * (C) Copyright IBM Corp. 1998-2004.  All Rights Reserved.
  *
  * The program is provided "as is" without any warranty express or
  * implied, including the warranty of non-infringement and the implied
  * warranties of merchantibility and fitness for a particular purpose.
  * IBM will not be liable for any damages suffered by you as a result
  * of using the Program. In no event will IBM be liable for any
  * special, indirect or consequential damages or lost profits even if
  * IBM has been advised of the possibility of their occurrence. IBM
  * will not be liable for any third party claims against you.
  */
 package com.ibm.richtext.styledtext;

 import java.util.Vector;

 import java.io.Externalizable;
 import java.io.ObjectInput;
 import java.io.ObjectOutput;
 import java.io.IOException;

 /**
  * This class is a standard implementation of MTabRuler.
  * It can have a finite number of client-specified TabStops.  After
  * the client-specified TabStops, all TabStops have type
  * <code>TabStop.kAuto</code> and are at the autospace intervals.
  * @see TabStop
  */
 public final class StandardTabRuler extends MTabRuler
                                     implements Externalizable
 {
     static final String COPYRIGHT =
                 "(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved";
     private static final int CURRENT_VERSION = 1;
     private static final long serialVersionUID = 22356934;

     private static final TabStop AUTO_ZERO = new TabStop(0, TabStop.kAuto);

     private TabStop[] fTabs = null;
     private int fAutoSpacing = 36; // every 1/2 inch.

     /**
      * Create a StandardTabRuler with only auto tabs, with spacing of 36.
      */
     public StandardTabRuler()
     {
     }

     /**
      * Create a StandardTabRuler with only auto tabs, with the
      * given autoSpacing.
      * @param autoSpacing the autoSpacing for this tab ruler
      */
     public StandardTabRuler(int autoSpacing)
     {
         fAutoSpacing = autoSpacing;
     }

     /**
      * Create a StandardTabRuler.  The first TabStops on the ruler will be
      * the TabStops in the <code>tabs</code> array.  After these tabs all
      * tabs are auto tabs.
      * @param tabs an array of TabStops.  The TabStops in the array must
      *    be in strictly increasing order (of positions), and cannot have
      *    type <code>TabStop.kAuto</code>.
      * @param autoSpacing the autoSpacing interval to use after the last
      *    client-specified tab.
      */
     public StandardTabRuler(TabStop[] tabs, int autoSpacing)
     {
         if (tabs.length > 0) {
             validateTabArray(tabs);
             fTabs = (TabStop[]) tabs.clone();
         }
         else {
             fTabs = null;
         }
         fAutoSpacing = autoSpacing;
     }

     /** Tabs as provided, then autoSpacing after the last tab to eternity.  Use this constructor when
         munging a ruler, it does no validation on the tabs in the vector. Vector may not be null. */

     /*public*/ StandardTabRuler(Vector v, int autoSpacing)
     {
         fTabs = tabArrayFromVector(v);
         fAutoSpacing = autoSpacing;
     }

     /** Construct from another ruler. No validation. Ruler may not be null. */

     /*public*/ StandardTabRuler(MTabRuler ruler)
     {
         if (ruler == null) {
             throw new IllegalArgumentException("ruler may not be null");
         }

         fTabs = tabArrayFromVector(vectorFromTabRuler(ruler));
         fAutoSpacing = ruler.autoSpacing();
     }

     public void readExternal(ObjectInput in) throws IOException,
                                             ClassNotFoundException {

         int version = in.readInt();
         if (version != CURRENT_VERSION) {
             throw new IOException("Invalid version of StyledText: " + version);
         }
         fTabs = (TabStop[]) in.readObject();
         fAutoSpacing = in.readInt();
     }

     public void writeExternal(ObjectOutput out) throws IOException {

         out.writeInt(CURRENT_VERSION);
         out.writeObject(fTabs);
         out.writeInt(fAutoSpacing);
     }

     /**
      * Return first tab in the ruler.  If an autoTab, it is at position zero, and
      * all subsequent tabs will be autotabs at autoSpacing intervals.
      */
     public TabStop firstTab()
     {
         if (fTabs != null && fTabs.length > 0) {
             return fTabs[0];
         }

         return AUTO_ZERO;
     }

     /**
      * Return the first tab in the ruler with fPosition > position.  If it is an
      * autotab, it is at an increment of autoSpacing, and all subsequent tabs will be
      * autotabs at autoSpacing intervals.
      * @param position the position of the TabStop returned will be greater than this parameter
      */
     public TabStop nextTab(int position)
     {
         if (fTabs != null) {
             for (int i = 0; i < fTabs.length; ++i) {
                 if (position < fTabs[i].getPosition())
                     return fTabs[i];
             }
         }

         if (position >= 4000) { // debug: sanity check
             System.out.println("auto tab past 4000");
         }

         return new TabStop(((position / fAutoSpacing) + 1) * fAutoSpacing, TabStop.kAuto);
     }

     /**
      * Return the interval for autotabs.
      */
     public int autoSpacing()
     {
         return fAutoSpacing;
     }

     /**
      * Compare this to another Object. Returns true if the object
      * is an MTabRuler with the same autoSpacing and tabs.
      */
     public boolean equals(Object o)
     {
         if (o == this) {
             return true;
         }
         else if (o == null) {
             return false;
         }

         MTabRuler rhs;
         try {
             rhs = (MTabRuler)o;
         }
         catch(ClassCastException e) {
             return false;
         }

         if (fAutoSpacing != rhs.autoSpacing())
             return false;

         TabStop rhsTab = rhs.firstTab();

         if (fTabs != null) {
             for (int i = 0; i < fTabs.length; ++i) {
                 if (!fTabs[i].equals(rhsTab))
                     return false;

                 rhsTab = rhs.nextTab(rhsTab.getPosition());
             }
         }

         return rhsTab.getType() == TabStop.kAuto;
     }

     /**
      * Return debug information about this tab ruler.
      */
     public String toString()
     {
         StringBuffer buffer = new StringBuffer(super.toString());
         buffer.append(" auto: ");
         buffer.append(Integer.toString(fAutoSpacing));

         if (fTabs != null) {
             for (int i = 0; i < fTabs.length; ++i) {
                 buffer.append(fTabs[i].toString());
             }
         }

         return buffer.toString();
     }

     /** Utility to convert a vector of tabs to an array. */

     private static TabStop[] tabArrayFromVector(Vector v)
     {
         int count = v.size();
         TabStop[] tabs = new TabStop[count];
         for (int i = 0; i < count; ++i) {
             tabs[i] = (TabStop)v.elementAt(i);
         }

         return tabs;
     }

     /** Utility to convert a ruler to a vector of tabs, for munging. */

     private static Vector vectorFromTabRuler(MTabRuler ruler)
     {
         Vector v = new Vector();
         for (TabStop tab = ruler.firstTab(); tab != null && tab.getType() != TabStop.kAuto; tab = ruler.nextTab(tab.getPosition())) {
             v.addElement(tab);
         }

         return v;
     }

     /** Utility to validate an array of tabs.  The array must not be null, must not contain null
         entries, must not be kAuto, and positions must in increasing order. */

     private static void validateTabArray(TabStop[] tabs)
     {
         int pos = Integer.MIN_VALUE;
         for (int i = 0; i < tabs.length; ++i) {
             if (tabs[i].getType() == TabStop.kAuto) {
                 throw new IllegalArgumentException("can't explicitly specify an auto tab.");
             }
             int nextpos = tabs[i].getPosition();
             if (nextpos <= pos) {
                 throw new IllegalArgumentException("tab positions must be in increasing order.");
             }
             pos = nextpos;
         }
     }

     /**
      * Return a tab ruler identical to the given ruler, except with the
      * given tab added.
      * @param ruler the original ruler.  The MTabRuler will be the same as
      *   this except for the additional tab.  <code>ruler</code> is not modified.
      * @param tabToAdd the tab to add to the new tab ruler
      * @return an MTabRuler resulting from this operation
      */
     /*public*/ static MTabRuler addTabToRuler(MTabRuler ruler, TabStop tabToAdd)
     {
         if (ruler == null || tabToAdd == null)
             throw new IllegalArgumentException("ruler and tabToAdd may not be null");

         Vector vector = new Vector();

         int pos = 0;
         boolean added = false;
         for (TabStop tab = ruler.firstTab(); tab.getType() != TabStop.kAuto; tab = ruler.nextTab(pos)) {
             pos = tab.getPosition();

             if (!added && pos >= tabToAdd.getPosition()) {
                 if (pos == tabToAdd.getPosition())
                     tab = null;
                 vector.addElement(tabToAdd);
                 added = true;
             }

             if (tab != null)
                 vector.addElement(tab);
         }
         if (!added)
             vector.addElement(tabToAdd);

         return new StandardTabRuler(vector, ruler.autoSpacing());
     }

     /**
      * Return a tab ruler identical to the given ruler, except with the
      * given tab removed.
      * @param ruler the original ruler.  The MTabRuler will be the same as
      *   this except for the removed tab.  <code>ruler</code> is not modified.
      * @param position the position of the tab to remove from the new tab ruler
      * @return an MTabRuler resulting from this operation
      */
     /*public*/ static MTabRuler removeTabFromRuler(MTabRuler ruler, int position)
     {
         if (ruler == null)
             throw new IllegalArgumentException("ruler may not be null");

         Vector vector = new Vector();

         int pos = 0;
         boolean removed = false;
         for (TabStop tab = ruler.firstTab(); tab.getType() != TabStop.kAuto; tab = ruler.nextTab(pos)) {
             pos = tab.getPosition();

             if (!removed && pos >= position) {
                 if (pos == position) {
                     removed = true;
                     continue; // skip this tab and continue with the remainder
                 }
                 break; // we didn't remove a tab, but skipped position, so don't bother with the rest
             }

             vector.addElement(tab);
         }
         if (!removed) // no change
             return ruler;

         if (vector.size() == 0)
             return new StandardTabRuler(ruler.autoSpacing());

         return new StandardTabRuler(vector, ruler.autoSpacing());
     }

     /**
      * Return a tab ruler identical to the given ruler, except with the
      * tab at position <code>fromPosition</code> moved to position
      * <code>toPosition</code>.
      * @param ruler the original ruler.  The MTabRuler will be the same as
      *   this except for the moved tab.  <code>ruler</code> is not modified.
      * @param fromPosition the position of the tab to move
      * @param toPosition the new position of the tab
      * @return an MTabRuler resulting from this operation
      */
     /*public*/ static MTabRuler moveTabOnRuler(MTabRuler ruler, int fromPosition, int toPosition)
     {
         if (ruler == null)
             throw new IllegalArgumentException("ruler may not be null");

         Vector vector = new Vector();

         int pos = 0;
         boolean moved = false;
         for (TabStop tab = ruler.firstTab(); tab.getType() != TabStop.kAuto; tab = ruler.nextTab(pos)) {
             pos = tab.getPosition();

             if (!moved && pos == fromPosition) {
                 moved = true;
                 tab = new TabStop(toPosition, tab.getType()); // copy it
             }

             vector.addElement(tab);
         }
         if (!moved) // no change
             return ruler;

         return new StandardTabRuler(vector, ruler.autoSpacing());
     }

 }
	/*
	* (C) Copyright IBM Corp. 1998-2004. All Rights Reserved.
	*
	* The program is provided "as is" without any warranty express or
	* implied, including the warranty of non-infringement and the implied
	* warranties of merchantibility and fitness for a particular purpose.
	* IBM will not be liable for any damages suffered by you as a result
	* of using the Program. In no event will IBM be liable for any
	* special, indirect or consequential damages or lost profits even if
	* IBM has been advised of the possibility of their occurrence. IBM
	* will not be liable for any third party claims against you.
	*/
	package com.ibm.richtext.styledtext;

	import java.util.Vector;

	import java.io.Externalizable;
	import java.io.ObjectInput;
	import java.io.ObjectOutput;
	import java.io.IOException;

	/**
	* This class is a standard implementation of MTabRuler.
	* It can have a finite number of client-specified TabStops. After
	* the client-specified TabStops, all TabStops have type
	* <code>TabStop.kAuto</code> and are at the autospace intervals.
	* @see TabStop
	*/
	public final class StandardTabRuler extends MTabRuler
	implements Externalizable
	{
	static final String COPYRIGHT =
	"(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved";
	private static final int CURRENT_VERSION = 1;
	private static final long serialVersionUID = 22356934;

	private static final TabStop AUTO_ZERO = new TabStop(0, TabStop.kAuto);

	private TabStop[] fTabs = null;
	private int fAutoSpacing = 36; // every 1/2 inch.

	/**
	* Create a StandardTabRuler with only auto tabs, with spacing of 36.
	*/
	public StandardTabRuler()
	{
	}

	/**
	* Create a StandardTabRuler with only auto tabs, with the
	* given autoSpacing.
	* @param autoSpacing the autoSpacing for this tab ruler
	*/
	public StandardTabRuler(int autoSpacing)
	{
	fAutoSpacing = autoSpacing;
	}

	/**
	* Create a StandardTabRuler. The first TabStops on the ruler will be
	* the TabStops in the <code>tabs</code> array. After these tabs all
	* tabs are auto tabs.
	* @param tabs an array of TabStops. The TabStops in the array must
	* be in strictly increasing order (of positions), and cannot have
	* type <code>TabStop.kAuto</code>.
	* @param autoSpacing the autoSpacing interval to use after the last
	* client-specified tab.
	*/
	public StandardTabRuler(TabStop[] tabs, int autoSpacing)
	{
	if (tabs.length > 0) {
	validateTabArray(tabs);
	fTabs = (TabStop[]) tabs.clone();
	}
	else {
	fTabs = null;
	}
	fAutoSpacing = autoSpacing;
	}

	/** Tabs as provided, then autoSpacing after the last tab to eternity. Use this constructor when
	munging a ruler, it does no validation on the tabs in the vector. Vector may not be null. */

	/public/ StandardTabRuler(Vector v, int autoSpacing)
	{
	fTabs = tabArrayFromVector(v);
	fAutoSpacing = autoSpacing;
	}

	/** Construct from another ruler. No validation. Ruler may not be null. */

	/public/ StandardTabRuler(MTabRuler ruler)
	{
	if (ruler == null) {
	throw new IllegalArgumentException("ruler may not be null");
	}

	fTabs = tabArrayFromVector(vectorFromTabRuler(ruler));
	fAutoSpacing = ruler.autoSpacing();
	}

	public void readExternal(ObjectInput in) throws IOException,
	ClassNotFoundException {

	int version = in.readInt();
	if (version != CURRENT_VERSION) {
	throw new IOException("Invalid version of StyledText: " + version);
	}
	fTabs = (TabStop[]) in.readObject();
	fAutoSpacing = in.readInt();
	}

	public void writeExternal(ObjectOutput out) throws IOException {

	out.writeInt(CURRENT_VERSION);
	out.writeObject(fTabs);
	out.writeInt(fAutoSpacing);
	}

	/**
	* Return first tab in the ruler. If an autoTab, it is at position zero, and
	* all subsequent tabs will be autotabs at autoSpacing intervals.
	*/
	public TabStop firstTab()
	{
	if (fTabs != null && fTabs.length > 0) {
	return fTabs[0];
	}

	return AUTO_ZERO;
	}

	/**
	* Return the first tab in the ruler with fPosition > position. If it is an
	* autotab, it is at an increment of autoSpacing, and all subsequent tabs will be
	* autotabs at autoSpacing intervals.
	* @param position the position of the TabStop returned will be greater than this parameter
	*/
	public TabStop nextTab(int position)
	{
	if (fTabs != null) {
	for (int i = 0; i < fTabs.length; ++i) {
	if (position < fTabs[i].getPosition())
	return fTabs[i];
	}
	}

	if (position >= 4000) { // debug: sanity check
	System.out.println("auto tab past 4000");
	}

	return new TabStop(((position / fAutoSpacing) + 1) * fAutoSpacing, TabStop.kAuto);
	}

	/**
	* Return the interval for autotabs.
	*/
	public int autoSpacing()
	{
	return fAutoSpacing;
	}

	/**
	* Compare this to another Object. Returns true if the object
	* is an MTabRuler with the same autoSpacing and tabs.
	*/
	public boolean equals(Object o)
	{
	if (o == this) {
	return true;
	}
	else if (o == null) {
	return false;
	}

	MTabRuler rhs;
	try {
	rhs = (MTabRuler)o;
	}
	catch(ClassCastException e) {
	return false;
	}

	if (fAutoSpacing != rhs.autoSpacing())
	return false;

	TabStop rhsTab = rhs.firstTab();

	if (fTabs != null) {
	for (int i = 0; i < fTabs.length; ++i) {
	if (!fTabs[i].equals(rhsTab))
	return false;

	rhsTab = rhs.nextTab(rhsTab.getPosition());
	}
	}

	return rhsTab.getType() == TabStop.kAuto;
	}

	/**
	* Return debug information about this tab ruler.
	*/
	public String toString()
	{
	StringBuffer buffer = new StringBuffer(super.toString());
	buffer.append(" auto: ");
	buffer.append(Integer.toString(fAutoSpacing));

	if (fTabs != null) {
	for (int i = 0; i < fTabs.length; ++i) {
	buffer.append(fTabs[i].toString());
	}
	}

	return buffer.toString();
	}

	/** Utility to convert a vector of tabs to an array. */

	private static TabStop[] tabArrayFromVector(Vector v)
	{
	int count = v.size();
	TabStop[] tabs = new TabStop[count];
	for (int i = 0; i < count; ++i) {
	tabs[i] = (TabStop)v.elementAt(i);
	}

	return tabs;
	}

	/** Utility to convert a ruler to a vector of tabs, for munging. */

	private static Vector vectorFromTabRuler(MTabRuler ruler)
	{
	Vector v = new Vector();
	for (TabStop tab = ruler.firstTab(); tab != null && tab.getType() != TabStop.kAuto; tab = ruler.nextTab(tab.getPosition())) {
	v.addElement(tab);
	}

	return v;
	}

	/** Utility to validate an array of tabs. The array must not be null, must not contain null
	entries, must not be kAuto, and positions must in increasing order. */

	private static void validateTabArray(TabStop[] tabs)
	{
	int pos = Integer.MIN_VALUE;
	for (int i = 0; i < tabs.length; ++i) {
	if (tabs[i].getType() == TabStop.kAuto) {
	throw new IllegalArgumentException("can't explicitly specify an auto tab.");
	}
	int nextpos = tabs[i].getPosition();
	if (nextpos <= pos) {
	throw new IllegalArgumentException("tab positions must be in increasing order.");
	}
	pos = nextpos;
	}
	}

	/**
	* Return a tab ruler identical to the given ruler, except with the
	* given tab added.
	* @param ruler the original ruler. The MTabRuler will be the same as
	* this except for the additional tab. <code>ruler</code> is not modified.
	* @param tabToAdd the tab to add to the new tab ruler
	* @return an MTabRuler resulting from this operation
	*/
	/public/ static MTabRuler addTabToRuler(MTabRuler ruler, TabStop tabToAdd)
	{
	if (ruler == null \|\| tabToAdd == null)
	throw new IllegalArgumentException("ruler and tabToAdd may not be null");

	Vector vector = new Vector();

	int pos = 0;
	boolean added = false;
	for (TabStop tab = ruler.firstTab(); tab.getType() != TabStop.kAuto; tab = ruler.nextTab(pos)) {
	pos = tab.getPosition();

	if (!added && pos >= tabToAdd.getPosition()) {
	if (pos == tabToAdd.getPosition())
	tab = null;
	vector.addElement(tabToAdd);
	added = true;
	}

	if (tab != null)
	vector.addElement(tab);
	}
	if (!added)
	vector.addElement(tabToAdd);

	return new StandardTabRuler(vector, ruler.autoSpacing());
	}

	/**
	* Return a tab ruler identical to the given ruler, except with the
	* given tab removed.
	* @param ruler the original ruler. The MTabRuler will be the same as
	* this except for the removed tab. <code>ruler</code> is not modified.
	* @param position the position of the tab to remove from the new tab ruler
	* @return an MTabRuler resulting from this operation
	*/
	/public/ static MTabRuler removeTabFromRuler(MTabRuler ruler, int position)
	{
	if (ruler == null)
	throw new IllegalArgumentException("ruler may not be null");

	Vector vector = new Vector();

	int pos = 0;
	boolean removed = false;
	for (TabStop tab = ruler.firstTab(); tab.getType() != TabStop.kAuto; tab = ruler.nextTab(pos)) {
	pos = tab.getPosition();

	if (!removed && pos >= position) {
	if (pos == position) {
	removed = true;
	continue; // skip this tab and continue with the remainder
	}
	break; // we didn't remove a tab, but skipped position, so don't bother with the rest
	}

	vector.addElement(tab);
	}
	if (!removed) // no change
	return ruler;

	if (vector.size() == 0)
	return new StandardTabRuler(ruler.autoSpacing());

	return new StandardTabRuler(vector, ruler.autoSpacing());
	}

	/**
	* Return a tab ruler identical to the given ruler, except with the
	* tab at position <code>fromPosition</code> moved to position
	* <code>toPosition</code>.
	* @param ruler the original ruler. The MTabRuler will be the same as
	* this except for the moved tab. <code>ruler</code> is not modified.
	* @param fromPosition the position of the tab to move
	* @param toPosition the new position of the tab
	* @return an MTabRuler resulting from this operation
	*/
	/public/ static MTabRuler moveTabOnRuler(MTabRuler ruler, int fromPosition, int toPosition)
	{
	if (ruler == null)
	throw new IllegalArgumentException("ruler may not be null");

	Vector vector = new Vector();

	int pos = 0;
	boolean moved = false;
	for (TabStop tab = ruler.firstTab(); tab.getType() != TabStop.kAuto; tab = ruler.nextTab(pos)) {
	pos = tab.getPosition();

	if (!moved && pos == fromPosition) {
	moved = true;
	tab = new TabStop(toPosition, tab.getType()); // copy it
	}

	vector.addElement(tab);
	}
	if (!moved) // no change
	return ruler;

	return new StandardTabRuler(vector, ruler.autoSpacing());
	}

	}