text:
using System;
using System.Diagnostics;
using System.Serialization;
using System.Threading;
using NodeApi.IO;
using NodeApi.Network;
using Cellar.Controllers;
using Cellar.DataModels;
using Cellar.Services;
using Cellar.Services.MongoLab;

namespace Cellar {

    internal sealed class CellarApplication {

        private IWineRepository _repository;

        public WinesController CreateWinesController() {
            return new WinesController(_repository);
        }

        public void Initialize(string dbUrl, Action<Exception> callback) {
            UrlData urlData = Url.Parse(dbUrl);
            string[] credentials = urlData.Auth.Split(':');

            MongoWineRepository.Create(urlData.HostName, Number.ParseInt(urlData.Port, 10),
                                       urlData.Path.Substr(1),
                                       credentials[0], credentials[1])
                .Done(delegate(MongoWineRepository repository) {
                    _repository = repository;
                    _repository.CountWines()
                        .ContinueWith(delegate(Task<int> countTask) {
                            if ((countTask.Error != null) ||
                                (countTask.Result == 0)) {
                                PopulateRepository(callback);
                            }
                            else {
                                Debug.WriteLine("Repository initialized (and already populated).");
                                callback(null);
                            }
                        });
                })
                .Fail(delegate(Exception error) {
                    callback(new Exception("Unable to create repository."));
                });
        }

        private void PopulateRepository(Action<Exception> callback) {
            Debug.WriteLine("Populating repository...");

            string data = FileSystem.ReadFileTextSync("data.json", Encoding.UTF8);
            Wine[] wines = Json.ParseData<Wine[]>(data);

            _repository.InsertWines(wines)
                .Done(delegate() {
                    Debug.WriteLine("Repository populated.");
                    callback(null);
                })
                .Fail(delegate(Exception error) {
                    callback(new Exception("Could not populate repository."));
                });
        }
    }
}


text:
package org.apache.asterix.metadata.entitytupletranslators;

import java.io.ByteArrayInputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

import org.apache.asterix.builders.OrderedListBuilder;
import org.apache.asterix.common.config.DatasetConfig.IndexType;
import org.apache.asterix.common.exceptions.AsterixException;
import org.apache.asterix.common.transactions.JobId;
import org.apache.asterix.formats.nontagged.AqlSerializerDeserializerProvider;
import org.apache.asterix.metadata.MetadataException;
import org.apache.asterix.metadata.MetadataNode;
import org.apache.asterix.metadata.bootstrap.MetadataPrimaryIndexes;
import org.apache.asterix.metadata.bootstrap.MetadataRecordTypes;
import org.apache.asterix.metadata.entities.AsterixBuiltinTypeMap;
import org.apache.asterix.metadata.entities.Index;
import org.apache.asterix.om.base.ABoolean;
import org.apache.asterix.om.base.ACollectionCursor;
import org.apache.asterix.om.base.AInt32;
import org.apache.asterix.om.base.AOrderedList;
import org.apache.asterix.om.base.ARecord;
import org.apache.asterix.om.base.AString;
import org.apache.asterix.om.base.IACursor;
import org.apache.asterix.om.types.AOrderedListType;
import org.apache.asterix.om.types.ARecordType;
import org.apache.asterix.om.types.BuiltinType;
import org.apache.asterix.om.types.IAType;
import org.apache.hyracks.api.dataflow.value.ISerializerDeserializer;
import org.apache.hyracks.data.std.util.ArrayBackedValueStorage;
import org.apache.hyracks.dataflow.common.data.accessors.ITupleReference;

/**
 * Translates an Index metadata entity to an ITupleReference and vice versa.
 */
public class IndexTupleTranslator extends AbstractTupleTranslator<Index> {
    // Field indexes of serialized Index in a tuple.
    // First key field.
    public static final int INDEX_DATAVERSENAME_TUPLE_FIELD_INDEX = 0;
    // Second key field.
    public static final int INDEX_DATASETNAME_TUPLE_FIELD_INDEX = 1;
    // Third key field.
    public static final int INDEX_INDEXNAME_TUPLE_FIELD_INDEX = 2;
    // Payload field containing serialized Index.
    public static final int INDEX_PAYLOAD_TUPLE_FIELD_INDEX = 3;
    // Field name of open field.
    public static final String GRAM_LENGTH_FIELD_NAME = "GramLength";
    public static final String INDEX_SEARCHKEY_TYPE_FIELD_NAME = "SearchKeyType";
    public static final String INDEX_ISENFORCED_FIELD_NAME = "IsEnforced";

    private OrderedListBuilder listBuilder = new OrderedListBuilder();
    private OrderedListBuilder primaryKeyListBuilder = new OrderedListBuilder();
    private AOrderedListType stringList = new AOrderedListType(BuiltinType.ASTRING, null);
    private ArrayBackedValueStorage nameValue = new ArrayBackedValueStorage();
    private ArrayBackedValueStorage itemValue = new ArrayBackedValueStorage();
    private List<List<String>> searchKey;
    private List<IAType> searchKeyType;
    @SuppressWarnings("unchecked")
    protected ISerializerDeserializer<AInt32> intSerde = AqlSerializerDeserializerProvider.INSTANCE
            .getSerializerDeserializer(BuiltinType.AINT32);
    @SuppressWarnings("unchecked")
    private ISerializerDeserializer<ARecord> recordSerde = AqlSerializerDeserializerProvider.INSTANCE
            .getSerializerDeserializer(MetadataRecordTypes.INDEX_RECORDTYPE);
    private final MetadataNode metadataNode;
    private final JobId jobId;

    public IndexTupleTranslator(JobId jobId, MetadataNode metadataNode, boolean getTuple) {
        super(getTuple, MetadataPrimaryIndexes.INDEX_DATASET.getFieldCount());
        this.jobId = jobId;
        this.metadataNode = metadataNode;
    }

    @Override
    public Index getMetadataEntityFromTuple(ITupleReference frameTuple) throws IOException, MetadataException {
        byte[] serRecord = frameTuple.getFieldData(INDEX_PAYLOAD_TUPLE_FIELD_INDEX);
        int recordStartOffset = frameTuple.getFieldStart(INDEX_PAYLOAD_TUPLE_FIELD_INDEX);
        int recordLength = frameTuple.getFieldLength(INDEX_PAYLOAD_TUPLE_FIELD_INDEX);
        ByteArrayInputStream stream = new ByteArrayInputStream(serRecord, recordStartOffset, recordLength);
        DataInput in = new DataInputStream(stream);
        ARecord rec = (ARecord) recordSerde.deserialize(in);
        String dvName = ((AString) rec.getValueByPos(MetadataRecordTypes.INDEX_ARECORD_DATAVERSENAME_FIELD_INDEX))
                .getStringValue();
        String dsName = ((AString) rec.getValueByPos(MetadataRecordTypes.INDEX_ARECORD_DATASETNAME_FIELD_INDEX))
                .getStringValue();
        String indexName = ((AString) rec.getValueByPos(MetadataRecordTypes.INDEX_ARECORD_INDEXNAME_FIELD_INDEX))
                .getStringValue();
        IndexType indexStructure = IndexType.valueOf(((AString) rec
                .getValueByPos(MetadataRecordTypes.INDEX_ARECORD_INDEXSTRUCTURE_FIELD_INDEX)).getStringValue());
        IACursor fieldNameCursor = ((AOrderedList) rec
                .getValueByPos(MetadataRecordTypes.INDEX_ARECORD_SEARCHKEY_FIELD_INDEX)).getCursor();
        List<List<String>> searchKey = new ArrayList<List<String>>();
        AOrderedList fieldNameList;
        while (fieldNameCursor.next()) {
            fieldNameList = (AOrderedList) fieldNameCursor.get();
            IACursor nestedFieldNameCursor = (fieldNameList.getCursor());
            List<String> nestedFieldName = new ArrayList<String>();
            while (nestedFieldNameCursor.next()) {
                nestedFieldName.add(((AString) nestedFieldNameCursor.get()).getStringValue());
            }
            searchKey.add(nestedFieldName);
        }
        int indexKeyTypeFieldPos = rec.getType().findFieldPosition(INDEX_SEARCHKEY_TYPE_FIELD_NAME);
        IACursor fieldTypeCursor = new ACollectionCursor();
        if (indexKeyTypeFieldPos > 0)
            fieldTypeCursor = ((AOrderedList) rec.getValueByPos(indexKeyTypeFieldPos)).getCursor();
        List<IAType> searchKeyType = new ArrayList<IAType>(searchKey.size());
        while (fieldTypeCursor.next()) {
            String typeName = ((AString) fieldTypeCursor.get()).getStringValue();
            IAType fieldType = AsterixBuiltinTypeMap.getTypeFromTypeName(metadataNode, jobId, dvName, typeName, false);
            searchKeyType.add(fieldType);
        }
        // index key type information is not persisted, thus we extract type information from the record metadata
        if (searchKeyType.isEmpty()) {
            String datatypeName = metadataNode.getDataset(jobId, dvName, dsName).getItemTypeName();
            ARecordType recordDt = (ARecordType) metadataNode.getDatatype(jobId, dvName, datatypeName).getDatatype();
            for (int i = 0; i < searchKey.size(); i++) {
                IAType fieldType = recordDt.getSubFieldType(searchKey.get(i));
                searchKeyType.add(fieldType);
            }
        }
        int isEnforcedFieldPos = rec.getType().findFieldPosition(INDEX_ISENFORCED_FIELD_NAME);
        Boolean isEnforcingKeys = false;
        if (isEnforcedFieldPos > 0)
            isEnforcingKeys = ((ABoolean) rec.getValueByPos(isEnforcedFieldPos)).getBoolean();
        Boolean isPrimaryIndex = ((ABoolean) rec.getValueByPos(MetadataRecordTypes.INDEX_ARECORD_ISPRIMARY_FIELD_INDEX))
                .getBoolean();
        int pendingOp = ((AInt32) rec.getValueByPos(MetadataRecordTypes.INDEX_ARECORD_PENDINGOP_FIELD_INDEX))
                .getIntegerValue();
        // Check if there is a gram length as well.
        int gramLength = -1;
        int gramLenPos = rec.getType().findFieldPosition(GRAM_LENGTH_FIELD_NAME);
        if (gramLenPos >= 0) {
            gramLength = ((AInt32) rec.getValueByPos(gramLenPos)).getIntegerValue();
        }
        return new Index(dvName, dsName, indexName, indexStructure, searchKey, searchKeyType, gramLength,
                isEnforcingKeys, isPrimaryIndex, pendingOp);
    }

