Apple-2-Tools/dmolony-DiskBrowser
1
0
Fork 0
mirror of https://github.com/dmolony/DiskBrowser.git synced 2025-02-06 19:30:01 +00:00
Code Issues Projects Releases Wiki Activity

unidisk

Browse Source
This commit is contained in:
Denis Molony 2019-11-14 21:55:30 +10:00
parent 8b9b9db2eb
commit d46564577b
11 changed files with 273 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/com/bytezone/diskbrowser/disk/DiskFactory.java
View File

@ -208,8 +208,9 @@ public class DiskFactory
// 2 x 400k disk images
AppleDisk appleDisk1 = new AppleDisk (file, 50, 32);
AppleDisk appleDisk2 = new AppleDisk (file, 50, 32, 409600);
disk = checkUnidos (appleDisk1);
disk2 = checkUnidos (appleDisk2);
disk = checkUnidos (appleDisk1, 1);
disk2 = checkUnidos (appleDisk2, 2);
assert disk != disk2;
if (disk != null && disk2 != null)
return new DualDosDisk (disk, disk2);
}
@ -533,7 +534,7 @@ public class DiskFactory
return null;
}
private static DosDisk checkUnidos (AppleDisk disk)
private static DosDisk checkUnidos (AppleDisk disk, int side)
{
if (debug)
System.out.println ("Checking UniDOS disk");
@ -544,7 +545,7 @@ public class DiskFactory
{
if (debug)
System.out.println (" --> UniDOS");
return new DosDisk (disk);
return new DosDisk (disk, side);
}
}
catch (Exception e)

88
src/com/bytezone/diskbrowser/disk/DualDosDisk.java
View File

