1. 11.1 资源元素
   1. 11.1.1 建立资源包
      1. 11.1.1.1 建立资源
      2. 11.1.1.2 载入资源
   2. 11.1.2  图像资源
   3. 11.1.3 索引图像
   4. 11.1.4 字体
      1. 11.1.4.1 系统字体
      2. 11.1.4.2 动态字体
   5. 11.1.5 本地化（L10N）
   6. 11.1.6 主题
2. 11.2 LWUIT Theme Creator
   1. 11.2.1 图像和动画
   2. 11.2.2 字体
   3. 11.2.3 本地化
   4. 11.2.4 主题
      1. 11.2.4.1 例子：添加一个新主题
      2. 11.2.4.2 修改主题的属性
      3. 11.2.4.3 数据
      4. 11.2.4.4 自定义预览面板
      5. 11.2.4.5 已知问题

《LWUIT 开发者指南 LWUIT Developer Guide》

LWUIT 允许使用下列资源：

• 图像资源
• 动态字体
• 本地化包（L10N Bundle）
• 主题

资源可以作为一个包（一个可以在设备上载入和使用的二进制文件）发布。一个包可以在一个文件中组合几种不同资源类型，因此简化了发布过程和改善压缩比率。LWUIT 支持两种建立资源包的方法：

• 使用一组 Ant 任务
• 或者图形化的主题建立工具（请参见 【Theme Creator】）

11.1 资源元素

下面的章节详细讲述了五种资源类型以及它们以何种方式与资源包机制关联。

11.1.1 建立资源包

可以在应用程序标准构建过程中使用 Ant 建立资源包。资源文件必要时将已存在的文件转换为资源包。一个应用程序可以有任意数量的资源文件。

一个资源文件被完整地载入内存（受 Java ME IO 的限制），因此你应该根据应用程序流程的需要对资源进行分组。这将允许应用程序只载入某个给定窗体或用例所需的资源，以节省内存用于其他窗体或用例需要的资源。

11.1.1.1 建立资源

为了建立一个 Resource，在你的 build 文件里使用类似于下例子示的代码：

<taskdef
  classpath="editor.jar"
  classname="com.sun.lwuit.tools.resourcebuilder.LWUITTask"
  name="build" />
<build dest="src/myresourceFile .res">
  <image file="images/myImage.png" name=”imageName” />
</build>

你可以把几种额外的资源类型加入 build 标签。这些可选的资源标签在本章后面的章节中讲述。

11.1.1.2 载入资源

使用类似下面所示的代码把资源载入你的应用程序：

Resources res = Resources.open(“/myresourceFile.res”);
Image i = res.getImage(“imageName”);

11.1.2  图像资源

LWUIT 里有几种图像类型，它们中的大多数既能单独存储在 JAR 文件里，也能打包放进资源包内。

使用下面的代码载入 JAR 文件里存储的图像：

Image image = Image.createImage("/images/duke.png");

Image 标签支持下列属性：

一旦被载入，图像就可以用作组件的背景，甚至可以作为一个能够包含图像的组件的图标。

可以使用索引图像里的示例代码把图像打包放进资源包。

11.1.3 索引图像

图像在程序运行时会占用大量内存。例如，一个作为 320×240 分辨率 1.6 百万色手机背景的不想将占用 320×240x4 字节（307200 字节 = 300 KB）。

某些设备只给 Java 分配了 2Mb 的 RAM，同时还具有高分辨率和高发色数，因此应用程序只有很少的空间可以使用。索引图像使用调色板绘制，而不是把图像保存为一组 Alpha，Red，Green 和 Blue（ARGB）数据，索引图像基于如下的设想：一个图像里的颜色不会多余256种（如果有更多颜色，Ant 任素将尝试适当降低颜色数，这样做会对是一些细节）。一个有 256 或更少色彩的图像可以用一个字节数组及一个整数数组（不大于 256×4=1KB）来表示，因此可以减少大约百分之 70 的 RAM 占用！

例如，假设上面提到的图像使用了所有的 256 中颜色，它占用的内存将会是 320×240+1024（77824 字节 = 76 KB），或者说节约了百分之 74.7 的空间！因为这种做法能够显著地节省内存占用，因此它在低端设备上特别受欢迎。

使用索引图像的缺点如下：

• 因为索引图像在绘制时需要对每一个像素进行查询，因此绘制速度较慢。这在绘制复杂元素的时候可以觉察到速度的下降，但在现代设备上（甚至在比较低端的设备上）并不明显。
• 必须使用资源包来存储索引图像，因为没有所有 Java ME 设备都能支持的索引图像标准存储格式。
• 在运行时把图像转换为索引图像的速度可能非常慢，甚至可能失败（如果发色数很高的话），这就是为什么要在构建阶段选择索引图像比较有利的原因。
• 因为索引图像保存的时候没有被压缩，因此资源文件的尺寸看起来比较大（在设备上需要的保存空间也较大），但是，实际使用时 JAR 文件里索引图像的压缩比例很高，因此实际上它压缩后所占用的空间要小于相同的 PNG 图像）。

更多有关内容可以参考 IndexedImage API 文档。因为索引图像从 Image 类派生，因此它们可以很好地在程序中代替 Image 类对象并保持兼容。

注意：索引图像不能变动（immutable），建立后不能被修改，因此象 getGraphics() 这样的方法不能正确工作。请查阅 API 文档来验证合适的功能。

11.1.4 字体

LWUIT 库支持位图字体（Bitmap Font），系统字体，以及可加载字体（Loadable Font）：

• 系统字体使用基本的原生字体，基于通用 MIDP 字体。更多内容请参见 install-dir/docs/api/lwuit 下的 Font API 文档。
• 位图字体在桌面上生成作为图像文件的字体。这些图像可以用于在不需设备特殊支持的情况下绘制桌面高质量字体。
• 可载入字体支持使用名字甚至 TrueType 字体文件指定字体，如果底层操作系统支持这些字体，就会建立字体对象。

所有字体都能用于主题文件并用 LWUIT 的 Font 类表示。

11.1.4.1 系统字体

使用三个基本参数可以定义一个系统字体：

使用下面的代码建立一个系统字体：