    @Override
    public ITupleReference getTupleFromMetadataEntity(Index instance) throws IOException, MetadataException {
        // write the key in the first 3 fields of the tuple
        tupleBuilder.reset();
        aString.setValue(instance.getDataverseName());
        stringSerde.serialize(aString, tupleBuilder.getDataOutput());
        tupleBuilder.addFieldEndOffset();
        aString.setValue(instance.getDatasetName());
        stringSerde.serialize(aString, tupleBuilder.getDataOutput());
        tupleBuilder.addFieldEndOffset();
        aString.setValue(instance.getIndexName());
        stringSerde.serialize(aString, tupleBuilder.getDataOutput());
        tupleBuilder.addFieldEndOffset();

        // write the payload in the fourth field of the tuple
        recordBuilder.reset(MetadataRecordTypes.INDEX_RECORDTYPE);
        // write field 0
        fieldValue.reset();
        aString.setValue(instance.getDataverseName());
        stringSerde.serialize(aString, fieldValue.getDataOutput());
        recordBuilder.addField(MetadataRecordTypes.INDEX_ARECORD_DATAVERSENAME_FIELD_INDEX, fieldValue);

        // write field 1
        fieldValue.reset();
        aString.setValue(instance.getDatasetName());
        stringSerde.serialize(aString, fieldValue.getDataOutput());
        recordBuilder.addField(MetadataRecordTypes.INDEX_ARECORD_DATASETNAME_FIELD_INDEX, fieldValue);

        // write field 2
        fieldValue.reset();
        aString.setValue(instance.getIndexName());
        stringSerde.serialize(aString, fieldValue.getDataOutput());
        recordBuilder.addField(MetadataRecordTypes.INDEX_ARECORD_INDEXNAME_FIELD_INDEX, fieldValue);

        // write field 3
        fieldValue.reset();
        aString.setValue(instance.getIndexType().toString());
        stringSerde.serialize(aString, fieldValue.getDataOutput());
        recordBuilder.addField(MetadataRecordTypes.INDEX_ARECORD_INDEXSTRUCTURE_FIELD_INDEX, fieldValue);

        // write field 4
        primaryKeyListBuilder
                .reset((AOrderedListType) MetadataRecordTypes.INDEX_RECORDTYPE.getFieldTypes()[MetadataRecordTypes.INDEX_ARECORD_SEARCHKEY_FIELD_INDEX]);
        this.searchKey = instance.getKeyFieldNames();
        for (List<String> field : this.searchKey) {
            listBuilder.reset(stringList);
            for (String subField : field) {
                itemValue.reset();
                aString.setValue(subField);
                stringSerde.serialize(aString, itemValue.getDataOutput());
                listBuilder.addItem(itemValue);
            }
            itemValue.reset();
            listBuilder.write(itemValue.getDataOutput(), true);
            primaryKeyListBuilder.addItem(itemValue);
        }
        fieldValue.reset();
        primaryKeyListBuilder.write(fieldValue.getDataOutput(), true);
        recordBuilder.addField(MetadataRecordTypes.INDEX_ARECORD_SEARCHKEY_FIELD_INDEX, fieldValue);

        // write field 5
        fieldValue.reset();
        if (instance.isPrimaryIndex()) {
            booleanSerde.serialize(ABoolean.TRUE, fieldValue.getDataOutput());
        } else {
            booleanSerde.serialize(ABoolean.FALSE, fieldValue.getDataOutput());
        }
        recordBuilder.addField(MetadataRecordTypes.INDEX_ARECORD_ISPRIMARY_FIELD_INDEX, fieldValue);

        // write field 6
        fieldValue.reset();
        aString.setValue(Calendar.getInstance().getTime().toString());
        stringSerde.serialize(aString, fieldValue.getDataOutput());
        recordBuilder.addField(MetadataRecordTypes.INDEX_ARECORD_TIMESTAMP_FIELD_INDEX, fieldValue);

        // write field 7
        fieldValue.reset();
        intSerde.serialize(new AInt32(instance.getPendingOp()), fieldValue.getDataOutput());
        recordBuilder.addField(MetadataRecordTypes.INDEX_ARECORD_PENDINGOP_FIELD_INDEX, fieldValue);

        // write optional field 8
        if (instance.getGramLength() > 0) {
            fieldValue.reset();
            nameValue.reset();
            aString.setValue(GRAM_LENGTH_FIELD_NAME);
            stringSerde.serialize(aString, nameValue.getDataOutput());
            intSerde.serialize(new AInt32(instance.getGramLength()), fieldValue.getDataOutput());
            try {
                recordBuilder.addField(nameValue, fieldValue);
            } catch (AsterixException e) {
                throw new MetadataException(e);
            }
        }

        if (instance.isEnforcingKeyFileds()) {
            // write optional field 9
            OrderedListBuilder typeListBuilder = new OrderedListBuilder();
            typeListBuilder.reset(new AOrderedListType(BuiltinType.ASTRING, null));
            ArrayBackedValueStorage nameValue = new ArrayBackedValueStorage();
            nameValue.reset();
            aString.setValue(INDEX_SEARCHKEY_TYPE_FIELD_NAME);

            stringSerde.serialize(aString, nameValue.getDataOutput());

            this.searchKeyType = instance.getKeyFieldTypes();
            for (IAType type : this.searchKeyType) {
                itemValue.reset();
                aString.setValue(type.getTypeName());
                stringSerde.serialize(aString, itemValue.getDataOutput());
                typeListBuilder.addItem(itemValue);
            }
            fieldValue.reset();
            typeListBuilder.write(fieldValue.getDataOutput(), true);
            try {
                recordBuilder.addField(nameValue, fieldValue);
            } catch (AsterixException e) {
                throw new MetadataException(e);
            }

            // write optional field 10
            fieldValue.reset();
            nameValue.reset();
            aString.setValue(INDEX_ISENFORCED_FIELD_NAME);

            stringSerde.serialize(aString, nameValue.getDataOutput());

            booleanSerde.serialize(ABoolean.TRUE, fieldValue.getDataOutput());

            try {
                recordBuilder.addField(nameValue, fieldValue);
            } catch (AsterixException e) {
                throw new MetadataException(e);
            }
        }

        // write record
        try {
            recordBuilder.write(tupleBuilder.getDataOutput(), true);
        } catch (AsterixException e) {
            throw new MetadataException(e);
        }
        tupleBuilder.addFieldEndOffset();

        tuple.reset(tupleBuilder.getFieldEndOffsets(), tupleBuilder.getByteArray());
        return tuple;
    }
}

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<META http-equiv="Content-Type" content="text/html; charset=utf-8">
<TITLE>
类 javax.swing.JComponent 的使用 (Java Platform SE 6)
</TITLE>

<META NAME="date" CONTENT="2007-03-19">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../stylesheet.css" TITLE="Style">

      概述
      软件包
      类
    使用
      树
      已过时
      索引
      帮助

JavaTM Platform
Standard Ed. 6

 上一个
 下一个

  框架
 无框架

  所有类

类 javax.swing.JComponent
的使用

使用 JComponent 的软件包

javax.swing
提供一组“轻量级”(全部是 Java 语言)组件,尽量让这些组件在所有平台上的工作方式都相同。

javax.swing.colorchooser
包含供 JColorChooser 组件使用的类和接口。

javax.swing.event
供 Swing 组件触发的事件使用。

javax.swing.plaf
提供一个接口和许多抽象类,Swing 用它们来提供自己的可插入外观功能。

javax.swing.plaf.basic
提供了根据基本外观构建的用户界面对象。

javax.swing.plaf.metal
提供根据 Java 外观(曾经代称为 Metal)构建的用户界面对象,Java 外观是默认外观。

javax.swing.plaf.multi
提供了组合两个或多个外观的用户界面对象。

javax.swing.plaf.synth

Synth 是一个可更换皮肤 (skinnable) 的外观,在其中可委托所有绘制。

javax.swing.table
提供用于处理 javax.swing.JTable 的类和接口。

javax.swing.text
提供类 HTMLEditorKit 和创建 HTML 文本编辑器的支持类。

javax.swing.tree
提供处理 javax.swing.JTree 的类和接口。

javax.swing 中 JComponent 的使用

javax.swing 中 JComponent 的子类

 class
AbstractButton

          定义按钮和菜单项的一般行为。

 class
Box

          使用 BoxLayout 对象作为其布局管理器的一个轻量级容器。

static class
Box.Filler

          参与布局但没有视图的轻量级组件的实现。

 class
DefaultListCellRenderer

          呈现列表中的一个项。

static class
DefaultListCellRenderer.UIResource

          实现 UIResource 的 DefaultListCellRenderer 的子类。

 class
JButton

          "push" 按钮的实现。

 class
JCheckBox

          复选框的实现,复选框是一个可以被选定和取消选定的项,它将其状态显示给用户。

 class
JCheckBoxMenuItem

          可以被选定或取消选定的菜单项。

 class
JColorChooser

          JColorChooser 提供一个用于允许用户操作和选择颜色的控制器窗格。

 class
JComboBox

          将按钮或可编辑字段与下拉列表组合的组件。

 class
JDesktopPane

          用于创建多文档界面或虚拟桌面的容器。

 class
JEditorPane

          可编辑各种内容的文本组件。

 class
JFileChooser

          JFileChooser 为用户选择文件提供了一种简单的机制。

 class
JFormattedTextField

          JFormattedTextField 扩展了 JTextField,添加了对格式化任意值的支持,以及一旦用户编辑了文本就检索特定对象的支持。

 class
JInternalFrame

          提供很多本机窗体功能的轻量级对象,这些功能包括拖动、关闭、变成图标、调整大小、标题显示和支持菜单栏。

static class
JInternalFrame.JDesktopIcon

          此组件表示 JInternalFrame 的图标化版本。

 class
