public static List<TreePath> collectExpandedPaths(@NotNull final JTree tree) {
final ArrayList<TreePath> result = new ArrayList<TreePath>();
final Object root = tree.getModel().getRoot();
final TreePath rootPath = new TreePath(root);
result.addAll(collectExpandedPaths(tree, rootPath));
return result;
}
public void reset() {
mySelectedSchema = new CustomActionsSchema();
mySelectedSchema.copyFrom(CustomActionsSchema.getInstance());
patchActionsTreeCorrespondingToSchema(
(DefaultMutableTreeNode) myActionsTree.getModel().getRoot());
myRestoreAllDefaultButton.setEnabled(mySelectedSchema.isModified(new CustomActionsSchema()));
}
public static List<TreePath> collectExpandedPaths(final JTree tree, TreePath path) {
final ArrayList<TreePath> result = new ArrayList<TreePath>();
if (!tree.isExpanded(path)) return result;
final Object lastPathComponent = path.getLastPathComponent();
final TreeModel model = tree.getModel();
if (model.isLeaf(lastPathComponent)) {
result.add(path);
} else {
boolean pathWasAdded = false;
for (int i = model.getChildCount(lastPathComponent) - 1; i >= 0; i--) {
final TreePath childPath = path.pathByAddingChild(model.getChild(lastPathComponent, i));
if (model.isLeaf(lastPathComponent)) {
if (!pathWasAdded) {
result.add(path);
pathWasAdded = true;
}
} else if (tree.isExpanded(childPath)) {
result.addAll(collectExpandedPaths(tree, childPath));
} else {
if (!pathWasAdded) {
result.add(path);
pathWasAdded = true;
}
}
}
}
return result;
}
private void updateImmediately() {
if (myProject.isDisposed()) return;
checkNodeValidity((DefaultMutableTreeNode) myTree.getModel().getRoot());
if (myUsagePreviewPanel != null) {
myUsagePreviewPanel.updateLayout(getSelectedUsageInfos());
}
}
// reorder the nodes
private void reorder(Vector nodes) {
debug("reorder nodes");
// remove all the children of topNode (they'll be added back later)
topNode.removeAllChildren();
// Create an array of the elements for sorting & copy the elements
// into the array.
DefaultMutableTreeNode[] array = new DefaultMutableTreeNode[nodes.size()];
nodes.copyInto(array);
// Sort the array (Quick Sort)
quickSort(array, 0, array.length - 1);
// Reload the topNode. Everthing is in order now.
for (int i = 0; i < array.length; i++) {
topNode.add((DefaultMutableTreeNode) array[i]);
}
// Tell the tree to repaint itself
((DefaultTreeModel) tree.getModel()).reload();
tree.invalidate();
tree.repaint();
}
public static ActionCallback selectFirstNode(final JTree tree) {
final TreeModel model = tree.getModel();
final Object root = model.getRoot();
TreePath selectionPath = new TreePath(root);
if (!tree.isRootVisible() && model.getChildCount(root) > 0)
selectionPath = selectionPath.pathByAddingChild(model.getChild(root, 0));
return selectPath(tree, selectionPath);
}
/**
* Constructor.
*
* @param tree a JTree
*/
public CheckTreeManager(JTree tree) {
this.tree = tree;
selectionModel = new CheckTreeSelectionModel(tree.getModel());
tree.setCellRenderer(new CheckTreeCellRenderer(tree.getCellRenderer(), selectionModel));
tree.addMouseListener(this);
tree.addMouseMotionListener(this);
selectionModel.addTreeSelectionListener(this);
}
/**
* @param tree JTree to collect expanded paths from.
* @param paths output parameter.
*/
public static void collectExpandedPaths(
@NotNull final JTree tree, @NotNull final List<TreePath> paths) {
final TreeModel model = tree.getModel();
final Object root = model.getRoot();
LOG.assertTrue(root != null);
collectExpandedPathsImpl(tree, paths, new TreePath(root));
}
public void addSelectionPathTo(final Object element) {
DefaultMutableTreeNode node = myAbstractTreeBuilder.getNodeForElement(element);
if (node != null) {
final JTree tree = getTree();
final TreePath path = new TreePath(node.getPath());
if (node == tree.getModel().getRoot() && !tree.isExpanded(path)) tree.expandPath(path);
tree.addSelectionPath(path);
}
}
@Override
public void adoptElement(SceneElement elem) {
if (!(elem instanceof NenyaImageSceneElement
|| elem instanceof NenyaTileSceneElement
|| elem instanceof NenyaComponentSceneElement)) {
enableEditor(false);
return;
}
DefaultComboBoxModel dcm = (DefaultComboBoxModel) itemList.getModel();
// Important: Work on a copy, not on the original. Otherwise we mess up the undomanager
sceneElement = elem.copy();
if ((sceneElement instanceof NenyaImageSceneElement) && !locked) {
dcm.removeAllElements();
String[] tmp = ((NenyaImageSceneElement) sceneElement).getPath();
dcm.addElement(tmp[tmp.length - 1]);
}
if ((sceneElement instanceof NenyaTileSceneElement) && !locked) {
dcm.removeAllElements();
dcm.addElement(((NenyaTileSceneElement) sceneElement).getTileName());
}
if ((sceneElement instanceof NenyaComponentSceneElement) && !locked) {
dcm.removeAllElements();
NenyaComponentItem[] ni = ((NenyaComponentSceneElement) sceneElement).getComponents();
for (NenyaComponentItem element : ni) {
dcm.addElement(element);
}
}
try {
ClassedItem[] cols = null;
if (elem instanceof NenyaTileSceneElement)
cols = ((NenyaTileSceneElement) elem).getColorList();
if (elem instanceof NenyaImageSceneElement)
cols = ((NenyaImageSceneElement) elem).getColorList();
if (elem instanceof NenyaComponentSceneElement) {
NenyaComponentItem nci = (NenyaComponentItem) dcm.getSelectedItem();
cols = nci.getColorList();
}
Vector<TreePath> collect = new Vector<TreePath>();
TreeNode root = (TreeNode) colors.getModel().getRoot();
for (ClassedItem col : cols) {
String[] tmp = {root.toString(), col.getClassName(), col.getItemName()};
collect.add(TreeUtil.findPath(root, tmp));
}
TreePath[] path = collect.toArray(new TreePath[0]);
colors.getSelectionModel().setSelectionPaths(path);
} catch (Exception e) {
// Either the tree is filtered away or the selected item is not colorized.
}
enableEditor(true);
itemList.setEnabled(elem instanceof NenyaComponentSceneElement);
}
private void patchActionsTreeCorrespondingToSchema(DefaultMutableTreeNode root) {
root.removeAllChildren();
if (mySelectedSchema != null) {
mySelectedSchema.fillActionGroups(root);
for (final ActionUrl actionUrl : mySelectedSchema.getActions()) {
ActionUrl.changePathInActionsTree(myActionsTree, actionUrl);
}
}
((DefaultTreeModel) myActionsTree.getModel()).reload();
}
public static void moveSelectedRow(final JTree tree, final int direction) {
final TreePath selectionPath = tree.getSelectionPath();
final DefaultMutableTreeNode treeNode =
(DefaultMutableTreeNode) selectionPath.getLastPathComponent();
final DefaultMutableTreeNode parent = (DefaultMutableTreeNode) treeNode.getParent();
final int idx = parent.getIndex(treeNode);
parent.remove(treeNode);
parent.insert(treeNode, idx + direction);
((DefaultTreeModel) tree.getModel()).reload(parent);
selectNode(tree, treeNode);
}
public static void expandAll(final JTree tree) {
tree.expandPath(new TreePath(tree.getModel().getRoot()));
int oldRowCount = 0;
do {
int rowCount = tree.getRowCount();
if (rowCount == oldRowCount) break;
oldRowCount = rowCount;
for (int i = 0; i < rowCount; i++) {
tree.expandRow(i);
}
} while (true);
}
@Nullable
private DefaultMutableTreeNode getNodeForPath(String path) {
Enumeration enumeration =
((DefaultMutableTreeNode) myTree.getModel().getRoot()).preorderEnumeration();
while (enumeration.hasMoreElements()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) enumeration.nextElement();
if (Comparing.equal(getPath(node), path)) {
return node;
}
}
return null;
}
@Nullable
private DefaultMutableTreeNode findNodeOnToolbar(String actionId) {
final TreeNode toolbar =
((DefaultMutableTreeNode) myActionsTree.getModel().getRoot()).getChildAt(1);
for (int i = 0; i < toolbar.getChildCount(); i++) {
final DefaultMutableTreeNode child = (DefaultMutableTreeNode) toolbar.getChildAt(i);
final String childId = getActionId(child);
if (childId != null && childId.equals(actionId)) {
return child;
}
}
return null;
}
private ArrayList<DefaultMutableTreeNode> getNodesByPaths(ArrayList<String> paths) {
final ArrayList<DefaultMutableTreeNode> result = new ArrayList<DefaultMutableTreeNode>();
Enumeration enumeration =
((DefaultMutableTreeNode) myTree.getModel().getRoot()).preorderEnumeration();
while (enumeration.hasMoreElements()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) enumeration.nextElement();
final String path = getPath(node);
if (paths.contains(path)) {
result.add(node);
}
}
return result;
}
private void restoreUsageExpandState(final Collection<UsageState> states) {
// always expand the last level group
final DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTree.getModel().getRoot();
for (int i = root.getChildCount() - 1; i >= 0; i--) {
final DefaultMutableTreeNode child = (DefaultMutableTreeNode) root.getChildAt(i);
if (child instanceof GroupNode) {
final TreePath treePath = new TreePath(child.getPath());
myTree.expandPath(treePath);
}
}
myTree.getSelectionModel().clearSelection();
for (final UsageState usageState : states) {
usageState.restore();
}
}
private void reset(
final Keymap keymap,
final QuickList[] allQuickLists,
String filter,
@Nullable KeyboardShortcut shortcut) {
myKeymap = keymap;
final PathsKeeper pathsKeeper = new PathsKeeper();
pathsKeeper.storePaths();
myRoot.removeAllChildren();
ActionManager actionManager = ActionManager.getInstance();
Project project =
CommonDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext(myComponent));
Group mainGroup =
ActionsTreeUtil.createMainGroup(
project,
myKeymap,
allQuickLists,
filter,
true,
ActionsTreeUtil.isActionFiltered(actionManager, myKeymap, shortcut, filter, true));
if ((filter != null && filter.length() > 0 || shortcut != null)
&& mainGroup.initIds().isEmpty()) {
mainGroup =
ActionsTreeUtil.createMainGroup(
project,
myKeymap,
allQuickLists,
filter,
false,
ActionsTreeUtil.isActionFiltered(actionManager, myKeymap, shortcut, filter, false));
}
myRoot = ActionsTreeUtil.createNode(mainGroup);
myMainGroup = mainGroup;
MyModel model = (MyModel) myTree.getModel();
model.setRoot(myRoot);
model.nodeStructureChanged(myRoot);
pathsKeeper.restorePaths();
}
// Public Methods
public void appendNextTreeGeneration(Vector generation) {
DefaultMutableTreeNode nextGeneration = generationNodeBuilder(generation);
generations.add(nextGeneration);
// If Generations contains leaf nodes (generated objects)
// Enabled Save All Menu Item
if (generations.getLeafCount() > 0) miSaveAll.setEnabled(true);
else miSaveAll.setEnabled(false);
// Update JTree View
// affected nodes needing updating
int[] nodeRangeToUpdate = {generations.getIndex(nextGeneration)};
((DefaultTreeModel) tree.getModel()).nodesWereInserted(generations, nodeRangeToUpdate);
// Expand Parent after first child node is displayed
if (generationNumber == 1) tree.expandRow(0);
++generationNumber;
}
private void rulesChanged() {
ApplicationManager.getApplication().assertIsDispatchThread();
final ArrayList<UsageState> states = new ArrayList<UsageState>();
captureUsagesExpandState(new TreePath(myTree.getModel().getRoot()), states);
final List<Usage> allUsages = new ArrayList<Usage>(myUsageNodes.keySet());
Collections.sort(allUsages, USAGE_COMPARATOR);
final Set<Usage> excludedUsages = getExcludedUsages();
reset();
myBuilder.setGroupingRules(getActiveGroupingRules(myProject));
myBuilder.setFilteringRules(getActiveFilteringRules(myProject));
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
for (Usage usage : allUsages) {
if (!usage.isValid()) {
continue;
}
if (usage instanceof MergeableUsage) {
((MergeableUsage) usage).reset();
}
appendUsage(usage);
}
}
});
excludeUsages(excludedUsages.toArray(new Usage[excludedUsages.size()]));
if (myCentralPanel != null) {
setupCentralPanel();
}
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
if (isDisposed) return;
restoreUsageExpandState(states);
updateImmediately();
}
});
}
public static void collapseAll(final JTree tree, final int keepSelectionLevel) {
final TreePath leadSelectionPath = tree.getLeadSelectionPath();
// Collapse all
int row = tree.getRowCount() - 1;
while (row >= 0) {
tree.collapseRow(row);
row--;
}
final DefaultMutableTreeNode root = (DefaultMutableTreeNode) tree.getModel().getRoot();
tree.expandPath(new TreePath(root));
if (leadSelectionPath != null) {
final Object[] path = leadSelectionPath.getPath();
final Object[] pathToSelect =
new Object
[path.length > keepSelectionLevel && keepSelectionLevel >= 0
? keepSelectionLevel
: path.length];
System.arraycopy(path, 0, pathToSelect, 0, pathToSelect.length);
if (pathToSelect.length == 0) return;
selectPath(tree, new TreePath(pathToSelect));
}
}
private static boolean collectExpandedPathsImpl(
final JTree tree, final Collection<TreePath> paths, final TreePath path) {
final TreeModel model = tree.getModel();
final Object lastPathComponent = path.getLastPathComponent();
if (model.isLeaf(lastPathComponent)) {
return false;
}
boolean hasExpandedChildren = false;
for (int i = model.getChildCount(lastPathComponent) - 1; i >= 0; i--) {
hasExpandedChildren |=
collectExpandedPathsImpl(
tree, paths, path.pathByAddingChild(model.getChild(lastPathComponent, i)));
}
if (!hasExpandedChildren) {
paths.add(path);
return true;
} else {
return false;
}
}
@Nullable
public static Range<Integer> getExpandControlRange(final JTree aTree, final TreePath path) {
TreeModel treeModel = aTree.getModel();
final BasicTreeUI basicTreeUI = (BasicTreeUI) aTree.getUI();
Icon expandedIcon = basicTreeUI.getExpandedIcon();
Range<Integer> box = null;
if (path != null && !treeModel.isLeaf(path.getLastPathComponent())) {
int boxWidth;
Insets i = aTree.getInsets();
if (expandedIcon != null) {
boxWidth = expandedIcon.getIconWidth();
} else {
boxWidth = 8;
}
int boxLeftX = i != null ? i.left : 0;
boolean leftToRight = aTree.getComponentOrientation().isLeftToRight();
int depthOffset = getDepthOffset(aTree);
int totalChildIndent = basicTreeUI.getLeftChildIndent() + basicTreeUI.getRightChildIndent();
if (leftToRight) {
boxLeftX +=
((path.getPathCount() + depthOffset - 2) * totalChildIndent
+ basicTreeUI.getLeftChildIndent())
- boxWidth / 2;
}
int boxRightX = boxLeftX + boxWidth;
box = new Range<Integer>(boxLeftX, boxRightX);
}
return box;
}
protected void doOKAction() {
final ActionManager actionManager = ActionManager.getInstance();
TreeUtil.traverseDepth(
(TreeNode) myTree.getModel().getRoot(),
new TreeUtil.Traverse() {
public boolean accept(Object node) {
if (node instanceof DefaultMutableTreeNode) {
final DefaultMutableTreeNode mutableNode = (DefaultMutableTreeNode) node;
final Object userObject = mutableNode.getUserObject();
if (userObject instanceof Pair) {
String actionId = (String) ((Pair) userObject).first;
final AnAction action = actionManager.getAction(actionId);
Icon icon = (Icon) ((Pair) userObject).second;
action.getTemplatePresentation().setIcon(icon);
action.setDefaultIcon(icon == null);
editToolbarIcon(actionId, mutableNode);
}
}
return true;
}
});
super.doOKAction();
setCustomizationSchemaForCurrentProjects();
}
public DefaultMutableTreeNode getModelRoot() {
return (DefaultMutableTreeNode) myTree.getModel().getRoot();
}
public void init() {
guangdong.add(foshan);
guangdong.add(shantou);
guangxi.add(guilin);
guangxi.add(nanning);
root.add(guangdong);
root.add(guangxi);
jf = new JFrame("树");
tree = new JTree(root);
// 获取JTree对应的TreeModel对象
model = (DefaultTreeModel) tree.getModel();
// 设置JTree可编辑
tree.setEditable(true);
MouseListener ml =
new MouseAdapter() {
// 按下鼠标时候获得被拖动的节点
public void mousePressed(MouseEvent e) {
// 如果需要唯一确定某个节点，必须通过TreePath来获取。
TreePath tp = tree.getPathForLocation(e.getX(), e.getY());
if (tp != null) {
movePath = tp;
}
}
// 鼠标松开时获得需要拖到哪个父节点
public void mouseReleased(MouseEvent e) {
// 根据鼠标松开时的TreePath来获取TreePath
TreePath tp = tree.getPathForLocation(e.getX(), e.getY());
if (tp != null && movePath != null) {
// 阻止向子节点拖动
if (movePath.isDescendant(tp) && movePath != tp) {
JOptionPane.showMessageDialog(
jf, "目标节点是被移动节点的子节点，无法移动！", "非法操作", JOptionPane.ERROR_MESSAGE);
return;
}
// 既不是向子节点移动，而且鼠标按下、松开的不是同一个节点
else if (movePath != tp) {
System.out.println(tp.getLastPathComponent());
// add方法可以先将原节点从原父节点删除，再添加到新父节点中
((DefaultMutableTreeNode) tp.getLastPathComponent())
.add((DefaultMutableTreeNode) movePath.getLastPathComponent());
movePath = null;
tree.updateUI();
}
}
}
};
tree.addMouseListener(ml);
JPanel panel = new JPanel();
addSiblingButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent event) {
// 获取选中节点
DefaultMutableTreeNode selectedNode =
(DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
// 如果节点为空，直接返回
if (selectedNode == null) return;
// 获取该选中节点的父节点
DefaultMutableTreeNode parent = (DefaultMutableTreeNode) selectedNode.getParent();
// 如果父节点为空，直接返回
if (parent == null) return;
// 创建一个新节点
DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("新节点");
// 获取选中节点的选中索引
int selectedIndex = parent.getIndex(selectedNode);
// 在选中位置插入新节点
model.insertNodeInto(newNode, parent, selectedIndex + 1);
// --------下面代码实现显示新节点（自动展开父节点）-------
// 获取从根节点到新节点的所有节点
TreeNode[] nodes = model.getPathToRoot(newNode);
// 使用指定的节点数组来创建TreePath
TreePath path = new TreePath(nodes);
// 显示指定TreePath
tree.scrollPathToVisible(path);
}
});
panel.add(addSiblingButton);
addChildButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent event) {
// 获取选中节点
DefaultMutableTreeNode selectedNode =
(DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
// 如果节点为空，直接返回
if (selectedNode == null) return;
// 创建一个新节点
DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("新节点");
// 直接通过model来添加新节点，则无需通过调用JTree的updateUI方法
// model.insertNodeInto(newNode, selectedNode, selectedNode.getChildCount());
// 直接通过节点添加新节点，则需要调用tree的updateUI方法
selectedNode.add(newNode);
// --------下面代码实现显示新节点（自动展开父节点）-------
TreeNode[] nodes = model.getPathToRoot(newNode);
TreePath path = new TreePath(nodes);
tree.scrollPathToVisible(path);
tree.updateUI();
}
});
panel.add(addChildButton);
deleteButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent event) {
DefaultMutableTreeNode selectedNode =
(DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
if (selectedNode != null && selectedNode.getParent() != null) {
// 删除指定节点
model.removeNodeFromParent(selectedNode);
}
}
});
panel.add(deleteButton);
editButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent event) {
TreePath selectedPath = tree.getSelectionPath();
if (selectedPath != null) {
// 编辑选中节点
tree.startEditingAtPath(selectedPath);
}
}
});
panel.add(editButton);
jf.add(new JScrollPane(tree));
jf.add(panel, BorderLayout.SOUTH);
jf.pack();
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.setVisible(true);
}
/**
* Removes last component in the current selection path.
*
* @param tree to remove selected node from.
*/
public static void removeSelected(@NotNull final JTree tree) {
final TreePath selectionPath = tree.getSelectionPath();
if (selectionPath == null) return;
removeLastPathComponent((DefaultTreeModel) tree.getModel(), selectionPath)
.restoreSelection(tree);
}
public static void removeLastPathComponent(
@NotNull final JTree tree, @NotNull final TreePath pathToBeRemoved) {
removeLastPathComponent((DefaultTreeModel) tree.getModel(), pathToBeRemoved)
.restoreSelection(tree);
}
/**
* Expands n levels of the tree counting from the root
*
* @param tree to expand nodes of
* @param levels depths of the expantion
*/
public static void expand(JTree tree, int levels) {
expand(tree, new TreePath(tree.getModel().getRoot()), levels);
}
/**
* Constructs a X509 certificate panel.
*
* @param certificates <tt>X509Certificate</tt> objects
*/
public X509CertificatePanel(Certificate[] certificates) {
setLayout(new BorderLayout(5, 5));
// Certificate chain list
TransparentPanel topPanel = new TransparentPanel(new BorderLayout());
topPanel.add(
new JLabel(
"<html><body><b>"
+ R.getI18NString("service.gui.CERT_INFO_CHAIN")
+ "</b></body></html>"),
BorderLayout.NORTH);
DefaultMutableTreeNode top = new DefaultMutableTreeNode();
DefaultMutableTreeNode previous = top;
for (int i = certificates.length - 1; i >= 0; i--) {
Certificate cert = certificates[i];
DefaultMutableTreeNode next = new DefaultMutableTreeNode(cert);
previous.add(next);
previous = next;
}
JTree tree = new JTree(top);
tree.setBorder(new BevelBorder(BevelBorder.LOWERED));
tree.setRootVisible(false);
tree.setExpandsSelectedPaths(true);
tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
tree.setCellRenderer(
new DefaultTreeCellRenderer() {
@Override
public Component getTreeCellRendererComponent(
JTree tree,
Object value,
boolean sel,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
JLabel component =
(JLabel)
super.getTreeCellRendererComponent(
tree, value, sel, expanded, leaf, row, hasFocus);
if (value instanceof DefaultMutableTreeNode) {
Object o = ((DefaultMutableTreeNode) value).getUserObject();
if (o instanceof X509Certificate) {
component.setText(getSimplifiedName((X509Certificate) o));
} else {
// We don't know how to represent this certificate type,
// let's use the first 20 characters
String text = o.toString();
if (text.length() > 20) {
text = text.substring(0, 20);
}
component.setText(text);
}
}
return component;
}
});
tree.getSelectionModel()
.addTreeSelectionListener(
new TreeSelectionListener() {
@Override
public void valueChanged(TreeSelectionEvent e) {
valueChangedPerformed(e);
}
});
tree.setSelectionPath(
new TreePath((((DefaultTreeModel) tree.getModel()).getPathToRoot(previous))));
topPanel.add(tree, BorderLayout.CENTER);
add(topPanel, BorderLayout.NORTH);
// Certificate details pane
Caret caret = infoTextPane.getCaret();
if (caret instanceof DefaultCaret) {
((DefaultCaret) caret).setUpdatePolicy(DefaultCaret.NEVER_UPDATE);
}
/*
* Make JEditorPane respect our default font because we will be using it
* to just display text.
*/
infoTextPane.putClientProperty(JEditorPane.HONOR_DISPLAY_PROPERTIES, true);
infoTextPane.setOpaque(false);
infoTextPane.setEditable(false);
infoTextPane.setContentType("text/html");
infoTextPane.setText(toString(certificates[0]));
final JScrollPane certScroll = new JScrollPane(infoTextPane);
certScroll.setPreferredSize(new Dimension(300, 500));
add(certScroll, BorderLayout.CENTER);
}