Font.createSystemFont(Font.FACE_SYSTEM,
                      Font.STYLE_BOLD,
                      Font.SIZE_MEDIUM);

使用下面的代码建立一个粗/斜体字体样式：

Font.createSystemFont(Font.FACE_SYSTEM,
                      Font.STYLE_BOLD | Font.STYLE_ITALIC,
                      Font.SIZE_MEDIUM);

11.1.4.2 动态字体

不同的平台提供不同的字体支持，例如，手机通常只支持系统字体和位图字体，而电视通常支持 TrueType 字体，但对位图字体的支持不佳。LWUIT 支持在资源中定义字体，允许资源适配不同设备。为了实现可移植性，如果底层系统支持某个可加载字体，LWUIT 允许指定它，并允许打包位图以进一步提高可移植性。作为后备，总是会定义一个系统字体，这样就可以在系统不支持原生字体或开发者不想使用位图字体的时候使用这个系统字体。也可以使用下面的格式利用 Ant 任务定义一个字体：

<build dest="src/myresourceFile.res">
     <font logicalName=”SansSerif” name=”myFont” size=”20” />
</build>

字体的 Ant 任务支持下列属性：

11.1.5 本地化（L10N）

资源包支持本地化资源，允许开发者在资源文件里存储“键-值”对。本地化包使用 Java 属性文件格式，只支持 USASCII 字符。要输入其他语言的字符，可以使用特殊的编辑器（例如 NetBeans）或与 Ant 任务一同使用 JDK native2ascii 工具来转换文件。

使用下面的代码建立一个资源包：

<build dest="src/myresourceFile.res">
   <l10n name="localize">
      <locale name="en" file="l10n/localize.properties" />
       <locale name="iw" file="l10n/localize_iw_IL.properties" />
   </l10n>
</build>

使用下面的语法格式载入本地化资源：

Hashtable h = bundle.getL10N("localize", "en");

这个哈希表包含了资源包里定义的资源键值对，简化了本地化工作。LWUIT 通过 UIManager.setResourceBundle(Hashtable) 方法支持自动自动本地化。这样做将在建立一个本地化资源时安装一个全局资源包，因此允许替换整个 UI 语言而不需要手工查询资源包。

11.1.6 主题

This section discusses how themes work as resources. See Chapter 8 and Chapter 10 to both of these chapters in-depth discussions of styles and theming in LWUIT.

这一节讨论如何把主题作为资源使用。更多关于 LWUIT 样式和主题的深入内容请参考【第八章】和【第十章】。

A theme can be defined using a key value properties file containing selectors and values. A selector can be defined as an attribute value, optionally with a component name prepended to it for narrowing the selection further.

可以使用一个包含选择器（Selector）以及值的键值属性文件定义一个主题。一个选择器可以被定义为一个属性值，可选地，在属性前加上一个组件名作为前缀来进一步缩小选择范围。

The value of an entry in the theme depends on the type of the entry, some entries such as bgImage expect an image object and some entries such as Font expect a font definition. Most entries just expect numbers. For example, this is a typical snippet from a theme:

主题中某个条目的值取决于这个条目的类型，某些条目例如 bgImage 的值是一个图像对象，某些条目例如 Font 的值则是一个字体定义。大多数条目的值就是数字。例如，下面是一个主题中的常见片段：

sel#fgColor= 0017ff
font= systemSmall
Form.bgImage=myBackground
Form.font=Serif
SoftButton.bgColor= ff
SoftButton.fgColor= ffffff

使用下面的代码把这个主题加入一个资源：

<build dest="src/myresourceFile .res">
   <font logicalName="Serif" bold="true" />
   <font createBitmap="false" name="systemSmall"
        system="FACE_SYSTEM ; STYLE_PLAIN; SIZE_SMALL" />
   <image file="images/background.png" name="myBackground"
        pack="true" />
   <theme file="themes/myTheme.conf" name="myTheme" />
</build>

可以使用下面的代码安装这个主题：

UIManager.getInstance().setThemeProps(res.getTheme(myTheme));

11.2 LWUIT Theme Creator

… …

Theme Creator 能够完成 Ant 任务能够完成的工作，只有一个限制：在 Theme Creator 里，主题使用的所有位图字体必须在主题内部定义，主题不能引用其他资源文件里定义的位图字体。

Theme Creator 支持资源元素里描述的六种资源类型。

… …

11.2.1 图像和动画

图像和动画可以用于主题或 LWUIT 应用程序。Theme Creator 支持图像（JPEG，PNG）和动画 GIF。图像和动画可以使用 … 按钮来替换。

标准图像也可以被索引。索引图像在最终应用程序里占用的空间更小，因此占用的内存也更小，但是绘制它需要更长的时间而且只支持 256 中颜色。当你点击 Indexed 图像单选按钮时，将检验颜色的数目。如果颜色多于 256 种颜色，应用程序将尝试减少发色数（将给出画质选项）。一个好方法是在包含图像前使用图像编辑工具来对它们进行索引。

11.2.2 字体

Theme Creator 可以使用设备特定字体或从任何桌面系统字体生成位图字体。… …

… …

为了建立位图字体，必须选择“Create Bitmap”复选框。确定指定了这种字体里你所需要的字符（默认是英文大小写字母、数字及符号）。注意：从字体中挑选的字符越多，字体占用设备的 RAM 就越多。位图字体内建了反锯齿（Anti-aliasing）功能。但在 Java 5 下运行时，Theme Creator 有两个反锯齿选项：Off 表示这个位图字体里没有反锯齿功能，Simple 表示标准反锯齿功能。

11.2.3 本地化

A localization resource can be edited by assigning key/value pairs to use within the application. A key can be mapped to a resource name (?) in any locale.

可以通过分配键值对使用本程序来编辑本地化资源。一个键可以映射到任何 Locale 的一个资源名。

… …

11.2.4 主题

为了修改主题资源，可以设置选择器和主题资源为适当的值来生成漂亮的 UI。当建立新主题时，将显示一个包含选择器和资源的表格（开发者需要的关于主题的更深入内容请参见【第十章】）。

要修改主题，在左边选择一个选择器并点击 Edit 按钮。你可以使用 Add 按钮在主题中添加新选择器。要修改一个已经存在的选择器，选择它并双击或按下 Edit 按钮。