JLabel

          用于短文本字符串或图像或二者的显示区。

 class
JLayeredPane

          JLayeredPane 为 JFC/Swing 容器添加了深度,允许组件在需要时互相重叠。

 class
JList

          显示对象列表并且允许用户选择一个或多个项的组件。

 class
JMenu

          菜单的该实现是一个包含 JMenuItem 的弹出窗口,用户选择 JMenuBar 上的项时会显示该 JMenuItem。

 class
JMenuBar

          菜单栏的实现。

 class
JMenuItem

          菜单中的项的实现。

 class
JOptionPane

          JOptionPane 有助于方便地弹出要求用户提供值或向其发出通知的标准对话框。

 class
JPanel

          JPanel 是一般轻量级容器。

 class
JPasswordField

          JPasswordField 是一个轻量级组件,允许编辑单行文本,其视图指示键入内容,但不显示原始字符。

 class
JPopupMenu

          弹出菜单的实现,弹出菜单是一个可弹出并显示一系列选项的小窗口。

static class
JPopupMenu.Separator

          弹出与菜单有关的分隔符。

 class
JProgressBar

          以可视化形式显示某些任务进度的组件。

 class
JRadioButton

          实现一个单选按钮,此按钮项可被选择或取消选择,并可为用户显示其状态。

 class
JRadioButtonMenuItem

          一个单选按钮菜单项的实现。

 class
JRootPane

          该轻量级容器由 JFrame、JDialog、JWindow、JApplet 和 JInternalFrame 在后台使用。

 class
JScrollBar

          滚动条的实现。

 class
JScrollPane

          提供轻量级组件的 scrollable 视图。

protected  class
JScrollPane.ScrollBar

          默认情况下,JScrollPane 创建的滚动条为此类的实例。

 class
JSeparator

          JSeparator 为实现分隔线提供了一个通用组件 - 通常用作菜单项之间的分隔符,以便将菜单项分成几个逻辑组。

 class
JSlider

          一个让用户以图形方式在有界区间内通过移动滑块来选择值的组件。

 class
JSpinner

          让用户从一个有序序列中选择一个数字或者一个对象值的单行输入字段。

static class
JSpinner.DateEditor

          其模型为 SpinnerDateModel 的 JSpinner 编辑器。

static class
JSpinner.DefaultEditor

          一个针对非常特殊编辑器的简单基类,该类在 JFormattedTextField 中显示模型的当前值的只读视图。

static class
JSpinner.ListEditor

          其模型为 SpinnerListModel 的 JSpinner 编辑器。

static class
JSpinner.NumberEditor

          其模型为 SpinnerNumberModel 的 JSpinner 编辑器。

 class
JSplitPane

          JSplitPane 用于分隔两个(只能两个)Component。

 class
JTabbedPane

          一个组件,它允许用户通过单击具有给定标题和/或图标的选项卡,在一组组件之间进行切换。

 class
JTable

          JTable 用来显示和编辑常规二维单元表。

 class
JTextArea

          JTextArea 是一个显示纯文本的多行区域。

 class
JTextField

          JTextField 是一个轻量级组件,它允许编辑单行文本。

 class
JTextPane

          可以用以图形方式表示的属性来标记的文本组件。

 class
JToggleButton

          具有两个状态的(two-state)按钮的实现。

 class
JToolBar

          JToolBar 提供了一个用来显示常用的 Action 或控件的组件。

static class
JToolBar.Separator

          一个特定于工具栏的分隔符。

 class
JToolTip

          用来显示 Component 的"提示"。

 class
JTree

          将分层数据集显示为轮廓的控件。

 class
JViewport

          用于查看底层信息的“视口”或“观察孔”。

声明为 JComponent 的 javax.swing 中的字段

protected  JComponent
DefaultCellEditor.editorComponent

          正被编辑的 Swing 组件。

返回 JComponent 的 javax.swing 中的方法

protected  JComponent
JSpinner.createEditor(SpinnerModel model)

          此方法由构造方法调用,以创建显示序列当前值的 JComponent。

 JComponent
JFileChooser.getAccessory()

          返回 accessory 组件。

 JComponent
JToolTip.getComponent()

          返回工具提示所描述的组件。

 JComponent
ComponentInputMap.getComponent()

          返回为其创建 InputMap 的组件。

 JComponent
JSpinner.getEditor()

          返回显示和潜在更改模型值的组件。

 JComponent
JColorChooser.getPreviewPanel()

          返回显示选取颜色的预览面板。

参数类型为 JComponent 的 javax.swing 中的方法

 void
RepaintManager.addDirtyRegion(JComponent c,
               int x,
               int y,
               int w,
               int h)

          在应刷新的组件列表中添加组件。

 void
RepaintManager.addInvalidComponent(JComponent invalidComponent)

          按照布局需要标记组件,并将事件指派线程的 runnable 排入队列,该线程将验证组件的第一个 isValidateRoot() 祖先。

 GroupLayout.SequentialGroup
GroupLayout.SequentialGroup.addPreferredGap(JComponent comp1,
                JComponent comp2,
                LayoutStyle.ComponentPlacement type)

          添加一个表示两个组件之间首选间隙的元素。

 GroupLayout.SequentialGroup
GroupLayout.SequentialGroup.addPreferredGap(JComponent comp1,
                JComponent comp2,
                LayoutStyle.ComponentPlacement type,
                int pref,
                int max)

          添加一个表示两个组件之间首选间隙的元素。

 void
DefaultDesktopManager.beginDraggingFrame(JComponent f)

 void
DesktopManager.beginDraggingFrame(JComponent f)

          通常在用户已经指示他们将开始拖动某个组件时调用此方法。

 void
DefaultDesktopManager.beginResizingFrame(JComponent f,
                   int direction)

 void
DesktopManager.beginResizingFrame(JComponent f,
                   int direction)

          通常在用户已经指示他们将开始重新调整窗体的大小时调用此方法。

static Rectangle
SwingUtilities.calculateInnerArea(JComponent c,
                   Rectangle r)

          将指定组件的内部绘制区域的位置和大小存储在 r 中,然后返回 r。

 boolean
TransferHandler.canImport(JComponent comp,
          DataFlavor[] transferFlavors)

          指示一个组件在实际尝试导入给定数据 flavor 的集合之前是否接受其导入。

protected  Transferable
TransferHandler.createTransferable(JComponent c)

          创建一个要用作数据传输源的 Transferable。

static RepaintManager
RepaintManager.currentManager(JComponent c)

          在给定 JComponent 的情况下,返回调用线程的 RepaintManager。

 void
DefaultDesktopManager.dragFrame(JComponent f,
          int newX,
          int newY)

          将正被拖动窗体的可见位置移动到指定位置。

 void
DesktopManager.dragFrame(JComponent f,
          int newX,
          int newY)

          用户已经移动窗体。

 void
DefaultDesktopManager.endDraggingFrame(JComponent f)

 void
DesktopManager.endDraggingFrame(JComponent f)

          此方法在拖动会话结束时发出信号。

 void
DefaultDesktopManager.endResizingFrame(JComponent f)

 void
DesktopManager.endResizingFrame(JComponent f)

          此方法在重新调整大小会话结束时发出信号。

 void
TransferHandler.exportAsDrag(JComponent comp,
             InputEvent e,
             int action)

          导致 Swing 拖动支持的启用。

protected  void
TransferHandler.exportDone(JComponent source,
           Transferable data,
           int action)

          在导出数据之后调用。

 void
TransferHandler.exportToClipboard(JComponent comp,
                  Clipboard clip,
                  int action)

          导致从给定组件到给定剪贴板的传输。

abstract  int
LayoutStyle.getContainerGap(JComponent component,
                int position,
                Container parent)

          返回组件与其父容器的指定边缘之间放置的空格数量。

 Rectangle
RepaintManager.getDirtyRegion(JComponent aComponent)

          返回组件的当前脏区。

 Icon
LookAndFeel.getDisabledIcon(JComponent component,
                Icon icon)

          返回具有禁用外观的 Icon。

 Icon
LookAndFeel.getDisabledSelectedIcon(JComponent component,
                        Icon icon)

          返回由选定的禁用组件使用的 Icon。

static int
JLayeredPane.getLayer(JComponent c)

          获得 JComponent 的 layer 属性,此方法不会产生与 setLayer() 类似的副作用(绘制、添加/移除等)。

abstract  int
LayoutStyle.getPreferredGap(JComponent component1,
                JComponent component2,
                LayoutStyle.ComponentPlacement type,
                int position,
                Container parent)

          返回两个组件之间使用的空格的数量。

 int
TransferHandler.getSourceActions(JComponent c)

          返回源支持的传输动作的类型;COPY、MOVE 和 LINK 的任意按位或组合。

 ComponentUI
UIDefaults.getUI(JComponent target)

          创建一个指定组件的 ComponentUI 实现。

static ComponentUI
UIManager.getUI(JComponent target)

          返回 target 的适当 ComponentUI 实现。

static ActionMap
SwingUtilities.getUIActionMap(JComponent component)

          返回该 UI 在组件 component 中提供的 ActionMap。

static InputMap
SwingUtilities.getUIInputMap(JComponent component,
              int condition)

          返回由组件 component 中的条件 condition 的 UI 提供的 InputMap。

 boolean
TransferHandler.importData(JComponent comp,
           Transferable t)

          导致从剪贴板或 DND 放置操作向组件的传输。

static void
LookAndFeel.installBorder(JComponent c,
              String defaultBorderName)

          使用默认的值设置组件边框属性的便捷方法。

static void
LookAndFeel.installColors(JComponent c,
              String defaultBgName,
              String defaultFgName)

          使用默认的值设置组件的前景和背景颜色属性的便捷方法。

static void
LookAndFeel.installColorsAndFont(JComponent c,
                     String defaultBgName,
                     String defaultFgName,
                     String defaultFontName)

          使用默认的值设置组件的前景、背景和字体属性的便捷方法。

static void
LookAndFeel.installProperty(JComponent c,
                String propertyName,
                Object propertyValue)

          在组件上安装具有指定名称和值的属性的便捷方法,条件是该属性尚未由开发人员设置。

 boolean