@ -15,14 +15,21 @@ import com.bytezone.diskbrowser.gui.DataSource;
// Apple Assembly Lines disks are dual-dos
// Should be renamed MultiVolumeDisk (and allow >2 volumes)
// -----------------------------------------------------------------------------------//
public class DualDosDisk implements FormattedDisk
// -----------------------------------------------------------------------------------//
{
private final FormattedDisk[] disks = new FormattedDisk[2];
private int currentDisk;
private final JTree tree;
// ---------------------------------------------------------------------------------//
public DualDosDisk (FormattedDisk disk0, FormattedDisk disk1)
// ---------------------------------------------------------------------------------//
{
// System.out.printf ("Disk0:%n %s%n", disk0);
// System.out.printf ("Disk1:%n %s%n", disk1);
assert disk0 != disk1;
String diskName = disk0.getDisk ().getFile ().getName ();
String text = "This disk contains files from DOS and another OS\n\n"
+ disk0.getDisk () + "\n\n" + disk1.getDisk ();
@ -46,99 +53,128 @@ public class DualDosDisk implements FormattedDisk
(DefaultMutableTreeNode) disk0.getCatalogTree ().getModel ().getRoot ();
DefaultMutableTreeNode root1 =
(DefaultMutableTreeNode) disk1.getCatalogTree ().getModel ().getRoot ();
root.add ((DefaultMutableTreeNode) root0.getChildAt (0));
root.add ((DefaultMutableTreeNode) root1.getChildAt (0));
// TreeNode[] nodes = ((DefaultTreeModel) tree.getModel ()).getPathToRoot (child);
// tree.setSelectionPath (new TreePath (nodes));
}
// ---------------------------------------------------------------------------------//
@Override
public JTree getCatalogTree ()
// ---------------------------------------------------------------------------------//
{
return tree;
}
// ---------------------------------------------------------------------------------//
@Override
public List<DiskAddress> getFileSectors (int fileNo)
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getFileSectors (fileNo);
}
// ---------------------------------------------------------------------------------//
@Override
public List<AppleFileSource> getCatalogList ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getCatalogList ();
}
// ---------------------------------------------------------------------------------//
@Override
public DataSource getFormattedSector (DiskAddress da)
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getFormattedSector (da);
}
// ---------------------------------------------------------------------------------//
@Override
public SectorType getSectorType (DiskAddress da)
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getSectorType (da);
}
// ---------------------------------------------------------------------------------//
@Override
public SectorType getSectorType (int track, int sector)
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getSectorType (track, sector);
}
// ---------------------------------------------------------------------------------//
@Override
public SectorType getSectorType (int block)
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getSectorType (block);
}
// ---------------------------------------------------------------------------------//
@Override
public List<SectorType> getSectorTypeList ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getSectorTypeList ();
}
// ---------------------------------------------------------------------------------//
@Override
public Disk getDisk ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getDisk ();
}
public void setCurrentDisk (AppleFileSource afs)
// ---------------------------------------------------------------------------------//
public void setCurrentDisk (FormattedDisk fd)
// ---------------------------------------------------------------------------------//
{
FormattedDisk fd = afs.getFormattedDisk ();
if (disks[0] == fd && currentDisk != 0)
currentDisk = 0;
else if (disks[1] == fd && currentDisk != 1)
currentDisk = 1;
System.out.printf ("1. Setting disk: %d%n", currentDisk);
}
// ---------------------------------------------------------------------------------//
public void setCurrentDiskNo (int n)
// ---------------------------------------------------------------------------------//
{
currentDisk = n;
System.out.printf ("2. Setting disk: %d%n", currentDisk);
}
// ---------------------------------------------------------------------------------//
public int getCurrentDiskNo ()
// ---------------------------------------------------------------------------------//
{
return currentDisk;
}
// ---------------------------------------------------------------------------------//
public FormattedDisk getCurrentDisk ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk];
}
// ---------------------------------------------------------------------------------//
@Override
public void writeFile (AbstractFile file)
// ---------------------------------------------------------------------------------//
{
disks[currentDisk].writeFile (file);
}
// ---------------------------------------------------------------------------------//
@Override
public AppleFileSource getCatalog ()
// ---------------------------------------------------------------------------------//
{
return new DefaultAppleFileSource ("text",
disks[0].getCatalog ().getDataSource ().getText () + "\n\n"
@ -146,128 +182,170 @@ public class DualDosDisk implements FormattedDisk
this);
}
// ---------------------------------------------------------------------------------//
@Override
public AppleFileSource getFile (String uniqueName)
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getFile (uniqueName);
}
// ---------------------------------------------------------------------------------//
@Override
public int clearOrphans ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].clearOrphans ();
}
// ---------------------------------------------------------------------------------//
@Override
public boolean isSectorFree (DiskAddress da)
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].isSectorFree (da);
}
// ---------------------------------------------------------------------------------//
@Override
public void verify ()
// ---------------------------------------------------------------------------------//
{
disks[currentDisk].verify ();
}
// ---------------------------------------------------------------------------------//
@Override
public boolean stillAvailable (DiskAddress da)
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].stillAvailable (da);
}
// ---------------------------------------------------------------------------------//
@Override
public void setSectorType (int block, SectorType type)
// ---------------------------------------------------------------------------------//
{
disks[currentDisk].setSectorType (block, type);
}
// ---------------------------------------------------------------------------------//
@Override
public void setSectorFree (int block, boolean free)
// ---------------------------------------------------------------------------------//
{
disks[currentDisk].setSectorFree (block, free);
}
// ---------------------------------------------------------------------------------//
@Override
public int falseNegativeBlocks ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].falseNegativeBlocks ();
}
// ---------------------------------------------------------------------------------//
@Override
public int falsePositiveBlocks ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].falsePositiveBlocks ();
}
// ---------------------------------------------------------------------------------//
@Override
public Dimension getGridLayout ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getGridLayout ();
}
// ---------------------------------------------------------------------------------//
@Override
public boolean isSectorFree (int block)
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].isSectorFree (block);
}
// ---------------------------------------------------------------------------------//
@Override
public boolean stillAvailable (int block)
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].stillAvailable (block);
}
// ---------------------------------------------------------------------------------//
@Override
public void setOriginalPath (Path path)
// ---------------------------------------------------------------------------------//
{
disks[currentDisk].setOriginalPath (path);
}
// ---------------------------------------------------------------------------------//
@Override
public String getAbsolutePath ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getAbsolutePath ();
}
// ---------------------------------------------------------------------------------//
@Override
public String getDisplayPath ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getDisplayPath ();
}
// ---------------------------------------------------------------------------------//
@Override
public FormattedDisk getParent ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getParent ();
}
// ---------------------------------------------------------------------------------//
@Override
public void setParent (FormattedDisk disk)
// ---------------------------------------------------------------------------------//
{
disks[currentDisk].setParent (disk);
}
// ---------------------------------------------------------------------------------//
@Override
public String getSectorFilename (DiskAddress da)
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getSectorFilename (da);
}
// ---------------------------------------------------------------------------------//
@Override
public String getName ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getName ();
}
// ---------------------------------------------------------------------------------//
@Override
public boolean isTempDisk ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].isTempDisk ();
}
// ---------------------------------------------------------------------------------//
@Override
public Path getOriginalPath ()
// ---------------------------------------------------------------------------------//
{
return disks[currentDisk].getOriginalPath ();
}