11.2.4.1 例子：添加一个新主题

… …

… …

关于选择器的更多内容请参考【第八章】和【第十章】。

11.2.4.2 修改主题的属性

… …

… …

11.2.4.3 数据

数据（Data）通常被开发者而不是设计者使用。

在这个部分里可以放入任何文件，以便开发者在运行时访问它们。这一部分（甚至当数据文件是图像或字体时）对其他部分的功能没有任何影响。

11.2.4.4 自定义预览面板

显示 LWUIT Demo 的预览面板可以方便地自定义其他的 MIDlet。Theme Creator 支持插入你自己的 MIDlet，这样你就能够实时测试你的主题。

使用Theme Creator 的 MIDlet > Pick MIDlet 菜单并选择你自己的 MIDlet JAR 文件将其装入预览面板。

但是，使用这个功能时有一些限制：因为 MIDlet 将在 Java SE 中运行，它不能使用 javax.microedition 的 API。如果在程序中使用了这些 API，它们将以存根（Stub）的形式实现。例如，如果你使用了 RMS，GCF 或诸如此类的 API，所有的查询将返回 null，所有的操作都将不执行实际动作。另外，调用主题将不会有任何效果。

If there is a failure in the MIDlet the Theme Creator will silently load the LWUIT Demo in the preview and use it instead. To debug the failure, execute the Theme Creator from command line using java -jar ResourceEditor.jar. When entering the theme option you can see the stack trace of the exception that caused the failure.

如果在这个 MIDlet 里发生了错误，Theme Creator 将在预览面板里自动载入 LWUIT Demo 来代替你的 MIDlet。为了调试错误，使用命令行 java -jar ResourceEditor.jar 来执行 Theme Creator。当进入主题选项时（HOW?），将显示导致程序崩溃的异常有关的堆栈跟踪信息。

11.2.4.5 已知问题

当使用 Aero 主题时，某些操作系统在某些情形下可能会使得 Theme Creator 崩溃。这个问题源于 Java SE 的 Look & Feel 的实现，唯一的解决办法是使用  Look & Feel 菜单选项改变应用程序的 Look & Feel。

1. 2.1 组件
2. 2.2 容器
3. 2.3 窗体
4. 2.4 建立和设置一个 Form Label
5. 2.5 按钮
6. 2.6 单选按钮
7. 2.7 按钮组
8. 2.8 复选框
9. 2.10 标签面板 TabbedPane
10. 2.11 文本区 TextArea
11. 2.12 文本域 TextField

《LWUIT 开发者指南 LWUIT Developer Guide》

2.1 组件

A Component is an object having a graphical representation that can be displayed on the screen and can interact with the user. The buttons, check boxes, and radio buttons in a typical graphical UI are all examples of a component. Component is the base class. All the widgets in the Lightweight UI Toolkit library use the composite pattern in a manner similar to the AWT Container and Component relationship.

Component 是基类。所有 LWUIT 器件都使用复合模式，类似于 AWT 容器和组件之间的关系。

2.2 容器

A Container is a composite pattern with a Component object. It enables nesting and arranging multiple components using a pluggable layout manager architecture. Containers can be nested one within the other to form elaborate UIs. Components added to a container are tracked in a list. The order of the list defines the components’ front-to-back stacking order within the container. If you do not specify an index when you add a component to a container, it is added to the end of the list (and hence to the bottom of the stacking order).

使用可插拔的布局管理器架构嵌套和布置多个组件。容器可以嵌套。加入容器的组件用一个列表跟踪。列表元素的顺序定义了组件在容器里从前往后的顺序。如果在容器里加入组件时没有指定索引，这个组件将被加入到列表的末尾。

2.3 窗体

Form is a top‐level component that serves as the root for the UI library. This Container handles the title and menus and allows content to be placed between them. By default the form’s central content (the content pane) is scrollable. Form contains Title bar, MenuBar and a ContentPane. Invocations of Form’s addComponent method are delegated to the content pane’s addComponent. The same applies to most composite related methods (e.g. setLayout, getComponent and so forth).

窗体是一个顶层组件，作为整个 UI 库的根元素。容器管理标题和菜单并在其间加入内容。默认请款下，窗体中央的内容（内容面板）可以滚动。窗体包含标题条，菜单条和一个内容面板。对窗体 addComponent 方法的调用将被委派到内容面板的 addComponent 方法。同样的机制也用于大多数和复合模式有关的方法（例如 setLayout, getComponent 等等）。

The following code demonstrates creation and setup of a form.

窗体建立和设置的示例代码：

// 1. Create a Form
Form mainForm = new Form("Form Title");
// 2. Set LayoutManager
mainForm.setLayout(new BorderLayout());
// 3. Add a Label to the center of Form content pane
mainForm.addComponent(BorderLayout.CENTER, new Label(“Hello World”));
// 4. Set Transitions animation of Fade
mainForm.setTransitionOutAnimator(CommonTransitions.createFade(400));
// 5. Add Command key
mainForm.addCommand(new Command("Run", 2));
// 6. Show it
mainForm.show();

2.4 建立和设置一个 Form Label

The Label widget can display a single line of text and/or an image and align them using multiple options. If you need to create a component that displays a string, an image, or both, you should use or extend Label. If the component is interactive and has a specific state, a Button is the most suitable widget (instead of a label).

如果你需要建立一个组件显示字符串，图像或同时显示二者，你应该使用或扩展 Label。如果这是一个交互式的组件并有某个特定的状态，Button 是最合适的器件。

To create a Label, use one of the following calls:

使用下列代码之一建立一个 Label：

Label textLabel = new Label("I am a Label"); // for a text label

或

// create an image for an icon label
Image icon = Image.createImage("/images/duke.png");
Label imageLabel = new Label(icon);

Labels can be aligned to one of the following directions: CENTER, LEFT, RIGHT. LEFT is the default. In addition the text can be aligned relative to the image position. Valid values are TOP, BOTTOM, LEFT, RIGHT, where the default is RIGHT. To update the text position use:

Label 可以按照下列方式对齐：CENTER, LEFT, RIGHT。默认值是 LEFT。另外，文本能够相对于图像对齐，可用的选项有 TOP, BOTTOM, LEFT, RIGHT，默认值是 RIGHT。为了更新文本的位置，可以使用：