RepaintManager.isCompletelyDirty(JComponent aComponent)

          在下一个 paintDirtyRegions() 中全部绘制 aComponent 时返回 true 的便捷方法。

static String
SwingUtilities.layoutCompoundLabel(JComponent c,
                    FontMetrics fm,
                    String text,
                    Icon icon,
                    int verticalAlignment,
                    int horizontalAlignment,
                    int verticalTextPosition,
                    int horizontalTextPosition,
                    Rectangle viewR,
                    Rectangle iconR,
                    Rectangle textR,
                    int textIconGap)

          计算并返回图标原点的位置,文本基线的原点的位置,以及复合标签字符串的可能进行了修剪的版本。

static ComponentInputMap
LookAndFeel.makeComponentInputMap(JComponent c,
                      Object[] keys)

          根据 keys 创建一个 ComponentInputMapUIResource。

 void
RepaintManager.markCompletelyClean(JComponent aComponent)

          标记完全干净的组件。

 void
RepaintManager.markCompletelyDirty(JComponent aComponent)

          标记完全弄脏的组件。

static void
JLayeredPane.putLayer(JComponent c,
         int layer)

          设置 JComponent 上的 layer 属性。

 void
ToolTipManager.registerComponent(JComponent component)

          注册一个工具提示管理组件。

 void
RepaintManager.removeInvalidComponent(JComponent component)

          从无效组件的列表移除组件。

static void
SwingUtilities.replaceUIActionMap(JComponent component,
                   ActionMap uiActionMap)

          将 component 的 UI ActionMap 更改为 uiActionMap 的便捷方法。

static void
SwingUtilities.replaceUIInputMap(JComponent component,
                  int type,
                  InputMap uiInputMap)

          将 component 的 UI InputMap 更改为 uiInputMap 的便捷方法。

 void
DefaultDesktopManager.resizeFrame(JComponent f,
            int newX,
            int newY,
            int newWidth,
            int newHeight)

          使用新值调用 setBoundsForFrame。

 void
DesktopManager.resizeFrame(JComponent f,
            int newX,
            int newY,
            int newWidth,
            int newHeight)

          用户已经重新调整组件的大小。

 void
JFileChooser.setAccessory(JComponent newAccessory)

          设置 accessory 组件。

 void
DefaultDesktopManager.setBoundsForFrame(JComponent f,
                  int newX,
                  int newY,
                  int newWidth,
                  int newHeight)

          此方法移动 JComponent 并重新绘制已毁坏的区域。

 void
DesktopManager.setBoundsForFrame(JComponent f,
                  int newX,
                  int newY,
                  int newWidth,
                  int newHeight)

          这是一个基本重塑方法。

 void
JToolTip.setComponent(JComponent c)

          指定工具提示所描述的组件。

 void
JSpinner.setEditor(JComponent editor)

          更改显示 SpinnerModel 当前值的 JComponent。

 void
JColorChooser.setPreviewPanel(JComponent preview)

          设置当前预览面板。

 boolean
InputVerifier.shouldYieldFocus(JComponent input)

          调用 verify(input) 来确保输入是有效的。

static void
LookAndFeel.uninstallBorder(JComponent c)

          卸载边框的便捷方法。

 void
ToolTipManager.unregisterComponent(JComponent component)

          从工具提示控件中移除一个组件。

abstract  boolean
InputVerifier.verify(JComponent input)

          检查 JComponent 的输入是否有效。

参数类型为 JComponent 的 javax.swing 中的构造方法

ComponentInputMap(JComponent component)

          创建一个与给定组件相关联的 ComponentInputMap。

DebugGraphics(Graphics graphics,
              JComponent component)

          根据现有图形上下文构造一个调试图形上下文,该上下文可以减慢指定组件的绘制。

javax.swing.colorchooser 中 JComponent 的使用

javax.swing.colorchooser 中 JComponent 的子类

 class
AbstractColorChooserPanel

          这是用于颜色选取器的抽象超类。

返回 JComponent 的 javax.swing.colorchooser 中的方法

static JComponent
ColorChooserComponentFactory.getPreviewPanel()

javax.swing.event 中 JComponent 的使用

返回 JComponent 的 javax.swing.event 中的方法

 JComponent
AncestorEvent.getComponent()

          返回添加了侦听器的组件。

参数类型为 JComponent 的 javax.swing.event 中的构造方法

AncestorEvent(JComponent source,
              int id,
              Container ancestor,
              Container ancestorParent)

          构造一个 AncestorEvent 对象,以标识祖先组件显示状态的更改。

javax.swing.plaf 中 JComponent 的使用

参数类型为 JComponent 的 javax.swing.plaf 中的方法

 boolean
ComponentUI.contains(JComponent c,
         int x,
         int y)

          如果指定 x,y 位置包含在指定组件外观的已定义形状中,则返回 true。

static ComponentUI
ComponentUI.createUI(JComponent c)

          返回指定组件的一个 UI 委托实例。

 Accessible
ComponentUI.getAccessibleChild(JComponent c,
                   int i)

          返回对象的第 i 个 Accessible 子对象。

 int
ComponentUI.getAccessibleChildrenCount(JComponent c)

          返回对象中的可访问子对象数。

 int
ComponentUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 Component.BaselineResizeBehavior
ComponentUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,指示组件的基线如何随大小的改变而发生更改。

 Dimension
ComponentUI.getMaximumSize(JComponent c)

          返回指定组件的适合外观的最大大小。

 Dimension
ComponentUI.getMinimumSize(JComponent c)

          返回指定组件的适合外观的最小大小。

 Dimension
ComponentUI.getPreferredSize(JComponent c)

          返回指定组件的适合外观的首选大小。

 void
ComponentUI.installUI(JComponent c)

          配置指定组件,使其适合外观。

 void
ComponentUI.paint(Graphics g,
      JComponent c)

          绘制指定组件,使其适合外观。

 void
ComponentUI.uninstallUI(JComponent c)

          在 installUI 期间,在指定组件上反向执行的配置操作。

 void
ComponentUI.update(Graphics g,
       JComponent c)

          通知此 UI 委托开始绘制指定的组件。

参数类型为 JComponent 的 javax.swing.plaf 中的构造方法

ComponentInputMapUIResource(JComponent component)

javax.swing.plaf.basic 中 JComponent 的使用

javax.swing.plaf.basic 中 JComponent 的子类

 class
BasicArrowButton

          一个 JButton 对象,它绘制朝某个基本方向的缩放箭头。

 class
BasicComboBoxRenderer

          ComboBox 渲染器

警告:此类的序列化对象将与以后的 Swing 版本不兼容。

static class
BasicComboBoxRenderer.UIResource

          实现 UIResource 的 BasicComboBoxRenderer 的子类。

 class
BasicComboPopup

          此为 ComboPopup 接口的基本实现。

 class
BasicInternalFrameTitlePane

          管理基本标题栏的类

警告:此类的序列化对象将与以后的 Swing 版本不兼容。

 class
BasicInternalFrameTitlePane.SystemMenuBar

          此类应视为“受保护”内部类。

声明为 JComponent 的 javax.swing.plaf.basic 中的字段

protected  JComponent
BasicInternalFrameUI.eastPane

protected  JComponent
BasicDesktopIconUI.iconPane

          在桌面图标中使用的标题窗格组件。

protected  JComponent
BasicOptionPaneUI.inputComponent

          如果 optionPane.getWantsInput() 返回 true,则 JComponent 提供输入。

protected  JComponent
BasicInternalFrameUI.northPane

protected  JComponent
BasicInternalFrameUI.southPane

protected  JComponent
BasicInternalFrameUI.westPane

返回 JComponent 的 javax.swing.plaf.basic 中的方法

protected  JComponent
BasicInternalFrameUI.createEastPane(JInternalFrame w)

protected  JComponent
BasicSpinnerUI.createEditor()

          installUI 通过调用此方法获取 JSpinner 的编辑器组件。

protected  JComponent
BasicInternalFrameUI.createNorthPane(JInternalFrame w)

protected  JComponent
BasicInternalFrameUI.createSouthPane(JInternalFrame w)

protected  JComponent
BasicInternalFrameUI.createWestPane(JInternalFrame w)

 JComponent
BasicInternalFrameUI.getEastPane()

 JComponent
BasicInternalFrameUI.getNorthPane()

 JComponent
BasicInternalFrameUI.getSouthPane()

 JComponent
BasicInternalFrameUI.getWestPane()

参数类型为 JComponent 的 javax.swing.plaf.basic 中的方法

protected  ChangeListener
BasicMenuUI.createChangeListener(JComponent c)

static View
BasicHTML.createHTMLView(JComponent c,
               String html)

          创建给定组件和 html 字符串的 html 渲染器。

protected  MenuDragMouseListener
BasicMenuUI.createMenuDragMouseListener(JComponent c)

protected  MenuDragMouseListener
BasicMenuItemUI.createMenuDragMouseListener(JComponent c)

protected  MenuKeyListener
BasicMenuUI.createMenuKeyListener(JComponent c)

protected  MenuKeyListener
BasicMenuItemUI.createMenuKeyListener(JComponent c)

protected  MenuListener
BasicMenuUI.createMenuListener(JComponent c)

protected  MouseInputListener
BasicMenuUI.createMouseInputListener(JComponent c)

protected  MouseInputListener
BasicMenuItemUI.createMouseInputListener(JComponent c)

protected  PropertyChangeListener
BasicMenuUI.createPropertyChangeListener(JComponent c)

protected  PropertyChangeListener
BasicMenuItemUI.createPropertyChangeListener(JComponent c)

          创建一个将被添加到菜单项的 PropertyChangeListener。

static ComponentUI
BasicCheckBoxUI.createUI(JComponent b)

static ComponentUI
BasicColorChooserUI.createUI(JComponent c)

static ComponentUI
BasicDesktopIconUI.createUI(JComponent c)

static ComponentUI
BasicDesktopPaneUI.createUI(JComponent c)

static ComponentUI
BasicEditorPaneUI.createUI(JComponent c)

          创建 JTextPane 的 UI。

static ComponentUI
BasicFormattedTextFieldUI.createUI(JComponent c)

          创建 JFormattedTextField 的 UI。

