TextFieldpublic class TextField extends Item A TextField is an editable text component that may be
placed into
a {@link Form Form}. It can be
given a piece of text that is used as the initial value.
A TextField has a maximum size, which is the
maximum number of characters
that can be stored in the object at any time (its capacity). This limit is
enforced when the TextField instance is constructed,
when the user is editing text within the TextField, as well as
when the application program calls methods on the
TextField that modify its
contents. The maximum size is the maximum stored capacity and is unrelated
to the number of characters that may be displayed at any given time.
The number of characters displayed and their arrangement into rows and
columns are determined by the device.
The implementation may place a boundary on the maximum size, and the
maximum size actually assigned may be smaller than the application had
requested. The value actually assigned will be reflected in the value
returned by {@link #getMaxSize() getMaxSize()}. A defensively-written
application should compare this value to the maximum size requested and be
prepared to handle cases where they differ.
Input Constraints
The TextField shares the concept of input
constraints with the {@link TextBox TextBox} class. The different
constraints allow the application to request that the user's input be
restricted in a variety of ways. The implementation is required to
restrict the user's input as requested by the application. For example, if
the application requests the NUMERIC constraint on a
TextField, the
implementation must allow only numeric characters to be entered.
The actual contents of the text object are set and modified by
and are
reported to the application through the TextBox and
TextField APIs. The displayed contents may differ
from the actual contents if the implementation has chosen to provide
special formatting suitable for the text object's constraint setting.
For example, a PHONENUMBER field might be displayed with
digit separators and punctuation as
appropriate for the phone number conventions in use, grouping the digits
into country code, area code, prefix, etc. Any spaces or punctuation
provided are not considered part of the text object's actual contents. For
example, a text object with the PHONENUMBER
constraint might display as
follows:
but the actual contents of the object visible to the application
through the APIs would be the string
"4085551212".
The size method reflects the number of characters in the
actual contents, not the number of characters that are displayed, so for
this example the size method would return 10.
Some constraints, such as DECIMAL, require the
implementation to perform syntactic validation of the contents of the text
object. The syntax checking is performed on the actual contents of the
text object, which may differ from the displayed contents as described
above. Syntax checking is performed on the initial contents passed to the
constructors, and it is also enforced for all method calls that affect the
contents of the text object. The methods and constructors throw
IllegalArgumentException if they would result in the contents
of the text object not conforming to the required syntax.
The value passed to the {@link #setConstraints setConstraints()} method
consists of a restrictive constraint setting described above, as well as a
variety of flag bits that modify the behavior of text entry and display.
The value of the restrictive constraint setting is in the low order
16 bits
of the value, and it may be extracted by combining the constraint value
with the CONSTRAINT_MASK constant using the bit-wise
AND (&) operator.
The restrictive constraint settings are as follows:
ANY
EMAILADDR
NUMERIC
PHONENUMBER
URL
DECIMAL
The modifier flags reside in the high order 16 bits
of the constraint
value, that is, those in the complement of the
CONSTRAINT_MASK constant.
The modifier flags may be tested individually by combining the constraint
value with a modifier flag using the bit-wise AND
(&) operator. The
modifier flags are as follows:
PASSWORD
UNEDITABLE
SENSITIVE
NON_PREDICTIVE
INITIAL_CAPS_WORD
INITIAL_CAPS_SENTENCE
Input Modes
The TextField shares the concept of input
modes with the {@link
TextBox TextBox} class. The application can request that the
implementation use a particular input mode when the user initiates editing
of a TextField or TextBox. The input
mode is a concept that exists within
the user interface for text entry on a particular device. The application
does not request an input mode directly, since the user interface for text
entry is not standardized across devices. Instead, the application can
request that the entry of certain characters be made convenient. It can do
this by passing the name of a Unicode character subset to the {@link
#setInitialInputMode setInitialInputMode()} method. Calling this method
requests that the implementation set the mode of the text entry user
interface so that it is convenient for the user to enter characters in this
subset. The application can also request that the input mode have certain
behavioral characteristics by setting modifier flags in the constraints
value.
The requested input mode should be used whenever the user initiates the
editing of a TextBox or TextField object.
If the user had changed input
modes in a previous editing session, the application's requested input mode
should take precedence over the previous input mode set by the user.
However, the input mode is not restrictive, and the user is allowed to
change the input mode at any time during editing. If editing is already in
progress, calls to the setInitialInputMode method do not
affect the current input mode, but instead take effect at the next time the
user initiates editing of this text object.
The initial input mode is a hint to the implementation. If the
implementation cannot provide an input mode that satisfies the
application's request, it should use a default input mode.
The input mode that results from the application's request is not a
restriction on the set of characters the user is allowed to enter. The
user MUST be allowed to switch input modes to enter any character that is
allowed within the current constraint setting. The constraint
setting takes precedence over an input mode request, and the implementation
may refuse to supply a particular input mode if it is inconsistent with the
current constraint setting.
For example, if the current constraint is ANY, the call
setInitialInputMode("MIDP_UPPERCASE_LATIN");
|
should set the initial input mode to allow entry of uppercase Latin
characters. This does not restrict input to these characters, and the user
will be able to enter other characters by switching the input mode to allow
entry of numerals or lowercase Latin letters. However, if the current
constraint is NUMERIC, the implementation may ignore
the request to set an
initial input mode allowing MIDP_UPPERCASE_LATIN
characters because these
characters are not allowed in a TextField whose
constraint is NUMERIC. In
this case, the implementation may instead use an input mode that allows
entry of numerals, since such an input mode is most appropriate for entry
of data under the NUMERIC constraint.
A string is used to name the Unicode character subset passed as a
parameter to the
{@link #setInitialInputMode setInitialInputMode()} method.
String comparison is case sensitive.
Unicode character blocks can be named by adding the prefix
"UCB_" to the
the string names of fields representing Unicode character blocks as defined
in the J2SE class java.lang.Character.UnicodeBlock. Any
Unicode character block may be named in this fashion. For convenience, the
most common Unicode character blocks are listed below.
UCB_BASIC_LATIN
UCB_GREEK
UCB_CYRILLIC
UCB_ARMENIAN
UCB_HEBREW
UCB_ARABIC
UCB_DEVANAGARI
UCB_BENGALI
UCB_THAI
UCB_HIRAGANA
UCB_KATAKANA
UCB_HANGUL_SYLLABLES
"Input subsets" as defined by the J2SE class
java.awt.im.InputSubset may be named by adding the prefix
"IS_" to the string names of fields
representing input subsets as defined
in that class. Any defined input subset may be used. For convenience, the
names of the currently defined input subsets are listed below.
IS_FULLWIDTH_DIGITS
IS_FULLWIDTH_LATIN
IS_HALFWIDTH_KATAKANA
IS_HANJA
IS_KANJI
IS_LATIN
IS_LATIN_DIGITS
IS_SIMPLIFIED_HANZI
IS_TRADITIONAL_HANZI
MIDP has also defined the following character subsets:
MIDP_UPPERCASE_LATIN - the subset of
IS_LATIN that corresponds to
uppercase Latin letters
MIDP_LOWERCASE_LATIN - the subset of
IS_LATIN that corresponds to
lowercase Latin letters
Finally, implementation-specific character subsets may be named with
strings that have a prefix of "X_". In
order to avoid namespace conflicts,
it is recommended that implementation-specific names include the name of
the defining company or organization after the initial
"X_" prefix.
For example, a Japanese language application might have a particular
TextField that the application intends to be used
primarily for input of
words that are "loaned" from languages other than Japanese. The
application might request an input mode facilitating Hiragana input by
issuing the following method call:
textfield.setInitialInputMode("UCB_HIRAGANA");
|
Implementation Note
Implementations need not compile in all the strings listed above.
Instead, they need only to compile in the strings that name Unicode
character subsets that they support. If the subset name passed by the
application does not match a known subset name, the request should simply
be ignored without error, and a default input mode should be used. This
lets implementations support this feature reasonably inexpensively.
However, it has the consequence that the application cannot tell whether
its request has been accepted, nor whether the Unicode character subset it
has requested is actually a valid subset. |
| Fields Summary |
|---|
| public static final int | ANYThe user is allowed to enter any text.
Line breaks may be entered.
Constant 0 is assigned to ANY. | | public static final int | EMAILADDRThe user is allowed to enter an e-mail address.
Constant 1 is assigned to EMAILADDR. | | public static final int | NUMERICThe user is allowed to enter only an integer value. The implementation
must restrict the contents either to be empty or to consist of an
optional minus sign followed by a string of one or more decimal
numerals. Unless the value is empty, it will be successfully parsable
using {@link java.lang.Integer#parseInt(String)}.
The minus sign consumes space in the text object. It is thus
impossible to enter negative numbers into a text object whose maximum
size is 1.
Constant 2 is assigned to NUMERIC. | | public static final int | PHONENUMBERThe user is allowed to enter a phone number. The phone number is a
special
case, since a phone-based implementation may be linked to the
native phone
dialing application. The implementation may automatically start a phone
dialer application that is initialized so that pressing a single key
would be enough to make a call. The call must not made automatically
without requiring user's confirmation. Implementations may also
provide a feature to look up the phone number in the device's phone or
address database.
The exact set of characters allowed is specific to the device and to
the device's network and may include non-numeric characters, such as a
"+" prefix character.
Some platforms may provide the capability to initiate voice calls
using the {@link javax.microedition.midlet.MIDlet#platformRequest
MIDlet.platformRequest} method.
Constant 3 is assigned to PHONENUMBER. | | public static final int | URLThe user is allowed to enter a URL.
Constant 4 is assigned to URL. | | public static final int | DECIMALThe user is allowed to enter numeric values with optional decimal
fractions, for example "-123", "0.123", or
".5".
The implementation may display a period "." or a
comma "," for the decimal fraction separator, depending on
the conventions in use on the device. Similarly, the implementation
may display other device-specific characters as part of a decimal
string, such as spaces or commas for digit separators. However, the
only characters allowed in the actual contents of the text object are
period ".", minus sign "-", and the decimal
digits.
The actual contents of a DECIMAL text object may be
empty. If the actual contents are not empty, they must conform to a
subset of the syntax for a FloatingPointLiteral as defined
by the Java Language Specification, section 3.10.2. This
subset syntax is defined as follows: the actual contents
must consist of an optional minus sign
"-", followed by one or more whole-number decimal digits,
followed by an optional fraction separator, followed by zero or more
decimal fraction digits. The whole-number decimal digits may be
omitted if the fraction separator and one or more decimal fraction
digits are present.
The syntax defined above is also enforced whenever the application
attempts to set or modify the contents of the text object by calling
a constructor or a method.
Parsing this string value into a numeric value suitable for
computation is the responsibility of the application. If the contents
are not empty, the result can be parsed successfully by
Double.valueOf and related methods if they are present
in the runtime environment.
The sign and the fraction separator consume space in the text
object. Applications should account for this when assigning a maximum
size for the text object.
Constant 5 is assigned to DECIMAL. | | public static final int | PASSWORDIndicates that the text entered is confidential data that should be
obscured whenever possible. The contents may be visible while the
user is entering data. However, the contents must never be divulged
to the user. In particular, the existing contents must not be shown
when the user edits the contents. The means by which the contents
are obscured is implementation-dependent. For example, each
character of the data might be masked with a
"*" character. The
PASSWORD modifier is useful for entering
confidential information
such as passwords or personal identification numbers (PINs).
Data entered into a PASSWORD field is treated
similarly to SENSITIVE
in that the implementation must never store the contents into a
dictionary or table for use in predictive, auto-completing, or other
accelerated input schemes. If the PASSWORD bit is
set in a constraint
value, the SENSITIVE and
NON_PREDICTIVE bits are also considered to be
set, regardless of their actual values. In addition, the
INITIAL_CAPS_WORD and
INITIAL_CAPS_SENTENCE flag bits should be ignored
even if they are set.
The PASSWORD modifier can be combined with
other input constraints
by using the bit-wise OR operator (|).
The PASSWORD modifier is not
useful with some constraint values such as
EMAILADDR, PHONENUMBER,
and URL. These combinations are legal, however,
and no exception is
thrown if such a constraint is specified.
Constant 0x10000 is assigned to
PASSWORD. | | public static final int | UNEDITABLEIndicates that editing is currently disallowed. When this flag is set,
the implementation must prevent the user from changing the text
contents of this object. The implementation should also provide a
visual indication that the object's text cannot be edited. The intent
of this flag is that this text object has the potential to be edited,
and that there are circumstances where the application will clear this
flag and allow the user to edit the contents.
The UNEDITABLE modifier can be combined with
other input constraints
by using the bit-wise OR operator (|).
Constant 0x20000 is assigned to UNEDITABLE. | | public static final int | SENSITIVEIndicates that the text entered is sensitive data that the
implementation must never store into a dictionary or table for use in
predictive, auto-completing, or other accelerated input schemes. A
credit card number is an example of sensitive data.
The SENSITIVE modifier can be combined with other input
constraints by using the bit-wise OR operator
(|).
Constant 0x40000 is assigned to
SENSITIVE. | | public static final int | NON_PREDICTIVEIndicates that the text entered does not consist of words that are
likely to be found in dictionaries typically used by predictive input
schemes. If this bit is clear, the implementation is allowed to (but
is not required to) use predictive input facilities. If this bit is
set, the implementation should not use any predictive input facilities,
but it instead should allow character-by-character text entry.
The NON_PREDICTIVE modifier can be combined
with other input
constraints by using the bit-wise OR operator
(|).
Constant 0x80000 is assigned to
NON_PREDICTIVE. | | public static final int | INITIAL_CAPS_WORDThis flag is a hint to the implementation that during text editing, the
initial letter of each word should be capitalized. This hint should be
honored only on devices for which automatic capitalization is
appropriate and when the character set of the text being edited has the
notion of upper case and lower case letters. The definition of
word boundaries is implementation-specific.
If the application specifies both the
INITIAL_CAPS_WORD and the
INITIAL_CAPS_SENTENCE flags,
INITIAL_CAPS_WORD behavior should be used.
The INITIAL_CAPS_WORD modifier can be combined
with other input
constraints by using the bit-wise OR operator
(|).
Constant 0x100000 is assigned to
INITIAL_CAPS_WORD. | | public static final int | INITIAL_CAPS_SENTENCEThis flag is a hint to the implementation that during text editing, the
initial letter of each sentence should be capitalized. This hint
should be honored only on devices for which automatic capitalization is
appropriate and when the character set of the text being edited has the
notion of upper case and lower case letters. The definition of
sentence boundaries is implementation-specific.
If the application specifies both the
INITIAL_CAPS_WORD and the
INITIAL_CAPS_SENTENCE flags,
INITIAL_CAPS_WORD behavior should be used.
The INITIAL_CAPS_SENTENCE modifier can be
combined with other input
constraints by using the bit-wise OR operator
(|).
Constant 0x200000 is assigned to
INITIAL_CAPS_SENTENCE. | | public static final int | CONSTRAINT_MASKThe mask value for determining the constraint mode. The application
should
use the bit-wise AND operation with a value returned by
getConstraints() and
CONSTRAINT_MASK in order to retrieve the current
constraint mode,
in order to remove any modifier flags such as the
PASSWORD flag.
Constant 0xFFFF is assigned to
CONSTRAINT_MASK. | | private boolean | firstTimeInTraverseflag indicating if it is the first time that traverse is being
called | | private boolean | editableeditable state of the text field | | private boolean | fitsOneLineAn internal flag, True means this TextField prefers to be on one line | | private static int | BORDER_PADThe pixel padding around this TextField to draw the border | | com.sun.midp.lcdui.DynamicCharacterArray | bufferbuffer to store the text | | com.sun.midp.lcdui.TextCursor | cursorcursor to keep track of where to draw the cursor | | char | currentInputCharcurrent character waiting to be committed | | int | oldNumCharsprevious number of characters in the buffer | | boolean | multiLinetrue if the text field is allowed to have multiple lines | | boolean | hasBordertrue if the text field should draw a border | | boolean | usePreferredXtrue if the preferredX field in TextCursor should be updated with
the latest TextCursor.x coordinate | | String | initialInputModethe initial input mode for when the text field gets focus | | com.sun.midp.lcdui.InputMethodHandler | inputHandlerthe input handler to use to retreive input | | InputMethodClientImpl | inputClientthe input client to receive callbacks from the input handler | | private boolean | ignoreNextKeyEnteredwill ignore the next key entered.
used if we know input buffer is full | | private char[] | inputCharsbuffer to hold characters that will be inserted when
the user enters text |
| Constructors Summary |
|---|
public TextField(String label, String text, int maxSize, int constraints)Creates a new TextField object with the given label, initial
contents, maximum size in characters, and constraints.
If the text parameter is null, the
TextField is created empty.
The maxSize parameter must be greater than zero.
An IllegalArgumentException is thrown if the
length of the initial contents string exceeds maxSize.
However,
the implementation may assign a maximum size smaller than the
application had requested. If this occurs, and if the length of the
contents exceeds the newly assigned maximum size, the contents are
truncated from the end in order to fit, and no exception is thrown.
super(label);
synchronized (Display.LCDUILock) {
// IllegalArgumentException thrown here
buffer = new DynamicCharacterArray(maxSize);
cursor = new TextCursor(0);
cursor.visible = false;
hasBorder = true;
inputHandler = InputMethodHandler.getInputMethodHandler();
inputClient = new InputMethodClientImpl();
//
// we need to set the constraints before we tell the
// handler about the client
//
setConstraints(constraints);
inputClient.setInputMethodHandler(inputHandler);
inputHandler.setInputMethodClient(inputClient);
//
// this will use inputClient
//
setString(text);
}
|
| Methods Summary |
|---|
| void | callHideNotify()Called when this item is hidden
firstTimeInTraverse = true;
| | void | callKeyPressed(int keyCode)Handle a key press
synchronized (Display.LCDUILock) {
if (Display.getSystemKey(keyCode) ==
EventHandler.SYSTEM_KEY_SEND) {
if ((inputClient.getConstraints() & TextField.CONSTRAINT_MASK)
== TextField.PHONENUMBER) {
PhoneDial.call(getString());
}
return;
}
if (!editable) {
// play sound
AlertType.WARNING.playSound(owner.currentDisplay);
return;
}
/*
* At present, Form uses all of the arrow keys for traversal,
* so keystrokes for the arrow keys are never delivered here.
* If the traversal policy changes such that keystrokes on the
* arrow keys might be delivered here, this code should be
* uncommented.
*************************************************************
*
if (keyCode == Display.KEYCODE_UP
|| keyCode == Display.KEYCODE_DOWN
|| keyCode == Display.KEYCODE_LEFT
|| keyCode == Display.KEYCODE_RIGHT) {
if (moveCursor(Display.getGameAction(keyCode))) {
invalidate();
return;
}
}
*
*************************************************************
*/
int key;
if ((key = inputHandler.keyPressed(keyCode)) !=
InputMethodHandler.KEYCODE_NONE) {
if (buffer.length() == buffer.capacity()) {
// play sound
AlertType.WARNING.playSound(owner.currentDisplay);
inputHandler.flush();
return;
}
currentInputChar = (char)key;
cursor.visible = false;
invalidate();
return;
}
}
| | void | callKeyReleased(int keyCode)Handle a key release event
synchronized (Display.LCDUILock) {
inputHandler.keyReleased(keyCode);
}
| | void | callKeyRepeated(int keyCode)Handle a key repeated event
callKeyPressed(keyCode);
| | void | callKeyTyped(char c)Handle a key typed event
synchronized (Display.LCDUILock) {
if (!editable) {
// play sound
AlertType.WARNING.playSound(owner.currentDisplay);
return;
}
inputHandler.keyTyped(c);
}
| | int | callMinimumHeight()Return the minimum height required for this TextField
// Plus pixels to draw the box around the text
return Screen.CONTENT_HEIGHT + (2 * BORDER_PAD);
| | int | callMinimumWidth()Return the minimum width required for this TextField
if ((layout == Item.LAYOUT_DEFAULT) || (equateNLB() && equateNLA())) {
if (owner != null) {
return owner.getWidth();
}
}
return (Screen.CONTENT_FONT.charWidth('W") * 8);
| | void | callPaint(Graphics g, int width, int height)Paint this TextField
//
// draw label
//
int labelHeight = getLabelHeight(width);
int labelWidth = getLabelWidth();
// Add some padding
if (labelWidth > 0) {
labelWidth += LABEL_PAD;
}
if (g.getClipY() < labelHeight) {
if (fitsOneLine) {
g.translate(0, LABEL_PAD);
}
super.paintLabel(g, width);
if (fitsOneLine) {
g.translate(0, -LABEL_PAD);
}
}
if (fitsOneLine) {
width = width - labelWidth;
g.translate(labelWidth, 0);
} else {
height = height - labelHeight;
g.translate(0, labelHeight);
}
if (hasBorder) {
if (!hasFocus) {
g.setColor(0x00AFAFAF);
}
// draw box
g.drawRect(0, 0, width - 1, height - 1);
}
g.setColor(editable ? Display.FG_COLOR : 0x00AFAFAF);
g.translate(BORDER_PAD + 1, BORDER_PAD);
TextPolicy.paint(buffer, currentInputChar,
inputClient.getConstraints(), inputHandler,
Screen.CONTENT_FONT,
g, width - (2 * BORDER_PAD + 1), height, 0,
Text.NORMAL, cursor);
g.translate(-(BORDER_PAD + 1), -BORDER_PAD);
if (fitsOneLine) {
g.translate(-labelWidth, 0);
} else {
g.translate(0, -labelHeight);
}
g.setColor(Display.FG_COLOR);
if (usePreferredX) {
cursor.preferredX = cursor.x;
}
| | int | callPreferredHeight(int w)Get the preferred height for this TextField for the given width
fitsOneLine = (w == -1) ? true : (w >= callPreferredWidth(-1));
if (fitsOneLine) {
return (2 * BORDER_PAD) + Screen.CONTENT_HEIGHT;
} else {
if (buffer.length() == 0) {
return (2 * BORDER_PAD) + getLabelHeight(w) +
Screen.CONTENT_HEIGHT;
} else {
return (2 * BORDER_PAD) + getLabelHeight(w) +
Text.getHeightForWidth(
TextPolicy.getDisplayString(buffer,
currentInputChar,
inputClient.getConstraints(),
inputHandler, cursor),
Screen.CONTENT_FONT, w - (2 * BORDER_PAD + 1), 0);
}
}
| | int | callPreferredWidth(int h)Get the preferred width for this TextField for the given height
// FIX ME: we ignore the 'h' value and just return
// a basic width based on our contents. That is, this
// StringItem's preferred width is always based on
// being one line high
int textW = Screen.CONTENT_FONT.charWidth('W") * buffer.capacity();
// Plus pixels to draw the box around the text
textW += (2 * BORDER_PAD);
int labelW = getLabelWidth();
if (labelW > 0) {
labelW += LABEL_PAD;
}
return textW + labelW;
| | boolean | callTraverse(int dir, int viewportWidth, int viewportHeight, int[] visRect_inout)Called by the system
The default implementation of the traverse() method always returns
false.
super.callTraverse(dir, viewportWidth, viewportHeight, visRect_inout);
boolean ret = false;
usePreferredX = !(dir == Canvas.UP || dir == Canvas.DOWN);
if (firstTimeInTraverse || dir == CustomItem.NONE) {
if (firstTimeInTraverse) {
inputClient.setInputMode(initialInputMode);
inputHandler.setInputMethodClient(inputClient);
cursor.option = Text.PAINT_USE_CURSOR_INDEX;
cursor.visible = editable;
firstTimeInTraverse = false;
}
repaint();
if (owner.currentDisplay != null) {
owner.currentDisplay.serviceRepaints(owner);
}
ret = true;
} else {
inputHandler.endComposition(false);
if (moveCursor(dir)) {
repaint();
if (owner.currentDisplay != null) {
owner.currentDisplay.serviceRepaints(owner);
}
ret = true;
}
}
visRect_inout[X] = cursor.x;
visRect_inout[Y] = cursor.y - cursor.height;
if (!fitsOneLine) {
// If we're not on one line, we adjust for any
// possible label offset
visRect_inout[Y] += getLabelHeight(visRect_inout[WIDTH]);
}
visRect_inout[WIDTH] = cursor.width;
// We include space for the border padding and for the
// border so that when we "traverse" to the last line
// in the TextField, Form will scroll far enough to include
// our border as well as room for the traversal box
visRect_inout[HEIGHT] = cursor.height + BORDER_PAD + 2;
return ret;
| | void | callTraverseOut()Called by the system to indicate traversal has left this Item
super.callTraverseOut();
firstTimeInTraverse = true;
inputHandler.clearInputMethodClient(inputClient);
// We re-set the Display's input mode indicator
try {
owner.currentDisplay.setInputMode(0);
} catch (Throwable t) {
// if owner.currentDisplay is null, we just
// quietly catch the error and continue
}
cursor.option = Text.PAINT_USE_CURSOR_INDEX;
cursor.index = buffer.length();
cursor.visible = false;
repaint();
| | void | commitPendingInteraction()Called to commit any pending character from the input handler
inputHandler.endComposition(false);
| | public void | delete(int offset, int length)Deletes characters from the TextField.
The offset and length parameters must
specify a valid range of characters within
the contents of the TextField.
The offset parameter must be within the
range [0..(size())], inclusive.
The length parameter
must be a non-negative integer such that
(offset + length) <= size().
synchronized (Display.LCDUILock) {
if (length == 0) {
return;
}
String str = buffer.toString();
buffer.delete(offset, length);
if (!TextPolicy.isValidString(buffer,
inputClient.getConstraints())) {
buffer.delete(0, buffer.length());
buffer.insert(0, str);
throw new IllegalArgumentException();
}
if (cursor.index >= offset) {
int diff = cursor.index - offset;
cursor.index -= (diff < length) ? diff : length;
cursor.option = Text.PAINT_USE_CURSOR_INDEX;
}
invalidate();
}
| | boolean | equateNLA()Determine if this Item should have a newline after it
if (super.equateNLA()) {
return true;
}
return ((layout & Item.LAYOUT_2) != Item.LAYOUT_2);
| | boolean | equateNLB()Determine if this Item should have a newline before it
if (super.equateNLB()) {
return true;
}
return ((layout & Item.LAYOUT_2) != Item.LAYOUT_2);
| | public int | getCaretPosition()Gets the current input position. For some UIs this may block and ask
the user for the intended caret position, and on other UIs this may
simply return the current caret position.
synchronized (Display.LCDUILock) {
return cursor.index;
}
| | public int | getChars(char[] data)Copies the contents of the TextField into a
character array starting at
index zero. Array elements beyond the characters copied are left
unchanged.
synchronized (Display.LCDUILock) {
try {
buffer.getChars(0, buffer.length(), data, 0);
} catch (IndexOutOfBoundsException e) {
throw new ArrayIndexOutOfBoundsException(e.getMessage());
}
return buffer.length();
}
| | public int | getConstraints()Gets the current input constraints of the TextField.
synchronized (Display.LCDUILock) {
return inputClient.getConstraints();
}
| | public int | getMaxSize()Returns the maximum size (number of characters) that can be
stored in this TextField.
synchronized (Display.LCDUILock) {
return buffer.capacity();
}
| | public java.lang.String | getString()Gets the contents of the TextField as a string value.
synchronized (Display.LCDUILock) {
return buffer.toString();
}
| | public void | insert(java.lang.String src, int position)Inserts a string into the contents of the
TextField. The string is
inserted just prior to the character indicated by the
position parameter, where zero specifies the first
character of the contents of the TextField. If
position is
less than or equal to zero, the insertion occurs at the beginning of
the contents, thus effecting a prepend operation. If
position is greater than or equal to the current size of
the contents, the insertion occurs immediately after the end of the
contents, thus effecting an append operation. For example,
text.insert(s, text.size()) always appends the string
s to the current contents.
The current size of the contents is increased by the number of
inserted characters. The resulting string must fit within the current
maximum capacity.
If the application needs to simulate typing of characters it can
determining the location of the current insertion point
("caret")
using the with {@link #getCaretPosition() getCaretPosition()} method.
For example,
text.insert(s, text.getCaretPosition()) inserts the string
s at the current caret position.
insert(src.toCharArray(), 0, src.length(), position);
| | public void | insert(char[] data, int offset, int length, int position)Inserts a subrange of an array of characters into the contents of
the TextField. The offset and
length parameters indicate the subrange
of the data array to be used for insertion. Behavior is otherwise
identical to {@link #insert(String, int) insert(String, int)}.
The offset and length parameters must
specify a valid range of characters within
the character array data.
The offset parameter must be within the
range [0..(data.length)], inclusive.
The length parameter
must be a non-negative integer such that
(offset + length) <= data.length.
synchronized (Display.LCDUILock) {
int pos = buffer.insert(data, offset, length, position);
if (!TextPolicy.isValidString(buffer,
inputClient.getConstraints())) {
buffer.delete(pos, length);
throw new IllegalArgumentException();
}
if (position <= cursor.index) {
cursor.index += length;
cursor.option = Text.PAINT_USE_CURSOR_INDEX;
}
invalidate();
}
| | private void | insert(char ch, int position)Insert a single character at the given position
char chArray[] = { ch };
insert(chArray, 0, 1, position);
| | void | keyEntered(int keyCode)Handle a key committed from the input handler
synchronized (Display.LCDUILock) {
oldNumChars = buffer.length();
cursor.visible = true;
currentInputChar = 0;
switch (keyCode) {
case InputMethodHandler.KEYCODE_CLEARALL:
if (buffer.length() > 0) {
delete(0, buffer.length());
notifyStateChanged();
}
break;
case InputMethodHandler.KEYCODE_CLEAR:
try {
if (cursor.index > 0) {
delete(cursor.index - 1, 1);
notifyStateChanged();
}
} catch (IllegalArgumentException e) {
if (buffer.length() > 0) {
delete(0, buffer.length());
notifyStateChanged();
}
}
break;
case InputMethodHandler.KEYCODE_SIGNCHANGE:
try {
if (buffer.length() > 0) {
if (buffer.charAt(0) == '-") {
delete(0, 1);
} else {
insert('-", 0);
}
notifyStateChanged();
}
} catch (IllegalArgumentException e) {
//
// beep?
//
AlertType.WARNING.playSound(owner.currentDisplay);
}
break;
default:
try {
int inputLength = 0;
if ((inputClient.getConstraints() & CONSTRAINT_MASK)
== DECIMAL) {
if (keyCode == '." && buffer.length() == 0) {
inputChars[inputLength] = '0";
inputLength++;
}
}
inputChars[inputLength] = (char)keyCode;
inputLength++;
insert(inputChars, 0, inputLength, cursor.index);
notifyStateChanged();
} catch (IllegalArgumentException e) {
//
// beep?
//
AlertType.WARNING.playSound(owner.currentDisplay);
}
break;
}
}
| | boolean | moveCursor(int dir)Move the text cursor in the given direction
boolean keyUsed = false;
int height;
switch (dir) {
case Canvas.LEFT:
if (cursor.index > 0) {
cursor.index--;
cursor.option = Text.PAINT_USE_CURSOR_INDEX;
keyUsed = true;
}
break;
case Canvas.RIGHT:
if (cursor.index < buffer.length()) {
cursor.index++;
cursor.option = Text.PAINT_USE_CURSOR_INDEX;
keyUsed = true;
}
break;
case Canvas.UP:
if (multiLine) {
cursor.y -= Screen.CONTENT_FONT.getHeight();
if (cursor.y > 0) {
cursor.option = Text.PAINT_GET_CURSOR_INDEX;
keyUsed = true;
} else {
cursor.y += Screen.CONTENT_FONT.getHeight();
}
}
break;
case Canvas.DOWN:
if (multiLine) {
cursor.y += Screen.CONTENT_FONT.getHeight();
height = bounds[HEIGHT];
if (getLabelHeight(bounds[WIDTH]) != height) {
height -= getLabelHeight(bounds[WIDTH]);
}
if (cursor.y < height) {
cursor.option = Text.PAINT_GET_CURSOR_INDEX;
keyUsed = true;
} else {
cursor.y -= Screen.CONTENT_FONT.getHeight();
}
}
break;
}
return keyUsed;
| | void | setBorder(boolean state)Turns the border on or off
hasBorder = state;
| | public void | setChars(char[] data, int offset, int length)Sets the contents of the TextField from a
character array, replacing the
previous contents. Characters are copied from the region of the
data array
starting at array index offset and running for
length characters.
If the data array is null, the TextField
is set to be empty and the other parameters are ignored.
The offset and length parameters must
specify a valid range of characters within
the character array data.
The offset parameter must be within the
range [0..(data.length)], inclusive.
The length parameter
must be a non-negative integer such that
(offset + length) <= data.length.
synchronized (Display.LCDUILock) {
if (data == null) {
buffer.delete(0, buffer.length());
cursor.index = 0;
cursor.option = Text.PAINT_USE_CURSOR_INDEX;
} else {
if (offset < 0 || offset > data.length
|| length < 0 || length > data.length
|| offset + length < 0
|| offset + length > data.length) {
throw new ArrayIndexOutOfBoundsException();
}
if (length > buffer.capacity()) {
throw new IllegalArgumentException();
}
if (length > 0) {
DynamicCharacterArray dca =
new DynamicCharacterArray(length);
dca.set(data, offset, length);
if (!TextPolicy.isValidString(dca,
inputClient.getConstraints())) {
throw new IllegalArgumentException();
}
}
buffer.set(data, offset, length);
cursor.index = buffer.length();
cursor.option = Text.PAINT_USE_CURSOR_INDEX;
}
invalidate();
}
| | public void | setConstraints(int constraints)Sets the input constraints of the TextField. If
the the current contents
of the TextField do not match the new
constraints, the contents are
set to empty.
synchronized (Display.LCDUILock) {
if ((constraints & CONSTRAINT_MASK) < ANY ||
(constraints & CONSTRAINT_MASK) > DECIMAL) {
throw new IllegalArgumentException();
}
if (inputClient.setConstraints(constraints)) {
if (!TextPolicy.isValidString(buffer, constraints)) {
delete(0, buffer.length());
}
}
// saved the editable state
editable = !((UNEDITABLE & constraints) == UNEDITABLE);
multiLine = (constraints & CONSTRAINT_MASK) != PHONENUMBER;
invalidate();
}
| | public void | setInitialInputMode(java.lang.String characterSubset)Sets a hint to the implementation as to the input mode that should be
used when the user initiates editing of this TextField. The
characterSubset parameter names a subset of Unicode
characters that is used by the implementation to choose an initial
input mode. If null is passed, the implementation should
choose a default input mode.
See Input Modes for a full explanation of input
modes.
synchronized (Display.LCDUILock) {
initialInputMode = characterSubset;
}
| | public int | setMaxSize(int maxSize)Sets the maximum size (number of characters) that can be contained
in this
TextField. If the current contents of the
TextField are larger than
maxSize, the contents are truncated to fit.
synchronized (Display.LCDUILock) {
int oldCapacity = buffer.capacity();
buffer.setCapacity(maxSize);
if (!TextPolicy.isValidString(buffer,
inputClient.getConstraints())) {
buffer.setCapacity(oldCapacity);
throw new IllegalArgumentException();
}
invalidate();
return buffer.capacity();
}
| | public void | setString(java.lang.String text)Sets the contents of the TextField as a string
value, replacing the
previous contents.
if (text == null) {
setChars(null, 0, 0);
} else {
setChars(text.toCharArray(), 0, text.length());
}
| | public int | size()Gets the number of characters that are currently stored in this
TextField.
synchronized (Display.LCDUILock) {
return buffer.length();
}
|
|
