837 lines
27 KiB
Java
837 lines
27 KiB
Java
/*
|
|
* AppleCommander - An Apple ][ image utility.
|
|
* Copyright (C) 2002 by Robert Greene
|
|
* robgreene at users.sourceforge.net
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
package com.webcodepro.applecommander.ui.swt;
|
|
|
|
import java.io.File;
|
|
import java.io.FileOutputStream;
|
|
import java.io.OutputStream;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import com.webcodepro.applecommander.storage.AppleWorksWordProcessorFileFilter;
|
|
import com.webcodepro.applecommander.storage.ApplesoftFileFilter;
|
|
import com.webcodepro.applecommander.storage.BinaryFileFilter;
|
|
import com.webcodepro.applecommander.storage.FileEntry;
|
|
import com.webcodepro.applecommander.storage.FileEntryComparator;
|
|
import com.webcodepro.applecommander.storage.FileFilter;
|
|
import com.webcodepro.applecommander.storage.FormattedDisk;
|
|
import com.webcodepro.applecommander.storage.GraphicsFileFilter;
|
|
import com.webcodepro.applecommander.storage.IntegerBasicFileFilter;
|
|
import com.webcodepro.applecommander.storage.TextFileFilter;
|
|
import com.webcodepro.applecommander.storage.FormattedDisk.FileColumnHeader;
|
|
import com.webcodepro.applecommander.ui.UserPreferences;
|
|
|
|
import org.eclipse.swt.SWT;
|
|
import org.eclipse.swt.custom.CTabFolder;
|
|
import org.eclipse.swt.custom.CTabItem;
|
|
import org.eclipse.swt.custom.SashForm;
|
|
import org.eclipse.swt.events.MenuAdapter;
|
|
import org.eclipse.swt.events.MenuEvent;
|
|
import org.eclipse.swt.events.SelectionAdapter;
|
|
import org.eclipse.swt.events.SelectionEvent;
|
|
import org.eclipse.swt.events.SelectionListener;
|
|
import org.eclipse.swt.graphics.GC;
|
|
import org.eclipse.swt.layout.GridData;
|
|
import org.eclipse.swt.layout.GridLayout;
|
|
import org.eclipse.swt.widgets.Composite;
|
|
import org.eclipse.swt.widgets.FileDialog;
|
|
import org.eclipse.swt.widgets.Menu;
|
|
import org.eclipse.swt.widgets.MenuItem;
|
|
import org.eclipse.swt.widgets.MessageBox;
|
|
import org.eclipse.swt.widgets.Shell;
|
|
import org.eclipse.swt.widgets.Table;
|
|
import org.eclipse.swt.widgets.TableColumn;
|
|
import org.eclipse.swt.widgets.TableItem;
|
|
import org.eclipse.swt.widgets.ToolBar;
|
|
import org.eclipse.swt.widgets.ToolItem;
|
|
import org.eclipse.swt.widgets.Tree;
|
|
import org.eclipse.swt.widgets.TreeItem;
|
|
|
|
/**
|
|
* Build the Disk File tab for the Disk Window.
|
|
* <p>
|
|
* Date created: Nov 17, 2002 9:46:53 PM
|
|
* @author: Rob Greene
|
|
*/
|
|
public class DiskExplorerTab {
|
|
private Shell shell;
|
|
private SashForm sashForm;
|
|
private Tree directoryTree;
|
|
private Table fileTable;
|
|
private ToolBar toolBar;
|
|
private ToolItem exportToolItem;
|
|
private ToolItem importToolItem;
|
|
private ToolItem deleteToolItem;
|
|
private ImageManager imageManager;
|
|
|
|
private UserPreferences userPreferences = UserPreferences.getInstance();
|
|
private FormattedDisk disk;
|
|
private FileFilter fileFilter;
|
|
private GraphicsFileFilter graphicsFilter = new GraphicsFileFilter();
|
|
private AppleWorksWordProcessorFileFilter awpFilter = new AppleWorksWordProcessorFileFilter();
|
|
|
|
private int currentFormat = FormattedDisk.FILE_DISPLAY_STANDARD;
|
|
private boolean formatChanged;
|
|
private List currentFileList;
|
|
private Map columnWidths = new HashMap();
|
|
private boolean showDeletedFiles;
|
|
/**
|
|
* Create the DISK INFO tab.
|
|
*/
|
|
public DiskExplorerTab(CTabFolder tabFolder, FormattedDisk disk, ImageManager imageManager) {
|
|
this.disk = disk;
|
|
this.shell = tabFolder.getShell();
|
|
this.imageManager = imageManager;
|
|
|
|
createFilesTab(tabFolder);
|
|
}
|
|
/**
|
|
* Dispose of resources.
|
|
*/
|
|
public void dispose() {
|
|
sashForm.dispose();
|
|
directoryTree.dispose();
|
|
fileTable.dispose();
|
|
exportToolItem.dispose();
|
|
importToolItem.dispose();
|
|
deleteToolItem.dispose();
|
|
toolBar.dispose();
|
|
|
|
directoryTree = null;
|
|
fileTable = null;
|
|
currentFileList = null;
|
|
}
|
|
/**
|
|
* Create the FILES tab.
|
|
*/
|
|
protected void createFilesTab(CTabFolder tabFolder) {
|
|
CTabItem ctabitem = new CTabItem(tabFolder, SWT.NULL);
|
|
ctabitem.setText("Files");
|
|
|
|
Composite composite = new Composite(tabFolder, SWT.NULL);
|
|
ctabitem.setControl(composite);
|
|
GridLayout gridLayout = new GridLayout(1, false);
|
|
composite.setLayout(gridLayout);
|
|
|
|
GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
|
|
createFileToolBar(composite, gridData);
|
|
|
|
sashForm = new SashForm(composite, SWT.NONE);
|
|
sashForm.setOrientation(SWT.HORIZONTAL);
|
|
gridData = new GridData(GridData.FILL_BOTH);
|
|
gridData.horizontalSpan = 2;
|
|
sashForm.setLayoutData(gridData);
|
|
|
|
directoryTree = new Tree(sashForm, SWT.SINGLE | SWT.BORDER);
|
|
directoryTree.setMenu(createDirectoryPopupMenu());
|
|
directoryTree.addSelectionListener(new SelectionListener() {
|
|
/**
|
|
* Single-click handler.
|
|
*/
|
|
public void widgetSelected(SelectionEvent event) {
|
|
changeCurrentFormat(currentFormat); // minor hack
|
|
}
|
|
/**
|
|
* Double-click handler.
|
|
*/
|
|
public void widgetDefaultSelected(SelectionEvent event) {
|
|
Tree item = (Tree) event.getSource();
|
|
TreeItem[] treeItem = item.getSelection();
|
|
treeItem[0].setExpanded(!treeItem[0].getExpanded());
|
|
}
|
|
});
|
|
|
|
fileTable = new Table(sashForm, SWT.MULTI | SWT.FULL_SELECTION | SWT.BORDER);
|
|
fileTable.setHeaderVisible(true);
|
|
|
|
sashForm.setWeights(new int[] {1,2});
|
|
|
|
TreeItem diskItem = new TreeItem(directoryTree, SWT.BORDER);
|
|
diskItem.setText(disk.getDiskName());
|
|
diskItem.setData(disk);
|
|
directoryTree.setSelection(new TreeItem[] { diskItem });
|
|
|
|
if (disk.canHaveDirectories()) {
|
|
Iterator files = disk.getFiles().iterator();
|
|
while (files.hasNext()) {
|
|
FileEntry entry = (FileEntry) files.next();
|
|
if (entry.isDirectory()) {
|
|
TreeItem item = new TreeItem(diskItem, SWT.BORDER);
|
|
item.setText(entry.getFilename());
|
|
item.setData(entry);
|
|
addDirectoriesToTree(item, entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
computeColumnWidths(FormattedDisk.FILE_DISPLAY_STANDARD);
|
|
computeColumnWidths(FormattedDisk.FILE_DISPLAY_NATIVE);
|
|
computeColumnWidths(FormattedDisk.FILE_DISPLAY_DETAIL);
|
|
|
|
formatChanged = true;
|
|
fillFileTable(disk.getFiles());
|
|
}
|
|
/**
|
|
* Construct the popup menu for the directory table on the File tab.
|
|
*/
|
|
protected Menu createDirectoryPopupMenu() {
|
|
Menu menu = new Menu(shell, SWT.POP_UP);
|
|
|
|
MenuItem item = new MenuItem(menu, SWT.CASCADE);
|
|
item.setText("Expand");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
TreeItem[] treeItem = directoryTree.getSelection();
|
|
treeItem[0].setExpanded(true);
|
|
}
|
|
});
|
|
item.setEnabled(disk.canHaveDirectories());
|
|
|
|
item = new MenuItem(menu, SWT.CASCADE);
|
|
item.setText("Collapse");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
TreeItem[] treeItem = directoryTree.getSelection();
|
|
treeItem[0].setExpanded(false);
|
|
}
|
|
});
|
|
item.setEnabled(disk.canHaveDirectories());
|
|
|
|
item = new MenuItem(menu, SWT.SEPARATOR);
|
|
|
|
item = new MenuItem(menu, SWT.CASCADE);
|
|
item.setText("Expand All");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
TreeItem[] treeItem = directoryTree.getSelection();
|
|
setDirectoryExpandedStates(treeItem[0], true);
|
|
}
|
|
});
|
|
item.setEnabled(disk.canHaveDirectories());
|
|
|
|
item = new MenuItem(menu, SWT.CASCADE);
|
|
item.setText("Collapse All");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
TreeItem[] treeItem = directoryTree.getSelection();
|
|
setDirectoryExpandedStates(treeItem[0], false);
|
|
}
|
|
});
|
|
item.setEnabled(disk.canHaveDirectories());
|
|
|
|
return menu;
|
|
}
|
|
/**
|
|
* Construct the popup menu for the file table on the File tab.
|
|
*/
|
|
protected Menu createFilePopupMenu() {
|
|
Menu menu = new Menu(shell, SWT.POP_UP);
|
|
|
|
MenuItem item = new MenuItem(menu, SWT.CASCADE);
|
|
item.setText("Import...");
|
|
item.setEnabled(disk.canCreateFile() && disk.canWriteFileData());
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
// FIXME
|
|
}
|
|
});
|
|
|
|
item = new MenuItem(menu, SWT.CASCADE);
|
|
item.setText("Export");
|
|
item.setEnabled(disk.canReadFileData());
|
|
item.setMenu(createFileExportMenu(SWT.DROP_DOWN));
|
|
|
|
item = new MenuItem(menu, SWT.SEPARATOR);
|
|
|
|
item = new MenuItem(menu, SWT.CASCADE);
|
|
item.setText("Delete...");
|
|
item.setEnabled(disk.canDeleteFile());
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
// FIXME
|
|
}
|
|
});
|
|
|
|
return menu;
|
|
}
|
|
/**
|
|
* Construct the popup menu for the export button on the toolbar.
|
|
*/
|
|
protected Menu createFileExportMenu(int style) {
|
|
Menu menu = new Menu(shell, style);
|
|
|
|
MenuItem item = new MenuItem(menu, SWT.NONE);
|
|
item.setText("Raw disk data...");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
fileFilter = null;
|
|
exportFile(null);
|
|
}
|
|
});
|
|
|
|
item = new MenuItem(menu, SWT.NONE);
|
|
item.setText("Binary...");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
fileFilter = new BinaryFileFilter();
|
|
exportFile(null);
|
|
}
|
|
});
|
|
|
|
item = new MenuItem(menu, SWT.NONE);
|
|
item.setText("Applesoft Basic...");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
fileFilter = new ApplesoftFileFilter();
|
|
exportFile(null);
|
|
}
|
|
});
|
|
|
|
item = new MenuItem(menu, SWT.NONE);
|
|
item.setText("Integer Basic...");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
fileFilter = new IntegerBasicFileFilter();
|
|
exportFile(null);
|
|
}
|
|
});
|
|
|
|
item = new MenuItem(menu, SWT.NONE);
|
|
item.setText("ASCII Text...");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
fileFilter = new TextFileFilter();
|
|
exportFile(null);
|
|
}
|
|
});
|
|
|
|
item = new MenuItem(menu, SWT.SEPARATOR);
|
|
|
|
item = new MenuItem(menu, SWT.NONE);
|
|
item.setText("AppleWorks WordProcessor File...");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
fileFilter = awpFilter;
|
|
exportFile(null);
|
|
}
|
|
});
|
|
item = new MenuItem(menu, SWT.CASCADE);
|
|
item.setText("Rendering");
|
|
Menu subMenu = new Menu(shell, SWT.DROP_DOWN);
|
|
item.setMenu(subMenu);
|
|
subMenu.addMenuListener(new MenuAdapter() {
|
|
/**
|
|
* Toggle all sub-menu MenuItems to the proper state to reflect
|
|
* the current file extension chosen.
|
|
*/
|
|
public void menuShown(MenuEvent event) {
|
|
Menu theMenu = (Menu) event.getSource();
|
|
MenuItem[] subItems = theMenu.getItems();
|
|
subItems[0].setSelection(awpFilter.isTextRendering());
|
|
subItems[1].setSelection(awpFilter.isHtmlRendering());
|
|
}
|
|
});
|
|
item = new MenuItem(subMenu, SWT.RADIO);
|
|
item.setText("Text");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
/**
|
|
* Set the appropriate rendering style.
|
|
*/
|
|
public void widgetSelected(SelectionEvent event) {
|
|
awpFilter.setRendering(AppleWorksWordProcessorFileFilter.RENDER_AS_TEXT);
|
|
}
|
|
});
|
|
item = new MenuItem(subMenu, SWT.RADIO);
|
|
item.setText("HTML");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
/**
|
|
* Set the appropriate rendering style.
|
|
*/
|
|
public void widgetSelected(SelectionEvent event) {
|
|
awpFilter.setRendering(AppleWorksWordProcessorFileFilter.RENDER_AS_HTML);
|
|
}
|
|
});
|
|
|
|
item = new MenuItem(menu, SWT.SEPARATOR);
|
|
|
|
item = new MenuItem(menu, SWT.NONE);
|
|
item.setText("Graphics...");
|
|
item.setEnabled(graphicsFilter.isCodecAvailable());
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
fileFilter = graphicsFilter;
|
|
exportFile(null);
|
|
}
|
|
});
|
|
|
|
// Add graphics mode
|
|
item = new MenuItem(menu, SWT.CASCADE);
|
|
item.setText("Mode");
|
|
item.setEnabled(graphicsFilter.isCodecAvailable());
|
|
subMenu = new Menu(shell, SWT.DROP_DOWN);
|
|
item.setMenu(subMenu);
|
|
subMenu.addMenuListener(new MenuAdapter() {
|
|
/**
|
|
* Toggle all sub-menu MenuItems to the proper state to reflect
|
|
* the current file extension chosen.
|
|
*/
|
|
public void menuShown(MenuEvent event) {
|
|
Menu theMenu = (Menu) event.getSource();
|
|
MenuItem[] subItems = theMenu.getItems();
|
|
subItems[0].setSelection(graphicsFilter.isHiresBlackAndWhiteMode());
|
|
subItems[1].setSelection(graphicsFilter.isHiresColorMode());
|
|
subItems[2].setSelection(graphicsFilter.isDoubleHiresBlackAndWhiteMode());
|
|
subItems[3].setSelection(graphicsFilter.isDoubleHiresColorMode());
|
|
}
|
|
});
|
|
item = new MenuItem(subMenu, SWT.RADIO);
|
|
item.setText("Hi-Res B&W");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
/**
|
|
* Set the appropriate graphics mode.
|
|
*/
|
|
public void widgetSelected(SelectionEvent event) {
|
|
graphicsFilter.setMode(GraphicsFileFilter.MODE_HGR_BLACK_AND_WHITE);
|
|
}
|
|
});
|
|
item = new MenuItem(subMenu, SWT.RADIO);
|
|
item.setText("Hi-Res Color");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
/**
|
|
* Set the appropriate graphics mode.
|
|
*/
|
|
public void widgetSelected(SelectionEvent event) {
|
|
graphicsFilter.setMode(GraphicsFileFilter.MODE_HGR_COLOR);
|
|
}
|
|
});
|
|
item = new MenuItem(subMenu, SWT.RADIO);
|
|
item.setText("Double Hi-Res B&W");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
/**
|
|
* Set the appropriate graphics mode.
|
|
*/
|
|
public void widgetSelected(SelectionEvent event) {
|
|
graphicsFilter.setMode(GraphicsFileFilter.MODE_DHR_BLACK_AND_WHITE);
|
|
}
|
|
});
|
|
item = new MenuItem(subMenu, SWT.RADIO);
|
|
item.setText("Double Hi-Res COLOR");
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
/**
|
|
* Set the appropriate graphics mode.
|
|
*/
|
|
public void widgetSelected(SelectionEvent event) {
|
|
graphicsFilter.setMode(GraphicsFileFilter.MODE_DHR_COLOR);
|
|
}
|
|
});
|
|
|
|
// Add graphics formats, if any are defined.
|
|
String[] formats = graphicsFilter.getFileExtensions();
|
|
if (formats != null && formats.length > 0) {
|
|
item = new MenuItem(menu, SWT.CASCADE);
|
|
item.setText("Format");
|
|
item.setEnabled(graphicsFilter.isCodecAvailable());
|
|
subMenu = new Menu(shell, SWT.DROP_DOWN);
|
|
item.setMenu(subMenu);
|
|
subMenu.addMenuListener(new MenuAdapter() {
|
|
/**
|
|
* Toggle all sub-menu MenuItems to the proper state to reflect
|
|
* the current file extension chosen.
|
|
*/
|
|
public void menuShown(MenuEvent event) {
|
|
Menu theMenu = (Menu) event.getSource();
|
|
MenuItem[] subItems = theMenu.getItems();
|
|
for (int i=0; i<subItems.length; i++) {
|
|
subItems[i].setSelection(subItems[i].getText().
|
|
equals(graphicsFilter.getExtension()));
|
|
}
|
|
}
|
|
});
|
|
// Add all graphics formats...
|
|
for (int i=0; i<formats.length; i++) {
|
|
item = new MenuItem(subMenu, SWT.RADIO);
|
|
item.setText(formats[i]);
|
|
item.addSelectionListener(new SelectionAdapter() {
|
|
/**
|
|
* Set the file extension to use.
|
|
*/
|
|
public void widgetSelected(SelectionEvent event) {
|
|
MenuItem menuItem = (MenuItem) event.getSource();
|
|
graphicsFilter.setExtension(menuItem.getText());
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
return menu;
|
|
}
|
|
/**
|
|
* Change the "expanded" state of the node.
|
|
*/
|
|
protected void setDirectoryExpandedStates(TreeItem treeItem, boolean expand) {
|
|
treeItem.setExpanded(expand);
|
|
TreeItem[] treeItems = treeItem.getItems();
|
|
for (int i=0; i<treeItems.length; i++) {
|
|
setDirectoryExpandedStates(treeItems[i], expand);
|
|
}
|
|
}
|
|
/**
|
|
* Pre-compute column widths for the file tab.
|
|
* These can and are over-ridden by user sizing.
|
|
*/
|
|
protected void computeColumnWidths(int format) {
|
|
List headers = disk.getFileColumnHeaders(format);
|
|
int[] headerWidths = new int[headers.size()];
|
|
GC gc = new GC(shell);
|
|
for (int i=0; i<headers.size(); i++) {
|
|
FileColumnHeader header = (FileColumnHeader) headers.get(i);
|
|
if (header.getTitle().length() >= header.getMaximumWidth()) {
|
|
headerWidths[i] = gc.stringExtent(header.getTitle()).x + gc.stringExtent("WW").x;
|
|
} else {
|
|
headerWidths[i] = gc.stringExtent("W").x * header.getMaximumWidth();
|
|
}
|
|
}
|
|
gc.dispose();
|
|
gc = null;
|
|
columnWidths.put(new Integer(format), headerWidths);
|
|
}
|
|
/**
|
|
* Preserve the column widths.
|
|
*/
|
|
protected void preserveColumnWidths() {
|
|
TableColumn[] columns = fileTable.getColumns();
|
|
int[] widths = new int[columns.length];
|
|
for (int i=0; i<columns.length; i++) {
|
|
widths[i] = columns[i].getWidth();
|
|
}
|
|
columnWidths.put(new Integer(currentFormat), widths);
|
|
}
|
|
/**
|
|
* Display files in the fileTable.
|
|
*/
|
|
protected void fillFileTable(List fileList) {
|
|
int[] weights = sashForm.getWeights();
|
|
|
|
if (formatChanged) {
|
|
fileTable.dispose();
|
|
fileTable = new Table(sashForm, SWT.MULTI | SWT.FULL_SELECTION | SWT.BORDER);
|
|
fileTable.setHeaderVisible(true);
|
|
fileTable.setMenu(createFilePopupMenu());
|
|
fileTable.addSelectionListener(new SelectionListener() {
|
|
/**
|
|
* Single-click handler.
|
|
*/
|
|
public void widgetSelected(SelectionEvent event) {
|
|
if (fileTable.getSelectionCount() > 0) {
|
|
exportToolItem.setEnabled(disk.canReadFileData());
|
|
importToolItem.setEnabled(disk.canCreateFile() && disk.canWriteFileData());
|
|
deleteToolItem.setEnabled(disk.canDeleteFile());
|
|
} else {
|
|
exportToolItem.setEnabled(false);
|
|
importToolItem.setEnabled(false);
|
|
deleteToolItem.setEnabled(false);
|
|
}
|
|
}
|
|
/**
|
|
* Double-click handler.
|
|
*/
|
|
public void widgetDefaultSelected(SelectionEvent event) {
|
|
// No action defined at this time
|
|
}
|
|
});
|
|
TableColumn column = null;
|
|
List headers = disk.getFileColumnHeaders(currentFormat);
|
|
int[] widths = (int[])columnWidths.get(new Integer(currentFormat));
|
|
for (int i=0; i<headers.size(); i++) {
|
|
FileColumnHeader header = (FileColumnHeader) headers.get(i);
|
|
int align = header.isCenterAlign() ? SWT.CENTER :
|
|
header.isLeftAlign() ? SWT.LEFT : SWT.RIGHT;
|
|
column = new TableColumn(fileTable, align);
|
|
column.setText(header.getTitle());
|
|
column.setWidth(widths[i]);
|
|
final int columnIndex = i;
|
|
column.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
sortFileTable(columnIndex);
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
fileTable.removeAll();
|
|
}
|
|
|
|
Iterator files = fileList.iterator();
|
|
while (files.hasNext()) {
|
|
FileEntry entry = (FileEntry) files.next();
|
|
if (showDeletedFiles || !entry.isDeleted()) {
|
|
TableItem item = new TableItem(fileTable, 0);
|
|
List data = entry.getFileColumnData(currentFormat);
|
|
for (int i=0; i<data.size(); i++) {
|
|
item.setText(i, (String)data.get(i));
|
|
}
|
|
item.setData(entry);
|
|
}
|
|
}
|
|
|
|
sashForm.setWeights(weights);
|
|
formatChanged = false;
|
|
currentFileList = fileList;
|
|
|
|
// disable all file-leve operations:
|
|
exportToolItem.setEnabled(false);
|
|
importToolItem.setEnabled(false);
|
|
deleteToolItem.setEnabled(false);
|
|
}
|
|
/**
|
|
* Export all selected files.
|
|
*/
|
|
private void exportFile(String directory) {
|
|
boolean promptForIndividualFiles = (directory == null);
|
|
TableItem[] selection = fileTable.getSelection();
|
|
for (int i=0; i<selection.length; i++) {
|
|
TableItem tableItem = selection[i];
|
|
FileEntry fileEntry = (FileEntry) tableItem.getData();
|
|
String filename = null;
|
|
if (promptForIndividualFiles) {
|
|
FileDialog fileDialog = new FileDialog(shell, SWT.SAVE);
|
|
fileDialog.setFilterPath(userPreferences.getExportDirectory());
|
|
if (fileFilter != null) {
|
|
fileDialog.setFileName(fileFilter.getSuggestedFileName(fileEntry));
|
|
} else {
|
|
fileDialog.setFileName(fileEntry.getFilename());
|
|
}
|
|
filename = fileDialog.open();
|
|
directory = fileDialog.getFilterPath();
|
|
} else {
|
|
filename = directory + File.separator + fileFilter.getSuggestedFileName(fileEntry);
|
|
}
|
|
if (filename != null) {
|
|
userPreferences.setExportDirectory(directory);
|
|
try {
|
|
File file = new File(filename);
|
|
if (file.exists()) {
|
|
Shell finalShell = shell;
|
|
MessageBox box = new MessageBox(finalShell, SWT.ICON_QUESTION | SWT.YES | SWT.NO);
|
|
box.setText("File already exists!");
|
|
box.setMessage(
|
|
"The file '" + filename + "' already exists. "
|
|
+ "Do you want to over-write it?");
|
|
if (box.open() == SWT.NO) {
|
|
return; // do not overwrite file
|
|
}
|
|
}
|
|
byte[] data = null;
|
|
if (fileFilter != null) {
|
|
data = fileFilter.filter(fileEntry);
|
|
} else {
|
|
data = disk.getFileData(fileEntry);
|
|
}
|
|
OutputStream outputStream = new FileOutputStream(file);
|
|
outputStream.write(data);
|
|
outputStream.close();
|
|
} catch (Exception ex) {
|
|
Shell finalShell = shell;
|
|
String errorMessage = ex.getMessage();
|
|
if (errorMessage == null) {
|
|
errorMessage = ex.getClass().getName();
|
|
}
|
|
MessageBox box = new MessageBox(finalShell,
|
|
SWT.ICON_ERROR | SWT.OK | SWT.CANCEL);
|
|
box.setText("Unable to export file data!");
|
|
box.setMessage(
|
|
"Unable to export '" + filename + "'.\n\n"
|
|
+ "AppleCommander was unable to save the disk\n"
|
|
+ "data. The system error given was '"
|
|
+ errorMessage + "'\n\n"
|
|
+ "Sorry!\n\n"
|
|
+ "Press OK to continue export or CANCEL to cancel export.");
|
|
int button = box.open();
|
|
if (button == SWT.CANCEL) break; // break out of loop
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Sort the file table by the specified columnIndex.
|
|
*/
|
|
protected void sortFileTable(int columnIndex) {
|
|
Collections.sort(currentFileList, new FileEntryComparator(columnIndex, currentFormat));
|
|
fillFileTable(currentFileList);
|
|
}
|
|
/**
|
|
* Helper function for building fileTree.
|
|
*/
|
|
protected void addDirectoriesToTree(TreeItem directoryItem, FileEntry directoryEntry) {
|
|
Iterator files = directoryEntry.getFiles().iterator();
|
|
while (files.hasNext()) {
|
|
final FileEntry entry = (FileEntry) files.next();
|
|
if (entry.isDirectory()) {
|
|
TreeItem item = new TreeItem(directoryItem, SWT.BORDER);
|
|
item.setText(entry.getFilename());
|
|
item.setData(entry);
|
|
addDirectoriesToTree(item, entry);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Creates the FILE tab toolbar.
|
|
*/
|
|
private void createFileToolBar(Composite composite, Object layoutData) {
|
|
toolBar = new ToolBar(composite, SWT.FLAT);
|
|
if (layoutData != null) toolBar.setLayoutData(layoutData);
|
|
|
|
ToolItem item = new ToolItem(toolBar, SWT.RADIO);
|
|
item.setImage(imageManager.getStandardFileViewIcon());
|
|
item.setText("Standard");
|
|
item.setToolTipText("Displays files in standard format");
|
|
item.setSelection(true);
|
|
item.addSelectionListener(new SelectionAdapter () {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
changeCurrentFormat(FormattedDisk.FILE_DISPLAY_STANDARD);
|
|
}
|
|
});
|
|
item = new ToolItem(toolBar, SWT.RADIO);
|
|
item.setImage(imageManager.getNativeFileViewIcon());
|
|
item.setText("Native");
|
|
item.setToolTipText("Displays files in native format for the operating system");
|
|
item.addSelectionListener(new SelectionAdapter () {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
changeCurrentFormat(FormattedDisk.FILE_DISPLAY_NATIVE);
|
|
}
|
|
});
|
|
item = new ToolItem(toolBar, SWT.RADIO);
|
|
item.setImage(imageManager.getDetailFileViewIcon());
|
|
item.setText("Detail");
|
|
item.setToolTipText("Displays files in with full details");
|
|
item.addSelectionListener(new SelectionAdapter () {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
changeCurrentFormat(FormattedDisk.FILE_DISPLAY_DETAIL);
|
|
}
|
|
});
|
|
item = new ToolItem(toolBar, SWT.SEPARATOR);
|
|
|
|
item = new ToolItem(toolBar, SWT.CHECK);
|
|
item.setImage(imageManager.getDeletedFilesIcon());
|
|
item.setText("Deleted");
|
|
item.setToolTipText("Show deleted files");
|
|
item.setEnabled(disk.supportsDeletedFiles());
|
|
item.addSelectionListener(new SelectionAdapter () {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
ToolItem button = (ToolItem) e.getSource();
|
|
showDeletedFiles = button.getSelection();
|
|
fillFileTable(currentFileList);
|
|
}
|
|
});
|
|
item = new ToolItem(toolBar, SWT.SEPARATOR);
|
|
|
|
importToolItem = new ToolItem(toolBar, SWT.PUSH);
|
|
importToolItem.setImage(imageManager.getImportFileIcon());
|
|
importToolItem.setText("Import...");
|
|
importToolItem.setToolTipText("Import a file");
|
|
importToolItem.setEnabled(false);
|
|
importToolItem.addSelectionListener(new SelectionAdapter () {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
// FIXME
|
|
}
|
|
});
|
|
|
|
exportToolItem = new ToolItem(toolBar, SWT.DROP_DOWN);
|
|
exportToolItem.setImage(imageManager.getExportFileIcon());
|
|
exportToolItem.setText("Export...");
|
|
exportToolItem.setToolTipText("Export a file");
|
|
exportToolItem.setEnabled(false);
|
|
exportToolItem.addSelectionListener(
|
|
new DropDownSelectionListener(createFileExportMenu(SWT.NONE)));
|
|
exportToolItem.addSelectionListener(new SelectionAdapter () {
|
|
public void widgetSelected(SelectionEvent event) {
|
|
if (event.detail != SWT.ARROW) {
|
|
ExportWizard wizard = new ExportWizard(shell,
|
|
imageManager.getExportWizardLogo(), disk);
|
|
// Get a suggseted filter, if possible:
|
|
FileEntry fileEntry = (FileEntry) fileTable.getSelection()[0].getData();
|
|
if (fileEntry != null) {
|
|
fileFilter = fileEntry.getSuggestedFilter();
|
|
}
|
|
// Start wizard:
|
|
wizard.setFileFilter(fileFilter);
|
|
wizard.setDirectory(userPreferences.getExportDirectory());
|
|
wizard.open();
|
|
if (wizard.isWizardCompleted()) {
|
|
fileFilter = wizard.getFileFilter();
|
|
String exportDirectory = wizard.getDirectory();
|
|
exportFile(exportDirectory);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
item = new ToolItem(toolBar, SWT.SEPARATOR);
|
|
|
|
deleteToolItem = new ToolItem(toolBar, SWT.PUSH);
|
|
deleteToolItem.setImage(imageManager.getDeleteFileIcon());
|
|
deleteToolItem.setText("Delete");
|
|
deleteToolItem.setToolTipText("Delete a file");
|
|
deleteToolItem.setEnabled(false);
|
|
deleteToolItem.addSelectionListener(new SelectionAdapter () {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
// FIXME
|
|
}
|
|
});
|
|
item = new ToolItem(toolBar, SWT.SEPARATOR);
|
|
|
|
item = new ToolItem(toolBar, SWT.PUSH);
|
|
item.setImage(imageManager.getSaveImageIcon());
|
|
item.setText("Save");
|
|
item.setToolTipText("Save disk image");
|
|
item.setEnabled(false);
|
|
item.addSelectionListener(new SelectionAdapter () {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
// not available yet
|
|
}
|
|
});
|
|
|
|
toolBar.pack();
|
|
}
|
|
/**
|
|
* Change the current format and refresh the display.
|
|
*/
|
|
protected void changeCurrentFormat(int newFormat) {
|
|
TreeItem selection = directoryTree.getSelection()[0];
|
|
Object data = selection.getData();
|
|
List fileList = null;
|
|
if (data instanceof FileEntry) {
|
|
FileEntry directory = (FileEntry) data;
|
|
fileList = directory.getFiles();
|
|
} else if (data instanceof FormattedDisk) {
|
|
FormattedDisk disk = (FormattedDisk) data;
|
|
fileList = disk.getFiles();
|
|
}
|
|
|
|
formatChanged = (currentFormat != newFormat);
|
|
if (formatChanged || !fileList.equals(currentFileList)) {
|
|
preserveColumnWidths(); // must be done before assigning newFormat
|
|
currentFormat = newFormat;
|
|
fillFileTable(fileList);
|
|
}
|
|
}
|
|
}
|