static ComponentUI
BasicInternalFrameUI.createUI(JComponent b)

static ComponentUI
BasicOptionPaneUI.createUI(JComponent x)

          创建一个新的 BasicOptionPaneUI 实例。

static ComponentUI
BasicPasswordFieldUI.createUI(JComponent c)

          创建 JPasswordField 的 UI。

static ComponentUI
BasicPopupMenuSeparatorUI.createUI(JComponent c)

static ComponentUI
BasicSpinnerUI.createUI(JComponent c)

          返回 BasicSpinnerUI 的新实例。

static ComponentUI
BasicTextPaneUI.createUI(JComponent c)

          创建 JTextPane 的 UI。

static ComponentUI
BasicToolTipUI.createUI(JComponent c)

static ComponentUI
BasicRadioButtonMenuItemUI.createUI(JComponent b)

static ComponentUI
BasicCheckBoxMenuItemUI.createUI(JComponent c)

static ComponentUI
BasicSliderUI.createUI(JComponent b)

static ComponentUI
BasicTextAreaUI.createUI(JComponent ta)

          创建 JTextArea 的 UI。

static ComponentUI
BasicSplitPaneUI.createUI(JComponent x)

          创建新的 BasicSplitPaneUI 实例

static ComponentUI
BasicTreeUI.createUI(JComponent x)

static ComponentUI
BasicTableUI.createUI(JComponent c)

static ComponentUI
BasicTableHeaderUI.createUI(JComponent h)

static ComponentUI
BasicProgressBarUI.createUI(JComponent x)

static ComponentUI
BasicRadioButtonUI.createUI(JComponent b)

static ComponentUI
BasicTabbedPaneUI.createUI(JComponent c)

static ComponentUI
BasicToolBarSeparatorUI.createUI(JComponent c)

static ComponentUI
BasicTextFieldUI.createUI(JComponent c)

          创建 JTextField 的 UI。

static ComponentUI
BasicScrollPaneUI.createUI(JComponent x)

static ComponentUI
BasicViewportUI.createUI(JComponent c)

static ComponentUI
BasicListUI.createUI(JComponent list)

          返回 BasicListUI 的新实例。

static ComponentUI
BasicComboBoxUI.createUI(JComponent c)

static ComponentUI
BasicScrollBarUI.createUI(JComponent c)

static ComponentUI
BasicSeparatorUI.createUI(JComponent c)

static ComponentUI
BasicPopupMenuUI.createUI(JComponent x)

static ComponentUI
BasicMenuUI.createUI(JComponent x)

static ComponentUI
BasicMenuItemUI.createUI(JComponent c)

static ComponentUI
BasicToolBarUI.createUI(JComponent c)

static ComponentUI
BasicMenuBarUI.createUI(JComponent x)

static ComponentUI
BasicToggleButtonUI.createUI(JComponent b)

static ComponentUI
BasicButtonUI.createUI(JComponent c)

static ComponentUI
BasicLabelUI.createUI(JComponent c)

static ComponentUI
BasicRootPaneUI.createUI(JComponent c)

static ComponentUI
BasicPanelUI.createUI(JComponent c)

protected  void
BasicInternalFrameUI.deinstallMouseHandlers(JComponent c)

 Accessible
BasicComboBoxUI.getAccessibleChild(JComponent c,
                   int i)

 int
BasicComboBoxUI.getAccessibleChildrenCount(JComponent c)

 int
BasicSpinnerUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicSliderUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicTextAreaUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicTreeUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicTableUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicTableHeaderUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicProgressBarUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicTabbedPaneUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicTextFieldUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicScrollPaneUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicListUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicComboBoxUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicButtonUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicLabelUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 int
BasicPanelUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 Component.BaselineResizeBehavior
BasicSpinnerUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示该组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicSliderUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示该组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicTextAreaUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicTreeUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicTableUI.getBaselineResizeBehavior(JComponent c)

          返回指示该组件的基线如何随大小的改变而发生更改的枚举。

 Component.BaselineResizeBehavior
BasicProgressBarUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示该组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicTabbedPaneUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示该组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicTextFieldUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示该组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicScrollPaneUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示该组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicListUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示该组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicComboBoxUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示该组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicButtonUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示该组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicLabelUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示组件的基线如何随大小的改变而发生更改。

 Component.BaselineResizeBehavior
BasicPanelUI.getBaselineResizeBehavior(JComponent c)

          返回一个枚举,它指示该组件的基线如何随大小的改变而发生更改。

 Insets
BasicDesktopIconUI.getInsets(JComponent c)

 Insets
BasicSplitPaneUI.getInsets(JComponent jc)

          返回 insets。

 Dimension
BasicDesktopIconUI.getMaximumSize(JComponent c)

          不能调整桌面图标的大小。

 Dimension
BasicDesktopPaneUI.getMaximumSize(JComponent c)

 Dimension
BasicInternalFrameUI.getMaximumSize(JComponent x)

 Dimension
BasicToolTipUI.getMaximumSize(JComponent c)

 Dimension
BasicSliderUI.getMaximumSize(JComponent c)

 Dimension
BasicSplitPaneUI.getMaximumSize(JComponent jc)

          返回传入组件的最大大小,该大小将传递给当前布局管理器。

 Dimension
BasicTreeUI.getMaximumSize(JComponent c)

          返回此组件的最大大小,如果实例当前位于 JTree 中或 0, 0 处,则该大小将为首选大小。

 Dimension
BasicTableUI.getMaximumSize(JComponent c)

          返回表的最大大小。

 Dimension
BasicTableHeaderUI.getMaximumSize(JComponent c)

          返回标题的最大大小。

 Dimension
BasicProgressBarUI.getMaximumSize(JComponent c)

 Dimension
BasicTabbedPaneUI.getMaximumSize(JComponent c)

 Dimension
BasicTextUI.getMaximumSize(JComponent c)

          获取编辑器组件的最大大小。

 Dimension
BasicScrollPaneUI.getMaximumSize(JComponent c)

 Dimension
BasicComboBoxUI.getMaximumSize(JComponent c)

 Dimension
BasicScrollBarUI.getMaximumSize(JComponent c)

 Dimension
BasicSeparatorUI.getMaximumSize(JComponent c)

 Dimension
BasicMenuUI.getMaximumSize(JComponent c)

 Dimension
BasicMenuItemUI.getMaximumSize(JComponent c)

 Dimension
BasicMenuBarUI.getMaximumSize(JComponent c)

 Dimension
BasicButtonUI.getMaximumSize(JComponent c)

 Dimension
BasicLabelUI.getMaximumSize(JComponent c)

 Dimension
BasicDesktopIconUI.getMinimumSize(JComponent c)

 Dimension
BasicDesktopPaneUI.getMinimumSize(JComponent c)

 Dimension
BasicInternalFrameUI.getMinimumSize(JComponent x)

 Dimension
BasicToolTipUI.getMinimumSize(JComponent c)

 Dimension
BasicSliderUI.getMinimumSize(JComponent c)

 Dimension
BasicTextAreaUI.getMinimumSize(JComponent c)

          重写此方法以将插入符的宽度考虑在内。

 Dimension
BasicSplitPaneUI.getMinimumSize(JComponent jc)

          返回传入组件的最小大小,该大小将传递给当前布局管理器。

 Dimension
BasicTreeUI.getMinimumSize(JComponent c)

          返回此组件的最小大小。

 Dimension
BasicTableUI.getMinimumSize(JComponent c)

          返回表的最小大小。

 Dimension
BasicTableHeaderUI.getMinimumSize(JComponent c)

          返回标题的最小大小。

 Dimension
BasicProgressBarUI.getMinimumSize(JComponent c)

          此组件的最小大小为 10。

 Dimension
BasicTabbedPaneUI.getMinimumSize(JComponent c)

 Dimension
BasicTextUI.getMinimumSize(JComponent c)

          获取编辑器组件的最小大小。

 Dimension
BasicComboBoxUI.getMinimumSize(JComponent c)

          最小大小为显示区域加上 insets 再加上按钮的大小。

 Dimension
BasicSeparatorUI.getMinimumSize(JComponent c)

 Dimension
BasicMenuItemUI.getMinimumSize(JComponent c)

 Dimension
BasicMenuBarUI.getMinimumSize(JComponent c)

 Dimension
BasicButtonUI.getMinimumSize(JComponent c)

 Dimension
BasicLabelUI.getMinimumSize(JComponent c)

protected  Dimension
BasicMenuItemUI.getPreferredMenuItemSize(JComponent c,
                         Icon checkIcon,
                         Icon arrowIcon,
                         int defaultTextIconGap)

 Dimension
BasicDesktopIconUI.getPreferredSize(JComponent c)

 Dimension
BasicDesktopPaneUI.getPreferredSize(JComponent c)

 Dimension
BasicInternalFrameUI.getPreferredSize(JComponent x)

 Dimension
BasicOptionPaneUI.getPreferredSize(JComponent c)

          如果 c 为包含接收者的 JOptionPane,则返回的首选大小为 JOptionPane 的 LayoutManager 的最大首选大小和 getMinimumOptionPaneSize。

 Dimension
BasicPopupMenuSeparatorUI.getPreferredSize(JComponent c)

 Dimension
BasicToolTipUI.getPreferredSize(JComponent c)

 Dimension
BasicSliderUI.getPreferredSize(JComponent c)

 Dimension
BasicTextAreaUI.getPreferredSize(JComponent c)

          重写此方法以将插入符的宽度考虑在内。

 Dimension
BasicSplitPaneUI.getPreferredSize(JComponent jc)

          返回传入组件的首选大小,该大小将传递给当前布局管理器。

 Dimension
BasicTreeUI.getPreferredSize(JComponent c)

          返回首选大小以正确显示树,这是一种 getPreferredSize(c, false) 的替代方法。

 Dimension
BasicTableUI.getPreferredSize(JComponent c)

          返回表的首选大小。

 Dimension
BasicTableHeaderUI.getPreferredSize(JComponent c)

          返回标题的首选大小。

 Dimension
BasicProgressBarUI.getPreferredSize(JComponent c)

 Dimension
BasicRadioButtonUI.getPreferredSize(JComponent c)

          单选按钮的首选大小。

 Dimension