setTextPosition(int alignment);

… …

2.5 按钮

The Button component enables the GUI developer to receive action events when the user focuses on the component and clicks. In some devices a button might be more practical and usable than a command option. Button is the base class for several UI widgets that accept click actions. It has three states: rollover, pressed, and the default state. It can also have ActionListeners that react when the Button is clicked.

在某些设备上 Button 可能比命令选项更实用和有用。Button 是数个接受点击动作的 UI 器件的基类。它有三种状态：翻转（rollover），按下，以及默认状态。它可以和多个 ActionListener 连接以对按钮点击事件做出响应。

To get the user clicking event, you must implement an ActionListener, which is notified each time the user clicks the button. The following code snippet creates an action listener and changes the text on the button, every time the user clicks it.

为了获取用户点击事件，你必须实现一个 ActionListener，它在用户点击按钮时得到通知。下面的代码建立了一个动作监听器，当用户点击按钮时改变按钮上的文本：

final Button button  = new Button("Old Text");
button.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent evt) {
		button.setText("New Text");
	}
});

Button extends Label, so you can create three type of buttons: text only, image only or image and text button.

Button 扩展了 Label，因此你可以建立三种样式的按钮：仅文本，仅图像，以及图像和文本按钮。

2.6 单选按钮

RadioButton is a Button that maintains a selection state exclusively within a specific ButtonGroup. Because RadioButton inherits from Button, radio buttons have all the usual button characteristics, as discussed in Button. For example, you can specify the image displayed in a radio button. Each time the user clicks a radio button (even if it was already selected), the button fires an action event, just as in Button.

RadioButton 是维护特定 ButtonGroup 的一个唯一选择状态的 Button。因为 RadioButton 从 Button 派生，单选按钮拥有上面讨论的按钮的全部有用特征。例如，你可以指定一个单选按钮显示的图像。每次当用户点击一个单选按钮时（甚至当它已经被选择时），这个按钮象普通的按钮一样发送一个动作消息（Action Event）。

To create a RadioButton use:

使用下面的代码建立一个 RadioButton：

RadioButton radioButton = new RadioButton(“Radio Button”);

2.7 按钮组

The ButtonGroup component manages the selected and unselected states for a set of RadioButtons. For the group, the ButtonGroup instance guarantees that only one button can be selected at a time.

ButtonGroup 组件管理一组单选按钮的选定和未选状态。对于这个组，ButtonGroup 示例保证在任何时间只能有一个按钮被选择。

Initially, all RadioButtons in a ButtonGroup are unselected. Each ButtonGroup maintains the selected index, and can get a specific RadioButton by calling getRadioButton(int index).

开始的时候 ButtonGroup 里的所有 RadioButton 都处于未选状态。每个 ButtonGroup 都维护着一个选择索引，可以调用 getRadioButton(int index) 来获取某个指定的 RadioButton。

The following code snippet creates a button group made of two RadioButtons.

使用下面的代码建立一个包含两个 RadioButton 的按钮组：

Label radioButtonsLabel = new Label("RadioButton:");
....
RadioButton rb1 = new RadioButton("First RadioButton in Group 1");
RadioButton rb2 = new RadioButton("Second RadioButton in Group 1");

ButtonGroup group1 = new ButtonGroup();
group1.add(rb1);
group1.add(rb2);

exampleContainer.addComponent(radioButtonsLabel);
exampleContainer.addComponent(rb1);
exampleContainer.addComponent(rb2);

2.8 复选框

Check boxes are similar to RadioButtons but their selection model is different, because they can flip the selection state between selected and unselected modes. A group of radio buttons, on the other hand, can have only one button selected. Because CheckBox inherits from Button, check boxes have all the usual button characteristics, as discussed in Button. For example, you can specify the image displayed in a check box. Each time the user select a check box (even if it was already selected), it fires an action event, just as in Button.

复选框与 RadioButton 相似，但它们的选择模型不同。复选框的选择状态可以在选定和未选之间转换。另外，一组单选按钮只能有一个被选定。因为 CheckBox 从 Button 派生，单选框拥有上面讨论过的按钮所有的有用特征。

To create a CheckBox use:

使用下面的代码建立一个 CheckBox：

final CheckBox checkBox = new CheckBox(“Check Box”);

This code produces the CheckBox shown in FIGURE 2-7.

To catch select and unselect events you can try this:

为了捕捉选定和未选状态，可以使用下面的代码：

checkBox.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent evt) {
      if(checkBox.isSelected()) {
         System.out.println("CheckBox got selected");
      } else {
         System.out.println("CheckBox got unselected");
      }
   }
});

xxx

2.9 组合按钮 ComboBox

A combo box is a list that allows only one selection at a time. When a user clicks the combo box button, a drop‐down list of elements allows the user to select a single element. The combo box is driven by the list model and allows all the renderer features of the List as well.

组合框由一个列表模型驱动，可以使用 List 渲染器（Renderer）的所有功能。

Other components that can display one-of-many choices are groups of radio buttons, check boxes, buttons, and lists. Groups of radio buttons are generally the easiest for users to understand, but combo boxes can be more appropriate when space is limited or more than a few choices are available. Lists are not always attractive, but they are more appropriate than combo boxes when the number of items is large (say, over five).

可以显示“多个中选择一个”（One-of-many Choices）的组件还有单选按钮组，复选框组，按钮组，以及列表。单选按钮组通常最容易被用户理解，但当空间有限或少数几个选择项的时候组合框更为适用。列表不是很美观，但它在可选项很多时（例如大于五个）比组合框更合用。

The following code creates a combo box (a list model that is built from check boxes) and sets it up:

下面的代码建立了一个组合框（使用由复选框组成的列表）并对它进行设置：

String[] content = { "Red", "Blue", "Green", "Yellow" };

// 1. Creating the combo box
ComboBox comboBox = new ComboBox(content);

// 2. Setting a checkBox renderer
comboBox.setListCellRenderer(new checkBoxRenderer());

// 3. Adding a action listener to catch user clicking
//    to open the ComboBox
comboBox.addActionListener(myActionListener......);

The following notes correspond to the comments in the code above.

