2020-05-10 11:28:01 +00:00
|
|
|
package com.bytezone.diskbrowser.disk;
|
|
|
|
|
|
|
|
import java.awt.Dimension;
|
|
|
|
import java.nio.file.Path;
|
2020-12-20 21:50:51 +00:00
|
|
|
import java.util.ArrayList;
|
2020-05-10 11:28:01 +00:00
|
|
|
import java.util.List;
|
|
|
|
|
|
|
|
import javax.swing.JTree;
|
|
|
|
import javax.swing.tree.DefaultMutableTreeNode;
|
|
|
|
import javax.swing.tree.DefaultTreeModel;
|
|
|
|
|
|
|
|
import com.bytezone.diskbrowser.applefile.AbstractFile;
|
|
|
|
import com.bytezone.diskbrowser.applefile.AppleFileSource;
|
|
|
|
import com.bytezone.diskbrowser.gui.DataSource;
|
|
|
|
|
|
|
|
// Apple Assembly Lines disks are dual-dos
|
|
|
|
// Should be renamed MultiVolumeDisk (and allow >2 volumes)
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------------------//
|
2020-12-20 21:50:51 +00:00
|
|
|
public class HybridDisk implements FormattedDisk
|
2020-05-10 11:28:01 +00:00
|
|
|
// -----------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
private final List<FormattedDisk> disks = new ArrayList<> (2);
|
2020-05-10 11:28:01 +00:00
|
|
|
private int currentDisk;
|
|
|
|
private final JTree tree;
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
2020-12-20 21:50:51 +00:00
|
|
|
public HybridDisk (FormattedDisk disk0, FormattedDisk disk1)
|
2020-05-10 11:28:01 +00:00
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
assert disk0 != disk1;
|
|
|
|
String diskName = disk0.getDisk ().getFile ().getName ();
|
2020-12-20 21:50:51 +00:00
|
|
|
String text = "This disk is a hybrid of two or more OS\n\n" + disk0.getDisk ()
|
|
|
|
+ "\n\n" + disk1.getDisk ();
|
2020-05-10 11:28:01 +00:00
|
|
|
|
|
|
|
DefaultAppleFileSource dafs = new DefaultAppleFileSource (diskName, text, this);
|
|
|
|
DefaultMutableTreeNode root = new DefaultMutableTreeNode (dafs);
|
|
|
|
|
|
|
|
DefaultTreeModel treeModel = new DefaultTreeModel (root);
|
|
|
|
tree = new JTree (treeModel);
|
|
|
|
|
|
|
|
// allow empty nodes to appear as folders
|
|
|
|
treeModel.setAsksAllowsChildren (true);
|
|
|
|
|
2020-12-20 21:50:51 +00:00
|
|
|
disks.add (disk0);
|
|
|
|
disks.add (disk1);
|
2020-05-10 11:28:01 +00:00
|
|
|
|
|
|
|
disk0.setParent (this);
|
|
|
|
disk1.setParent (this);
|
|
|
|
|
|
|
|
DefaultMutableTreeNode root0 =
|
|
|
|
(DefaultMutableTreeNode) disk0.getCatalogTree ().getModel ().getRoot ();
|
|
|
|
DefaultMutableTreeNode root1 =
|
|
|
|
(DefaultMutableTreeNode) disk1.getCatalogTree ().getModel ().getRoot ();
|
|
|
|
|
|
|
|
root.add ((DefaultMutableTreeNode) root0.getChildAt (0));
|
|
|
|
root.add ((DefaultMutableTreeNode) root1.getChildAt (0));
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public JTree getCatalogTree ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
return tree;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public List<DiskAddress> getFileSectors (int fileNo)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getFileSectors (fileNo);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public List<AppleFileSource> getCatalogList ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getCatalogList ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public DataSource getFormattedSector (DiskAddress da)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getFormattedSector (da);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public SectorType getSectorType (DiskAddress da)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getSectorType (da);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public SectorType getSectorType (int track, int sector)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getSectorType (track, sector);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public SectorType getSectorType (int block)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getSectorType (block);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public List<SectorType> getSectorTypeList ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getSectorTypeList ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public Disk getDisk ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getDisk ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
public void setCurrentDisk (FormattedDisk fd)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
for (int i = 0; i < disks.size (); i++)
|
|
|
|
if (disks.get (i) == fd)
|
|
|
|
{
|
|
|
|
currentDisk = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if (disks[0] == fd)
|
|
|
|
// currentDisk = 0;
|
|
|
|
// else if (disks[1] == fd)
|
|
|
|
// currentDisk = 1;
|
|
|
|
// else
|
|
|
|
// {
|
|
|
|
// // this happens when the top-level folder is selected (i.e. neither disk)
|
|
|
|
// System.out.println ("Disk not found: " + fd);
|
|
|
|
// // Utility.printStackTrace ();
|
|
|
|
// }
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
public void setCurrentDiskNo (int n)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
currentDisk = n;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
public int getCurrentDiskNo ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
return currentDisk;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
public FormattedDisk getCurrentDisk ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public void writeFile (AbstractFile file)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
disks.get (currentDisk).writeFile (file);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public AppleFileSource getCatalog ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
StringBuilder text = new StringBuilder ();
|
|
|
|
|
|
|
|
for (FormattedDisk disk : disks)
|
|
|
|
{
|
|
|
|
text.append (disk.getCatalog ().getDataSource ().getText ());
|
|
|
|
text.append ("\n\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
text.deleteCharAt (text.length () - 1);
|
|
|
|
text.deleteCharAt (text.length () - 1);
|
|
|
|
|
|
|
|
return new DefaultAppleFileSource ("text", text.toString (), this);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public AppleFileSource getFile (String uniqueName)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getFile (uniqueName);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public int clearOrphans ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).clearOrphans ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public boolean isSectorFree (DiskAddress da)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).isSectorFree (da);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public void verify ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
disks.get (currentDisk).verify ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public boolean stillAvailable (DiskAddress da)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).stillAvailable (da);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public void setSectorType (int block, SectorType type)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
disks.get (currentDisk).setSectorType (block, type);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public void setSectorFree (int block, boolean free)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
disks.get (currentDisk).setSectorFree (block, free);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public int falseNegativeBlocks ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).falseNegativeBlocks ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public int falsePositiveBlocks ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).falsePositiveBlocks ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public Dimension getGridLayout ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getGridLayout ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public boolean isSectorFree (int block)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).isSectorFree (block);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public boolean stillAvailable (int block)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).stillAvailable (block);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public void setOriginalPath (Path path)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
disks.get (currentDisk).setOriginalPath (path);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public String getAbsolutePath ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getAbsolutePath ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public String getDisplayPath ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getDisplayPath ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public FormattedDisk getParent ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getParent ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public void setParent (FormattedDisk disk)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
disks.get (currentDisk).setParent (disk);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public String getSectorFilename (DiskAddress da)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getSectorFilename (da);
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public String getName ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getName ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public boolean isTempDisk ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).isTempDisk ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public Path getOriginalPath ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
2020-12-20 21:50:51 +00:00
|
|
|
return disks.get (currentDisk).getOriginalPath ();
|
2020-05-10 11:28:01 +00:00
|
|
|
}
|
2015-06-01 09:35:51 +00:00
|
|
|
}
|