BasicToolBarSeparatorUI.getPreferredSize(JComponent c)

 Dimension
BasicTextUI.getPreferredSize(JComponent c)

          获取编辑器组件的首选大小。

 Dimension
BasicListUI.getPreferredSize(JComponent c)

          列表的 preferredSize 依赖于布局方向。

 Dimension
BasicComboBoxUI.getPreferredSize(JComponent c)

 Dimension
BasicScrollBarUI.getPreferredSize(JComponent c)

          垂直滚动条的首选宽度是(非 null)递增/递减按钮的首选宽度的最大值,也是 thumb 的最小宽度。

 Dimension
BasicSeparatorUI.getPreferredSize(JComponent c)

 Dimension
BasicMenuItemUI.getPreferredSize(JComponent c)

 Dimension
BasicButtonUI.getPreferredSize(JComponent c)

 Dimension
BasicLabelUI.getPreferredSize(JComponent c)

 Dimension
BasicTreeUI.getPreferredSize(JComponent c,
                 boolean checkConsistancy)

          返回首选大小以表示 c 中的树。

protected  void
BasicToolTipUI.installDefaults(JComponent c)

protected  void
BasicViewportUI.installDefaults(JComponent c)

 void
BasicButtonListener.installKeyboardActions(JComponent c)

          注册默认键动作:按下空格键以“单击”按钮并注册键盘助记符(如果有)。

protected  void
BasicToolTipUI.installListeners(JComponent c)

protected  void
BasicInternalFrameUI.installMouseHandlers(JComponent c)

protected  void
BasicToolBarUI.installNonRolloverBorders(JComponent c)

          在 JComponent 的所有子组件上安装非翻转边框。

protected  void
BasicToolBarUI.installNormalBorders(JComponent c)

          在 JComponent 的所有子组件上安装普通边框。

protected  void
BasicToolBarUI.installRolloverBorders(JComponent c)

          在 JComponent 的所有子组件上安装翻转边框。

 void
BasicColorChooserUI.installUI(JComponent c)

 void
BasicDesktopIconUI.installUI(JComponent c)

 void
BasicDesktopPaneUI.installUI(JComponent c)

 void
BasicEditorPaneUI.installUI(JComponent c)

          安装组件的 UI。

 void
BasicFileChooserUI.installUI(JComponent c)

 void
BasicInternalFrameUI.installUI(JComponent c)

 void
BasicOptionPaneUI.installUI(JComponent c)

          安装作为传入 JOptionPane 的 L&F 的接收者。

 void
BasicSpinnerUI.installUI(JComponent c)

          调用 installDefaults、installListeners,然后添加由 createNextButton、createPreviousButton 和 createEditor 返回的组件。

 void
BasicTextPaneUI.installUI(JComponent c)

 void
BasicToolTipUI.installUI(JComponent c)

 void
BasicSliderUI.installUI(JComponent c)

 void
BasicSplitPaneUI.installUI(JComponent c)

          安装 UI。

 void
BasicTreeUI.installUI(JComponent c)

 void
BasicTableUI.installUI(JComponent c)

 void
BasicTableHeaderUI.installUI(JComponent c)

 void
BasicProgressBarUI.installUI(JComponent c)

 void
BasicTabbedPaneUI.installUI(JComponent c)

 void
BasicTextUI.installUI(JComponent c)

          安装组件的 UI。

 void
BasicScrollPaneUI.installUI(JComponent x)

 void
BasicViewportUI.installUI(JComponent c)

 void
BasicListUI.installUI(JComponent c)

          按顺序调用 installDefaults()、installListeners() 和 installKeyboardActions() 来初始化 this.list。

 void
BasicComboBoxUI.installUI(JComponent c)

 void
BasicScrollBarUI.installUI(JComponent c)

 void
BasicSeparatorUI.installUI(JComponent c)

 void
BasicPopupMenuUI.installUI(JComponent c)

 void
BasicMenuItemUI.installUI(JComponent c)

 void
BasicToolBarUI.installUI(JComponent c)

 void
BasicMenuBarUI.installUI(JComponent c)

 void
BasicButtonUI.installUI(JComponent c)

 void
BasicLabelUI.installUI(JComponent c)

 void
BasicRootPaneUI.installUI(JComponent c)

 void
BasicPanelUI.installUI(JComponent c)

 void
BasicDesktopIconUI.MouseInputHandler.moveAndRepaint(JComponent f,
               int newX,
               int newY,
               int newWidth,
               int newHeight)

 void
BasicDesktopPaneUI.paint(Graphics g,
      JComponent c)

 void
BasicPopupMenuSeparatorUI.paint(Graphics g,
      JComponent c)

 void
BasicToolTipUI.paint(Graphics g,
      JComponent c)

 void
BasicSliderUI.paint(Graphics g,
      JComponent c)

 void
BasicSplitPaneUI.paint(Graphics g,
      JComponent jc)

          传递消息以绘制外观。

 void
BasicTreeUI.paint(Graphics g,
      JComponent c)

 void
BasicTableUI.paint(Graphics g,
      JComponent c)

          绘制用 installUI() 设置的 table 实例的表示形式。

 void
BasicTableHeaderUI.paint(Graphics g,
      JComponent c)

 void
BasicProgressBarUI.paint(Graphics g,
      JComponent c)

          将绘制委托给两种方法之一:paintDeterminate 和 paintIndeterminate。

 void
BasicRadioButtonUI.paint(Graphics g,
      JComponent c)

          绘制单选按钮

 void
BasicTabbedPaneUI.paint(Graphics g,
      JComponent c)

 void
BasicToolBarSeparatorUI.paint(Graphics g,
      JComponent c)

 void
BasicTextUI.paint(Graphics g,
      JComponent c)

          绘制界面。

 void
BasicScrollPaneUI.paint(Graphics g,
      JComponent c)

 void
BasicListUI.paint(Graphics g,
      JComponent c)

          绘制与 Graphics 对象 clipRect 相交的行。

 void
BasicComboBoxUI.paint(Graphics g,
      JComponent c)

 void
BasicScrollBarUI.paint(Graphics g,
      JComponent c)

 void
BasicSeparatorUI.paint(Graphics g,
      JComponent c)

 void
BasicMenuItemUI.paint(Graphics g,
      JComponent c)

 void
BasicToggleButtonUI.paint(Graphics g,
      JComponent c)

 void
BasicButtonUI.paint(Graphics g,
      JComponent c)

 void
BasicLabelUI.paint(Graphics g,
      JComponent c)

          使用前景色绘制标签文本,如果标签不透明,则利用背景色绘制整个背景。

protected  void
BasicProgressBarUI.paintDeterminate(Graphics g,
                 JComponent c)

          对几乎所有线性、确定进度条都能正确执行操作的多用途绘制方法。

protected  void
BasicTreeUI.paintHorizontalLine(Graphics g,
                    JComponent c,
                    int y,
                    int left,
                    int right)

          绘制水平线。

protected  void
BasicButtonUI.paintIcon(Graphics g,
          JComponent c,
          Rectangle iconRect)

protected  void
BasicProgressBarUI.paintIndeterminate(Graphics g,
                   JComponent c)

          对所有线性跳动框进度条都能正确执行操作的多用途绘制方法。

protected  void
BasicMenuItemUI.paintMenuItem(Graphics g,
              JComponent c,
              Icon checkIcon,
              Icon arrowIcon,
              Color background,
              Color foreground,
              int defaultTextIconGap)

protected  void
BasicButtonUI.paintText(Graphics g,
          JComponent c,
          Rectangle textRect,
          String text)

          从 Java 2 平台 v 1.4 开始,不应再使用或重写此方法。

protected  void
BasicScrollBarUI.paintThumb(Graphics g,
           JComponent c,
           Rectangle thumbBounds)

protected  void
BasicScrollBarUI.paintTrack(Graphics g,
           JComponent c,
           Rectangle trackBounds)

protected  void
BasicTreeUI.paintVerticalLine(Graphics g,
                  JComponent c,
                  int x,
                  int top,
                  int bottom)

          绘制垂直线。

protected  void
BasicSpinnerUI.replaceEditor(JComponent oldEditor,
              JComponent newEditor)

          当 JSpinner 编辑器属性更改时,由 PropertyChangeListener 调用。

protected  void
BasicInternalFrameUI.replacePane(JComponent currentPane,
            JComponent newPane)

          将必需的鼠标处理程序安装在 newPane 上并将其添加到窗体。

 void
BasicInternalFrameUI.setEastPane(JComponent c)

 void
BasicInternalFrameUI.setNorthPane(JComponent c)

 void
BasicInternalFrameUI.setSouthPane(JComponent c)

 void
BasicInternalFrameUI.setWestPane(JComponent c)

protected  void
BasicToolTipUI.uninstallDefaults(JComponent c)

protected  void
BasicViewportUI.uninstallDefaults(JComponent c)

 void
BasicButtonListener.uninstallKeyboardActions(JComponent c)

          未注册的默认键动作

protected  void
BasicToolTipUI.uninstallListeners(JComponent c)

protected  void
BasicScrollPaneUI.uninstallListeners(JComponent c)

 void
BasicColorChooserUI.uninstallUI(JComponent c)

 void
BasicDesktopIconUI.uninstallUI(JComponent c)

 void
BasicDesktopPaneUI.uninstallUI(JComponent c)

 void
BasicEditorPaneUI.uninstallUI(JComponent c)

          卸载组件的 UI。

 void
BasicFileChooserUI.uninstallUI(JComponent c)

 void
BasicInternalFrameUI.uninstallUI(JComponent c)

 void
BasicOptionPaneUI.uninstallUI(JComponent c)

          从传入拆分窗格的 L&F 控制器移除接收者。

 void
BasicSpinnerUI.uninstallUI(JComponent c)

          调用 uninstallDefaults、uninstallListeners,然后移除所有子 spinner。

 void
BasicToolTipUI.uninstallUI(JComponent c)

 void
BasicSliderUI.uninstallUI(JComponent c)

 void
BasicSplitPaneUI.uninstallUI(JComponent c)

          卸载 UI。

 void
BasicTreeUI.uninstallUI(JComponent c)

 void
BasicTableUI.uninstallUI(JComponent c)

 void