• This combo box code contains an array of strings, but you could just as easily use labels instead.
• To put anything else into a combo box or to customize how the items in a combo box look, you need to write a custom renderer.
• The next line of code (which calls setListCellRender) registers an action listener on the combo box.

下面是对上面代码的一些注释：

The following is a sample of renderer code:

下面的代码是渲染器的一个例子：

/**
* Demonstrates implementation of a renderer derived from a CheckBox
*/
private static class checkBoxRenderer extends CheckBox implements ListCellRenderer {

	/** Creates a new instance of checkBoxRenderer */
	public checkBoxRenderer() {
		super("");
	}

	// Setting the current check box text and status
	public Component getListCellRendererComponent(List list,
	Object value, int index, boolean isSelected) {
		setText("" + value);
		if (isSelected) {
			setFocus(true);
			setSelected(true);
		} else {
			setFocus(false);
			setSelected(false);
		}
		return this;
	}

	// Returning the list focus component
	public Component getListFocusComponent(List list) {
		setText("");
		setFocus(true);
		setSelected(true);
		return this;
	}
}

The sample code produces the combo box in FIGURE 2-8.

示例代码建立的组合框见下图：

2.10 标签面板 TabbedPane

A tabbed Pane is a container that lets the user switch between a group of components that all share the same space by focusing on a tab with a title, an icon, or both. The user chooses which component to view by selecting the tab corresponding to the desired component.

标签面板是一个容器，允许用户在一组组件之间切换，这些组件通过选择一个带有标题或图标（或二者兼而有之）的标签共享同一个显示空间。用户选择对应的标签来决定显示哪一个组件。

To create a tabbed pane, instantiate TabbedPane, create the components you wish it to display, and then add the components to the tabbed pane using the addTab or insertTab methods. TabbedPane has the ability to remove tabs as well, by calling removeTabAt(int index) at a given position index. A tab is represented by an index corresponding to the position it was added in, where the first tab has an index equal to 0 and the last tab has an index equal to the tab count minus 1.

建立组件后，使用 addTab 或 insertTab 方法把组件加入标签。使用 removeTabAt(int index) 移除指定位置的组件。标签用索引表示，这个索引对应于添加它的位置。第一个标签的索引是0，最后一个标签的索引等于标签总数减去1。

If the tab count is greater than 0, then there is always a selected index, which by default is initialized to the first tab. If the tab count is 0, then the selected index is -1.

标签总数大于0时就存在一个选择索引，默认值是第一个标签。如果标签总数是0，那么选择索引就是-1。

TabbedPane has four different tab placement orientations. The default tab placement is set to the TOP location. You can change the tab placement to LEFT, RIGHT, TOP or BOTTOM using the setTabPlacement method.

TabbedPane 可以按照四种不同的方向定位。标签的默认位置是 TOP。可以使用 setTabPlacement 方法使用方向 LEFT, RIGHT, TOP 或 BOTTOM 来改变标签的定位。

The following code creates a TabbedPane with tab placement of bottom, and places a Label in the center of the first (and only) tab.

下面的代码建立了一个 TabbedPane，标签的位置在顶部，并在第一个标签（只有一个）的中央位置放置了一个 Label：

2.11 文本区 TextArea

The text area represents text that might be editable using the system native editor (it might occur in a new screen). The native editor is used to enable complex input methods (such as T9) and application internationalization. The following code creates and initializes the text area:

文本区表示可以编辑的文本，它使用系统原生编辑器（可能会打开一个新屏幕）。在原生编辑器里可以使用复杂的舒服发（例如 T9）和应用程序国际化。下面的代码建立和初始化了一个文本区：

TextArea textArea = new TextArea(5, 20, TextArea.NUMERIC);
textArea.setEditable(false);

The first two arguments to the TextArea constructor are hints as to the number of rows and columns, respectively, that the text area should display. The third one is a constraint that is passed into the native text editor. Valid values can be one of ANY, EMAILADDR, NUMERIC, PHONENUMBER, URL, or DECIMAL. In addition it can be bitwise OR’d with one of PASSWORD, UNEDITABLE, SENSITIVE, NON_PREDICTIVE, INITIAL_CAPS_SENTENCE, INITIAL_CAPS_WORD. For example, ANY | PASSWORD. The default value is ANY. In the above example NUMERIC only allows the user to type numbers.

TextArea 构造函数的第三个参数是传递给原生文本编辑器的一个约束，有效值是：ANY, EMAILADDR, NUMERIC, PHONENUMBER, URL, 或 DECIMAL。这些值还可以和 PASSWORD, UNEDITABLE, SENSITIVE, NON_PREDICTIVE, INITIAL_CAPS_SENTENCE, INITIAL_CAPS_WORD 中的一个做或运算。例如 ANY | PASSWORD。默认值是 ANY。

Text areas are editable by default. The code setEditable(false) makes the text area uneditable. It is still selectable, but the user cannot change the text area’s contents directly.

文本区默认是可编辑的。代码 setEditable(false) 使得文本区不可编辑。在其内仍然能够选择文本，但用户不能直接改变文本区的内容。

2.12 文本域 TextField

TextArea doesn’t always allow in-place editing on existing devices and doesn’t provide “fine grained control” over the input. This allows a text area to be lightweight, and portable for all possible devices. These restrictions sometimes cause a poor user experience because it requires users to go into a different screen for input (since all input is handled natively by the device). From a developer standpoint the native input can be a problem since it doesn’t send change events and doesn’t provide control over allowed input.

文本区并不总是支持现存设备上的原地（In-place）编辑，因此不支持输入时的“细粒度控制”（Fine Grained Control）。这种做法使得文本区对于所有可能的设备更轻量级和可移植。但这些限制有时候会带来糟糕的用户体验，因为它需要用户在输入时使用另一个不同的屏幕（因为所有的输入都由设备本身处理）。从开发者的角度来看，原生输入可能是个问题，因为它不发送改变（Change）事件，也不提供允许输入内容方面的控制。

LWUIT provides the TextField component to support direct mobile phone input from within LWUIT. Unlike a TextArea, TextField is completely implemented in LWUIT. Developers can override almost all of its features to provide deep customization (for example, masked input, localization, and more).

