下面列出了javax.swing.tree.DefaultMutableTreeNode#setAllowsChildren ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
void setupTreeNode(DefaultMutableTreeNode node, DiagnosticsNode diagnosticsNode, boolean expandChildren) {
node.setUserObject(diagnosticsNode);
node.setAllowsChildren(diagnosticsNode.hasChildren());
final InspectorInstanceRef valueRef = diagnosticsNode.getValueRef();
// Properties do not have unique values so should not go in the valueToTreeNode map.
if (valueRef.getId() != null && !diagnosticsNode.isProperty()) {
valueToTreeNode.put(valueRef, node);
}
if (parentTree != null) {
parentTree.maybeUpdateValueUI(valueRef);
}
if (diagnosticsNode.hasChildren() || !diagnosticsNode.getInlineProperties().isEmpty()) {
if (diagnosticsNode.childrenReady() || !diagnosticsNode.hasChildren()) {
final CompletableFuture<ArrayList<DiagnosticsNode>> childrenFuture = diagnosticsNode.getChildren();
assert (childrenFuture.isDone());
setupChildren(diagnosticsNode, node, childrenFuture.getNow(null), expandChildren);
}
else {
node.removeAllChildren();
node.add(new DefaultMutableTreeNode("Loading..."));
}
}
}
void setupTreeNode(DefaultMutableTreeNode node, DiagnosticsNode diagnosticsNode, boolean expandChildren) {
node.setUserObject(diagnosticsNode);
node.setAllowsChildren(diagnosticsNode.hasChildren());
final InspectorInstanceRef valueRef = diagnosticsNode.getValueRef();
// Properties do not have unique values so should not go in the valueToTreeNode map.
if (valueRef.getId() != null && !diagnosticsNode.isProperty()) {
valueToTreeNode.put(valueRef, node);
}
if (parentTree != null) {
parentTree.maybeUpdateValueUI(valueRef);
}
if (diagnosticsNode.hasChildren() || !diagnosticsNode.getInlineProperties().isEmpty()) {
if (diagnosticsNode.childrenReady() || !diagnosticsNode.hasChildren()) {
final CompletableFuture<ArrayList<DiagnosticsNode>> childrenFuture = diagnosticsNode.getChildren();
assert (childrenFuture.isDone());
setupChildren(diagnosticsNode, node, childrenFuture.getNow(null), expandChildren);
}
else {
node.removeAllChildren();
node.add(new DefaultMutableTreeNode("Loading..."));
}
}
}
void addNodes (DefaultMutableTreeNode root, InfocomDisk disk)
// ---------------------------------------------------------------------------------//
{
root.setAllowsChildren (true);
// should be set by now - do this better!
codeSize = header.stringPointer - header.highMemory;
int count = 0;
for (Routine routine : routines.values ())
{
String name = String.format ("%3d %s (%04X)", ++count, routine.getName (),
routine.startPtr / 2);
DefaultAppleFileSource dafs = new DefaultAppleFileSource (name, routine, disk);
dafs.setSectors (getSectors (routine, disk.getDisk ()));
DefaultMutableTreeNode node = new DefaultMutableTreeNode (dafs);
node.setAllowsChildren (false);
root.add (node);
}
}
private void linkPictures (String title, DiskAddress da,
DefaultMutableTreeNode headerNode)
// ---------------------------------------------------------------------------------//
{
List<DiskAddress> blocks = new ArrayList<> ();
blocks.add (da);
byte[] buffer = owner.getDisk ().readBlock (da);
String text = printChars (buffer, 0);
DefaultAppleFileSource dafs = new DefaultAppleFileSource (title, text, owner);
dafs.setSectors (blocks);
DefaultMutableTreeNode node = new DefaultMutableTreeNode (dafs);
node.setAllowsChildren (false);
headerNode.add (node);
}
private void addToNode (AbstractFile af, DefaultMutableTreeNode node,
List<DiskAddress> blocks, SectorType type)
// ---------------------------------------------------------------------------------//
{
DefaultAppleFileSource dafs =
new DefaultAppleFileSource (af.getName (), af, this, blocks);
DefaultMutableTreeNode childNode = new DefaultMutableTreeNode (dafs);
node.add (childNode);
childNode.setAllowsChildren (false);
}
private DefaultMutableTreeNode generateTreeModel(HierarchicalClusterNode cl) {
DefaultMutableTreeNode result = new DefaultMutableTreeNode(cl);
result.setAllowsChildren(true);
// Add sub clusters
for (HierarchicalClusterNode subNode : cl.getSubNodes()) {
result.add(generateTreeModel(subNode));
}
// Add objects
for (Object exampleId : cl.getExampleIdsInSubtree()) {
result.add(createLeaf(exampleId));
}
return result;
}
private MutableTreeNode createLeaf(Object id) {
ObjectVisualizer viz = ObjectVisualizerService.getVisualizerForObject(clusterModel);
String title = viz.getTitle(id);
if (title == null) {
if (id instanceof String) {
title = (String) id;
} else {
title = ((Integer) id).toString();
}
}
DefaultMutableTreeNode newLeaf = new DefaultMutableTreeNode(new ClusterTreeLeaf(title, id));
newLeaf.setAllowsChildren(false);
return newLeaf;
}
public void addNodes (DefaultMutableTreeNode root, FormattedDisk disk)
// ---------------------------------------------------------------------------------//
{
root.setAllowsChildren (true);
for (ZObject zo : list)
if (zo.parent == 0)
buildObjectTree (zo, root, disk);
}
private void buildObjectTree (ZObject object, DefaultMutableTreeNode parentNode,
FormattedDisk disk)
// ---------------------------------------------------------------------------------//
{
DefaultMutableTreeNode child = new DefaultMutableTreeNode (
new DefaultAppleFileSource (object.getName (), object, disk));
parentNode.add (child);
if (object.sibling > 0)
buildObjectTree (list.get (object.sibling - 1), parentNode, disk);
if (object.child > 0)
buildObjectTree (list.get (object.child - 1), child, disk);
else
child.setAllowsChildren (false);
}
private DefaultMutableTreeNode addToTree (DefaultMutableTreeNode root, String title,
DataSource af, boolean allowsChildren)
// ---------------------------------------------------------------------------------//
{
DefaultAppleFileSource dafs = new DefaultAppleFileSource (title, af, this);
// dafs.setSectors (blocks);
DefaultMutableTreeNode node = new DefaultMutableTreeNode (dafs);
node.setAllowsChildren (allowsChildren);
root.add (node);
return node;
}
public void addNodes (DefaultMutableTreeNode node, FormattedDisk disk)
// ---------------------------------------------------------------------------------//
{
node.setAllowsChildren (true);
int count = 0;
for (Statistic stat : list)
{
DefaultMutableTreeNode child = new DefaultMutableTreeNode (
new DefaultAppleFileSource (("Attribute " + count++), stat.getText (), disk));
node.add (child);
child.setAllowsChildren (false);
}
}
public void addNodes (DefaultMutableTreeNode node, FormattedDisk disk)
// ---------------------------------------------------------------------------------//
{
node.setAllowsChildren (true);
for (Statistic stat : list)
if (stat.list.size () > 0)
{
String title = "Property " + header.getPropertyName (stat.id).trim ();
DefaultMutableTreeNode child = new DefaultMutableTreeNode (
new DefaultAppleFileSource (title, stat.getText (), disk));
node.add (child);
child.setAllowsChildren (false);
}
}
private DefaultMutableTreeNode createNode (File file, boolean allowsChildren)
// ---------------------------------------------------------------------------------//
{
FileNode fileNode = new FileNode (file);
DefaultMutableTreeNode newNode = new DefaultMutableTreeNode (fileNode);
fileNode.setTreeNode (newNode);
newNode.setAllowsChildren (allowsChildren);
return newNode;
}
private void linkText (String title, DiskAddress da, DefaultMutableTreeNode headerNode)
// ---------------------------------------------------------------------------------//
{
List<DiskAddress> blocks = new ArrayList<> ();
blocks.add (da);
StringBuilder text = new StringBuilder (scenarioTitle + "\n\n");
int ptr = 106;
byte[] buffer = owner.getDisk ().readBlock (da);
while (buffer[ptr] != -1)
{
text.append (HexFormatter.getPascalString (buffer, ptr) + "\n");
ptr += 10;
}
ptr += 2;
text.append ("\n");
while (ptr < 512)
{
int value = Utility.intValue (buffer[ptr], buffer[ptr + 1]);
text.append (String.format ("%04X %,6d%n", value, value));
ptr += 2;
}
DefaultAppleFileSource dafs =
new DefaultAppleFileSource (title, text.toString (), owner);
dafs.setSectors (blocks);
DefaultMutableTreeNode node = new DefaultMutableTreeNode (dafs);
node.setAllowsChildren (false);
headerNode.add (node);
}
private void linkSpells (String title, DiskAddress da,
DefaultMutableTreeNode headerNode)
// ---------------------------------------------------------------------------------//
{
List<DiskAddress> blocks = new ArrayList<> ();
blocks.add (da);
int level = 1;
StringBuilder list = new StringBuilder ("Level " + level + ":\n");
byte[] buffer = owner.getDisk ().readBlock (da);
String text = HexFormatter.getString (buffer, 0, 512);
String[] spells = text.split ("\n");
for (String s : spells)
{
if (s.length () == 0)
break;
if (s.startsWith ("*"))
{
s = s.substring (1);
level++;
list.append ("\nLevel " + level + ":\n");
}
list.append (" " + s + "\n");
}
DefaultAppleFileSource dafs =
new DefaultAppleFileSource (title, list.toString (), owner);
dafs.setSectors (blocks);
DefaultMutableTreeNode node = new DefaultMutableTreeNode (dafs);
node.setAllowsChildren (false);
headerNode.add (node);
}
/**
* Clone/Copy a tree node. TreeNodes in Swing don't support deep cloning.
*
* @param orig to be cloned
* @return cloned copy
*/
private DefaultMutableTreeNode copyNode(final DefaultMutableTreeNode orig) {
if (orig == null)
return null;
DefaultMutableTreeNode newOne = new DefaultMutableTreeNode();
newOne.setUserObject(orig.getUserObject());
newOne.setAllowsChildren(!orig.isLeaf());
Enumeration<DefaultMutableTreeNode> enm = orig.children();
while (enm.hasMoreElements()) {
DefaultMutableTreeNode child = enm.nextElement();
newOne.add(copyNode(child));
}
return newOne;
}
private void linkBlock2 (DefaultMutableTreeNode scenarioNode, FileEntry fileEntry)
// ---------------------------------------------------------------------------------//
{
byte[] buffer = fileEntry.getDataSource ().buffer;
List<DiskAddress> blocks = fileEntry.getSectors ();
StringBuilder text = new StringBuilder ();
List<DiskAddress> allBlocks = new ArrayList<> ();
for (int i = 0; i < 19; i++)
{
allBlocks.add (blocks.get (87 + i));
}
int offset = 0xAE00;
int length = 60;
for (int i = 0; i < 150; i++)
{
text.append (String.format ("%04X : %s%n", (offset + i * length),
HexFormatter.getHexString (buffer, offset + i * length, length)));
}
DefaultMutableTreeNode oracleNode =
linkNode ("Block2", text.toString (), scenarioNode);
oracleNode.setAllowsChildren (false);
DefaultAppleFileSource afs = (DefaultAppleFileSource) oracleNode.getUserObject ();
afs.setSectors (allBlocks);
}
private void linkOracle (DefaultMutableTreeNode scenarioNode, FileEntry fileEntry)
// ---------------------------------------------------------------------------------//
{
byte[] buffer = fileEntry.getDataSource ().buffer;
List<DiskAddress> blocks = fileEntry.getSectors ();
StringBuilder text = new StringBuilder ();
for (int i = 0; i < 320; i++)
{
// System.out.println (HexFormatter.format (buffer, 0x08600 + i * 32, 32));
int offset = 0x08600 + i * 32 + 18;
int key = Utility.unsignedShort (buffer, offset);
if (key > 0)
text.append (String.format ("%04X %04X * %s%n", offset, key,
messageBlock.getMessageText (key)));
key = Utility.unsignedShort (buffer, offset + 8);
if (key > 0)
text.append (String.format ("%04X %04X %s%n", offset + 8, key,
messageBlock.getMessageText (key)));
}
List<DiskAddress> allOracleBlocks = new ArrayList<> ();
for (int i = 0; i < 20; i++)
{
allOracleBlocks.add (blocks.get (67 + i));
}
DefaultMutableTreeNode oracleNode =
linkNode ("Oracle", text.toString (), scenarioNode);
oracleNode.setAllowsChildren (false);
DefaultAppleFileSource afs = (DefaultAppleFileSource) oracleNode.getUserObject ();
afs.setSectors (allOracleBlocks);
}
public PascalDisk (Disk disk)
// ---------------------------------------------------------------------------------//
{
super (disk);
sectorTypesList.add (diskBootSector);
sectorTypesList.add (catalogSector);
sectorTypesList.add (dataSector);
sectorTypesList.add (codeSector);
sectorTypesList.add (textSector);
sectorTypesList.add (infoSector);
sectorTypesList.add (grafSector);
sectorTypesList.add (fotoSector);
sectorTypesList.add (badSector);
List<DiskAddress> blocks = disk.getDiskAddressList (0, 1); // B0, B1
this.bootSector = new BootSector (disk, disk.readBlocks (blocks), "Pascal");
for (int i = 0; i < 2; i++)
if (!disk.isBlockEmpty (i))
{
sectorTypes[i] = diskBootSector;
freeBlocks.set (i, false);
}
for (int i = 2; i < disk.getTotalBlocks (); i++)
freeBlocks.set (i, true);
byte[] buffer = disk.readBlock (2);
byte[] data = new byte[CATALOG_ENTRY_SIZE];
System.arraycopy (buffer, 0, data, 0, CATALOG_ENTRY_SIZE);
volumeEntry = new VolumeEntry (this, data);
DefaultMutableTreeNode root = getCatalogTreeRoot ();
DefaultMutableTreeNode volumeNode = new DefaultMutableTreeNode (volumeEntry);
root.add (volumeNode);
List<DiskAddress> sectors = new ArrayList<> ();
int max = Math.min (volumeEntry.lastBlock, disk.getTotalBlocks ());
for (int i = 2; i < max; i++)
{
DiskAddress da = disk.getDiskAddress (i);
if (!disk.isBlockEmpty (da))
sectorTypes[i] = catalogSector;
sectors.add (da);
freeBlocks.set (i, false);
}
diskCatalogSector =
new PascalCatalogSector (disk, disk.readBlocks (sectors), sectors);
// read the catalog
List<DiskAddress> addresses = new ArrayList<> ();
for (int i = 2; i < max; i++)
addresses.add (disk.getDiskAddress (i));
buffer = disk.readBlocks (addresses);
// loop through each catalog entry (what if there are deleted files?)
for (int i = 1; i <= volumeEntry.totalFiles; i++)
{
int ptr = i * CATALOG_ENTRY_SIZE;
data = new byte[CATALOG_ENTRY_SIZE];
System.arraycopy (buffer, ptr, data, 0, CATALOG_ENTRY_SIZE);
FileEntry fileEntry = new FileEntry (this, data);
fileEntries.add (fileEntry);
DefaultMutableTreeNode node = new DefaultMutableTreeNode (fileEntry);
fileEntry.setNode (node);
if (fileEntry.fileType == 2)
{
node.setAllowsChildren (true);
fileEntry.getDataSource (); // build segments
}
else
node.setAllowsChildren (false);
volumeNode.add (node);
for (int j = fileEntry.firstBlock; j < fileEntry.lastBlock; j++)
freeBlocks.set (j, false);
}
volumeNode.setUserObject (getCatalog ());
makeNodeVisible (volumeNode.getFirstLeaf ());
}
public WizardryScenarioDisk (Disk disk)
// ---------------------------------------------------------------------------------//
{
super (disk);
if (false)
{
sectorTypesList.add (mazeSector);
sectorTypesList.add (monsterSector);
sectorTypesList.add (itemSector);
sectorTypesList.add (characterSector);
sectorTypesList.add (spellSector);
sectorTypesList.add (messageSector);
sectorTypesList.add (imageSector);
sectorTypesList.add (experienceSector);
sectorTypesList.add (treasureSector);
}
CodedMessage.codeOffset = 185;
Monster.counter = 0;
Item.counter = 0;
DefaultTreeModel model = (DefaultTreeModel) catalogTree.getModel ();
DefaultMutableTreeNode currentRoot = (DefaultMutableTreeNode) model.getRoot ();
DefaultMutableTreeNode dataNode = findNode (currentRoot, "SCENARIO.DATA");
DefaultMutableTreeNode msgNode = findNode (currentRoot, "SCENARIO.MESGS");
if (dataNode == null || msgNode == null)
{
System.out.println ("Wizardry data or msg node not found");
return;
}
dataNode.setAllowsChildren (true);
msgNode.setAllowsChildren (true);
scenarioHeader = new Header (dataNode, this);
// Process SCENARIO.MESGS (requires scenario)
AppleFileSource afs = (AppleFileSource) msgNode.getUserObject ();
// DefaultMutableTreeNode node = linkNode ("Messages", "Messages string", msgNode);
extractMessages (msgNode, afs.getSectors ());
// makeNodeVisible (node);
// Process SCENARIO.DATA (requires scenario and messages)
afs = (AppleFileSource) dataNode.getUserObject ();
List<DiskAddress> sectors = afs.getSectors ();
extractItems (linkNode ("Items", "Items string", dataNode), sectors);
extractRewards (linkNode ("Rewards", "Treasure string", dataNode), sectors);
extractMonsters (linkNode ("Monsters", "Monsters string", dataNode), sectors);
extractCharacters (linkNode ("Characters", "Characters string", dataNode), sectors);
extractImages (linkNode ("Images", "Images string", dataNode), sectors);
extractExperienceLevels (linkNode ("Experience", "Experience string", dataNode),
sectors);
// node = linkNode ("Spells", "Spells string", dataNode);
DefaultMutableTreeNode node = null;
extractSpells (node, sectors);
extractLevels (linkNode ("Maze", "Levels string", dataNode), sectors);
// Make the Spells node (and its siblings) visible
// makeNodeVisible (node);
// add information about each characters' baggage, spells known etc.
for (Character c : characters)
{
c.linkItems (items);
c.linkSpells (spells);
int type = c.getStatistics ().typeInt;
c.linkExperience (experiences.get (type));
}
}