BasicTableHeaderUI.uninstallUI(JComponent c)

 void
BasicProgressBarUI.uninstallUI(JComponent c)

 void
BasicTabbedPaneUI.uninstallUI(JComponent c)

 void
BasicTextUI.uninstallUI(JComponent c)

          卸载组件的 UI。

 void
BasicScrollPaneUI.uninstallUI(JComponent c)

 void
BasicViewportUI.uninstallUI(JComponent c)

 void
BasicListUI.uninstallUI(JComponent c)

          按顺序调用 uninstallListeners()、uninstallKeyboardActions() 和 uninstallDefaults() 来取消初始化 this.list。

 void
BasicComboBoxUI.uninstallUI(JComponent c)

 void
BasicScrollBarUI.uninstallUI(JComponent c)

 void
BasicSeparatorUI.uninstallUI(JComponent c)

 void
BasicPopupMenuUI.uninstallUI(JComponent c)

 void
BasicMenuItemUI.uninstallUI(JComponent c)

 void
BasicToolBarUI.uninstallUI(JComponent c)

 void
BasicMenuBarUI.uninstallUI(JComponent c)

 void
BasicButtonUI.uninstallUI(JComponent c)

 void
BasicLabelUI.uninstallUI(JComponent c)

 void
BasicRootPaneUI.uninstallUI(JComponent c)

 void
BasicPanelUI.uninstallUI(JComponent c)

 void
BasicTextUI.update(Graphics g,
       JComponent c)

          超类以无法控制的方式绘制背景(即有人可能希望将图像平铺在背景中)。

 void
BasicMenuItemUI.update(Graphics g,
       JComponent c)

          使用 paintMenuItem() 绘制背景,从而重写 update(默认情况下填充不透明组件的背景)以调用 paint()。

static void
BasicHTML.updateRenderer(JComponent c,
               String text)

          将给定文本的 HTML 渲染器隐藏在给定 JComponent 的客户端属性中。

javax.swing.plaf.metal 中 JComponent 的使用

javax.swing.plaf.metal 中 JComponent 的子类

 class
MetalComboBoxButton

          协助 MetalComboBoxUI 的 JButton 子类

警告:此类的已序列化对象与以后的 Swing 版本不兼容。

 class
MetalComboBoxUI.MetalComboPopup

          已过时。 从 Java 2 platform v1.4 开始。

protected  class
MetalFileChooserUI.FileRenderer

 class
MetalFileChooserUI.FilterComboBoxRenderer

          呈现不同的类型大小和风格。

 class
MetalInternalFrameTitlePane

          管理 JLF 标题栏的类

 class
MetalScrollButton

          Metal 滚动条箭头的 JButton 对象。

返回 JComponent 的 javax.swing.plaf.metal 中的方法

protected  JComponent
MetalInternalFrameUI.createNorthPane(JInternalFrame w)

参数类型为 JComponent 的 javax.swing.plaf.metal 中的方法

static ComponentUI
MetalDesktopIconUI.createUI(JComponent c)

static ComponentUI
MetalFileChooserUI.createUI(JComponent c)

static ComponentUI
MetalInternalFrameUI.createUI(JComponent c)

static ComponentUI
MetalToolTipUI.createUI(JComponent c)

static ComponentUI
MetalSliderUI.createUI(JComponent c)

static ComponentUI
MetalSplitPaneUI.createUI(JComponent x)

          创建一个新的 MetalSplitPaneUI 实例

static ComponentUI
MetalTreeUI.createUI(JComponent x)

static ComponentUI
MetalProgressBarUI.createUI(JComponent c)

static ComponentUI
MetalCheckBoxUI.createUI(JComponent b)

static ComponentUI
MetalRadioButtonUI.createUI(JComponent c)

static ComponentUI
MetalTabbedPaneUI.createUI(JComponent x)

static ComponentUI
MetalTextFieldUI.createUI(JComponent c)

static ComponentUI
MetalScrollPaneUI.createUI(JComponent x)

static ComponentUI
MetalComboBoxUI.createUI(JComponent c)

static ComponentUI
MetalScrollBarUI.createUI(JComponent c)

static ComponentUI
MetalPopupMenuSeparatorUI.createUI(JComponent c)

static ComponentUI
MetalSeparatorUI.createUI(JComponent c)

static ComponentUI
MetalToolBarUI.createUI(JComponent c)

static ComponentUI
MetalMenuBarUI.createUI(JComponent x)

          为传入的组件创建 ComponentUI 实现。

static ComponentUI
MetalToggleButtonUI.createUI(JComponent b)

static ComponentUI
MetalButtonUI.createUI(JComponent c)

static ComponentUI
MetalLabelUI.createUI(JComponent c)

static ComponentUI
MetalRootPaneUI.createUI(JComponent c)

          为 JRootPane 创建一个 UI。

 int
MetalComboBoxUI.getBaseline(JComponent c,
            int width,
            int height)

          返回基线。

 Icon
MetalLookAndFeel.getDisabledIcon(JComponent component,
                Icon icon)

          返回具有禁用外观的 Icon。

 Icon
MetalLookAndFeel.getDisabledSelectedIcon(JComponent component,
                        Icon icon)

          返回由选定的禁用组件使用的 Icon。

 Dimension
MetalDesktopIconUI.getMaximumSize(JComponent c)

 Dimension
MetalFileChooserUI.getMaximumSize(JComponent c)

          返回 JFileChooser 的最大大小。

 Dimension
MetalDesktopIconUI.getMinimumSize(JComponent c)

 Dimension
MetalFileChooserUI.getMinimumSize(JComponent c)

          返回 JFileChooser 的最小大小。

 Dimension
MetalComboBoxUI.getMinimumSize(JComponent c)

 Dimension
MetalDesktopIconUI.getPreferredSize(JComponent c)

 Dimension
MetalFileChooserUI.getPreferredSize(JComponent c)

          返回指定 JFileChooser 的首选大小。

 Dimension
MetalToolTipUI.getPreferredSize(JComponent c)

 Dimension
MetalScrollBarUI.getPreferredSize(JComponent c)

 Dimension
MetalPopupMenuSeparatorUI.getPreferredSize(JComponent c)

 Dimension
MetalSeparatorUI.getPreferredSize(JComponent c)

 void
MetalFileChooserUI.installUI(JComponent c)

 void
MetalInternalFrameUI.installUI(JComponent c)

 void
MetalToolTipUI.installUI(JComponent c)

 void
MetalSliderUI.installUI(JComponent c)

 void
MetalTreeUI.installUI(JComponent c)

 void
MetalScrollPaneUI.installUI(JComponent c)

 void
MetalToolBarUI.installUI(JComponent c)

 void
MetalMenuBarUI.installUI(JComponent c)

          配置指定组件,使其适合 metal 外观。

 void
MetalRootPaneUI.installUI(JComponent c)

          调用 installUI 的超实现来在传入的 JRootPane 上安装必要的状态,以呈现 RootPaneUI 的 metal 外观实现。

 void
MetalToolTipUI.paint(Graphics g,
      JComponent c)

 void
MetalTreeUI.paint(Graphics g,
      JComponent c)

 void
MetalRadioButtonUI.paint(Graphics g,
      JComponent c)

 void
MetalTabbedPaneUI.paint(Graphics g,
      JComponent c)

 void
MetalComboBoxUI.paint(Graphics g,
      JComponent c)

 void
MetalPopupMenuSeparatorUI.paint(Graphics g,
      JComponent c)

 void
MetalSeparatorUI.paint(Graphics g,
      JComponent c)

 void
MetalProgressBarUI.paintDeterminate(Graphics g,
                 JComponent c)

          在进度条上绘制少量特殊的高亮显示。

protected  void
MetalTreeUI.paintHorizontalSeparators(Graphics g,
                          JComponent c)

 void
MetalProgressBarUI.paintIndeterminate(Graphics g,
                   JComponent c)

          在进度条和跳动框上绘制少量特殊的高亮显示。

protected  void
MetalToggleButtonUI.paintText(Graphics g,
          JComponent c,
          Rectangle textRect,
          String text)

protected  void
MetalButtonUI.paintText(Graphics g,
          JComponent c,
          Rectangle textRect,
          String text)

protected  void
MetalScrollBarUI.paintThumb(Graphics g,
           JComponent c,
           Rectangle thumbBounds)

protected  void
MetalScrollBarUI.paintTrack(Graphics g,
           JComponent c,
           Rectangle trackBounds)

 void
MetalFileChooserUI.uninstallUI(JComponent c)

 void
MetalInternalFrameUI.uninstallUI(JComponent c)

 void
MetalToolTipUI.uninstallUI(JComponent c)

 void
MetalTreeUI.uninstallUI(JComponent c)

 void
MetalScrollPaneUI.uninstallUI(JComponent c)

 void
MetalToolBarUI.uninstallUI(JComponent c)

 void
MetalMenuBarUI.uninstallUI(JComponent c)

          在 installUI 期间,在指定组件上反向执行的配置操作。

 void
MetalRootPaneUI.uninstallUI(JComponent c)

          调用超实现来卸载所有状态。

 void
MetalTabbedPaneUI.update(Graphics g,
       JComponent c)

 void
MetalToolBarUI.update(Graphics g,
       JComponent c)

          如果必要,绘制组件的背景,然后调用 paint。

 void
MetalMenuBarUI.update(Graphics g,
       JComponent c)

          如果必要,绘制组件的背景,然后调用 paint。

 void
MetalToggleButtonUI.update(Graphics g,
       JComponent c)

          如果必要,绘制组件的背景,然后调用 paint。

 void
MetalButtonUI.update(Graphics g,
       JComponent c)

          如果必要,绘制组件的背景,然后调用 paint。

javax.swing.plaf.multi 中 JComponent 的使用

参数类型为 JComponent 的 javax.swing.plaf.multi 中的方法

 boolean
MultiButtonUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiColorChooserUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiComboBoxUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiDesktopIconUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiDesktopPaneUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiFileChooserUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiInternalFrameUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiLabelUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiListUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiMenuBarUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiMenuItemUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiOptionPaneUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiPanelUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiPopupMenuUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiProgressBarUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiRootPaneUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiScrollBarUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiScrollPaneUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiSeparatorUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiSliderUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiSpinnerUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiSplitPaneUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiTabbedPaneUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiTableHeaderUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiTableUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiTextUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiToolBarUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiToolTipUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiTreeUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

 boolean