37
src/com/bytezone/diskbrowser/dos/DosDisk.java
View File

@ -24,6 +24,7 @@ public class DosDisk extends AbstractFormattedDisk
private int freeSectors;
private int usedSectors;
private final int volumeNo; // for multi-volume disks
public final SectorType vtocSector = new SectorType ("VTOC", Color.magenta);
public final SectorType catalogSector = new SectorType ("Catalog", green);
@ -39,9 +40,16 @@ public class DosDisk extends AbstractFormattedDisk
}
public DosDisk (Disk disk)
{
this (disk, 0);
}
public DosDisk (Disk disk, int volumeNo)
{
super (disk);
this.volumeNo = volumeNo;
sectorTypesList.add (dosSector);
sectorTypesList.add (vtocSector);
sectorTypesList.add (catalogSector);
@ -95,7 +103,7 @@ public class DosDisk extends AbstractFormattedDisk
// if (sectorBuffer[0] != 0 && (sectorBuffer[0] & 0xFF) != 0xFF && false)
// {
// System.out
// .println ("Dos catalog sector buffer byte #0 invalid : " + sectorBuffer[0]);
// .println ("Dos catalog sector buffer byte #0 invalid : " + sectorBuffer[0]);
// break;
// }
@ -218,15 +226,23 @@ public class DosDisk extends AbstractFormattedDisk
deletedFilesNode.setUserObject (getDeletedList ());
makeNodeVisible (deletedFilesNode.getFirstLeaf ());
}
volumeNode.setUserObject (getCatalog ());
makeNodeVisible (volumeNode.getFirstLeaf ());
}
public int getVolumeNo ()
{
return volumeNo;
}
@Override
public void setOriginalPath (Path path)
{
super.setOriginalPath (path);
volumeNode.setUserObject (getCatalog ()); // this has already been set in the constructor
// this has already been set in the constructor
volumeNode.setUserObject (getCatalog ());
}
// Beagle Bros FRAMEUP disk only has one catalog block
@ -355,7 +371,16 @@ public class DosDisk extends AbstractFormattedDisk
@Override
public String toString ()
{
StringBuffer text = new StringBuffer (dosVTOCSector.toString ());
// StringBuffer text = new StringBuffer (dosVTOCSector.toString ());
// return text.toString ();
StringBuffer text = new StringBuffer ();
text.append (
String.format ("DOS version ........... %s%n", dosVTOCSector.dosVersion));
text.append (
String.format ("Sectors per track ..... %d%n", dosVTOCSector.maxSectors));
text.append (String.format ("Volume no ............. %d", volumeNo));
return text.toString ();
}
@ -416,8 +441,10 @@ public class DosDisk extends AbstractFormattedDisk
"%nActual: Free sectors: %3d "
+ "Used sectors: %3d Total sectors: %3d",
freeSectors, usedSectors, (usedSectors + freeSectors)));
return new DefaultAppleFileSource ("Volume " + dosVTOCSector.volume, text.toString (),
this);
String volumeText = volumeNo == 0 ? "" : "Side " + volumeNo + " ";
return new DefaultAppleFileSource (volumeText + "Volume " + dosVTOCSector.volume,
text.toString (), this);
}
private AppleFileSource getDeletedList ()

3
src/com/bytezone/diskbrowser/gui/AppleDiskTab.java
View File

