diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextProcessor.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextProcessor.java index 0d6a2e9..c8c23a1 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextProcessor.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextProcessor.java @@ -14,8 +14,11 @@ import org.eclipse.equinox.bidi.custom.STextTypeHandler; /** - * Provides a number of convenience functions facilitating the - * processing of structured text. + * Provides methods to process structured text. The methods in this class + * are the most straightforward way to transform lean text into + * full text and vice versa (for the meaning of lean and + * full text, please see the + * package documentation). * * @noextend This class is not intended to be subclassed by clients. * @noinstantiate This class is not intended to be instantiated by clients. @@ -50,9 +53,9 @@ } /** - * Processes the given text and returns a string with appropriate - * directional formatting characters. This is equivalent to calling - * {@link #process(String str, String separators)} with the default + * Processes the given (lean) text and returns a string with appropriate + * directional formatting characters (full text). This is equivalent to + * calling {@link #process(String str, String separators)} with the default * set of separators. *

* The processing adds directional formatting characters so that presentation @@ -66,9 +69,11 @@ * d:\myfolder\REDLOF\ELIFYM.java. *

* - * @param str the text to be processed. + * @param str the lean text to process. * - * @return the processed string. + * @return the processed string (full text). + * + * @see #deprocess(String) */ public static String process(String str) { return process(str, defaultSeparators); @@ -77,13 +82,14 @@ /** * Processes a string that has a particular semantic meaning to render * it correctly on bidi locales. - * - * @see #process(String) + * For more details, see {@link #process(String)}. * - * @param str the text to process. + * @param str the lean text to process. * @param separators characters by which the string will be segmented. * - * @return the processed string. + * @return the processed string (full text). + * + * @see #deprocess(String) */ public static String process(String str, String separators) { if ((str == null) || (str.length() <= 1)) @@ -131,17 +137,18 @@ /** * Processes a string that has a particular semantic meaning to render * it correctly on bidi locales. + * For more details, see {@link #process(String)}. * - * @see #process(String) - * - * @param str the text to process. - * @param textType an identifier for the handler instance appropriate - * for the type of the structured text. + * @param str the lean text to process. + * @param textType an identifier for the structured text handler + * appropriate for the type of the text submitted. * It may be one of the identifiers defined in * {@link STextTypeHandlerFactory} or a type handler identifier - * specified in a plug-in. + * registered by a plug-in. * - * @return the processed string + * @return the processed string (full text). + * + * @see #deprocessTyped */ public static String processTyped(String str, String textType) { if ((str == null) || (str.length() <= 1)) @@ -163,9 +170,9 @@ /** * Removes directional formatting characters in the given string. * - * @param str string with directional characters to remove. + * @param str string with directional characters to remove (full text). * - * @return string without directional formatting characters. + * @return string without directional formatting characters (lean text). */ public static String deprocess(String str) { if ((str == null) || (str.length() <= 1)) @@ -195,15 +202,16 @@ /** * Removes directional formatting characters in the given string. * - * @param str string with directional characters to remove. - * - * @param textType an identifier for the handler instance appropriate - * for the type of the structured text. + * @param str string with directional characters to remove (full text). + * @param textType an identifier for the structured text handler + * appropriate for the type of the text submitted. * It may be one of the identifiers defined in * {@link STextTypeHandlerFactory} or a type handler identifier - * specified in a plug-in. + * registered by a plug-in. * - * @return string without directional formatting characters. + * @return string without directional formatting characters (lean text). + * + * @see #processTyped(String, String) */ public static String deprocessTyped(String str, String textType) { if ((str == null) || (str.length() <= 1)) diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextTypeHandlerFactory.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextTypeHandlerFactory.java index d134e55..4f4513a 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextTypeHandlerFactory.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/STextTypeHandlerFactory.java @@ -10,12 +10,28 @@ ******************************************************************************/ package org.eclipse.equinox.bidi; +import org.eclipse.equinox.bidi.advanced.STextEnvironment; +import org.eclipse.equinox.bidi.advanced.STextExpertFactory; import org.eclipse.equinox.bidi.custom.STextTypeHandler; import org.eclipse.equinox.bidi.internal.STextTypesCollector; /** * Provides access to registered structured text handlers. - * + *

+ * A structured text handler is a subclass of {@link STextTypeHandler} + * adapted for a given type of structured text. + *

+ * The constants in this class are identifiers for structured text + * handlers which are defined and supported "out of the box" by this package. + * Text handler identifiers can be used when invoking {@link STextProcessor#processTyped(String, String)}, + * or when invoking getExpert methods in {@link STextExpertFactory}. + *

+ * The {@link #getHandler} method in this class can be used to get a + * structured text handler reference for one of the handlers defined in this + * package or for additional structured text handlers registered by plug-ins. + * Text handler references can be used when invoking + * {@link STextExpertFactory#getStatefulExpert(STextTypeHandler, STextEnvironment)}. + * * @noinstantiate This class is not intended to be instantiated by clients. */ final public class STextTypeHandlerFactory { diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/ISTextExpert.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/ISTextExpert.java index 171a2e6..9cea28f 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/ISTextExpert.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/ISTextExpert.java @@ -105,6 +105,7 @@ /** * Obtains the structured type handler associated with this * ISTextExpert instance. + * * @return the type handler instance. */ public STextTypeHandler getTypeHandler(); @@ -214,8 +215,18 @@ *

* If necessary, leading and trailing directional formatting characters * (LRE, RLE and PDF) can be added depending on the value of the - * affix argument. - *

+ * affix argument.

+ *

A value of 1 means that one LRM or RLM must be prefixed, depending + * on the direction. This is useful when the GUI component presenting + * this text has a contextual orientation.
A value of 2 means that LRE+LRM or RLE+RLM must be prefixed, + * depending on the direction, and LRM+PDF or RLM+PDF must be + * suffixed, depending on the direction. + * This is useful if the GUI component presenting this text needs to + * have the text orientation explicitly specified.
A value of 0 means that no prefix or suffix are needed.

* @see ISTextExpert#leanBidiCharOffsets(String) * * @param text the structured text string @@ -256,6 +267,7 @@ /** * Sets the state for the next text processing call. * This method does nothing if the expert instance is not a stateful one. + * * @param state an object returned by a previous call to {@link #getState}. */ public void setState(Object state); @@ -263,7 +275,8 @@ /** * Gets the state established by the last text processing call. * This is null if the expert instance is not a stateful one, - * or if the last text processing call has nothing to pass to the next call. + * or if the last text processing call had nothing to pass to the next call. + * * @return the last established state. */ public Object getState(); diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/STextEnvironment.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/STextEnvironment.java index 474fb00..6705ddf 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/STextEnvironment.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/STextEnvironment.java @@ -97,11 +97,11 @@ /** * Creates an instance of a structured text environment. * - * @param lang the language to of the environment, encoded as specified + * @param lang the language of the environment, encoded as specified * in ISO-639. Might be null, in which case the default * locale is used. * @param mirrored specifies if the environment is mirrored. - * @param orientation the orientation of the GUI component: + * @param orientation the orientation of the GUI component, one of the values: * {@link #ORIENT_LTR ORIENT_LTR}, * {@link #ORIENT_LTR ORIENT_RTL}, * {@link #ORIENT_CONTEXTUAL_LTR ORIENT_CONTEXTUAL_LTR}, @@ -124,6 +124,7 @@ /** * Returns a 2-letters code representing a language as defined by * ISO-639. + * * @return language of the environment */ public String getLanguage() { @@ -134,6 +135,7 @@ * Returns a flag indicating that structured text processed * within this environment should assume that the GUI is mirrored * (globally going from right to left). + * * @return true if environment is mirrored */ public boolean getMirrored() { @@ -145,7 +147,7 @@ * component in which the full structured text * will be displayed. *

- * The orientation values: + * The orientation value is one of the following: *

{@link #ORIENT_LTR ORIENT_LTR},
{@link #ORIENT_LTR ORIENT_RTL},

true

stateful, obtained by calling {@link #getStatefulExpert getStatefulExpert}.
not stateful, obtained by calling {@link #getExpert getExpert}.

Only the stateful kind can remember the state established by a call to * a text processing method and transmit it as initial state in the next call * to a text processing method. + *

In other words, the methods + * {@link ISTextExpert#getState() getState}, + * {@link ISTextExpert#setState setState} and + * {@link ISTextExpert#clearState() clearState} of + * {@link ISTextExpert} are inoperative for experts which are not stateful. *

* Using a stateful expert is more resource intensive, thus not stateful * experts should be used when feasible. diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/package.html b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/package.html index 9b71e0c..438719b 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/package.html +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/advanced/package.html @@ -4,17 +4,11 @@ - +

This package provides classes for users who need finer control on structured text handling. -
-Note that the basic functions are provided in package -{@link -org.eclipse.equinox.bidi} and its -{@link STextProcessor} class. -

In particular, the user should use the methods in the -{@link ISTextExpert} class +ISTextExpert class in the following cases:

The structured type handler to use is not one of those @@ -27,5 +21,31 @@
The user needs to manage the offsets where directional formatting characters are inserted in the text.

+Note that the basic functions are provided in package +{@link +org.eclipse.equinox.bidi} and its +{@link STextProcessor} class. +

+To access the more sophisticated methods for processing structured text, +the user should proceed as follows:

The user has to obtain an appropriate + ISTextExpert instance using the methods in + STextExpertFactory.
The user may then invoke the more sophisticated methods provided by + ISTextExpert + for processing the structured text.
If those methods should work in an environment different from the default, + the user may specify properties of the environment using the class + STextEnvironment. +
+ This should be done before obtaining a ISTextExpert instance, + and the specific environment must be specified when invoking + STextExpertFactory methods. This will + associate a type handler with the given environment and provide + a customized ISTextExpert instance to the user.

Handler instances may be accessed simultaneously by * several threads. They should have no instance variables.
The common logic uses handler methods to query the + *
This class provides common logic in code which can be invoked + * by any {@link STextTypeHandler structured text handler}. + * This common logic uses handler methods to query the * characteristics of the specific handler: *
- the separators which separate the structured text into @@ -87,26 +89,21 @@ * is invoked. The handler can use ISTextExpert methods to * query items stored in the expert instance, like the current * {@link STextEnvironment environment}. - * * @param text the structured text string before * addition of any directional formatting characters. - * * @param charTypes an object whose methods can be useful to the * handler. - * * @param offsets an object whose methods can be useful to the * handler. - * * @param caseNumber number of the special case to locate. * This number varies from 1 to the number of special cases * returned by {@link #getSpecialsCount getSpecialsCount} * for this handler. * The meaning of this number is internal to the class * implementing indexOfSpecial. - * * @param fromIndex the index within text to start * the search from. - * + * * @return the position where the start of the special case * corresponding to caseNumber was located. * The method must return the first occurrence of whatever @@ -131,7 +128,7 @@ /** * Handles special cases specific to this handler. * It is called when a special case occurrence - * is located by {@link #indexOfSpecial}. + * is located by {@link #indexOfSpecial indexOfSpecial}. *
  * If a special processing cannot be completed within a current call to * processSpecial (for instance, a comment has been started @@ -154,18 +151,13 @@ * is invoked. The handler can use ISTextExpert methods to * query items stored in the expert instance, like the current * {@link STextEnvironment environment}. - * * @param text the structured text string before * addition of any directional formatting characters. - * * @param charTypes an object whose methods can be useful to the * handler. - * * @param offsets an object whose methods can be useful to the * handler. - * * @param caseNumber number of the special case to handle. - * * @param separLocation the position returned by * {@link #indexOfSpecial indexOfSpecial}. After calls to * {@link ISTextExpert#leanToFullText leanToFullText} and other @@ -195,8 +187,10 @@ /** * Specifies that a mark character must be added before the character * at the specified position of the lean text when generating the - * full text. This method can be called from within {@link #indexOfSpecial} - * or {@link #processSpecial} in extensions of STextTypeHandler. + * full text. This method can be called from within + * {@link #indexOfSpecial indexOfSpecial} or + * {@link #processSpecial processSpecial} in extensions of + * STextTypeHandler. * The mark character will be LRM for structured text * with a LTR base direction, and RLM for structured text with RTL * base direction. The mark character is not added physically by this @@ -206,13 +200,10 @@ * @param text is the structured text string received as * parameter to indexOfSpecial or * processSpecial. - * * @param charTypes is a parameter received by indexOfSpecial * or processSpecial. - * * @param offsets is a parameter received by indexOfSpecial * or processSpecial. - * * @param offset position of the character in the lean text. * It must be a non-negative number smaller than the length * of the lean text. @@ -228,8 +219,9 @@ * display, depending on the base direction of the text and on the * class of the characters in the lean text preceding and * following the separator itself. This method - * can be called from within {@link #indexOfSpecial} or - * {@link #processSpecial} in extensions of STextTypeHandler. + * can be called from within {@link #indexOfSpecial indexOfSpecial} or + * {@link #processSpecial processSpecial} in extensions of + * STextTypeHandler. *
  * The logic implemented in this method considers the text before * separLocation and the text following it. If, and only if, @@ -240,13 +232,10 @@ * @param text is the structured text string received as * parameter to indexOfSpecial or * processSpecial. - * * @param charTypes is a parameter received by indexOfSpecial * or processSpecial. - * * @param offsets is a parameter received by indexOfSpecial * or processSpecial. - * * @param separLocation offset of the separator in the lean text. * It must be a non-negative number smaller than the length * of the lean text. @@ -283,7 +272,6 @@ * is invoked. The handler can use ISTextExpert methods to * query items stored in the expert instance, like the current * {@link STextEnvironment environment}. - * * @param text the structured text string to process. * * @return the base direction of the structured text. This direction @@ -308,9 +296,7 @@ * is invoked. The handler can use ISTextExpert methods to * query items stored in the expert instance, like the current * {@link STextEnvironment environment}. - * * @param text is the structured text string to process. - * * @param charTypes is a parameter received by indexOfSpecial * or processSpecial. * @@ -364,9 +350,7 @@ * is invoked. The handler can use ISTextExpert methods to * query items stored in the expert instance, like the current * {@link STextEnvironment environment}. - * * @param text is the structured text string to process. - * * @param charTypes is a parameter received by indexOfSpecial * or processSpecial. * diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/custom/package.html b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/custom/package.html index 5f7ead0..6b7ac75 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/custom/package.html +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/custom/package.html @@ -5,11 +5,9 @@
  -This package provides classes for -developing structured text type handlers. -
  -This package is to be used together with package -{@link -org.eclipse.equinox.bidi}. +This package provides classes for developing structured text type handlers. +It is to be used together with package +{@link org.eclipse.equinox.bidi}. +
  diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelims.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelims.java index d71fcdd..ba6419f 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelims.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextDelims.java @@ -50,7 +50,7 @@ /** * Handles the text between start and end delimiters as a token. - * This methoed inserts a directional mark if needed at position + * This method inserts a directional mark if needed at position * separLocation which corresponds to a start delimiter, * and skips until after the matching end delimiter. * diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextImpl.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextImpl.java index 4285ba6..d26f419 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextImpl.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextImpl.java @@ -10,8 +10,7 @@ ******************************************************************************/ package org.eclipse.equinox.bidi.internal; -import org.eclipse.equinox.bidi.advanced.ISTextExpert; -import org.eclipse.equinox.bidi.advanced.STextEnvironment; +import org.eclipse.equinox.bidi.advanced.*; import org.eclipse.equinox.bidi.custom.*; /** @@ -52,11 +51,30 @@ static final int FIXES_LENGTH = PREFIX_LENGTH + SUFFIX_LENGTH; static final int[] EMPTY_INT_ARRAY = new int[0]; + /** + * The structured text handler utilized by this expert. + */ protected final STextTypeHandler handler; + /** + * The environment associated with the expert. + */ protected final STextEnvironment environment; + /** + * Flag which is true if the expert is stateful. + */ protected final boolean sharedExpert; + /** + * Last state value set by {@link #setState} or {@link #clearState}. + */ protected Object state; + /** + * Constructor used in {@link STextExpertFactory}. + * + * @param structuredTextHandler the structured text handler used by this expert. + * @param environment the environment associated with this expert. + * @param shared flag which is true if the expert is stateful. + */ public STextImpl(STextTypeHandler structuredTextHandler, STextEnvironment environment, boolean shared) { this.handler = structuredTextHandler; this.environment = environment; @@ -127,6 +145,9 @@ return nextLocation + (((long) idxLocation) << 32); } + /** + * @see STextTypeHandler#processSeparator STextTypeHandler.processSeparator + */ static public void processSeparator(String text, STextCharTypes charTypes, STextOffsets offsets, int separLocation) { int len = text.length(); int direction = charTypes.getDirection(); @@ -226,7 +247,6 @@ * {@link ISTextExpert#leanToFullText leanToFullText} does not add any directional * formatting characters as either prefix or suffix of the full text. *
  - * @see ISTextExpert#leanToFullText STextEngine.leanToFullText */ public String leanToFullText(String text) { int len = text.length(); @@ -512,8 +532,9 @@ } else { // When the orientation is RTL, we need to add EMBED at the // start of the text and PDF at its end. - // However, because of a bug in Windows' handling of LRE/PDF, - // we add EMBED_PREFIX at the start and EMBED_SUFFIX at the end. + // However, because of a bug in Windows' handling of LRE/RLE/PDF, + // we add LRM or RLM (according to the direction) after the + // LRE/RLE and again before the PDF. char curEmbed = EMBEDS[direction]; fullChars[0] = curEmbed; fullChars[1] = curMark; diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextStringRecord.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextStringRecord.java index 0c60489..df62726 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextStringRecord.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextStringRecord.java @@ -10,9 +10,8 @@ ******************************************************************************/ package org.eclipse.equinox.bidi.internal; -import org.eclipse.equinox.bidi.STextTypeHandlerFactory; - import java.lang.ref.SoftReference; +import org.eclipse.equinox.bidi.STextTypeHandlerFactory; /** * Records strings which contain structured text. Several static @@ -80,19 +79,15 @@ * and ending offsets for the first segment. * * @param string the string to record. - * * @param segmentCount number of segments allowed in this string. * This number must be >= 1. - * * @param handlerID identifier for the handler appropriate to handle * the type of structured text present in the first segment. * It may be one of the predefined identifiers in * {@link STextTypeHandlerFactory}, or it may be an identifier * for a type handler created by a plug-in or by the application. - * * @param start offset in the string of the starting character of the first * segment. It must be >= 0 and less than the length of the string. - * * @param limit offset of the character following the first segment. It * must be greater than the start argument and * not greater than the length of the string. @@ -147,10 +142,8 @@ * It may be one of the predefined identifiers in * {@link STextTypeHandlerFactory}, or it may be an identifier * for a type handler created by a plug-in or by the application. - * * @param start offset in the string of the starting character of the * segment. It must be >= 0 and less than the length of the string. - * * @param limit offset of the character following the segment. It must be * greater than the start argument and not greater * than the length of the string. @@ -179,7 +172,7 @@ } /** - * Checks if a string is recorded and retrieve its record. + * Checks if a string is recorded and retrieves its record. * * @param string the string to check. * diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextTypesCollector.java b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextTypesCollector.java index 4b94cac..6daa9af 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextTypesCollector.java +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/internal/STextTypesCollector.java @@ -36,10 +36,16 @@ registry.addListener(this, EXT_POINT); } + /** + * @return a static instance. + */ static public STextTypesCollector getInstance() { return instance; } + /** + * @return a list of all the registered structured text handler types. + */ public String[] getTypes() { if (types == null) read(); @@ -49,6 +55,11 @@ return result; } + /** + * @param type the identifier for a structured text handler. + * + * @return the structured text handler instance. + */ public STextTypeHandler getHandler(String type) { if (types == null) read(); diff --git a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/package.html b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/package.html index 665718d..1b23975 100644 --- a/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/package.html +++ b/bundles/org.eclipse.equinox.bidi/src/org/eclipse/equinox/bidi/package.html @@ -20,7 +20,8 @@ For plain text, the Unicode Bidirectional Algorithm (UBA) generally specifies satisfactorily how to reorder bidirectional text for -display. This algorithm is implemented in Java's presentation system. +display. This algorithm is implemented in many presentation and operating +systems, like Java/Swing, Windows, Linux.
  However, all bidirectional text is not necessarily plain text. There are also instances of text structured to follow a given syntax, which @@ -72,17 +73,6 @@ These identifiers can be used as argument in some methods of STextProcessor to specify the type of handler to apply.
  -Another class in this package may be used to -complement the action of -{@link STextProcessor}: -
  - {@link STextStringRecord} - allows to record strings which are structured text with the - type of the appropriate handler, - so that another module can check if a given string has been recorded - as a structured text string and run its type handler.
  -
  The classes included in this package are intended for users who need to process structured text in the most straightforward manner, when the following conditions are satisfied: @@ -102,51 +92,30 @@ When their needs go beyond the conditions above, users can use classes in the {@link -org.eclipse.equinox.bidi.advanced} package: -
  - {@link ISTextExpert} - provides more sophisticated methods for processing the - structured text.
  - {@link STextEnvironment} - specifies properties of the environment.
  - {@link STextExpertFactory} - associates a type handler with an environment and provides - a STextExpert instance for the user. -
  -
  +org.eclipse.equinox.bidi.advanced} package. +
  Developers who want to develop new handlers to support types of -structured text not currently supported can use the following components +structured text not currently supported can use components of the package {@link -org.eclipse.equinox.bidi.custom}: -
  - {@link STextTypeHandler} - is a generic handler to be used as superclass for specific - handlers.
  - {@link STextCharTypes} - provides services related to the bidi classification of characters.
  - {@link STextOffsets} - provides services related to managing an array of offsets to locations - where directional formatting characters should be added in the source - string.
  -
  -There are two other packages associated with the current one: +org.eclipse.equinox.bidi.custom}. +
  +There are two other packages associated with the current one:
  - {@link org.eclipse.equinox.bidi.internal}
  - {@link org.eclipse.equinox.bidi.internal.consumable}
  +
  The tools in the first package can serve as example of how to develop processors for currently unsupported types of structured text.
  The latter package contains classes for the processors implementing the currently supported types of structured text. -
  +
  However, users wishing to process the currently supported types of structured text typically don't need to interact with these two packages. - -
  
  +
  
  Abbreviations used in the documentation of this package
  @@ -188,7 +157,7 @@ Linux) are very similar but nevertheless have known differences. Those differences are minor and will not have a visible effect in most cases. However there might be cases in which the same bidi text on two -platforms might look different. These differences will surface in Java +platforms will look different. These differences will surface in Java applications when they use the platform visual components for their UI (e.g., AWT, SWT).

Abbreviations used in the documentation of this package