LWUIT 提供了 TextField 组件来支持 LWUIT 内直接移动电话输入

TextField inherits the TextArea component and all of its features. It also supports moving to the native text editor.

TextField 继承了 TextArea 组件和它的所有功能。它还支持转移到原生文本编辑器。

The constructor also accepts several arguments, similar to the TextArea component.

它的构造器也接受几个参数，与 TextArea 组件相似。

TextField also has some limitations:

TextField 还有一些限制：

Does not support input in foreign locales unless you provide code for foreign input

Does not support device features, such as T9 input

Might not correctly detect QWERTY devices

Does not work on devices with unique keyboards, such as the Perl

Creating a text field is trivial:

1. 1.1 API 概览
   1. 1.1.1 应用域和可移植性
      1. 1.1.1.1 MIDP 的 Hello World 例子
   2. 1.1.2 事件和线程

《LWUIT 开发者指南 LWUIT Developer Guide》

This book describes how to use the Lightweight UI Toolkit (LWUIT) library. The Lightweight UI Toolkit library helps you create appealing graphical user interface (GUI) applications for mobile phones and other devices that support MIDP 2.0. Lightweight UI Toolkit supports visual components and other user interface (UI) ingredients such as theming, transitions, animation and more.

使用 LWUIT 可以在支持 MIDP 2.0 的设备或手机上建立具有漂亮外观的应用程序。

LWUIT 支持可视化组件和其他 UI 特性，如主题（Theming），转换（Transition），动画等。

After covering the basics of the Lightweight UI Toolkit, this book provides a walk through of the various widgets and uses of the LWUIT packages.

1.1 API 概览

The Lightweight UI Toolkit is a lightweight widget library inspired by Swing but designed for constrained devices such as mobile phones and set-top boxes. Lightweight UI Toolkit supports pluggable theme-ability, a component and container hierarchy, and abstraction of the underlying GUI toolkit. The term lightweight indicates that the widgets in the library draw their state in Java source without native peer rendering.

LWUIT 收到 Swing 的启发，用于资源受限的设备（例如移动电话和机顶盒等）。LWUIT 支持可插拔的主题，组件及容器层次结构，以及底层 GUI 工具库的抽象。在这里，轻量级的意思是库中的小器件在自己的 Java 代码里绘制自己的状态，而不是通过本地对应 GUI 元素来绘制。

Internal interfaces and abstract classes provide abstraction of interfaces and APIs in the underlying profile. This allows portability and a migration path for both current and future devices and profiles. For example, Graphics would be an abstraction of the graphics object in the underlying profile.

The Lightweight UI Toolkit library tries to avoid the “lowest common denominator” mentality by implementing some features missing in the low‐end platforms and taking better advantage of high-end platforms. FIGURE 1-1 shows the widget class hierarchy.

1.1.1 应用域和可移植性

The Lightweight UI Toolkit library is strictly a widget UI library and does not try to abstract the underlying system services such as networking or storage. It also doesn’t try to solve other UI issues related to native graphics, etcetera.

To enable portability, the Lightweight UI Toolkit library implements its own thin layer on top of the native system canvas and provides a widget abstraction. This abstraction is achieved using several key classes that hide the system specific equivalents to said classes, such as Graphics, Image and Font.

When working with the Lightweight UI Toolkit library it is critical to use the abstract classes for everything. To avoid corruption, there is no way to access the “real” underlying instances of these classes (for example,javax.microedition.lwuit.Graphics).

使用 LWUIT 时，在任何情况下都使用抽象类（LWUIT 定义的类）非常重要。为了防止破坏抽象层次，绝对不要使用底层类，例如 javax.microedition.lwuit.Graphics。

LWUIT strives to enable great functionality on small devices that might be incapable of anti-aliasing at runtime, or might choke under the weight of many images. To solve these problems the LWUIT library ships with an optional resource file format that improves resource utilization. For more details, see Chapter 11.

1.1.1.1 MIDP 的 Hello World 例子

这里是建立在 MIDP 上的一个简单的 Hello World 例子。这里使用 LWUIT 的界面代码与其他平台（例如 CDC）兼容。

但这个例子特定于 MIDP。对于 MIDP，应用程序管理系统（AMS）要求存在一个 MIDlet 类，而在 CDC 环境里则期望一个 Xlet 类（在 Java SE 环境里需要的则是一个主类 main，等等）。

import com.sun.lwuit.Display;
import com.sun.lwuit.Form;
import com.sun.lwuit.Label;
import com.sun.lwuit.layouts.BorderLayout;
import com.sun.lwuit.plaf.UIManager;
import com.sun.lwuit.util.Resources;

public class HelloMidlet extends javax.microedition.midlet.MIDlet {

   public void startApp() {
       //init the LWUIT Display
       Display.init(this);

       // Setting the application theme is discussed
       // later in the theme chapter and the resources chapter
       try {
             Resources r = Resources.open("/myresources.res");
            UIManager.getInstance().setThemeProps(r.getTheme(
               r.getThemeResourceNames()[0])
                );
       } catch (java.io.IOException e) {
       }
       Form f = new Form();
       f.setTitle("Hello World");
       f.setLayout(new BorderLayout());
       f.addComponent("Center", new Label("I am a Label"));
       f.show();
   }

   public void pauseApp() {
   }

   public void destroyApp(boolean unconditional) {
   }
}

注意，如同这个例子所示，任何使用 LWUIT 的应用程序的第一行代码必须在 display 里注册主类。这个行为是工具包特定的。在 MIDP 里，如果没有到父 MIDlet 的引用，你将做不了什么事情，因此这个操作必须在应用程序的开始完成。

为了简化起见，在 MIDlet 里建立了 UI 代码，但它们可以被分离到其他类里完成，以便移植到未来任何移植了 LWUIT 的平台上。

1.1.2 事件和线程

为了达到更高的兼容性，LWUIT 库完整地处理和封装了 UI 线程。它有一个独立的主线程 EDT（受到了 Swing 和 AWT 事件分发线程 Event Dispatch Thread 的启发）。这个线程被用来分发所有的事件和绘制调用。这保证了事件和绘制调用顺序进行，因此不会产生线程问题。通过使用它，那些线程模型可能有些微不一致性的 profile 也能被移植。有关与 EDT 继承和在其上顺序执行调用的详细内容请参见 Display 类（API 文档里的 com.sun.lwuit.Display）。