@ -49,6 +49,7 @@ class AppleDiskTab extends AbstractTab
RedoHandler redoHandler, Font font, String lastFileUsed)
{
super (redoHandler, selector, font);
System.out.println ("******************");
create (disk);
// System.out.println ("ooh - couldn't find the previous file");
DefaultMutableTreeNode node = findNode (lastFileUsed);
@ -117,7 +118,7 @@ class AppleDiskTab extends AbstractTab
void redoEvent (RedoEvent event)
{
selectNode (((FileSelectedEvent) event.value).file.getUniqueName ());
selectNode (((FileSelectedEvent) event.value).appleFileSource.getUniqueName ());
}
private DefaultMutableTreeNode findNode (String nodeName)

92
src/com/bytezone/diskbrowser/gui/CatalogPanel.java
View File

@ -35,9 +35,11 @@ import com.bytezone.diskbrowser.gui.RedoHandler.RedoEvent;
import com.bytezone.diskbrowser.gui.RedoHandler.RedoListener;
import com.bytezone.diskbrowser.gui.TreeBuilder.FileNode;
// -----------------------------------------------------------------------------------//
class CatalogPanel extends JTabbedPane
implements RedoListener, SectorSelectionListener, QuitListener, FontChangeListener,
RootDirectoryChangeListener, DiskTableSelectionListener
// -----------------------------------------------------------------------------------//
{
private static final String prefsLastDiskUsed = "Last disk used";
private static final String prefsLastDosUsed = "Last dos used";
@ -53,7 +55,9 @@ class CatalogPanel extends JTabbedPane
private File rootFolder;
private boolean restored = false;
// ---------------------------------------------------------------------------------//
public CatalogPanel (RedoHandler redoHandler)
// ---------------------------------------------------------------------------------//
{
this.redoHandler = redoHandler;
@ -61,8 +65,10 @@ class CatalogPanel extends JTabbedPane
setPreferredSize (new Dimension (360, 802)); // width, height
}
// ---------------------------------------------------------------------------------//
@Override
public void rootDirectoryChanged (File oldRootFolder, File newRootFolder)
// ---------------------------------------------------------------------------------//
{
rootFolder = newRootFolder;
if (!restored)
@ -76,14 +82,18 @@ class CatalogPanel extends JTabbedPane
setSelectedIndex (0);
}
// ---------------------------------------------------------------------------------//
private void insertFileSystemTab (DiskSelectedEvent diskEvent)
// ---------------------------------------------------------------------------------//
{
fileTab = new FileSystemTab (rootFolder, selector, redoHandler, font, diskEvent);
fileTab.addTreeMouseListener (new MouseListener ()); // listen for disk selection
insertTab ("Disk Tree", null, fileTab, "Display Apple disks", 0);
}
// ---------------------------------------------------------------------------------//
public void activate ()
// ---------------------------------------------------------------------------------//
{
if (fileTab == null)
{
@ -97,13 +107,17 @@ class CatalogPanel extends JTabbedPane
setSelectedIndex (0);
}
// ---------------------------------------------------------------------------------//
void setCloseTabAction (CloseTabAction action)
// ---------------------------------------------------------------------------------//
{
this.closeTabAction = action;
}
// called after a double-click in the fileTab
// ---------------------------------------------------------------------------------//
public void addDiskPanel (FormattedDisk disk, String lastFileUsed, boolean activate)
// ---------------------------------------------------------------------------------//
{
int tabNo = 1;
for (AppleDiskTab tab : diskTabs)
@ -124,7 +138,9 @@ class CatalogPanel extends JTabbedPane
}
// Called from RefreshTreeAction
// ---------------------------------------------------------------------------------//
public void refreshTree ()
// ---------------------------------------------------------------------------------//
{
Tab tab = (Tab) getSelectedComponent ();
tab.refresh ();
@ -135,7 +151,9 @@ class CatalogPanel extends JTabbedPane
}
// Called from CloseTabAction
// ---------------------------------------------------------------------------------//
public void closeCurrentTab ()
// ---------------------------------------------------------------------------------//
{
Tab tab = (Tab) getSelectedComponent ();
if (!(tab instanceof AppleDiskTab) || diskTabs.size () < 2)
@ -151,7 +169,9 @@ class CatalogPanel extends JTabbedPane
checkCloseTabAction ();
}
// ---------------------------------------------------------------------------------//
private void checkCloseTabAction ()
// ---------------------------------------------------------------------------------//
{
Tab tab = (Tab) getSelectedComponent ();
if (diskTabs.size () > 1 && tab instanceof AppleDiskTab)
@ -160,8 +180,10 @@ class CatalogPanel extends JTabbedPane
closeTabAction.setEnabled (false);
}
// ---------------------------------------------------------------------------------//
@Override
public void quit (Preferences prefs)
// ---------------------------------------------------------------------------------//
{
if (fileTab == null)
{
@ -203,7 +225,7 @@ class CatalogPanel extends JTabbedPane
if (event instanceof FileSelectedEvent)
{
AppleFileSource afs = ((FileSelectedEvent) event).file;
AppleFileSource afs = ((FileSelectedEvent) event).appleFileSource;
prefs.put (prefsLastFileUsed, afs == null ? "" : afs.getUniqueName ());
prefs.put (prefsLastSectorsUsed, "");
}
@ -217,15 +239,18 @@ class CatalogPanel extends JTabbedPane
}
}
// ---------------------------------------------------------------------------------//
@Override
public void restore (Preferences prefs)
// ---------------------------------------------------------------------------------//
{
System.out.println ("Started CatalogPanel restore");
String lastDiskUsed = prefs.get (prefsLastDiskUsed, "");
int lastDosUsed = prefs.getInt (prefsLastDosUsed, -1);
String lastFileUsed = prefs.get (prefsLastFileUsed, "");
String lastSectorsUsed = prefs.get (prefsLastSectorsUsed, "");
if (false)
if (true)
{
System.out.println ("Last disk : " + lastDiskUsed);
System.out.println ("Last dos : " + lastDosUsed);
@ -258,6 +283,7 @@ class CatalogPanel extends JTabbedPane
if (!lastFileUsed.isEmpty ())
{
AppleFileSource afs = fd.getFile (lastFileUsed);
System.out.println (afs);
if (afs != null)
{
FileSelectedEvent fileEvent = FileSelectedEvent.create (this, afs);
@ -285,30 +311,41 @@ class CatalogPanel extends JTabbedPane
}
addChangeListener (new TabChangeListener ());
restored = true;
System.out.println ("Finished CatalogPanel restore");
}
// Pass through to DiskSelector
// ---------------------------------------------------------------------------------//
public void addDiskSelectionListener (DiskSelectionListener listener)
// ---------------------------------------------------------------------------------//
{
selector.addDiskSelectionListener (listener);
}
// Pass through to DiskSelector
// ---------------------------------------------------------------------------------//
public void addFileSelectionListener (FileSelectionListener listener)
// ---------------------------------------------------------------------------------//
{
selector.addFileSelectionListener (listener);
}
// Pass through to DiskSelector
// ---------------------------------------------------------------------------------//
public void addFileNodeSelectionListener (FileNodeSelectionListener listener)
// ---------------------------------------------------------------------------------//
{
selector.addFileNodeSelectionListener (listener);
}
// ---------------------------------------------------------------------------------//
private class TabChangeListener implements ChangeListener
// ---------------------------------------------------------------------------------//
{
// -------------------------------------------------------------------------------//
@Override
public void stateChanged (ChangeEvent e)
// -------------------------------------------------------------------------------//
{
Tab tab = (Tab) getSelectedComponent ();
if (tab != null)
@ -319,39 +356,44 @@ class CatalogPanel extends JTabbedPane
}
}
// ---------------------------------------------------------------------------------//
@Override
public void redo (RedoEvent event)
// ---------------------------------------------------------------------------------//
{
System.out.println ("Started redo: " + event.type);
Tab tab = (Tab) getSelectedComponent ();
selector.redo = true;
if (event.type.equals ("DiskEvent"))
switch (event.type)
{
if (tab instanceof FileSystemTab)
((FileSystemTab) tab).redoEvent (event);
case "DiskEvent":
case "FileNodeEvent":
if (tab instanceof FileSystemTab)
((FileSystemTab) tab).redoEvent (event);
break;
case "FileEvent":
if (tab instanceof AppleDiskTab)
((AppleDiskTab) tab).redoEvent (event);
break;
case "SectorEvent":
// don't care
break;
default:
System.out.println ("Unknown event type : " + event.type);
}
else if (event.type.equals ("FileEvent"))
{
if (tab instanceof AppleDiskTab)
((AppleDiskTab) tab).redoEvent (event);
}
else if (event.type.equals ("FileNodeEvent"))
{
if (tab instanceof FileSystemTab)
((FileSystemTab) tab).redoEvent (event);
}
else if (event.type.equals ("SectorEvent"))
{
// don't care
}
else
System.out.println ("Unknown event type : " + event.type);
selector.redo = false;
System.out.println ("Finished redo");
}
// ---------------------------------------------------------------------------------//
@Override
public void sectorSelected (SectorSelectedEvent event)
// ---------------------------------------------------------------------------------//
{
// user has clicked in the DiskLayoutPanel, so turn off any current file selection
Tab tab = (Tab) getSelectedComponent ();
@ -359,8 +401,10 @@ class CatalogPanel extends JTabbedPane
((AppleDiskTab) tab).tree.setSelectionPath (null);
}
// ---------------------------------------------------------------------------------//
@Override
public void changeFont (FontChangeEvent fontChangeEvent)
// ---------------------------------------------------------------------------------//
{
font = fontChangeEvent.font;
if (fileTab != null)
@ -369,10 +413,14 @@ class CatalogPanel extends JTabbedPane
tab.setTreeFont (font);
}
// ---------------------------------------------------------------------------------//
private class MouseListener extends MouseAdapter
// ---------------------------------------------------------------------------------//
{
// -------------------------------------------------------------------------------//
@Override
public void mousePressed (MouseEvent e)
// -------------------------------------------------------------------------------//
{
JTree tree = (JTree) e.getSource ();
int selRow = tree.getRowForLocation (e.getX (), e.getY ());
@ -393,8 +441,10 @@ class CatalogPanel extends JTabbedPane
}
// a disk has been selected from the Disk Duplicates Table
// -------------------------------------------------------------------------------//
@Override
public void diskSelected (DiskDetails diskDetails)
// -------------------------------------------------------------------------------//
{
if (getSelectedIndex () != 0)
setSelectedIndex (0);

2
src/com/bytezone/diskbrowser/gui/DataPanel.java
View File

@ -391,7 +391,7 @@ class DataPanel extends JTabbedPane
@Override
public void fileSelected (FileSelectedEvent event)
{
DataSource dataSource = event.file.getDataSource ();
DataSource dataSource = event.appleFileSource.getDataSource ();
setDataSource (dataSource);
}

4
src/com/bytezone/diskbrowser/gui/DiskLayoutPanel.java
View File

@ -142,9 +142,9 @@ class DiskLayoutPanel extends JPanel
public void fileSelected (FileSelectedEvent event)
{
// This can happen if a file is selected from a dual-dos disk
checkCorrectDisk (event.file.getFormattedDisk ());
checkCorrectDisk (event.appleFileSource.getFormattedDisk ());
diskLayoutImage.setSelection (event.file.getSectors ());
diskLayoutImage.setSelection (event.appleFileSource.getSectors ());
}
class LayoutDetails

1
src/com/bytezone/diskbrowser/gui/DiskSelectedEvent.java
View File

@ -35,6 +35,7 @@ public class DiskSelectedEvent extends EventObject
public static DiskSelectedEvent create (Object source, String path)
{
FormattedDisk formattedDisk = DiskFactory.createDisk (path);
System.out.println (formattedDisk);
return formattedDisk == null ? null : new DiskSelectedEvent (source, formattedDisk);
}
}

14
src/com/bytezone/diskbrowser/gui/FileSelectedEvent.java
View File

@ -7,30 +7,30 @@ import com.bytezone.diskbrowser.disk.DualDosDisk;
public class FileSelectedEvent extends EventObject
{
public final AppleFileSource file;
public final AppleFileSource appleFileSource;
boolean redo;
public FileSelectedEvent (Object source, AppleFileSource file)
public FileSelectedEvent (Object source, AppleFileSource appleFileSource)
{
super (source);
this.file = file;
this.appleFileSource = appleFileSource;
// If a file is selected from a disk which is contained in a Dual-dos disk, then the DDS
// must be told so that it can ensure its internal currentDisk is set correctly
DualDosDisk ddd = (DualDosDisk) file.getFormattedDisk ().getParent ();
DualDosDisk ddd = (DualDosDisk) appleFileSource.getFormattedDisk ().getParent ();
if (ddd != null)
ddd.setCurrentDisk (file);
ddd.setCurrentDisk (appleFileSource.getFormattedDisk ());
}
@Override
public String toString ()
{
return file.getUniqueName ();
return appleFileSource.getUniqueName ();
}
public String toText ()
{
return file.getUniqueName ();
return appleFileSource.getUniqueName ();
}
public static FileSelectedEvent create (Object source, AppleFileSource afs)

4
src/com/bytezone/diskbrowser/gui/MenuHandler.java
View File

@ -447,9 +447,9 @@ public class MenuHandler
public void fileSelected (FileSelectedEvent event)
{
// This can happen if a file is selected from a dual-dos disk
if (event.file.getFormattedDisk () != currentDisk)
if (event.appleFileSource.getFormattedDisk () != currentDisk)
{
currentDisk = event.file.getFormattedDisk ();
currentDisk = event.appleFileSource.getFormattedDisk ();
adjustMenus (currentDisk);
}
}

73
src/com/bytezone/diskbrowser/gui/RedoHandler.java
View File

@ -12,8 +12,11 @@ import java.util.List;
import javax.swing.*;
import javax.swing.event.EventListenerList;
class RedoHandler implements FileSelectionListener, DiskSelectionListener,
SectorSelectionListener, FileNodeSelectionListener
// -----------------------------------------------------------------------------------//
class RedoHandler
implements FileSelectionListener, DiskSelectionListener, SectorSelectionListener,
FileNodeSelectionListener
// -----------------------------------------------------------------------------------//
{
private static final String base = "/com/bytezone/diskbrowser/icons/";
EventListenerList listenerList = new EventListenerList ();
@ -22,7 +25,9 @@ class RedoHandler implements FileSelectionListener, DiskSelectionListener,
RedoData redoData = new RedoData (leftAction, rightAction);
static int id = 0;
// ---------------------------------------------------------------------------------//
public RedoHandler (JRootPane jRootPane, JToolBar toolBar)
// ---------------------------------------------------------------------------------//
{
// This code works as long as the toolBar arrows have focus first
InputMap inputMap = jRootPane.getInputMap (JComponent.WHEN_IN_FOCUSED_WINDOW);
@ -39,14 +44,18 @@ class RedoHandler implements FileSelectionListener, DiskSelectionListener,
toolBar.add (rightAction);
}
// ---------------------------------------------------------------------------------//
public RedoData createData ()
// ---------------------------------------------------------------------------------//
{
RedoData data = new RedoData (leftAction, rightAction);
this.redoData = data; // doesn't fire an event this way
return data;
}
// ---------------------------------------------------------------------------------//
public void setCurrentData (RedoData data)
// ---------------------------------------------------------------------------------//
{
this.redoData = data;
RedoEvent event = redoData.getCurrentEvent ();
@ -54,83 +63,111 @@ class RedoHandler implements FileSelectionListener, DiskSelectionListener,
fireRedoEvent (event);
}
// ---------------------------------------------------------------------------------//
private void fireRedoEvent (RedoEvent event)
// ---------------------------------------------------------------------------------//
{
RedoListener[] listeners = (listenerList.getListeners (RedoListener.class));
for (RedoListener listener : listeners)
listener.redo (event);
}
// ---------------------------------------------------------------------------------//
public void addRedoListener (RedoListener listener)
// ---------------------------------------------------------------------------------//
{
listenerList.add (RedoListener.class, listener);
}
// ---------------------------------------------------------------------------------//
public void removeRedoListener (RedoListener listener)
// ---------------------------------------------------------------------------------//
{
listenerList.remove (RedoListener.class, listener);
}
// ---------------------------------------------------------------------------------//
@Override
public void diskSelected (DiskSelectedEvent event)
// ---------------------------------------------------------------------------------//
{
if (!event.redo) // it's an event we just caused
if (!event.redo) // it's an event we just caused
addEvent (new RedoEvent ("DiskEvent", event));
}
// ---------------------------------------------------------------------------------//
@Override
public void fileNodeSelected (FileNodeSelectedEvent event)
// ---------------------------------------------------------------------------------//
{
if (!event.redo) // it's an event we just caused
if (!event.redo) // it's an event we just caused
addEvent (new RedoEvent ("FileNodeEvent", event));
}
// ---------------------------------------------------------------------------------//
@Override
public void fileSelected (FileSelectedEvent event)
// ---------------------------------------------------------------------------------//
{
if (!event.redo) // it's an event we just caused
if (!event.redo) // it's an event we just caused
addEvent (new RedoEvent ("FileEvent", event));
}
// ---------------------------------------------------------------------------------//
@Override
public void sectorSelected (SectorSelectedEvent event)
// ---------------------------------------------------------------------------------//
{
if (!event.redo) // it's an event we just caused
if (!event.redo) // it's an event we just caused
addEvent (new RedoEvent ("SectorEvent", event));
}
// ---------------------------------------------------------------------------------//
private void addEvent (RedoEvent event)
// ---------------------------------------------------------------------------------//
{
redoData.addEvent (event);
}
// ---------------------------------------------------------------------------------//
public class RedoEvent extends EventObject
// ---------------------------------------------------------------------------------//
{
String type;
EventObject value;
// -------------------------------------------------------------------------------//
public RedoEvent (String type, EventObject value)
// -------------------------------------------------------------------------------//
{
super (RedoHandler.this);
this.type = type;
this.value = value;
}
// -------------------------------------------------------------------------------//
@Override
public String toString ()
// -------------------------------------------------------------------------------//
{
return ("[type=" + type + ", value=" + value + "]");
}
}
// ---------------------------------------------------------------------------------//
public interface RedoListener extends EventListener
// ---------------------------------------------------------------------------------//
{
void redo (RedoEvent event);
}
// ---------------------------------------------------------------------------------//
class LeftAction extends AbstractAction
// ---------------------------------------------------------------------------------//
{
// -------------------------------------------------------------------------------//
public LeftAction ()
// -------------------------------------------------------------------------------//
{
super ("Back");
putValue (Action.SHORT_DESCRIPTION, "Undo selection");
@ -139,16 +176,22 @@ class RedoHandler implements FileSelectionListener, DiskSelectionListener,
putValue (Action.LARGE_ICON_KEY, new ImageIcon (url));
}
// -------------------------------------------------------------------------------//
@Override
public void actionPerformed (ActionEvent e)
// -------------------------------------------------------------------------------//
{
fireRedoEvent (redoData.getPreviousEvent ());
}
}
// ---------------------------------------------------------------------------------//
class RightAction extends AbstractAction
// ---------------------------------------------------------------------------------//
{
// -------------------------------------------------------------------------------//
public RightAction ()
// -------------------------------------------------------------------------------//
{
super ("Forward");
putValue (Action.SHORT_DESCRIPTION, "Redo selection");
@ -157,14 +200,18 @@ class RedoHandler implements FileSelectionListener, DiskSelectionListener,
putValue (Action.LARGE_ICON_KEY, new ImageIcon (url));
}
// -------------------------------------------------------------------------------//
@Override
public void actionPerformed (ActionEvent e)
// -------------------------------------------------------------------------------//
{
fireRedoEvent (redoData.getNextEvent ());
}
}
// ---------------------------------------------------------------------------------//
class RedoData
// ---------------------------------------------------------------------------------//
{
List<RedoEvent> events = new ArrayList<RedoEvent> ();
int currentEvent = -1;
@ -172,14 +219,18 @@ class RedoHandler implements FileSelectionListener, DiskSelectionListener,
Action rightAction;
final int seq = id++;
// -------------------------------------------------------------------------------//
public RedoData (Action left, Action right)
// -------------------------------------------------------------------------------//
{
leftAction = left;
rightAction = right;
setArrows ();
}
// -------------------------------------------------------------------------------//
RedoEvent getCurrentEvent ()
// -------------------------------------------------------------------------------//
{
if (currentEvent < 0)
return null;
@ -187,21 +238,27 @@ class RedoHandler implements FileSelectionListener, DiskSelectionListener,
return events.get (currentEvent);
}
// -------------------------------------------------------------------------------//
RedoEvent getNextEvent ()
// -------------------------------------------------------------------------------//
{
RedoEvent event = events.get (++currentEvent);
setArrows ();
return event;
}
// -------------------------------------------------------------------------------//
RedoEvent getPreviousEvent ()
// -------------------------------------------------------------------------------//
{
RedoEvent event = events.get (--currentEvent);
setArrows ();
return event;
}
// -------------------------------------------------------------------------------//
void addEvent (RedoEvent event)
// -------------------------------------------------------------------------------//
{
while (currentEvent < events.size () - 1)
events.remove (events.size () - 1);
@ -210,14 +267,18 @@ class RedoHandler implements FileSelectionListener, DiskSelectionListener,
setArrows ();
}
// -------------------------------------------------------------------------------//
private void setArrows ()
// -------------------------------------------------------------------------------//
{
rightAction.setEnabled (currentEvent < events.size () - 1);
leftAction.setEnabled (currentEvent > 0);
}
// -------------------------------------------------------------------------------//
@Override
public String toString ()
// -------------------------------------------------------------------------------//
{
StringBuilder text = new StringBuilder ();
text.append ("Current event (" + seq + ") : " + currentEvent + "\n");