MultiViewportUI.contains(JComponent a,
         int b,
         int c)

          在由此对象处理的每个 UI 上调用 contains 方法。

static ComponentUI
MultiButtonUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiColorChooserUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiComboBoxUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiDesktopIconUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiDesktopPaneUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiFileChooserUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiInternalFrameUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiLabelUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiListUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiMenuBarUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiMenuItemUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiOptionPaneUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiPanelUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiPopupMenuUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiProgressBarUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiRootPaneUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiScrollBarUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiScrollPaneUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiSeparatorUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiSliderUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiSpinnerUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiSplitPaneUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiTabbedPaneUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiTableHeaderUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiTableUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiTextUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiToolBarUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiToolTipUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiTreeUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiViewportUI.createUI(JComponent a)

          如果任意辅助 LookAndFeel 都支持此 UI,则返回一个多路 UI 实例。

static ComponentUI
MultiLookAndFeel.createUIs(ComponentUI mui,
          Vector uis,
          JComponent target)

          创建表示 target 组件所需的 ComponentUI 对象,将对象放入 uis 向量中,并返回最能表示该组件 UI 的 ComponentUI 对象。

 Accessible
MultiButtonUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiColorChooserUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiComboBoxUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiDesktopIconUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiDesktopPaneUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiFileChooserUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiInternalFrameUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiLabelUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiListUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiMenuBarUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiMenuItemUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiOptionPaneUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiPanelUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiPopupMenuUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiProgressBarUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiRootPaneUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiScrollBarUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiScrollPaneUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiSeparatorUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiSliderUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiSpinnerUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiSplitPaneUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiTabbedPaneUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiTableHeaderUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiTableUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiTextUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiToolBarUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiToolTipUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiTreeUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 Accessible
MultiViewportUI.getAccessibleChild(JComponent a,
                   int b)

          在由此对象处理的每个 UI 上调用 getAccessibleChild 方法。

 int
MultiButtonUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiColorChooserUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiComboBoxUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiDesktopIconUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiDesktopPaneUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiFileChooserUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiInternalFrameUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiLabelUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiListUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiMenuBarUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiMenuItemUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiOptionPaneUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiPanelUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiPopupMenuUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiProgressBarUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiRootPaneUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiScrollBarUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiScrollPaneUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiSeparatorUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiSliderUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiSpinnerUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiSplitPaneUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiTabbedPaneUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiTableHeaderUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiTableUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiTextUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiToolBarUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiToolTipUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiTreeUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 int
MultiViewportUI.getAccessibleChildrenCount(JComponent a)

          在由此对象处理的每个 UI 上调用 getAccessibleChildrenCount 方法。

 Dimension
MultiButtonUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiColorChooserUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiComboBoxUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiDesktopIconUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiDesktopPaneUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiFileChooserUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法

 Dimension
MultiInternalFrameUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiLabelUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiListUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiMenuBarUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiMenuItemUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiOptionPaneUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiPanelUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiPopupMenuUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiProgressBarUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiRootPaneUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiScrollBarUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiScrollPaneUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiSeparatorUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiSliderUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiSpinnerUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiSplitPaneUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiTabbedPaneUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiTableHeaderUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiTableUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiTextUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiToolBarUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiToolTipUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiTreeUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiViewportUI.getMaximumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMaximumSize 方法。

 Dimension
MultiButtonUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiColorChooserUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiComboBoxUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiDesktopIconUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiDesktopPaneUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiFileChooserUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiInternalFrameUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiLabelUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiListUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiMenuBarUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiMenuItemUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiOptionPaneUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiPanelUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiPopupMenuUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiProgressBarUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiRootPaneUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiScrollBarUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiScrollPaneUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiSeparatorUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiSliderUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiSpinnerUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiSplitPaneUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiTabbedPaneUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiTableHeaderUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiTableUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiTextUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiToolBarUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiToolTipUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiTreeUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiViewportUI.getMinimumSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getMinimumSize 方法。

 Dimension
MultiButtonUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiColorChooserUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiComboBoxUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiDesktopIconUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiDesktopPaneUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiFileChooserUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiInternalFrameUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiLabelUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiListUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiMenuBarUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiMenuItemUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiOptionPaneUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiPanelUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiPopupMenuUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiProgressBarUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiRootPaneUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiScrollBarUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiScrollPaneUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiSeparatorUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiSliderUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiSpinnerUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiSplitPaneUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiTabbedPaneUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiTableHeaderUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiTableUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiTextUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiToolBarUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiToolTipUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiTreeUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 Dimension
MultiViewportUI.getPreferredSize(JComponent a)

          在由此对象处理的每个 UI 上调用 getPreferredSize 方法。

 void
MultiButtonUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiColorChooserUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiComboBoxUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiDesktopIconUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiDesktopPaneUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiFileChooserUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiInternalFrameUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiLabelUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiListUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiMenuBarUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiMenuItemUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiOptionPaneUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiPanelUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiPopupMenuUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiProgressBarUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiRootPaneUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiScrollBarUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiScrollPaneUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiSeparatorUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiSliderUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiSpinnerUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiSplitPaneUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiTabbedPaneUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiTableHeaderUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiTableUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiTextUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiToolBarUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiToolTipUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiTreeUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiViewportUI.installUI(JComponent a)

          在由此对象处理的每个 UI 上调用 installUI 方法。

 void
MultiButtonUI.paint(Graphics a,
      JComponent b)

          在此对象处理的每个 UI 上调用 paint 方法。

 void
MultiColorChooserUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法

 void
MultiComboBoxUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiDesktopIconUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiDesktopPaneUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiFileChooserUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiInternalFrameUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiLabelUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiListUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiMenuBarUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiMenuItemUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiOptionPaneUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiPanelUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiPopupMenuUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiProgressBarUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiRootPaneUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiScrollBarUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiScrollPaneUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiSeparatorUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiSliderUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiSpinnerUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiSplitPaneUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiTabbedPaneUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiTableHeaderUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiTableUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiTextUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiToolBarUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiToolTipUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiTreeUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiViewportUI.paint(Graphics a,
      JComponent b)

          在由此对象处理的每个 UI 上调用 paint 方法。

 void
MultiButtonUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiColorChooserUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiComboBoxUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiDesktopIconUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiDesktopPaneUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiFileChooserUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiInternalFrameUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiLabelUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiListUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiMenuBarUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiMenuItemUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiOptionPaneUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiPanelUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiPopupMenuUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiProgressBarUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiRootPaneUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiScrollBarUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiScrollPaneUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiSeparatorUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiSliderUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiSpinnerUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiSplitPaneUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiTabbedPaneUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiTableHeaderUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiTableUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiTextUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiToolBarUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiToolTipUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiTreeUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiViewportUI.uninstallUI(JComponent a)

          在由此对象处理的每个 UI 上调用 uninstallUI 方法。

 void
MultiButtonUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiColorChooserUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiComboBoxUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiDesktopIconUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiDesktopPaneUI.update(Graphics a,
       JComponent b)

          在此对象处理的每个 UI 上调用 update 方法。

 void
MultiFileChooserUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiInternalFrameUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiLabelUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiListUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiMenuBarUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiMenuItemUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiOptionPaneUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiPanelUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiPopupMenuUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiProgressBarUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiRootPaneUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiScrollBarUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiScrollPaneUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用  update 方法。

 void
MultiSeparatorUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiSliderUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiSpinnerUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiSplitPaneUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiTabbedPaneUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiTableHeaderUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiTableUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiTextUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiToolBarUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiToolTipUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiTreeUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

 void
MultiViewportUI.update(Graphics a,
       JComponent b)

          在由此对象处理的每个 UI 上调用 update 方法。

javax.swing.plaf.synth 中 JComponent 的使用

返回 JComponent 的 javax.swing.plaf.synth 中的方法

 JComponent
SynthContext.getComponent()

          返回包含 region 的承载组件。

参数类型为 JComponent 的 javax.swing.plaf.synth 中的方法

static ComponentUI
SynthLookAndFeel.createUI(JComponent c)

          为传入的 JComponent 创建 Synth 外观 ComponentUI。

static Region
SynthLookAndFeel.getRegion(JComponent c)

          返回 JComponent c 的 Region。

abstract  SynthStyle
SynthStyleFactory.getStyle(JComponent c,
         Region id)

          返回指定 Component 的样式。

static SynthStyle
SynthLookAndFeel.getStyle(JComponent c,
         Region region)

          获取指定组件的指定 region 的 SynthStyle。

参数类型为 JComponent 的 javax.swing.plaf.synth 中的构造方法

SynthContext(JComponent component,
             Region region,
             SynthStyle style,
             int state)

          创建一个具有指定值的 SynthContext。

javax.swing.table 中 JComponent 的使用

javax.swing.table 中 JComponent 的子类

 class
DefaultTableCellRenderer

          呈现(显示) JTable 中每个单元格的标准类。

static class
DefaultTableCellRenderer.UIResource

          DefaultTableCellRenderer 的一个子类,它实现 UIResource。

 class
JTableHeader

          这是管理 JTable 的头的对象。

javax.swing.text 中 JComponent 的使用

javax.swing.text 中 JComponent 的子类

 class
JTextComponent

          JTextComponent 是 swing 文本组件的基类。

javax.swing.tree 中 JComponent 的使用

javax.swing.tree 中 JComponent 的子类

 class
DefaultTreeCellEditor.DefaultTextField

          不提供任何编辑器时所使用的 TextField。

 class
DefaultTreeCellRenderer

          显示树中的条目。

      概述
      软件包
      类
    使用
      树
      已过时
      索引
      帮助

JavaTM Platform
Standard Ed. 6

 上一个
 下一个

  框架
 无框架

  所有类

提交错误或意见
有关更多的 API 参考资料和开发人员文档,请参阅 Java SE 开发人员文档。该文档包含更详细的、面向开发人员的描述,以及总体概述、术语定义、使用技巧和工作代码示例。
版权所有 2007 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。