• 如何根据已有的 WSDL 文件测试 Web Services：Using Web Service Explorer to test a Web service
• 如何建立 Web Services：Webservices with Axis2 and the Eclipse Web Tool Platform (WTP)

可以在本地测试的 Web Services 只有一个框架，可以通过建立指向实际  Web Services 服务器的节点（Node）来测试远程 Web Services。

安装及配置

下载安装 JDK

下载安装 Eclipse

下载安装 Eclipse IDE for Java Developer Galileo（Eclipse 不同发行包的比较）。

下载安装 J2ME SDK

下载安装 J2ME SDK 3.0。

安装及配置 WTJ

安装

• 在 Eclipse 里选择安装软件，使用 Update Site http://download.eclipse.org/dsdp/mtj/updates/1.1.0/stable/ 安装 WTJ 1.1.0。

配置预处理器支持

由于 Eclipse Java 编译器自身扩展性的局限（更多信息参见 Bug 116143），需要在 Eclipse 平台底层挂入 MTJ 以提供预处理器支持。要得到这个支持需要对 Eclipse 做一些额外的改动：

• 必须将 MTJ 安装到 Eclipse 的基本目录下（例如 C:\software\eclipse）。安装结束后，文件 org.eclipse.mtj.core.hooks_[version].jar 必须与文件 org.eclipse.osgi_[version].jar 位于同一目录。
• 必须修改 Eclipse 配置文件来引用 MTJ 框架挂钩集合（Bundle）：
  1. 在 <eclipse install>/configuration 目录下找到文件 config.ini；
  2. 使用文本编辑器编辑 config.ini 文件；
  3. 在配置文件里添加下面的属性：

     osgi.framework.extensions=org.eclipse.mtj.core.hooks

     如果这个属性已经存在，在它的定义后追加“,org.eclipse.mtj.core.hooks”；

     这一行必须添加到文件结束标记（end-of-file Marker）之前。如果不是这样，Eclipse 将不能启动。
  4. 保存这个配置文件；
  5. 重新启动 Eclipse。

如果你的项目被配置为使用预处理，但还没有按照上述步骤配置 Eclipse，你将会在 Eclipse 工作空间日志文件里看到类似下面的信息：

Preprocessor invoked, but hook is not installed. Consult the installation instructions for MTJ.

配置 WTJ

配置 WTJ 和建立简单 MIDlet 的教程参见 Getting Started with WTJ。

开发应用程序

WTJ

参见 WTJ 用户文档。

J2ME GUI 库

LWUIT

• LWUIT 项目主页
• J2ME GUI实战之一 – LWUIT简介
• How to build LWUIT with Eclipse

javax.microedition.lcdui

• Documentation for package javax.microedition.lcdui

参考

• eclipseME: 已经成为 Eclipse Mobile Tools for Java (MTJ) 项目。
• 教程：
  • Eclipse 开发 J2ME 程序之安装配置
  • Eclipse 开发 J2ME 程序之插件安装
  • Eclipse 开发 J2ME 程序之 Hello World
  • Eclipse 开发 J2ME 程序之仿真机发布
  • Eclipse 开发 J2ME 程序之图形化游戏
• Eclipse+EclipseME+WTK 搭建 J2ME 开发环境：设置 Antenna JAR 编写打包脚本，使用 Proguard 加密程序等等。

CyanogenMod黑客宣布向HTC Dream和HTC Magic系列手机发布最新版的自制系统CyanogenMod 5.0.7(基于Android 2.1)。

新版增加了大量新特性，修正了大量bug，主要的特性包括：Kernel 2.6.33.4，Pershoot时钟模式，支持手机互联技术（Tethering）等等。开发者承认可能还存在一些小纰漏，但相信能作为日常使用稳定运行。

VoltDB 内存驻留（In-Memory）数据库管理系统正式宣布。

VoltDB是Postgres和Ingres联合创始人Mike Stonebraker领导开发的下一代开源数据库管理系统。它能在现有的廉价服务器集群上实现每秒数百万次数据处理。VoltDB大幅降低了服务器资源开销，单节点每秒数据处理远远高于其它数据库管理系统。不同于NoSQL的key-value储存，VoltDB能使用SQL存取，支持传统数据库的ACID模型。VoltDB代码采用GPLv3授权，支持订阅费用从15,000美元起步。

MIT技术评论》报道（中文版），MIT研究人员开发出名为KarDo的软件，能自动配置电子邮件账户，安装杀毒软件，或者设置VPN。

KarDo只需要观察管理员执行一次任务，就可以在运行不同软件的电脑上实施同样的工作。根据Forrester和Gartner的报告，企业每年花费在简单重复的IT任务上的资金达数十亿美元。KarDo能将这笔开销削减20%之多。在某些方面，KarDo与记录宏命令—用户在电脑上的一系列操作—的软件有相似之处。但KarDo会尝试学习每个操作的目的，从而在今后更广泛地使用该操作。当IT员工想要KarDo学习一项新任务时，只需要事先按下“开始”按钮并在结束后按“停止”即可。

1. 1.1 上机建立第一个工程
   1. 1.1.1 用 Visual Studio 创建工程
   2. 1.1.2 用 Visual Studio 查看汇编指令
2. 1.2 简要复习常用的汇编指令
   1. 1.2.1 堆栈相关指令
   2. 1.2.2 数据传送指令
   3. 1.2.3 跳转与比较指令
3. 1.3 C 函数的参数传递过程
   1. 基础知识
   2. 技术细节
   3. 代码分析

1.1 上机建立第一个工程

1.1.1 用 Visual Studio 创建工程

『略』

1.1.2 用 Visual Studio 查看汇编指令

C 语言程序对应的汇编代码，可以在 VC 中非常清楚地显示出对应关系。只需要调出汇编指令窗口，步骤：

1. VC 必须处于调试状态才能看到汇编指令窗口，因此可以在程序的最后一行代码上设置断点（F9）；
2. 按下 F5 调试程序。当程序停在断点位置时，打开菜单 [Debug]>[Windows]>[Disassembly]。

