| /* |
| * (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.io.Externalizable; |
| import java.io.ObjectInput; |
| import java.io.ObjectOutput; |
| import java.io.IOException; |
| |
| /** |
| * TabStop represents a position on a tab ruler. Each tab stop has a |
| * position, giving its location on the ruler, and one of several |
| * types. The type determines how a segment controled by this TabStop |
| * is positioned on a line: |
| * <ul> |
| * <li><code>kLeading</code> - the leading edge of the segment is aligned to |
| * the TabStop's position</li> |
| * <li><code>kCenter</code> - the segment is centered on this TabStop's |
| * position</li> |
| * <li><code>kTrailing</code> - the trailing edge of the segment is aligned to |
| * the TabStop's position</li> |
| * <li><code>kDecimal</code> - the first decimal in the segment is aligned to |
| * the TabStop's position</li> |
| * <li><code>kAuto</code> - semantically the same as <code>kLeading</code>. |
| * Used by tab rulers to indicate that all subsequent tab stops |
| * will be at autospaced intervals.</li> |
| * </ul> |
| * @see MTabRuler |
| */ |
| public final class TabStop 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 byte fType; // left, center, right, decimal |
| private int fPosition; // tab stop position from line origin. |
| |
| /** |
| * A TabStop with this type aligns its segment's leading edge |
| * to the TabStop's position. |
| */ |
| public static final byte kLeading = 0; |
| |
| /** |
| * A TabStop with this type aligns its segment's center |
| * to the TabStop's position. |
| */ |
| public static final byte kCenter = 1; |
| |
| /** |
| * A TabStop with this type aligns its segment's trailing edge |
| * to the TabStop's position. |
| */ |
| public static final byte kTrailing = 2; |
| |
| /** |
| * A TabStop with this type aligns its segment's first decimal |
| * to the TabStop's position. |
| */ |
| public static final byte kDecimal = 3; |
| |
| /** |
| * A TabStop with this type aligns its segment's leading edge |
| * to the TabStop's position. After a TabStop of this type, |
| * all tabs are at autospace intervals. Usually, clients will |
| * not construct TabStops with this type. |
| */ |
| public static final byte kAuto = 4; |
| |
| /** |
| * Create a TabStop with position 0 and type <code>kLeading</code>. |
| */ |
| public TabStop() { |
| |
| this(0, kLeading); |
| } |
| |
| /** |
| * Create a TabStop with the given position and type. |
| * @param position the TabStop's position |
| * @param type the TabStop's type. Must be one of constants |
| * in this class. |
| */ |
| public TabStop(int position, byte type) { |
| |
| if (type < kLeading || type > kAuto) { |
| throw new IllegalArgumentException("Invalid tab type"); |
| } |
| |
| fPosition = position; |
| fType = type; |
| } |
| |
| public void readExternal(ObjectInput in) throws IOException, |
| ClassNotFoundException { |
| |
| int version = in.readInt(); |
| if (version != CURRENT_VERSION) { |
| throw new IOException("Invalid version of TabStop."); |
| } |
| fPosition = in.readInt(); |
| fType = in.readByte(); |
| } |
| |
| public void writeExternal(ObjectOutput out) throws IOException { |
| |
| out.writeInt(CURRENT_VERSION); |
| out.writeInt(fPosition); |
| out.writeByte(fType); |
| } |
| |
| /** |
| * Compare this to another Object. TabStops are equal if |
| * their position and type are the same. |
| */ |
| public boolean equals(Object rhs) |
| { |
| if (rhs == null) { |
| return false; |
| } |
| |
| TabStop rhsTab; |
| try { |
| rhsTab = (TabStop) rhs; |
| } |
| catch(ClassCastException e) { |
| return false; |
| } |
| |
| return fType == rhsTab.fType && fPosition == rhsTab.fPosition; |
| } |
| |
| /** |
| * Return the hash code for this TabStop. The hash code is |
| * <code>position << type</code>. |
| */ |
| public int hashCode() { |
| |
| return fPosition << fType; |
| } |
| |
| public String toString() |
| { |
| char typeChar; |
| switch (fType) { |
| case kLeading: typeChar = 'L'; break; |
| case kCenter: typeChar = 'C'; break; |
| case kTrailing: typeChar = 'R'; break; |
| case kDecimal: typeChar = 'D'; break; |
| case kAuto: typeChar = 'A'; break; |
| default: typeChar = '?'; break; |
| } |
| return "TabStop[" + Integer.toString(fPosition) + typeChar + ']'; |
| } |
| |
| /** |
| * Return the type of this TabStop. Will be one of the constants |
| * in this class. |
| */ |
| public byte getType() { |
| return fType; |
| } |
| |
| /** |
| * Return the position of this TabStop. |
| */ |
| public int getPosition() { |
| return fPosition; |
| } |
| } |
| |