| // RAP [rh] package org.eclipse.ui.keys disabled |
| ///******************************************************************************* |
| // * Copyright (c) 2000, 2006 IBM Corporation and others. |
| // * All rights reserved. This program and the accompanying materials |
| // * are made available under the terms of the Eclipse Public License v1.0 |
| // * which accompanies this distribution, and is available at |
| // * http://www.eclipse.org/legal/epl-v10.html |
| // * |
| // * Contributors: |
| // * IBM Corporation - initial API and implementation |
| // *******************************************************************************/ |
| // |
| //package org.eclipse.ui.keys; |
| // |
| //import java.util.ArrayList; |
| //import java.util.Arrays; |
| //import java.util.Collections; |
| //import java.util.List; |
| //import java.util.StringTokenizer; |
| // |
| //import org.eclipse.ui.internal.util.Util; |
| // |
| ///** |
| // * <p> |
| // * A <code>KeySequence</code> is defined as a list of zero or more |
| // * <code>KeyStrokes</code>, with the stipulation that all |
| // * <code>KeyStroke</code> objects must be complete, save for the last one, |
| // * whose completeness is optional. A <code>KeySequence</code> is said to be |
| // * complete if all of its <code>KeyStroke</code> objects are complete. |
| // * </p> |
| // * <p> |
| // * All <code>KeySequence</code> objects have a formal string representation |
| // * available via the <code>toString()</code> method. There are a number of |
| // * methods to get instances of <code>KeySequence</code> objects, including one |
| // * which can parse this formal string representation. |
| // * </p> |
| // * <p> |
| // * All <code>KeySequence</code> objects, via the <code>format()</code> |
| // * method, provide a version of their formal string representation translated by |
| // * platform and locale, suitable for display to a user. |
| // * </p> |
| // * <p> |
| // * <code>KeySequence</code> objects are immutable. Clients are not permitted |
| // * to extend this class. |
| // * </p> |
| // * |
| // * @deprecated Please use org.eclipse.jface.bindings.keys.KeySequence |
| // * @since 3.0 |
| // */ |
| //public final class KeySequence implements Comparable { |
| // |
| // /** |
| // * The delimiter between multiple key strokes in a single key sequence -- |
| // * expressed in the formal key stroke grammar. This is not to be displayed |
| // * to the user. It is only intended as an internal representation. |
| // */ |
| // public final static String KEY_STROKE_DELIMITER = "\u0020"; //$NON-NLS-1$ |
| // |
| // /** |
| // * An empty key sequence instance for use by everyone. |
| // */ |
| // private final static KeySequence EMPTY_KEY_SEQUENCE = new KeySequence( |
| // Collections.EMPTY_LIST); |
| // |
| // /** |
| // * An internal constant used only in this object's hash code algorithm. |
| // */ |
| // private final static int HASH_FACTOR = 89; |
| // |
| // /** |
| // * An internal constant used only in this object's hash code algorithm. |
| // */ |
| // private final static int HASH_INITIAL = KeySequence.class.getName() |
| // .hashCode(); |
| // |
| // /** |
| // * The set of delimiters for <code>KeyStroke</code> objects allowed |
| // * during parsing of the formal string representation. |
| // */ |
| // public final static String KEY_STROKE_DELIMITERS = KEY_STROKE_DELIMITER |
| // + "\b\r\u007F\u001B\f\n\0\t\u000B"; //$NON-NLS-1$ |
| // |
| // /** |
| // * Gets an instance of <code>KeySequence</code>. |
| // * |
| // * @return a key sequence. This key sequence will have no key strokes. |
| // * Guaranteed not to be <code>null</code>. |
| // */ |
| // public static KeySequence getInstance() { |
| // return EMPTY_KEY_SEQUENCE; |
| // } |
| // |
| // /** |
| // * Gets an instance of <code>KeySequence</code> given a key sequence and |
| // * a key stroke. |
| // * |
| // * @param keySequence |
| // * a key sequence. Must not be <code>null</code>. |
| // * @param keyStroke |
| // * a key stroke. Must not be <code>null</code>. |
| // * @return a key sequence that is equal to the given key sequence with the |
| // * given key stroke appended to the end. Guaranteed not to be |
| // * <code>null</code>. |
| // */ |
| // public static KeySequence getInstance(KeySequence keySequence, |
| // KeyStroke keyStroke) { |
| // if (keySequence == null || keyStroke == null) { |
| // throw new NullPointerException(); |
| // } |
| // |
| // List keyStrokes = new ArrayList(keySequence.getKeyStrokes()); |
| // keyStrokes.add(keyStroke); |
| // return new KeySequence(keyStrokes); |
| // } |
| // |
| // /** |
| // * Gets an instance of <code>KeySequence</code> given a single key |
| // * stroke. |
| // * |
| // * @param keyStroke |
| // * a single key stroke. Must not be <code>null</code>. |
| // * @return a key sequence. Guaranteed not to be <code>null</code>. |
| // */ |
| // public static KeySequence getInstance(KeyStroke keyStroke) { |
| // return new KeySequence(Collections.singletonList(keyStroke)); |
| // } |
| // |
| // /** |
| // * Gets an instance of <code>KeySequence</code> given an array of key |
| // * strokes. |
| // * |
| // * @param keyStrokes |
| // * the array of key strokes. This array may be empty, but it |
| // * must not be <code>null</code>. This array must not contain |
| // * <code>null</code> elements. |
| // * @return a key sequence. Guaranteed not to be <code>null</code>. |
| // */ |
| // public static KeySequence getInstance(KeyStroke[] keyStrokes) { |
| // return new KeySequence(Arrays.asList(keyStrokes)); |
| // } |
| // |
| // /** |
| // * Gets an instance of <code>KeySequence</code> given a list of key |
| // * strokes. |
| // * |
| // * @param keyStrokes |
| // * the list of key strokes. This list may be empty, but it must |
| // * not be <code>null</code>. If this list is not empty, it |
| // * must only contain instances of <code>KeyStroke</code>. |
| // * @return a key sequence. Guaranteed not to be <code>null</code>. |
| // */ |
| // public static KeySequence getInstance(List keyStrokes) { |
| // return new KeySequence(keyStrokes); |
| // } |
| // |
| // /** |
| // * Gets an instance of <code>KeySequence</code> given a new-style key |
| // * sequence. |
| // * |
| // * @param newKeySequence |
| // * The new-style key sequence to convert into a legacy key |
| // * sequence; must not be <code>null</code>. |
| // * @return a key sequence; never <code>null</code>. |
| // */ |
| // public static final KeySequence getInstance( |
| // final org.eclipse.jface.bindings.keys.KeySequence newKeySequence) { |
| // final org.eclipse.jface.bindings.keys.KeyStroke[] newKeyStrokes = newKeySequence |
| // .getKeyStrokes(); |
| // final int newKeyStrokesCount = newKeyStrokes.length; |
| // final List legacyKeyStrokes = new ArrayList(newKeyStrokesCount); |
| // |
| // for (int i = 0; i < newKeyStrokesCount; i++) { |
| // final org.eclipse.jface.bindings.keys.KeyStroke newKeyStroke = newKeyStrokes[i]; |
| // legacyKeyStrokes.add(SWTKeySupport |
| // .convertAcceleratorToKeyStroke(newKeyStroke |
| // .getModifierKeys() |
| // | newKeyStroke.getNaturalKey())); |
| // } |
| // |
| // return new KeySequence(legacyKeyStrokes); |
| // } |
| // |
| // /** |
| // * Gets an instance of <code>KeySequence</code> by parsing a given a |
| // * formal string representation. |
| // * |
| // * @param string |
| // * the formal string representation to parse. |
| // * @return a key sequence. Guaranteed not to be <code>null</code>. |
| // * @throws ParseException |
| // * if the given formal string representation could not be |
| // * parsed to a valid key sequence. |
| // */ |
| // public static KeySequence getInstance(String string) throws ParseException { |
| // if (string == null) { |
| // throw new NullPointerException(); |
| // } |
| // |
| // List keyStrokes = new ArrayList(); |
| // StringTokenizer stringTokenizer = new StringTokenizer(string, |
| // KEY_STROKE_DELIMITERS); |
| // |
| // while (stringTokenizer.hasMoreTokens()) { |
| // keyStrokes.add(KeyStroke.getInstance(stringTokenizer.nextToken())); |
| // } |
| // |
| // try { |
| // return new KeySequence(keyStrokes); |
| // } catch (Throwable t) { |
| // throw new ParseException( |
| // "Could not construct key sequence with these key strokes: " //$NON-NLS-1$ |
| // + keyStrokes); |
| // } |
| // } |
| // |
| // /** |
| // * The cached hash code for this object. Because <code>KeySequence</code> |
| // * objects are immutable, their hash codes need only to be computed once. |
| // * After the first call to <code>hashCode()</code>, the computed value |
| // * is cached here for all subsequent calls. |
| // */ |
| // private transient int hashCode; |
| // |
| // /** |
| // * A flag to determine if the <code>hashCode</code> field has already |
| // * been computed. |
| // */ |
| // private transient boolean hashCodeComputed; |
| // |
| // /** |
| // * The list of key strokes for this key sequence. |
| // */ |
| // private List keyStrokes; |
| // |
| // /** |
| // * Constructs an instance of <code>KeySequence</code> given a list of key |
| // * strokes. |
| // * |
| // * @param keyStrokes |
| // * the list of key strokes. This list may be empty, but it must |
| // * not be <code>null</code>. If this list is not empty, it |
| // * must only contain instances of <code>KeyStroke</code>. |
| // */ |
| // private KeySequence(List keyStrokes) { |
| // this.keyStrokes = Util.safeCopy(keyStrokes, KeyStroke.class); |
| // |
| // for (int i = 0; i < this.keyStrokes.size() - 1; i++) { |
| // KeyStroke keyStroke = (KeyStroke) this.keyStrokes.get(i); |
| // |
| // if (!keyStroke.isComplete()) { |
| // throw new IllegalArgumentException(); |
| // } |
| // } |
| // } |
| // |
| // /** |
| // * @see java.lang.Object#equals(java.lang.Object) |
| // */ |
| // public int compareTo(Object object) { |
| // KeySequence castedObject = (KeySequence) object; |
| // int compareTo = Util.compare(keyStrokes, castedObject.keyStrokes); |
| // return compareTo; |
| // } |
| // |
| // /** |
| // * Returns whether or not this key sequence ends with the given key |
| // * sequence. |
| // * |
| // * @param keySequence |
| // * a key sequence. Must not be <code>null</code>. |
| // * @param equals |
| // * whether or not an identical key sequence should be considered |
| // * as a possible match. |
| // * @return <code>true</code>, iff the given key sequence ends with this |
| // * key sequence. |
| // */ |
| // public boolean endsWith(KeySequence keySequence, boolean equals) { |
| // if (keySequence == null) { |
| // throw new NullPointerException(); |
| // } |
| // |
| // return Util.endsWith(keyStrokes, keySequence.keyStrokes, equals); |
| // } |
| // |
| // /** |
| // * @see java.lang.Object#equals(java.lang.Object) |
| // */ |
| // public boolean equals(Object object) { |
| // if (!(object instanceof KeySequence)) { |
| // return false; |
| // } |
| // |
| // return keyStrokes.equals(((KeySequence) object).keyStrokes); |
| // } |
| // |
| // /** |
| // * Formats this key sequence into the current default look. |
| // * |
| // * @return A string representation for this key sequence using the default |
| // * look; never <code>null</code>. |
| // */ |
| // public String format() { |
| // return KeyFormatterFactory.getDefault().format(this); |
| // } |
| // |
| // /** |
| // * Returns the list of key strokes for this key sequence. |
| // * |
| // * @return the list of key strokes keys. This list may be empty, but is |
| // * guaranteed not to be <code>null</code>. If this list is not |
| // * empty, it is guaranteed to only contain instances of <code>KeyStroke</code>. |
| // */ |
| // public List getKeyStrokes() { |
| // return keyStrokes; |
| // } |
| // |
| // /** |
| // * @see java.lang.Object#hashCode() |
| // */ |
| // public int hashCode() { |
| // if (!hashCodeComputed) { |
| // hashCode = HASH_INITIAL; |
| // hashCode = hashCode * HASH_FACTOR + keyStrokes.hashCode(); |
| // hashCodeComputed = true; |
| // } |
| // |
| // return hashCode; |
| // } |
| // |
| // /** |
| // * Returns whether or not this key sequence is complete. Key sequences are |
| // * complete iff all of their key strokes are complete. |
| // * |
| // * @return <code>true</code>, iff the key sequence is complete. |
| // */ |
| // public boolean isComplete() { |
| // return keyStrokes.isEmpty() |
| // || ((KeyStroke) keyStrokes.get(keyStrokes.size() - 1)) |
| // .isComplete(); |
| // } |
| // |
| // /** |
| // * Returns whether or not this key sequence is empty. Key sequences are |
| // * complete iff they have no key strokes. |
| // * |
| // * @return <code>true</code>, iff the key sequence is empty. |
| // */ |
| // public boolean isEmpty() { |
| // return keyStrokes.isEmpty(); |
| // } |
| // |
| // /** |
| // * Returns whether or not this key sequence starts with the given key |
| // * sequence. |
| // * |
| // * @param keySequence |
| // * a key sequence. Must not be <code>null</code>. |
| // * @param equals |
| // * whether or not an identical key sequence should be considered |
| // * as a possible match. |
| // * @return <code>true</code>, iff the given key sequence starts with |
| // * this key sequence. |
| // */ |
| // public boolean startsWith(KeySequence keySequence, boolean equals) { |
| // if (keySequence == null) { |
| // throw new NullPointerException(); |
| // } |
| // |
| // return Util.startsWith(keyStrokes, keySequence.keyStrokes, equals); |
| // } |
| // |
| // /** |
| // * Returns the formal string representation for this key sequence. |
| // * |
| // * @return The formal string representation for this key sequence. |
| // * Guaranteed not to be <code>null</code>. |
| // * @see java.lang.Object#toString() |
| // */ |
| // public String toString() { |
| // return KeyFormatterFactory.getFormalKeyFormatter().format(this); |
| // } |
| //} |