1.2 简要复习常用的汇编指令

1.2.1 堆栈相关指令

• push：把一个 32 位操作数压入堆栈。注意：栈顶 esp 在压入数据后向低地址空间增长，每次减少 4（字节）。
• pop：esp 加 4。参数一般是一个寄存器。
• sub 和 add 常用来操作堆栈：便于在堆栈上一次性分配或回收空间。
• ret：等于 pop+jump。
• call：等于 push+jump。

1.2.2 数据传送指令

• mov：第一个参数是目的，第二个参数是来源。在 C 语言中相当于赋值操作符。
• xor：常用来对寄存器清零，这样比使用 mov 更快且占用内存更少，例如：

  xor eax, eax

  代替：

  mov eax, 0

  进行清零操作。

• lea：取得地址（第二个参数的地址）后放入寄存器（第一个参数）。实际上，有时使用它来做 mov 的工作，例如赋值，

  lea edi, [ebp-0cch]

  方括弧表示存储器，取 ebp-0cch 这个地址所指的存储器的地址，也就是 ebp-0cch。但 mov 指令无法完成这行代码的工作，因为 mov 指令里不支持第二个参数写成寄存器减去数字。

• stos (stosd)：串存储指令，它的功能是把 eax 里的数据放入 edi 所指的地址中，同时 edi 增加 4（字节数）。stos 的三个变形是 stosd（4）， stosb（1），stosw（2）。
• rep：重复指令。使后面的指令重复执行 ecx 中指定的次数。下面的代码

  mov ecx, 30h
  mov eax, 0CCCCCCCCh
  rep stos dword ptr es:[edi]

  把堆栈中的 30h*4 个字节初始化为 0cch（int3 指令的机器码），这样发生意外执行堆栈里的内容时将会引发调试中断。

1.2.3 跳转与比较指令

• jmp：无条件跳转。
• jg：大于的时候跳转。
• jl：小于的时候跳转。
• jge：大于等于时跳转。
• cmp：往往时条件跳转指令的执行条件。

1.3 C 函数的参数传递过程

基础知识

函数和堆栈的关系密切：

• C 语言通常通过堆栈把参数从函数外部传入到函数内部。这些参数对齐到机器字长（16/32/64位 CPU 分别对齐 2/4/8个字节）
• 在堆栈中划分区域容纳函数的内部变量。

调用 push 和 pop 指令时，esp 用于指向栈顶的位置（栈中地址最小的位置），push 时 esp 减小，pop 时 esp 增加。

不同的函数调用机制（Windows 上）

• C 方式（_cdecl）：
  • 参数从右到左进入堆栈；
  • 函数返回后，调用者要负责清除堆栈，因此这种方式会生成较大的可执行程序。

• WINAPI 方式（_stdcall）：
  • 参数从右到左进入堆栈；
  • 被调用的函数在返回前自行清除堆栈，所以生成的代码比 _cdecl 小。

• Pascal 方式：主要用在 Win16 函数库中，现在基本已经不再使用
  • 参数从左到右进入堆栈；
  • 被调用的函数在返回前自行清除堆栈；
  • 不支持可变参数的函数调用。
• Windows 内核中常见的还有快速调用方式（_fastcall）『后』；
• C++ 编译的代码中有 this call 方式（this_call）『后』。

技术细节

使用堆栈传递参数。

返回值写入 eax 中，然后返回。在 Windows 中，不管哪种调用方式都是通过 eax 传递返回值。

_cdecl 调用方式由调用者清理复原堆栈；_stdcall 调用方式由被调用者恢复堆栈（可变参数函数调用除外）。

_cdecl 方式下被调用函数需要做以下一些事情：

1. 保存 ebp：因为接下来通常将使用 ebp 保存这个函数执行之前的 esp 的值。执行完毕函数以后，再使用 ebp 恢复 esp。同时，调用这个函数的上层函数也用 ebp 做同样的事情，因此要先把 ebp 压入堆栈，返回之前弹出，以免改动 ebp。
2. 把 esp 保存到 ebp 中。上面两步的代码如下：

   ; 保存 ebp，并把 esp 放到 ebp 中，此时 ebp 与 esp
   ; 同样都是这次函数调用时的栈顶
   push ebp
   mov ebp, esp

3. 在堆栈中腾出一个区域用来保存局部变量，即常说的“局部变量保存在栈空间中”。方法是，把 esp 减少一个数值，这样就等于压入了一堆变量。要恢复时，只需要把 esp 恢复成 ebp 中保存的数据即可。
4. 把 ebx、esi 和 edi 保存到堆栈，函数调用完毕后恢复。这两步对应的代码如下：

   ; 把 esp 往下移动一个范围，等于在堆栈中放出一片新的
   ; 空间用来存放局部变量
   sub esp, 0cch
   ; 保存三个寄存器
   push ebx
   push esi
   push edi

5. 把局部变量区域初始化为全 0cccccccch（0cch 实际上是 int3 指令的机器码）。因为局部变量不可能被执行，如果执行了，必然程序有错，此时发生中断来提示开发者。这是 VC 编译 Debug 版本的特有操作。相关代码如下：

   lea edi, [ebp-0cch]
   mov ecx, 33h
   mov eax, 0cccccccch
   rep stos dword ptr [edi] ;串写入

6. 然后做函数应该做的工作。参数的获取：ebp+12 字节处为第二个参数，ebp+8 字节处为第一个参数（倒序压入），一次增加，最后 ebp+4 字节处是要返回的地址。
7. 恢复 ebx、esi、edi、esp、ebp，最后返回，代码如下：

   ; 恢复三个寄存器
   pop edi
   pop esi
   pop ebx
   ; 恢复原来的 ebp 和 esp，让上一个调用的函数正常使用
   mov esp, ebp
   pop ebp
   ret

8. 如果需要返回值，函数应该在返回之前，把返回值放入 eax。外部通过 eax 获取返回值。

代码分析

『略』：函数 myfunction(int, int) 的汇编代码，可以使用 VS 得到。

主函数对函数 myfunction(int, int) 的调用方式是：

mov eax, dword ptr[b]
mov eax
mov ecx, dword ptr[a]
push ecx
call myfunction
add esp, 8    ;恢复堆栈！