531 lines
19 KiB
Java
531 lines
19 KiB
Java
|
package com.eua.local.view.controller;
|
||
|
|
|
||
|
|
import java.io.File;
|
||
|
|
import java.io.FileInputStream;
|
||
|
|
import java.io.FileOutputStream;
|
||
|
|
import java.math.BigDecimal;
|
||
|
|
import java.util.Random;
|
||
|
|
import java.util.zip.ZipEntry;
|
||
|
|
import java.util.zip.ZipOutputStream;
|
||
|
|
|
||
|
|
import com.foundation.metadata.Attribute;
|
||
|
|
import com.foundation.util.IManagedList;
|
||
|
|
import com.foundation.util.ManagedList;
|
||
|
|
import com.foundation.view.ControlDecoration;
|
||
|
|
import com.foundation.view.IViewContext;
|
||
|
|
import com.foundation.view.swt.DirectoryDialog;
|
||
|
|
import com.foundation.view.swt.FileDialog;
|
||
|
|
import com.common.comparison.Comparator;
|
||
|
|
import com.common.debug.Debug;
|
||
|
|
import com.common.io.StreamSupport;
|
||
|
|
import com.common.io.SymmetricOutputStream;
|
||
|
|
import com.common.security.ISymmetricAlgorithm;
|
||
|
|
import com.common.security.Rijndael;
|
||
|
|
import com.common.security.Sha1;
|
||
|
|
import com.common.util.LiteHashSet;
|
||
|
|
import com.common.util.StringSupport;
|
||
|
|
import com.eua.controller.SettingsController;
|
||
|
|
import com.eua.local.view.EncryptView;
|
||
|
|
import com.eua.model.FileMetadata;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Copyright Declarative Engineering LLC 2009<p>
|
||
|
|
*/
|
||
|
|
public class EncryptViewController extends AbstractViewController {
|
||
|
|
private static final int METRIC_BYTES = 0;
|
||
|
|
private static final int METRIC_KILO_BYTES = 1;
|
||
|
|
private static final int METRIC_MEGA_BYTES = 2;
|
||
|
|
private static final int METRIC_GIGA_BYTES = 3;
|
||
|
|
|
||
|
|
//Note: The metrics must be in ascending sequential order starting with zero for both the options array and the names array.//
|
||
|
|
private static final Integer[] METRIC_OPTIONS = new Integer[] {new Integer(METRIC_BYTES), new Integer(METRIC_KILO_BYTES), new Integer(METRIC_MEGA_BYTES), new Integer(METRIC_GIGA_BYTES)};
|
||
|
|
private static final String[] METRIC_OPTION_NAMES = new String[] {"Bytes", "Kilobytes", "Megabytes", "Gigabytes"};
|
||
|
|
|
||
|
|
public static final Attribute FILES = registerCollection(EncryptViewController.class, "files", AO_REFERENCED | AO_LAZY);
|
||
|
|
public static final Attribute SELECTED_FILES = registerCollection(EncryptViewController.class, "selectedFiles", AO_REFERENCED | AO_LAZY);
|
||
|
|
public static final Attribute SPLIT = registerAttribute(EncryptViewController.class, "split", Boolean.FALSE);
|
||
|
|
public static final Attribute MAXIMUM_OUTPUT_SIZE = registerAttribute(EncryptViewController.class, "maximumOutputSize", new Long(1));
|
||
|
|
public static final Attribute MAXIMUM_OUTPUT_METRIC = registerAttribute(EncryptViewController.class, "maximumOutputMetric", new Integer(METRIC_MEGA_BYTES));
|
||
|
|
public static final Attribute PASSWORD = registerAttribute(EncryptViewController.class, "password");
|
||
|
|
public static final Attribute OUTPUT_DIRECTORY = registerAttribute(EncryptViewController.class, "outputDirectory", AO_LAZY);
|
||
|
|
public static final Attribute OUTPUT_NAME = registerAttribute(EncryptViewController.class, "outputName", AO_LAZY);
|
||
|
|
public static final Attribute FILE_METADATA_SET = registerAttribute(EncryptViewController.class, "fileMetadataSet", AO_REFERENCED | AO_LAZY);
|
||
|
|
public static final Attribute INPUT_DIRECTORY = registerAttribute(EncryptViewController.class, "inputDirectory", AO_REFERENCED | AO_LAZY);
|
||
|
|
/**
|
||
|
|
* EncryptViewController constructor.
|
||
|
|
* @param viewContext
|
||
|
|
*/
|
||
|
|
public EncryptViewController(IViewContext viewContext) {
|
||
|
|
super(viewContext);
|
||
|
|
}//EncryptViewController()//
|
||
|
|
/* (non-Javadoc)
|
||
|
|
* @see com.foundation.common.Entity#lazyLoadAttribute(int)
|
||
|
|
*/
|
||
|
|
protected Object lazyLoadAttribute(Attribute attributeNumber) {
|
||
|
|
Object result = null;
|
||
|
|
|
||
|
|
if(attributeNumber == FILES) {
|
||
|
|
result = new ManagedList(10, 100);
|
||
|
|
}//if//
|
||
|
|
else if(attributeNumber == SELECTED_FILES) {
|
||
|
|
result = new ManagedList(10, 100);
|
||
|
|
}//else if//
|
||
|
|
else if(attributeNumber == INPUT_DIRECTORY) {
|
||
|
|
result = SettingsController.getSingleton().getInputDirectory();
|
||
|
|
|
||
|
|
if(result == null) {
|
||
|
|
File desktop = new File(System.getProperty("user.home"), "desktop");
|
||
|
|
|
||
|
|
if(desktop.exists()) {
|
||
|
|
result = desktop.getAbsolutePath();
|
||
|
|
}//if//
|
||
|
|
else {
|
||
|
|
result = System.getProperty("user.dir");
|
||
|
|
}//else//
|
||
|
|
}//if//
|
||
|
|
}//else if//
|
||
|
|
else if(attributeNumber == OUTPUT_DIRECTORY) {
|
||
|
|
result = SettingsController.getSingleton().getEncryptionOutputDirectory();
|
||
|
|
|
||
|
|
if(result == null) {
|
||
|
|
File desktop = new File(System.getProperty("user.home"), "desktop");
|
||
|
|
|
||
|
|
if(desktop.exists()) {
|
||
|
|
result = desktop.getAbsolutePath();
|
||
|
|
}//if//
|
||
|
|
else {
|
||
|
|
result = System.getProperty("user.dir");
|
||
|
|
}//else//
|
||
|
|
}//if//
|
||
|
|
}//else if//
|
||
|
|
else if(attributeNumber == OUTPUT_NAME) {
|
||
|
|
result = SettingsController.getSingleton().getEncryptedFileName();
|
||
|
|
|
||
|
|
if(result == null) {
|
||
|
|
result = "encrypted";
|
||
|
|
}//if//
|
||
|
|
}//else if//
|
||
|
|
else if(attributeNumber == FILE_METADATA_SET) {
|
||
|
|
result = new LiteHashSet(10, LiteHashSet.DEFAULT_LOAD_FACTOR, Comparator.getLogicalComparator(), LiteHashSet.STYLE_NO_DUPLICATES);
|
||
|
|
}//else if//
|
||
|
|
else {
|
||
|
|
result = super.lazyLoadAttribute(attributeNumber);
|
||
|
|
}//else//
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}//lazyLoadAttribute()//
|
||
|
|
/* (non-Javadoc)
|
||
|
|
* @see com.foundation.controller.ViewController#getViewClass()
|
||
|
|
*/
|
||
|
|
protected Class getViewClass() {
|
||
|
|
return EncryptView.class;
|
||
|
|
}//getViewClass()//
|
||
|
|
/* (non-Javadoc)
|
||
|
|
* @see com.foundation.controller.ViewController#validate()
|
||
|
|
*/
|
||
|
|
public boolean validate() {
|
||
|
|
boolean result = true;
|
||
|
|
|
||
|
|
getDecorationManager().clearDecorations();
|
||
|
|
|
||
|
|
if(getSplit().booleanValue() && (getMaximumOutputSize() == null || getMaximumOutputSize().longValue() <= 0)) {
|
||
|
|
getDecorationManager().addDecoration(this, MAXIMUM_OUTPUT_SIZE, new ControlDecoration(IMAGE_ERROR, "Missing output size."));
|
||
|
|
result = false;
|
||
|
|
}//if//
|
||
|
|
else if(getSplit().booleanValue() && getMaximumOutputMetric().intValue() == METRIC_BYTES && getMaximumOutputSize().longValue() < 1000) {
|
||
|
|
getDecorationManager().addDecoration(this, MAXIMUM_OUTPUT_SIZE, new ControlDecoration(IMAGE_ERROR, "Maximum output size must be greater than 1000 if measured in bytes."));
|
||
|
|
result = false;
|
||
|
|
}//else if//
|
||
|
|
|
||
|
|
if(getPassword() == null || getPassword().length() == 0) {
|
||
|
|
getDecorationManager().addDecoration(this, PASSWORD, new ControlDecoration(IMAGE_ERROR, "Password required."));
|
||
|
|
result = false;
|
||
|
|
}//if//
|
||
|
|
|
||
|
|
if(getOutputDirectory() == null || getOutputDirectory().trim().length() == 0) {
|
||
|
|
getDecorationManager().addDecoration(this, OUTPUT_DIRECTORY, new ControlDecoration(IMAGE_ERROR, "Output directory required."));
|
||
|
|
result = false;
|
||
|
|
}//if//
|
||
|
|
|
||
|
|
if(getOutputName() == null || getOutputName().trim().length() == 0) {
|
||
|
|
getDecorationManager().addDecoration(this, OUTPUT_NAME, new ControlDecoration(IMAGE_ERROR, "Output name required."));
|
||
|
|
result = false;
|
||
|
|
}//if//
|
||
|
|
|
||
|
|
getDecorationManager().applyDecorationChanges();
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}//validate()//
|
||
|
|
/**
|
||
|
|
* Cancels the log-in process and closes the client.
|
||
|
|
*/
|
||
|
|
public void doCancel() {
|
||
|
|
close();
|
||
|
|
}//doCancel()//
|
||
|
|
/**
|
||
|
|
* Initiates the validation process and opens the next view upon sucsessful validation.
|
||
|
|
*/
|
||
|
|
public void doEncrypt() {
|
||
|
|
synchronize();
|
||
|
|
|
||
|
|
if(validate()) {
|
||
|
|
if(getFiles().getSize() > 0 && getPassword() != null) {
|
||
|
|
BigDecimal totalSize = new BigDecimal(0);
|
||
|
|
BigDecimal maximumOutputSize = getSplit().booleanValue() ? new BigDecimal(getMaximumOutputSize().longValue()) : null;
|
||
|
|
int currentFileIndex = 0;
|
||
|
|
FileMetadata nextFile = (FileMetadata) getFiles().getFirst();
|
||
|
|
FileInputStream fin = null;
|
||
|
|
FileOutputStream fout = null;
|
||
|
|
byte[] buffer = new byte[100000]; //100k
|
||
|
|
ISymmetricAlgorithm algorithm = new Rijndael(new Random(StringSupport.hash(getPassword())));
|
||
|
|
SymmetricOutputStream sout = null;
|
||
|
|
ZipOutputStream zout = null;
|
||
|
|
File outputFile = new File(getOutputDirectory(), getOutputName() + ".enc");
|
||
|
|
|
||
|
|
try {
|
||
|
|
fin = new FileInputStream(new File(nextFile.getPath(), nextFile.getName()));
|
||
|
|
|
||
|
|
//Calculate the maximum output size of each split segment in terms of bytes.//
|
||
|
|
if(maximumOutputSize != null) {
|
||
|
|
switch(getMaximumOutputMetric().intValue()) {
|
||
|
|
case METRIC_GIGA_BYTES: {
|
||
|
|
maximumOutputSize = maximumOutputSize.multiply(new BigDecimal(1073741824)); //1024^3
|
||
|
|
break;
|
||
|
|
}//case//
|
||
|
|
case METRIC_MEGA_BYTES: {
|
||
|
|
maximumOutputSize = maximumOutputSize.multiply(new BigDecimal(1048576)); //1024^2
|
||
|
|
break;
|
||
|
|
}//case//
|
||
|
|
case METRIC_KILO_BYTES: {
|
||
|
|
maximumOutputSize = maximumOutputSize.multiply(new BigDecimal(1024));
|
||
|
|
break;
|
||
|
|
}//case//
|
||
|
|
default: {
|
||
|
|
//Do nothing.//
|
||
|
|
break;
|
||
|
|
}//default//
|
||
|
|
}//switch//
|
||
|
|
}//if//
|
||
|
|
|
||
|
|
//Calculate the total size of all the input content.//
|
||
|
|
for(int index = 0; index < getFiles().getSize(); index++) {
|
||
|
|
FileMetadata next = (FileMetadata) getFiles().get(index);
|
||
|
|
|
||
|
|
totalSize = totalSize.add(new BigDecimal(next.getLength().longValue()));
|
||
|
|
}//for//
|
||
|
|
|
||
|
|
fout = new FileOutputStream(outputFile);
|
||
|
|
//Write the magic number which is used when reading to verify that the file is generated by this same tool.//
|
||
|
|
StreamSupport.writeInt(MAGIC_NUMBER, fout);
|
||
|
|
//Write the version number of the tool being used to generate the encrypted data.//
|
||
|
|
StreamSupport.writeInt(VERSION, fout);
|
||
|
|
//Create the symmetric encryption output stream.//
|
||
|
|
sout = new SymmetricOutputStream(fout, algorithm);
|
||
|
|
sout.encrypt(true);
|
||
|
|
//Create the zip output stream to ensure all encrypted content is first compressed.//
|
||
|
|
zout = new ZipOutputStream(sout);
|
||
|
|
zout.putNextEntry(new ZipEntry("main"));
|
||
|
|
//Write the number of input files.//
|
||
|
|
StreamSupport.writeInt(getFiles().getSize(), zout);
|
||
|
|
|
||
|
|
//Write each file name and size.//
|
||
|
|
for(int index = 0; index < getFiles().getSize(); index++) {
|
||
|
|
FileMetadata next = (FileMetadata) getFiles().get(index);
|
||
|
|
|
||
|
|
StreamSupport.writeString(next.getName(), zout);
|
||
|
|
StreamSupport.writeLong(next.getLength().longValue(), zout);
|
||
|
|
}//for//
|
||
|
|
|
||
|
|
//Write the file data as long as we have an input stream.//
|
||
|
|
while(fin != null) {
|
||
|
|
int readCount = 0;
|
||
|
|
|
||
|
|
//Read in a whole buffer of content.//
|
||
|
|
while(readCount < buffer.length && fin != null) {
|
||
|
|
readCount += StreamSupport.readBytes(fin, buffer, readCount, buffer.length - readCount);
|
||
|
|
|
||
|
|
//If we couldn't fill the buffer (due to not enough bytes in the input stream), then open a stream on the next file.//
|
||
|
|
if(readCount != buffer.length) {
|
||
|
|
fin.close();
|
||
|
|
|
||
|
|
//Increment to the next file and open an input stream.//
|
||
|
|
if(++currentFileIndex != getFiles().getSize()) {
|
||
|
|
nextFile = (FileMetadata) getFiles().get(currentFileIndex);
|
||
|
|
fin = new FileInputStream(new File(nextFile.getPath(), nextFile.getName()));
|
||
|
|
}//if//
|
||
|
|
else {
|
||
|
|
fin = null;
|
||
|
|
nextFile = null;
|
||
|
|
}//else//
|
||
|
|
}//if//
|
||
|
|
}//while//
|
||
|
|
|
||
|
|
zout.write(buffer, 0, readCount);
|
||
|
|
}//while//
|
||
|
|
|
||
|
|
zout.closeEntry();
|
||
|
|
zout.flush();
|
||
|
|
zout.finish();
|
||
|
|
sout.encrypt(false);
|
||
|
|
sout.flush();
|
||
|
|
zout.close();
|
||
|
|
sout.close();
|
||
|
|
fout.close();
|
||
|
|
|
||
|
|
//If the output should be split then split the generated file now.//
|
||
|
|
if(getSplit().booleanValue() && maximumOutputSize.compareTo(new BigDecimal(outputFile.length())) < 0) {
|
||
|
|
int outputFileIndex = 0;
|
||
|
|
BigDecimal bufferSize = new BigDecimal(buffer.length);
|
||
|
|
|
||
|
|
fin = new FileInputStream(outputFile);
|
||
|
|
fout = null;
|
||
|
|
|
||
|
|
//Keep reading and writing until the input stream is empty.//
|
||
|
|
while(fin != null) {
|
||
|
|
BigDecimal writeSize = new BigDecimal(0);
|
||
|
|
|
||
|
|
if(fout != null) {
|
||
|
|
fout.close();
|
||
|
|
}//if//
|
||
|
|
|
||
|
|
fout = new FileOutputStream(outputFile.getAbsolutePath() + "." + ++outputFileIndex);
|
||
|
|
|
||
|
|
//Keep writing to the current file until we can't write any more.//
|
||
|
|
while(fin != null && writeSize.compareTo(maximumOutputSize) < 0) {
|
||
|
|
int readCount;
|
||
|
|
BigDecimal readLength = maximumOutputSize.subtract(writeSize);
|
||
|
|
|
||
|
|
//If the read length is greater than the buffer size then use the buffer size.//
|
||
|
|
if(readLength.compareTo(bufferSize) > 0) {
|
||
|
|
readLength = bufferSize;
|
||
|
|
}//if//
|
||
|
|
|
||
|
|
readCount = StreamSupport.readBytes(fin, buffer, 0, readLength.intValue());
|
||
|
|
fout.write(buffer, 0, readCount);
|
||
|
|
writeSize = writeSize.add(new BigDecimal(readCount));
|
||
|
|
|
||
|
|
//Check to see if the input stream is empty.//
|
||
|
|
if(readCount != readLength.intValue()) {
|
||
|
|
fin.close();
|
||
|
|
fin = null;
|
||
|
|
}//if//
|
||
|
|
}//while//
|
||
|
|
}//while//
|
||
|
|
|
||
|
|
fout.close();
|
||
|
|
fout = new FileOutputStream(outputFile);
|
||
|
|
//Write the magic number which is used when reading to verify that the file is generated by this same tool.//
|
||
|
|
StreamSupport.writeInt(SEQUENCE_MAGIC_NUMBER, fout);
|
||
|
|
//Write the version number of the tool being used to generate the encrypted data.//
|
||
|
|
StreamSupport.writeInt(SEQUENCE_VERSION, fout);
|
||
|
|
//Write the number of files in the sequence.//
|
||
|
|
StreamSupport.writeInt(outputFileIndex, fout);
|
||
|
|
fout.close();
|
||
|
|
fout = null;
|
||
|
|
displayInformation("Encryption Successful", "The content was successfully encrypted and split. All results placed in \"" + outputFile.getParentFile().getCanonicalPath() + "\".");
|
||
|
|
}//if//
|
||
|
|
else {
|
||
|
|
displayInformation("Encryption Successful", "The content was successfully encrypted to \"" + outputFile.getCanonicalPath() + "\".");
|
||
|
|
}//else//
|
||
|
|
|
||
|
|
SettingsController.getSingleton().setEncryptionSettings(getOutputDirectory(), getOutputName(), getInputDirectory());
|
||
|
|
}//try//
|
||
|
|
catch(Throwable e) {
|
||
|
|
Debug.log(e);
|
||
|
|
}//catch//
|
||
|
|
finally {
|
||
|
|
if(fin != null) {
|
||
|
|
try {fin.close();}catch(Throwable e) {}
|
||
|
|
}//if//
|
||
|
|
|
||
|
|
if(fout != null) {
|
||
|
|
try {fout.close();}catch(Throwable e) {}
|
||
|
|
}//if//
|
||
|
|
}//finally//
|
||
|
|
}//if//
|
||
|
|
}//if//
|
||
|
|
}//doEncrypt()//
|
||
|
|
/**
|
||
|
|
* Changes the output directory by opening a dialog for the user to choose a location.
|
||
|
|
*/
|
||
|
|
public void doChangeOutputDirectory() {
|
||
|
|
DirectoryDialog dialog = new DirectoryDialog(getView(), 0);
|
||
|
|
String directory;
|
||
|
|
|
||
|
|
dialog.setMessage("Choose the output directory.");
|
||
|
|
|
||
|
|
if((directory = dialog.open()) != null) {
|
||
|
|
setOutputDirectory(directory);
|
||
|
|
}//if//
|
||
|
|
}//doChangeOutputDirectory()//
|
||
|
|
/**
|
||
|
|
* Adds files to the collection to be encrypted.
|
||
|
|
*/
|
||
|
|
public void doAddFiles() {
|
||
|
|
FileDialog dialog = new FileDialog(getView(), FileDialog.STYLE_MULTI);
|
||
|
|
String path;
|
||
|
|
|
||
|
|
dialog.setFilterPath(getInputDirectory());
|
||
|
|
dialog.setText("Select the files you wish to encrypt.");
|
||
|
|
|
||
|
|
if((path = dialog.open()) != null) {
|
||
|
|
String[] fileNames = dialog.getFileNames();
|
||
|
|
File pathFile = new File(path);
|
||
|
|
|
||
|
|
//Get the actual path. Doing this because the dialog's result isn't a directory path, but rather a path to the first selected file.//
|
||
|
|
path = pathFile.getParent();
|
||
|
|
setInputDirectory(path);
|
||
|
|
|
||
|
|
for(int index = 0; index < fileNames.length; index++) {
|
||
|
|
FileMetadata fileMetadata = new FileMetadata(fileNames[index], path);
|
||
|
|
|
||
|
|
if(getFileMetadataSet().add(fileMetadata) != -1) {
|
||
|
|
getFiles().add(fileMetadata);
|
||
|
|
}//if//
|
||
|
|
}//for//
|
||
|
|
}//if//
|
||
|
|
}//doAddFiles()//
|
||
|
|
/**
|
||
|
|
* Removes files from the collection to be encrypted.
|
||
|
|
*/
|
||
|
|
public void doRemoveFiles() {
|
||
|
|
if(getSelectedFiles().getSize() > 0) {
|
||
|
|
getFiles().removeAll(getSelectedFiles());
|
||
|
|
getSelectedFiles().removeAll();
|
||
|
|
}//if//
|
||
|
|
}//doRemoveFiles()//
|
||
|
|
/**
|
||
|
|
* Gets the files value.
|
||
|
|
* @return The files value.
|
||
|
|
*/
|
||
|
|
public IManagedList getFiles() {
|
||
|
|
return (IManagedList) getAttributeValue(FILES);
|
||
|
|
}//getFiles()//
|
||
|
|
/**
|
||
|
|
* Gets the selectedFiles value.
|
||
|
|
* @return The selectedFiles value.
|
||
|
|
*/
|
||
|
|
public IManagedList getSelectedFiles() {
|
||
|
|
return (IManagedList) getAttributeValue(SELECTED_FILES);
|
||
|
|
}//getSelectedFiles()//
|
||
|
|
/**
|
||
|
|
* Gets the split value.
|
||
|
|
* @return The split value.
|
||
|
|
*/
|
||
|
|
public Boolean getSplit() {
|
||
|
|
return (Boolean) getAttributeValue(SPLIT);
|
||
|
|
}//getSplit()//
|
||
|
|
/**
|
||
|
|
* Sets the split value.
|
||
|
|
* @param split The split value.
|
||
|
|
*/
|
||
|
|
public void setSplit(Boolean split) {
|
||
|
|
setAttributeValue(SPLIT, split);
|
||
|
|
}//setSplit()//
|
||
|
|
/**
|
||
|
|
* Gets the maximumOutputSize value.
|
||
|
|
* @return The maximumOutputSize value.
|
||
|
|
*/
|
||
|
|
public Long getMaximumOutputSize() {
|
||
|
|
return (Long) getAttributeValue(MAXIMUM_OUTPUT_SIZE);
|
||
|
|
}//getMaximumOutputSize()//
|
||
|
|
/**
|
||
|
|
* Sets the maximumOutputSize value.
|
||
|
|
* @param maximumOutputSize The maximumOutputSize value.
|
||
|
|
*/
|
||
|
|
public void setMaximumOutputSize(Long maximumOutputSize) {
|
||
|
|
setAttributeValue(MAXIMUM_OUTPUT_SIZE, maximumOutputSize);
|
||
|
|
}//setMaximumOutputSize()//
|
||
|
|
/**
|
||
|
|
* Gets the maximumOutputMetric value.
|
||
|
|
* @return The maximumOutputMetric value.
|
||
|
|
*/
|
||
|
|
public Integer getMaximumOutputMetric() {
|
||
|
|
return (Integer) getAttributeValue(MAXIMUM_OUTPUT_METRIC);
|
||
|
|
}//getMaximumOutputMetric()//
|
||
|
|
/**
|
||
|
|
* Sets the metric for the maximum output value.
|
||
|
|
* @param maximumOutputMetric The metric for the maximum output value.
|
||
|
|
*/
|
||
|
|
public void setMaximumOutputMetric(Integer maximumOutputMetric) {
|
||
|
|
setAttributeValue(MAXIMUM_OUTPUT_METRIC, maximumOutputMetric);
|
||
|
|
}//setMaximumOutputMetric()//
|
||
|
|
/**
|
||
|
|
* Gets the set of metrics allowed for the maximum output metric.
|
||
|
|
* @return The metrics allowed.
|
||
|
|
*/
|
||
|
|
public Integer[] getMetrics() {
|
||
|
|
return METRIC_OPTIONS;
|
||
|
|
}//getMetrics()//
|
||
|
|
/**
|
||
|
|
* Gets the metric name for the given metric identifier.
|
||
|
|
* @param metric The metric number.
|
||
|
|
* @return The name for the metric.
|
||
|
|
*/
|
||
|
|
public String getMetricName(Integer metric) {
|
||
|
|
return METRIC_OPTION_NAMES[metric.intValue()];
|
||
|
|
}//getMetricName()//
|
||
|
|
/**
|
||
|
|
* Gets the password value.
|
||
|
|
* @return The password value.
|
||
|
|
*/
|
||
|
|
public String getPassword() {
|
||
|
|
return (String) getAttributeValue(PASSWORD);
|
||
|
|
}//getPassword()//
|
||
|
|
/**
|
||
|
|
* Sets the password value.
|
||
|
|
* @param password The password value.
|
||
|
|
*/
|
||
|
|
public void setPassword(String password) {
|
||
|
|
setAttributeValue(PASSWORD, password);
|
||
|
|
}//setPassword()//
|
||
|
|
/**
|
||
|
|
* Gets the outputDirectory value.
|
||
|
|
* @return The outputDirectory value.
|
||
|
|
*/
|
||
|
|
public String getOutputDirectory() {
|
||
|
|
return (String) getAttributeValue(OUTPUT_DIRECTORY);
|
||
|
|
}//getOutputDirectory()//
|
||
|
|
/**
|
||
|
|
* Sets the outputDirectory value.
|
||
|
|
* @param outputDirectory The outputDirectory value.
|
||
|
|
*/
|
||
|
|
public void setOutputDirectory(String outputDirectory) {
|
||
|
|
setAttributeValue(OUTPUT_DIRECTORY, outputDirectory);
|
||
|
|
}//setOutputDirectory()//
|
||
|
|
/**
|
||
|
|
* Gets the outputName value.
|
||
|
|
* @return The outputName value.
|
||
|
|
*/
|
||
|
|
public String getOutputName() {
|
||
|
|
return (String) getAttributeValue(OUTPUT_NAME);
|
||
|
|
}//getOutputName()//
|
||
|
|
/**
|
||
|
|
* Sets the outputName value.
|
||
|
|
* @param outputName The outputName value.
|
||
|
|
*/
|
||
|
|
public void setOutputName(String outputName) {
|
||
|
|
setAttributeValue(OUTPUT_NAME, outputName);
|
||
|
|
}//setOutputName()//
|
||
|
|
/**
|
||
|
|
* Gets the fileMetadataSet value.
|
||
|
|
* @return The fileMetadataSet value.
|
||
|
|
*/
|
||
|
|
protected LiteHashSet getFileMetadataSet() {
|
||
|
|
return (LiteHashSet) getAttributeValue(FILE_METADATA_SET);
|
||
|
|
}//getFileMetadataSet()//
|
||
|
|
/**
|
||
|
|
* Gets the last used directory for selecting files to encrypt.
|
||
|
|
* @return The input directory path.
|
||
|
|
*/
|
||
|
|
public String getInputDirectory() {
|
||
|
|
return (String) getAttributeValue(INPUT_DIRECTORY);
|
||
|
|
}//getInputDirectory()//
|
||
|
|
/**
|
||
|
|
* Sets the last used directory for selecting files to encrypt.
|
||
|
|
* @param inputDirectory The input directory path.
|
||
|
|
*/
|
||
|
|
public void setInputDirectory(String inputDirectory) {
|
||
|
|
setAttributeValue(INPUT_DIRECTORY, inputDirectory);
|
||
|
|
}//setInputDirectory()//
|
||
|
|
}//EncryptViewController//
|