@Override
public void actionPerformed(ActionEvent e) {
Frame frame = getFrame();
JFileChooser chooser = new JFileChooser();
int ret = chooser.showOpenDialog(frame);
if (ret != JFileChooser.APPROVE_OPTION) {
return;
}
File f = chooser.getSelectedFile();
if (f.isFile() && f.canRead()) {
Document oldDoc = getEditor().getDocument();
if (oldDoc != null) {
oldDoc.removeUndoableEditListener(undoHandler);
}
if (elementTreePanel != null) {
elementTreePanel.setEditor(null);
}
getEditor().setDocument(new PlainDocument());
frame.setTitle(f.getName());
Thread loader = new FileLoader(f, editor.getDocument());
loader.start();
} else {
JOptionPane.showMessageDialog(
getFrame(),
"Could not open file: " + f,
"Error opening file",
JOptionPane.ERROR_MESSAGE);
}
}
private void changeDirectory(File dir) {
JFileChooser fc = getFileChooser();
// Traverse shortcuts on Windows
if (dir != null && FilePane.usesShellFolder(fc)) {
try {
ShellFolder shellFolder = ShellFolder.getShellFolder(dir);
if (shellFolder.isLink()) {
File linkedTo = shellFolder.getLinkLocation();
// If linkedTo is null we try to use dir
if (linkedTo != null) {
if (fc.isTraversable(linkedTo)) {
dir = linkedTo;
} else {
return;
}
} else {
dir = shellFolder;
}
}
} catch (FileNotFoundException ex) {
return;
}
}
fc.setCurrentDirectory(dir);
if (fc.getFileSelectionMode() == JFileChooser.FILES_AND_DIRECTORIES
&& fc.getFileSystemView().isFileSystem(dir)) {
setFileName(dir.getAbsolutePath());
}
}
private boolean checkForSave() {
// build warning message
String message;
if (file == null) {
message = "File has been modified. Save changes?";
} else {
message = "File \"" + file.getName() + "\" has been modified. Save changes?";
}
// show confirm dialog
int r =
JOptionPane.showConfirmDialog(
this,
new JLabel(message),
"Warning!",
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.WARNING_MESSAGE);
if (r == JOptionPane.YES_OPTION) {
// Save File
if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
// write the file
physWriteTextFile(fileChooser.getSelectedFile(), textView.getText());
} else {
// user cancelled save after all
return false;
}
}
return r != JOptionPane.CANCEL_OPTION;
}
protected void uninstallDefaults(JFileChooser fc) {
uninstallIcons(fc);
uninstallStrings(fc);
if (fc.getTransferHandler() instanceof UIResource) {
fc.setTransferHandler(null);
}
}
// Add a test case to testBox and tests array.
private void addTest() {
// Set up the frame for the file chooser.
final JFrame appframe = new JFrame("Select Application");
appframe.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Container contentPane = appframe.getContentPane();
JFileChooser fileChooser = new JFileChooser(".");
// Only let you select directories and add chooser to pane.
fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
contentPane.add(fileChooser, BorderLayout.CENTER);
// Make a new action listener for the file chooser.
ActionListener actionListener =
new ActionListener() {
public void actionPerformed(ActionEvent actionEvent) {
// Get the information to check if the file chosen is valid.
JFileChooser theFileChooser = (JFileChooser) actionEvent.getSource();
String command = actionEvent.getActionCommand();
// If the user cancels selecting a program.
if (command.equals(JFileChooser.CANCEL_SELECTION)) {
appframe.setVisible(false);
appframe.dispose();
return;
}
// If the file chosen is valid.
if (command.equals(JFileChooser.APPROVE_SELECTION)) {
// Retrieve the selected file and ask for the main class name.
File f = theFileChooser.getSelectedFile();
// Obtain the file URL.
String fileURL = null;
fileURL = f.getAbsolutePath();
// Add a checkbox to the testing check pane.
JCheckBox newTest = new JCheckBox(fileURL, true);
testBox.setEditable(true);
testBox.add(newTest);
testBox.repaint();
testBox.setEditable(false);
// Add the test to the list of tests.
tests.add(newTest);
// Make the file chooser disappear.
appframe.setVisible(false);
appframe.dispose();
}
}
};
// Add the action listener created above to file chooser, display it.
fileChooser.addActionListener(actionListener);
appframe.pack();
appframe.setVisible(true);
}
protected void uninstallListeners(JFileChooser fc) {
if (propertyChangeListener != null) {
fc.removePropertyChangeListener(propertyChangeListener);
}
fc.removePropertyChangeListener(getModel());
SwingUtilities.replaceUIInputMap(fc, JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);
SwingUtilities.replaceUIActionMap(fc, null);
}
// called when the load script button is pressed.
private void scriptPressed() {
int returnVal = fileChooser.showDialog(this, "Load Script");
if (returnVal == JFileChooser.APPROVE_OPTION) {
notifyControllerListeners(
ControllerEvent.SCRIPT_CHANGE, fileChooser.getSelectedFile().getAbsoluteFile());
scriptComponent.setContents(fileChooser.getSelectedFile().getAbsolutePath());
}
}
public Path dateiAuswählen() {
JFileChooser fc1 = new JFileChooser();
fc1.setDialogTitle("SyncOrdner auswählen");
fc1.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
if (fc1.showSaveDialog(this) == JFileChooser.APPROVE_OPTION)
return fc1.getSelectedFile().toPath();
else return null;
}
private void resetGlobFilter() {
if (actualFileFilter != null) {
JFileChooser chooser = getFileChooser();
FileFilter currentFilter = chooser.getFileFilter();
if (currentFilter != null && currentFilter.equals(globFilter)) {
chooser.setFileFilter(actualFileFilter);
chooser.removeChoosableFileFilter(globFilter);
}
actualFileFilter = null;
}
}
protected void installDefaults(JFileChooser fc) {
installIcons(fc);
installStrings(fc);
usesSingleFilePane = UIManager.getBoolean("FileChooser.usesSingleFilePane");
readOnly = UIManager.getBoolean("FileChooser.readOnly");
TransferHandler th = fc.getTransferHandler();
if (th == null || th instanceof UIResource) {
fc.setTransferHandler(defaultTransferHandler);
}
LookAndFeel.installProperty(fc, "opaque", Boolean.FALSE);
}
public void actionPerformed(ActionEvent e) {
JFileChooser chooser = new JFileChooser();
chooser.setDialogTitle("Load");
int choice = 0;
do {
int result = chooser.showOpenDialog(null);
if (result == JFileChooser.APPROVE_OPTION) {
file = chooser.getSelectedFile();
try {
if (file != null) {
fileName = file.getCanonicalPath();
reader = new BufferedReader(new FileReader(fileName));
String line;
while ((line = reader.readLine()) != null) {
myPatternList.add(line);
}
// for(int i=0;i<myPatternList.size();i++) {
// responseArea.append(myPatternList.get(i)+"\n");
// }
}
choice = 2;
reader.close();
} catch (IOException c) {
c.printStackTrace();
Object[] options = new String[] {"Load New File", "Exit"};
choice =
JOptionPane.showOptionDialog(
null,
"Invalid FileChoosen." + "Would you like to load a new file " + "or exit?",
"Options",
JOptionPane.YES_NO_OPTION,
JOptionPane.ERROR_MESSAGE,
null,
options,
options[0]);
if (choice == 1) System.exit(0);
}
} else if (result == JFileChooser.CANCEL_OPTION) {
Object[] options = new String[] {"Load Different File", "Exit"};
choice =
JOptionPane.showOptionDialog(
null,
"Would you like to load a new file " + " or exit?",
"Options",
JOptionPane.YES_NO_OPTION,
JOptionPane.ERROR_MESSAGE,
null,
options,
options[0]);
if (choice == 1) System.exit(0);
}
} while (choice == 0);
}
protected void installListeners(JFileChooser fc) {
propertyChangeListener = createPropertyChangeListener(fc);
if (propertyChangeListener != null) {
fc.addPropertyChangeListener(propertyChangeListener);
}
fc.addPropertyChangeListener(getModel());
InputMap inputMap = getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
SwingUtilities.replaceUIInputMap(fc, JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, inputMap);
ActionMap actionMap = getActionMap();
SwingUtilities.replaceUIActionMap(fc, actionMap);
}
public String getApproveButtonText(JFileChooser fc) {
String buttonText = fc.getApproveButtonText();
if (buttonText != null) {
return buttonText;
} else if (fc.getDialogType() == JFileChooser.OPEN_DIALOG) {
return openButtonText;
} else if (fc.getDialogType() == JFileChooser.SAVE_DIALOG) {
return saveButtonText;
} else {
return null;
}
}
public int getApproveButtonMnemonic(JFileChooser fc) {
int mnemonic = fc.getApproveButtonMnemonic();
if (mnemonic > 0) {
return mnemonic;
} else if (fc.getDialogType() == JFileChooser.OPEN_DIALOG) {
return openButtonMnemonic;
} else if (fc.getDialogType() == JFileChooser.SAVE_DIALOG) {
return saveButtonMnemonic;
} else {
return mnemonic;
}
}
/** Returns the title of this dialog */
public String getDialogTitle(JFileChooser fc) {
String dialogTitle = fc.getDialogTitle();
if (dialogTitle != null) {
return dialogTitle;
} else if (fc.getDialogType() == JFileChooser.OPEN_DIALOG) {
return openDialogTitleText;
} else if (fc.getDialogType() == JFileChooser.SAVE_DIALOG) {
return saveDialogTitleText;
} else {
return getApproveButtonText(fc);
}
}
private String fileNameString(File file) {
if (file == null) {
return null;
} else {
JFileChooser fc = getFileChooser();
if (fc.isDirectorySelectionEnabled() && !fc.isFileSelectionEnabled()) {
return file.getPath();
} else {
return file.getName();
}
}
}
public void installUI(JComponent c) {
accessoryPanel = new JPanel(new BorderLayout());
filechooser = (JFileChooser) c;
createModel();
clearIconCache();
installDefaults(filechooser);
installComponents(filechooser);
installListeners(filechooser);
filechooser.applyComponentOrientation(filechooser.getComponentOrientation());
}
public void actionPerformed(ActionEvent e) {
Frame frame = getFrame();
JFileChooser chooser = new JFileChooser();
int ret = chooser.showSaveDialog(frame);
if (ret != JFileChooser.APPROVE_OPTION) {
return;
}
File f = chooser.getSelectedFile();
frame.setTitle(f.getName());
Thread saver = new FileSaver(f, editor.getDocument());
saver.start();
}
public void actionPerformed(ActionEvent e) {
JFileChooser chooser = new JFileChooser();
chooser.setDialogTitle("SaveAs");
int choice = 0;
do {
int result = chooser.showOpenDialog(null);
if (result == JFileChooser.APPROVE_OPTION) {
file = chooser.getSelectedFile();
try {
if (file != null) {
fileName = file.getCanonicalPath();
printWriter = new PrintWriter(new FileOutputStream(fileName), true);
}
printWriter.append(responseArea.getText());
choice = 2;
} catch (IOException c) {
c.printStackTrace();
Object[] options = new String[] {"Choose New File", "Exit"};
choice =
JOptionPane.showOptionDialog(
null,
"Invalid FileChoosen." + "Would you like to choose a new file " + "or exit?",
"Options",
JOptionPane.YES_NO_OPTION,
JOptionPane.ERROR_MESSAGE,
null,
options,
options[0]);
if (choice == 1) System.exit(0);
}
} else if (result == JFileChooser.CANCEL_OPTION) {
Object[] options = new String[] {"Choose Different File", "Exit"};
choice =
JOptionPane.showOptionDialog(
null,
"Would you like to choose a new file " + " or exit?",
"Options",
JOptionPane.YES_NO_OPTION,
JOptionPane.ERROR_MESSAGE,
null,
options,
options[0]);
if (choice == 1) System.exit(0);
}
} while (choice == 0);
printWriter.flush();
printWriter.close();
}
public void actionPerformed(ActionEvent e) {
if (e.getSource() == save) {
JFileChooser c = new JFileChooser(ResourceFactory.getRootDir());
c.setDialogTitle("Save result");
if (c.showSaveDialog(resultFrame) == JFileChooser.APPROVE_OPTION) {
File output = c.getSelectedFile();
if (output.exists()) {
String[] options = {"Overwrite", "Cancel"};
if (JOptionPane.showOptionDialog(
resultFrame,
output + "exists. Overwrite?",
"Save result",
JOptionPane.YES_NO_OPTION,
JOptionPane.WARNING_MESSAGE,
null,
options,
options[0])
== 1) return;
}
try {
PrintWriter w = new PrintWriter(new BufferedWriter(new FileWriter(output)));
w.println("Searched for unused strings");
w.println("Number of hits: " + table.getRowCount());
w.println("");
for (int i = 0; i < table.getRowCount(); i++) {
w.println(
"StringRef: "
+ table.getTableItemAt(i).getObjectAt(1)
+ " /* "
+ table
.getTableItemAt(i)
.toString()
.replaceAll("\r\n", System.getProperty("line.separator"))
+ " */");
}
w.close();
JOptionPane.showMessageDialog(
resultFrame,
"Result saved to " + output,
"Save complete",
JOptionPane.INFORMATION_MESSAGE);
} catch (IOException ex) {
JOptionPane.showMessageDialog(
resultFrame, "Error while saving " + output, "Error", JOptionPane.ERROR_MESSAGE);
ex.printStackTrace();
}
}
}
}
public void saveFileAs() {
// Force user to enter new file name
if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
file = fileChooser.getSelectedFile();
} else {
// user cancelled save after all
return;
}
// file selected, so write it.
physWriteTextFile(file, textView.getText());
// update status
statusView.setText(" Saved file \"" + file.getName() + "\".");
// reset dirty bit
dirty = false;
}
// Get the name of the file
private File getFileName(int option) {
JFileChooser fc = new JFileChooser(new File(".."));
if (oldFile != null) fc.setSelectedFile(oldFile);
int returnVal = 0;
if (option == UintahGui.OPEN) {
returnVal = fc.showOpenDialog(UintahGui.this);
} else {
returnVal = fc.showSaveDialog(UintahGui.this);
}
if (returnVal == JFileChooser.APPROVE_OPTION) {
File file = fc.getSelectedFile();
oldFile = file;
return file;
} else return null;
}
public void openFile() {
if (!dirty || checkForSave()) {
if (fileChooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
file = fileChooser.getSelectedFile();
} else {
// user cancelled open after all
return;
}
// load file into text view
textView.setText(physReadTextFile(file));
// update status
statusView.setText(" Loaded file \"" + file.getName() + "\".");
// reset dirty bit
dirty = false;
}
}
public JFileChooser createFileChooser() {
// create a filechooser
JFileChooser fc = new JFileChooser();
if (getSwingSet2() != null && getSwingSet2().isDragEnabled()) {
fc.setDragEnabled(true);
}
// set the current directory to be the images directory
File swingFile = new File("resources/images/About.jpg");
if (swingFile.exists()) {
fc.setCurrentDirectory(swingFile);
fc.setSelectedFile(swingFile);
}
return fc;
}
public void actionPerformed(ActionEvent e) {
if (readOnly) {
return;
}
JFileChooser fc = getFileChooser();
File currentDirectory = fc.getCurrentDirectory();
if (!currentDirectory.exists()) {
JOptionPane.showMessageDialog(
fc,
newFolderParentDoesntExistText,
newFolderParentDoesntExistTitleText,
JOptionPane.WARNING_MESSAGE);
return;
}
File newFolder;
try {
newFolder = fc.getFileSystemView().createNewFolder(currentDirectory);
if (fc.isMultiSelectionEnabled()) {
fc.setSelectedFiles(new File[] {newFolder});
} else {
fc.setSelectedFile(newFolder);
}
} catch (IOException exc) {
JOptionPane.showMessageDialog(
fc,
newFolderErrorText + newFolderErrorSeparator + exc,
newFolderErrorText,
JOptionPane.ERROR_MESSAGE);
return;
}
fc.rescanCurrentDirectory();
}
// ask user for script file and name of new profile
// return false if user cancelled operation
private boolean getNewWkldInput(
JFileChooser chooser, Object[] optionDlgMsg, StringBuffer name, StringBuffer scriptFile) {
// let user select script file with queries
boolean fileOk = false;
int retval;
File file = null;
FileReader reader = null;
while (!fileOk) {
if ((retval = chooser.showDialog(this, "Ok")) != 0) {
return false;
}
file = chooser.getSelectedFile();
try {
reader = new FileReader(file.getPath());
fileOk = true;
scriptFile.append(file.getPath());
} catch (FileNotFoundException e) {
JOptionPane.showMessageDialog(
this,
"Selected script file does not exist",
"Error: New Profile",
JOptionPane.ERROR_MESSAGE);
}
}
// let user select filename for profile
int response =
JOptionPane.showOptionDialog(
this,
optionDlgMsg,
"New Profile",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.PLAIN_MESSAGE,
null,
null,
null);
if (response != JOptionPane.OK_OPTION) {
return false;
}
JTextField textFld = (JTextField) optionDlgMsg[1];
name.append(file.getParent() + "/" + textFld.getText());
return true;
}
public SwingDnDFrame() {
setTitle("SwingDnDTest");
JTabbedPane tabbedPane = new JTabbedPane();
JList list = SampleComponents.list();
tabbedPane.addTab("List", list);
JTable table = SampleComponents.table();
tabbedPane.addTab("Table", table);
JTree tree = SampleComponents.tree();
tabbedPane.addTab("Tree", tree);
JFileChooser fileChooser = new JFileChooser();
tabbedPane.addTab("File Chooser", fileChooser);
JColorChooser colorChooser = new JColorChooser();
tabbedPane.addTab("Color Chooser", colorChooser);
final JTextArea textArea = new JTextArea(4, 40);
JScrollPane scrollPane = new JScrollPane(textArea);
scrollPane.setBorder(new TitledBorder(new EtchedBorder(), "Drag text here"));
JTextField textField = new JTextField("Drag color here");
textField.setTransferHandler(new TransferHandler("background"));
tabbedPane.addChangeListener(
new ChangeListener() {
public void stateChanged(ChangeEvent e) {
textArea.setText("");
}
});
tree.setDragEnabled(true);
table.setDragEnabled(true);
list.setDragEnabled(true);
fileChooser.setDragEnabled(true);
colorChooser.setDragEnabled(true);
textField.setDragEnabled(true);
add(tabbedPane, BorderLayout.NORTH);
add(scrollPane, BorderLayout.CENTER);
add(textField, BorderLayout.SOUTH);
pack();
}
/**
* Show the selector for selecting the default folder.
*
* @return true if the user selected a default folder and false if not.
*/
protected boolean showDefaultFolderSelector() throws Exception {
final JFileChooser selector = new JFileChooser(_activeFileChooser.getCurrentDirectory());
selector.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
final String title =
(_subfolderName == null)
? "Default Folder"
: "Default Parent Folder of " + _subfolderName;
selector.setDialogTitle(title);
final int status = selector.showDialog(_view, "Make Default");
switch (status) {
case JFileChooser.APPROVE_OPTION:
final File defaultFolder = selector.getSelectedFile();
if (defaultFolder != null) {
_folderTracker.cacheURL(defaultFolder.toURI().toURL());
return true;
} else {
return false;
}
default:
return false;
}
}
private ObjectOutputStream getObjectOutputStream() {
File f = new File(".");
String loadDirectory = f.getAbsolutePath();
JFileChooser chooser = new JFileChooser(loadDirectory);
chooser.setDialogTitle("Save Generation File As...");
chooser.setMultiSelectionEnabled(false);
int result = chooser.showSaveDialog(this);
File selectedFile = chooser.getSelectedFile();
if (result == JFileChooser.APPROVE_OPTION) {
try {
FileOutputStream fileStream = new FileOutputStream(selectedFile.getPath());
ObjectOutputStream objectStream = new ObjectOutputStream(fileStream);
return objectStream;
} catch (IOException e) {
System.err.println(e);
}
}
return null;
}
protected void installStrings(JFileChooser fc) {
super.installStrings(fc);
Locale l = fc.getLocale();
enterFileNameLabelText = UIManager.getString("FileChooser.enterFileNameLabelText", l);
enterFileNameLabelMnemonic = UIManager.getInt("FileChooser.enterFileNameLabelMnemonic");
filesLabelText = UIManager.getString("FileChooser.filesLabelText", l);
filesLabelMnemonic = UIManager.getInt("FileChooser.filesLabelMnemonic");
foldersLabelText = UIManager.getString("FileChooser.foldersLabelText", l);
foldersLabelMnemonic = UIManager.getInt("FileChooser.foldersLabelMnemonic");
pathLabelText = UIManager.getString("FileChooser.pathLabelText", l);
pathLabelMnemonic = UIManager.getInt("FileChooser.pathLabelMnemonic");
filterLabelText = UIManager.getString("FileChooser.filterLabelText", l);
filterLabelMnemonic = UIManager.getInt("FileChooser.filterLabelMnemonic");
}