Initial commit from SVN.
This commit is contained in:
wcrisman
@@ -0,0 +1,531 @@
|
||||
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//
|
||||
Reference in New Issue
Block a user