package de.FeatureModellingTool.DictEditor.TermiPanelEditor;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.filechooser.*;
import java.io.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import javax.swing.tree.*;
import org.jdom.JDOMException;
import de.FeatureModellingTool.DictEditor.TerminologyModel.Terminology;
import de.FeatureModellingTool.DictEditor.TerminologyModel.TerminologyImpl;
import de.FeatureModellingTool.DictEditor.TerminologyModel.TerminologyModel;
import de.FeatureModellingTool.DictEditor.TerminologyModel.TerminologyModelImpl;
import de.FeatureModellingTool.DictEditor.TerminologyModel.TermiConstants;
import de.FeatureModellingTool.DictEditor.TerminologyModel.TermiGIDGenerator;
import de.FeatureModellingTool.DictEditor.store.TmdlParser;
import de.FeatureModellingTool.DictEditor.store.TmdlParserImpl;
import de.FeatureModellingTool.DictEditor.store.CommonFileFilter;
import de.FeatureModellingTool.DictEditor.store.TermiDictProject;
import de.FeatureModellingTool.DictEditor.event.TermiPropertyChangeListener;
import de.FeatureModellingTool.DictEditor.event.TermiPropertyChangeEvent;
import de.FeatureModellingTool.DictEditor.DictEditorImplementation;
/**
* Recoder: Raymond
* Date: 2003-10-10
* Time: 14:10:58
*/
public class TermiDictGUIMediator
{
private final TermiPropertyChangeListener iptpcListener = new InerInfoPanelTermiPropertyChangeListener();
private final TreeSelectionListener tsListener = new InerTermiTreeSelectionListener();
Color background = new Color(236, 233, 216);;
protected ArrayList projectList = null;
protected TerminologyModel curTermiModel = null;
protected Terminology curTerminology = null;
protected int unSaveModel = 0;
private TmdlParser tmdlParser = new TmdlParserImpl();
private JFileChooser fileChooser = null;
private DictEditorImplementation dictEditor = null;
protected Component container = null;
protected JButton delTermi = null;
protected JButton newTermi = null;
protected DefaultListModel termiListModel = null;
// findPane
JTextField keyField = null;
boolean findPaneIsShow = false;
JPanel findPane = null;
JLabel findLabel = new JLabel("result");
//findList
protected JList findList = new JList();
protected DefaultListModel findListModel = new DefaultListModel();
protected FListListener findlistListener = new FListListener();
protected TModelListListener tModelListListener = new TModelListListener();
public TermiDictGUIMediator(DictEditorImplementation dictEditor)
{
this.dictEditor = dictEditor;
container = (Component) dictEditor.getGlassPane();
termiListModel = dictEditor.getTerminologyPane().getListModel();
keyField = dictEditor.getTerminologyPane().getKeyField();
delTermi = dictEditor.getTermiInfoPane().getDelTermi();
newTermi = dictEditor.getTermiInfoPane().getNewTermi();
// TermiInfoPane listener
dictEditor.getTermiInfoPane().addTermiPropertyChangeListener(iptpcListener);
//tree Listener
dictEditor.getTerminologyPane().getTree().addTreeSelectionListener(tsListener);
//modelList listener
dictEditor.getTerminologyPane().getTermiList().addListSelectionListener(tModelListListener);
newTermi.addActionListener
(
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
creatTerminology();
}
}
);
delTermi.addActionListener
(
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
delTerminology();
}
}
);
dictEditor.getTerminologyPane().getAddBt().addActionListener
(
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
openTermiFile();
}
}
);
dictEditor.getTerminologyPane().getCreatBt().addActionListener
(
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
newButtonResponse();
}
}
);
dictEditor.getTerminologyPane().getSaveBt().addActionListener
(
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
saveTermiDict();
}
}
);
dictEditor.getTerminologyPane().getSaveASBt().addActionListener
(
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
saveASTermiDict();
}
}
);
keyField.addActionListener
(
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if (curTermiModel==null)
return;
int fnum;
fnum = findSearchTerminology(keyField.getText());
if (fnum > 0)
{
if (!findPaneIsShow)
{
createFindPane();
}
findPane.setVisible(true);
if (fnum == 1)
{
findLabel.setText("1 Topic Found");
}
else
{
findLabel.setText(fnum + " Topics Found");
System.out.println("Topics Found :--" + findListModel.size());
}
showFindTerminology();
}
else
{
if (findPaneIsShow)
{
findPane.setVisible(false);
}
IndexSearchTerminology();
// warning dialog...
container.setVisible(true);
JOptionPane.showInternalMessageDialog(container, "show the next terminology alphabetically",
"No terminology found", JOptionPane.WARNING_MESSAGE);
container.setVisible(false);
}
}
}
);
}
public void setCurTermiModel(TerminologyModel terminologyModel)
{
this.curTermiModel = terminologyModel;
}
public void setCurTerminology(Terminology terminology)
{
this.curTerminology = terminology;
}
public void setFindList(DefaultListModel featureListModel)
{
findList.setModel(findListModel);
findList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
findList.setVisibleRowCount(5);
findList.setBackground(background);
findList.addListSelectionListener(findlistListener);
}
///Panel
protected void createFindPane()
{
//findPane
findPane = new JPanel();
setFindList(findListModel);
findPane.setLayout(new BoxLayout(findPane, BoxLayout.Y_AXIS));
findPane.add(Box.createRigidArea(new Dimension(10, 1)));
findPane.add(findLabel, BorderLayout.NORTH);
findPane.add(new JScrollPane(findList));
dictEditor.getTerminologyPane().getTreePane().add(findPane, BorderLayout.SOUTH);
dictEditor.getTerminologyPane().getTreePane().updateUI();
// set the flag
findPaneIsShow = true;
}
///methods
public void IndexSearchTerminology()
{
Terminology terminology = indexSearchTermiModel(keyField.getText(), curTermiModel);
if (terminology != null)
{
DefaultMutableTreeNode node = dictEditor.getTerminologyPane().getTree().getTerminologyNode(curTermiModel, terminology);
//setTerminology
setCurTerminology(terminology);
dictEditor.getTermiInfoPane().setTerminology(terminology);
if (newTermi.isEnabled())
newTermi.setEnabled(false);
if (delTermi.isEnabled())
delTermi.setEnabled(false);
/*
//TreePath newPath = new TreePath(dictGUI.getTerminologyPane().getTree().getModel().getPathToRoot((TreeNode) node));
dictGUI.getTerminologyPane().getTree().setSelectionRow(3);//.
TreePath newPath = dictGUI.getTerminologyPane().getTree().getPathForRow(4);
dictGUI.getTerminologyPane().getTree().setSelectionPath(newPath );
System.out.println(dictGUI.getTerminologyPane().getTree().getRowForPath(newPath));
*/ // getPathForRow
}
}
private Terminology indexSearchTermiModel(String key, TerminologyModel terminologyModel)
{
Terminology terminology = null;
Iterator iter = terminologyModel.getTerminologyTree().iterator();
while (iter.hasNext())
{
terminology = (Terminology) iter.next();
String fname = terminology.getName();
if ((key.compareTo(fname) == 0) || (key.compareTo(fname) < 0))
{
return terminology;
}
}
return terminology;
}
public int findSearchTerminology(String key)
{
findListModel.clear();
Map allTerminology = curTermiModel.getAllTerminology();
if (allTerminology != null)
{
Iterator terminologyIterator = allTerminology.keySet().iterator();
Terminology terminology;
while (terminologyIterator.hasNext())
{
terminology = (Terminology) allTerminology.get(terminologyIterator.next());
String tname = terminology.getName();
if (tname.indexOf(key) > -1)
{
findListModel.addElement(terminology);
}
}
}
return findListModel.size();
}
public void showFindTerminology()
{
//terminologyTree.clearSelection();
findList.setSelectedIndex(0);
Terminology terminology = (Terminology) findListModel.getElementAt(0);
//set terminolgoy;
keyField.setText(terminology.getName());
//setTerminology
setCurTerminology(terminology);
dictEditor.getTermiInfoPane().setTerminology(terminology);
if (newTermi.isEnabled())
newTermi.setEnabled(false);
if (delTermi.isEnabled())
delTermi.setEnabled(false);
}
public void termiModelListSelected()
{
int num = dictEditor.getTerminologyPane().getTermiList().getSelectedIndex();
if (num < 0)
{
return;
}
if (termiListModel.getElementAt(0).toString().equals("no dictionary opened"))
return;
TerminologyModel terminologyModel = (TerminologyModel) termiListModel.getElementAt(num);
if (!terminologyModel.equals(curTermiModel))
{
setCurTermiModel(terminologyModel);
setCurTerminology(null);
//clear tree Selection
dictEditor.getTerminologyPane().getTree().getSelectionModel().clearSelection();
// diable delTermi button
if (delTermi.isEnabled())
delTermi.setEnabled(false);
}
}
public void findListSelected()
{
if ( findList== null)
return;
int num = findList.getSelectedIndex();
if (num < 0)
{
return;
}
Terminology terminology = (Terminology) findListModel.getElementAt(num);
if (terminology == null)
{
System.out.println("terminology findListSelected error!");
return;
}
keyField.setText(terminology.getName());
//clear tree Selection
dictEditor.getTerminologyPane().getTree().getSelectionModel().clearSelection();
//setTerminology
setCurTerminology(terminology);
dictEditor.getTermiInfoPane().setTerminology(terminology);
if (newTermi.isEnabled())
newTermi.setEnabled(false);
if (delTermi.isEnabled())
delTermi.setEnabled(false);
}
protected void saveASTermiDict()
{
if (curTermiModel == null)
{
container.setVisible(true);
JOptionPane.showInternalMessageDialog(container, "no terminologyMedel opend.", "warning", JOptionPane.ERROR_MESSAGE);
container.setVisible(false);
return;
}
TermiDictProject dictProject = null;
File prjFile = creatDictInfoFromUser(curTermiModel);
if (prjFile == null)
{
return;
}
try
{
tmdlParser.saveTmdl(prjFile, curTermiModel);
} catch (IOException e)
{
System.out.println("File not found");
return;
} catch (JDOMException e)
{
System.out.println("JDOM error");
return;
}
dictProject = new TermiDictProject(curTermiModel.getName(), prjFile);
dictProject.setTerminologyModel(curTermiModel);
dictProject.setValidity(true);
if (projectList == null)
projectList = new ArrayList();
projectList.add(dictProject);
}
protected void saveTermiDict()
{
if (curTermiModel == null)
{
container.setVisible(true);
JOptionPane.showInternalMessageDialog(container, "no terminologyMedel opend.", "warning", JOptionPane.ERROR_MESSAGE);
container.setVisible(false);
return;
}
File prjFile = null;
if (projectList != null)
{
for (int i = 0; i < projectList.size(); i++)
{
TermiDictProject tempProject = (TermiDictProject) projectList.get(i);
if (tempProject.getName().equals(curTermiModel.getName()))
{
prjFile = tempProject.getFile();
break;
}
}
}
if (prjFile != null)
{
try
{
tmdlParser.saveTmdl(prjFile, curTermiModel);
} catch (IOException e)
{
System.out.println("File not found");
return;
} catch (JDOMException e)
{
System.out.println("JDOM error");
return;
}
}
else
{
saveASTermiDict();
return;
}
}
// creat a null file
protected File creatDictInfoFromUser(TerminologyModel terminologyModel)
{
String title = "Save Terminology Dictionary";
if (fileChooser == null)
{
fileChooser = new JFileChooser(FileSystemView.getFileSystemView());
}
fileChooser.setBackground(new Color(218, 218, 206));
NewDictInfoPane dictInfoPane = new NewDictInfoPane();
dictInfoPane.setFileChooser(fileChooser);
for (; ;)
{
container.setVisible(true);
int result = JOptionPane.showInternalConfirmDialog(container, dictInfoPane, title,
JOptionPane.OK_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE);
if (result == 0)
{
if (dictInfoPane.isInfoValid() == false)
{
JOptionPane.showInternalMessageDialog(container, dictInfoPane.getErrorInfo(), "warning", JOptionPane.ERROR_MESSAGE);
container.setVisible(false);
continue;
}
else
{
terminologyModel.setName(dictInfoPane.getDictName());
terminologyModel.setDescription(dictInfoPane.getDescription());
}
}
container.setVisible(false);
break;
}
return dictInfoPane.getDictionaryFile();
}
protected void openTermiFile()
{
javax.swing.filechooser.FileFilter fileFilter = new CommonFileFilter("tdn", "Terminology Dictionary Files (*.tdn)");
File selectedFile = null;
if (fileChooser == null)
{
fileChooser = new JFileChooser(FileSystemView.getFileSystemView());
}
fileChooser.setDialogTitle("selcet dictionary file");
fileChooser.setDialogType(JFileChooser.OPEN_DIALOG);
fileChooser.setFileFilter(fileFilter);
if (fileChooser.showOpenDialog(container) == JFileChooser.APPROVE_OPTION)
{
selectedFile = fileChooser.getSelectedFile();
}
else
{
fileChooser.resetChoosableFileFilters();
return;
}
TermiDictProject dictProject = new TermiDictProject();
dictProject.setFile(selectedFile);
TerminologyModel newModel = new TerminologyModelImpl();
try
{
tmdlParser.openTmdl(selectedFile, newModel);
} catch (FileNotFoundException fnfe)
{
System.out.println("not find file: " + selectedFile.getPath());
return;
} catch (IOException e)
{
System.out.println("File not found");
} catch (JDOMException e)
{
System.out.println("JDOM error");
}
if (projectList != null)
{
for (int i = 0; i < projectList.size(); i++)
{
TermiDictProject tempProject = (TermiDictProject) projectList.get(i);
if (tempProject.getName().equals(newModel.getName()))
{
container.setVisible(true);
JOptionPane.showInternalMessageDialog(container, "duplicate terminologyMedel.", "warning", JOptionPane.ERROR_MESSAGE);
container.setVisible(false);
return;
}
}
}
else
{
projectList = new ArrayList();
}
// add into view
addTermiModel(newModel);
// set dictProject.
dictProject.setTerminologyModel(newModel);
dictProject.setName(newModel.getName());
// add into projectList
projectList.add(dictProject);
// show the discription
JLabel desLabel = new JLabel("This terminologyModel is descripted as");
JTextArea descriptionArea = new JTextArea(6, 20);
JScrollPane scrollPane = new JScrollPane();
JPanel showPane = new JPanel(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();
descriptionArea.setBackground(background);
descriptionArea.setLineWrap(true);
descriptionArea.setEditable(false);
//descriptionArea.setWrapStyleWord(false);
scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
scrollPane.setViewportView(descriptionArea);
descriptionArea.setText(newModel.getDescription());
gbc.gridx = 0;
gbc.anchor = GridBagConstraints.NORTHWEST;
showPane.add(desLabel, gbc);
showPane.add(Box.createVerticalStrut(10), gbc);
showPane.add(scrollPane, gbc);
//ff;
container.setVisible(true);
JOptionPane.showInternalMessageDialog(container, showPane, "TerminologyModel Description", JOptionPane.INFORMATION_MESSAGE);
container.setVisible(false);
}
protected void newButtonResponse()
{
if ((curTermiModel != null) && curTermiModel.getName().indexOf("Untitled") > -1)
{
Object message[] = {" Unsaved Changes", "", "Save it?", };
String title = "Unsaved Changes";
container.setVisible(true);
int result = JOptionPane.showInternalConfirmDialog(container,
message, title, JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE);
container.setVisible(false);
switch (result)
{
case JOptionPane.YES_OPTION:
saveTermiDict();
break;
case JOptionPane.NO_OPTION:
{
dictEditor.getTerminologyPane().getTree().removeTerminologyModel(curTermiModel);
curTermiModel.clear();
dictEditor.getTerminologyPane().getTree().addTerminologyModel(curTermiModel);
break;
}
case JOptionPane.CANCEL_OPTION:
break;
}
}
else
{
newTermiModel();
}
}
protected void newTermiModel()
{
TerminologyModel tempTerminologyModel = null;
if (unSaveModel == 0)
{
tempTerminologyModel = new TerminologyModelImpl("Untitled");
unSaveModel++;
}
else
tempTerminologyModel = new TerminologyModelImpl("Untitled--" + unSaveModel++);
addTermiModel(tempTerminologyModel);
}
public void addTermiModel(TerminologyModel terminologyModel)
{
// update tree and list
if (termiListModel.getElementAt(0).toString().equals("no dictionary opened"))
termiListModel.clear();
termiListModel.addElement(terminologyModel);
dictEditor.getTerminologyPane().getTree().addTerminologyModel(terminologyModel);
//setCurTermiModel
setCurTermiModel(terminologyModel);
//reset buttons
newTermi.setEnabled(true);
if (delTermi.isEnabled())
delTermi.setEnabled(false);
//set cur terminology
setCurTerminology(null);
}
public void delTerminology()
{
if (curTerminology == null)
return;
// remove this terminology from TerminologyModel
curTermiModel.removeTerminology(curTerminology);
//remove this terminology from treeView
dictEditor.getTerminologyPane().getTree().removeTerminologyNode(curTermiModel.getName(), curTerminology);
//clear curTerminology
setCurTerminology(null);
dictEditor.getTermiInfoPane().setTerminology(null);
//diable delete button
delTermi.setEnabled(false);
}
public void setListIndexAccording(TerminologyModel terminologyModel)
{
int indexP;
JList mList = dictEditor.getTerminologyPane().getTermiList();
for (indexP = 0; indexP < termiListModel.size(); indexP++)
{
TerminologyModel tempModel = (TerminologyModel) termiListModel.getElementAt(indexP);
if (tempModel.getName().equals(terminologyModel.getName()))
{
if (mList.getSelectedIndex() != indexP)
mList.setSelectedIndex(indexP);
break;
}
}
if (indexP == termiListModel.size())
System.out.println("TerminologyModel not found in the list.");
}
public void creatTerminology()
{
Terminology tempTermi = new TerminologyImpl(TermiGIDGenerator.getInstance().createTermiID());
String message = " Please Enter New Terminology Name";
container.setVisible(true);
String name = JOptionPane.showInternalInputDialog(container, message);
container.setVisible(false);
if (name == null)
return;
else
{
tempTermi.setName(name);
}
curTermiModel.addTerminology(tempTermi);
dictEditor.getTerminologyPane().getTree().addTerminologyNode(curTermiModel.getName(), tempTermi);
dictEditor.getTermiInfoPane().setTerminology(tempTermi);
dictEditor.getTermiInfoPane().setEditable(true);
}
private class InerInfoPanelTermiPropertyChangeListener implements TermiPropertyChangeListener
{
public void propertyChange(TermiPropertyChangeEvent evt)
{
Terminology terminology = (Terminology) curTermiModel.getAllTerminology().get((String) evt.getSource());
if (evt.getPropertyName().equals(TermiConstants.NAME))
{
terminology.setName((String) evt.getNewValue());
dictEditor.getTerminologyPane().getTree().updateUI();
}
else if (evt.getPropertyName().equals(TermiConstants.SOURCE))
{
terminology.setSource((String) evt.getNewValue());
}
else if (evt.getPropertyName().equals(TermiConstants.SYNONYM))
{
terminology.setSynonym((String) evt.getNewValue());
}
else if (evt.getPropertyName().equals(TermiConstants.DESCRIPTION))
{
terminology.setDescription((String) evt.getNewValue());
}
}
}
private class InerTermiTreeSelectionListener implements TreeSelectionListener
{
public void valueChanged(TreeSelectionEvent event)
{
TreePath path = event.getNewLeadSelectionPath();
if (path == null)
{
System.out.println("Selection cleared.");
return;
}
else
{
DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) path.getLastPathComponent();
Object selectedObject = selectedNode.getUserObject();
if (selectedObject instanceof TerminologyModel) //(path.getPathCount() == 2) dictionary node is selected.
{
//change current curTermiModel
curTermiModel = (TerminologyModel) selectedObject;
//dictGUI.getTermiInfoPane().setTerminology(null);
setCurTerminology(null);
// set buttons enable
if (delTermi.isEnabled())
delTermi.setEnabled(false);
if (!newTermi.isEnabled())
newTermi.setEnabled(true);
delTermi.setEnabled(false);
// setListIndexAccording
setListIndexAccording(curTermiModel);
}
else if (selectedObject instanceof TerminologyImpl)//Terminology node is selected.
{
//get the dictionary name
DefaultMutableTreeNode dictNode = (DefaultMutableTreeNode) selectedNode.getParent();
curTermiModel = (TerminologyModel) dictNode.getUserObject();
//setListIndexAccording(curTermiModel);
setListIndexAccording(curTermiModel);
Terminology terminology = (Terminology) selectedObject;
dictEditor.getTermiInfoPane().setTerminology(terminology);
setCurTerminology(terminology);
// set buttons enable
if (!delTermi.isEnabled())
delTermi.setEnabled(true);
if (!newTermi.isEnabled())
newTermi.setEnabled(true);
}
}
}
}
///class
class TModelListListener implements ListSelectionListener
{
public void valueChanged(ListSelectionEvent e)
{
if (!e.getValueIsAdjusting())
{
termiModelListSelected();
}
}
}
class FListListener implements ListSelectionListener
{
public void valueChanged(ListSelectionEvent e)
{
if (!e.getValueIsAdjusting())
{
findListSelected();
}
}
}
}
class NewDictInfoPane extends JPanel
{
protected JLabel dictNameLabel = new JLabel("Name");
protected JLabel descriptionLabel = new JLabel("Description");
protected JLabel pathLabel = new JLabel("Save Path");
protected JTextField dictNameField = new JTextField(25);
protected JTextArea descriptionArea = new JTextArea(6, 25);
protected JScrollPane scrollpane = new JScrollPane(descriptionArea);
protected JTextField pathField = new JTextField(25);
protected JButton pathButton = new JButton("...");
protected File currentPath = null;
protected String name = null;
protected String description = null;
protected String errorInfo = null;
protected File dictFile = null;
protected JFileChooser fileChooser = null;
private JFrame container = null;
private String fileChooserTitle = null;
private int fileChooserSelectionMode = -1;
private int fileChooserType = JFileChooser.OPEN_DIALOG;
public NewDictInfoPane()
{
super();
init();
}
protected void init()
{
GridBagLayout gbl = new GridBagLayout();
GridBagConstraints gbc = new GridBagConstraints();
setLayout(gbl);
descriptionArea.setLineWrap(true);
descriptionArea.setWrapStyleWord(false);
scrollpane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
Dimension size = pathButton.getMinimumSize();
size.setSize(size.getWidth(), size.getHeight() - 6);
pathButton.setMinimumSize(size);
pathButton.setPreferredSize(pathButton.getMinimumSize());
//row1
gbc.anchor = GridBagConstraints.NORTHWEST;
gbc.gridwidth = 1;
add(Box.createHorizontalStrut(10), gbc);
add(dictNameLabel, gbc);
add(Box.createHorizontalStrut(15), gbc);
gbc.gridwidth = GridBagConstraints.REMAINDER;
gbc.weightx = 1.0;
add(dictNameField, gbc);
gbc.weightx = 0;
add(Box.createVerticalStrut(10), gbc);
//row2
gbc.gridwidth = 1;
add(Box.createHorizontalStrut(10), gbc);
add(descriptionLabel, gbc);
add(Box.createHorizontalStrut(15), gbc);
gbc.gridwidth = GridBagConstraints.REMAINDER;
gbc.weightx = 1.0;
add(scrollpane, gbc);
gbc.weightx = 0;
add(Box.createVerticalStrut(10), gbc);
//row3
gbc.gridwidth = 1;
add(Box.createHorizontalStrut(10), gbc);
add(pathLabel, gbc);
add(Box.createHorizontalStrut(15), gbc);
add(pathField, gbc);
add(Box.createHorizontalStrut(15), gbc);
gbc.gridwidth = GridBagConstraints.REMAINDER;
gbc.weightx = 1.0;
add(pathButton, gbc);
gbc.weightx = 0;
add(Box.createVerticalStrut(10), gbc);
pathButton.addActionListener(
new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
JFileChooser pathChooser = createNewDictPathChooser();
if (pathChooser.showDialog(container, "choose") == JFileChooser.APPROVE_OPTION)
{
currentPath = pathChooser.getSelectedFile();
pathField.setText(currentPath.getAbsolutePath());
pathField.setCaretPosition(0);
}
releaseNewDictPathChooser();
}
}
);
pathField.setEditable(true);
pathField.setCursor(Cursor.getPredefinedCursor(Cursor.TEXT_CURSOR));
clear();
}
public void setFileChooser(JFileChooser fileChooser)
{
this.fileChooser = fileChooser;
}
public void setContainer(JFrame container)
{
this.container = container;
}
public String getDictName()
{
return dictNameField.getText();
}
public String getDescription()
{
return descriptionArea.getText();
}
public String getStoreDirectory()
{
return pathField.getText();
}
public void clear()
{
dictNameField.setText("");
descriptionArea.setText("");
currentPath = null;
pathField.setText("");
dictFile = null;
}
public boolean isInfoValid()
{
if ((dictNameField.getText() == null) || (dictNameField.getText().equals("")))
{
errorInfo = "Please input the name.";
return false;
}
if ((pathField.getText() == null) || (pathField.getText().equals("")))
{
errorInfo = "Please choose a direcionary.";
return false;
}
File filDirectory = new File(pathField.getText());
if (filDirectory.isDirectory() == false)
{
try
{
filDirectory.mkdirs();
} catch (SecurityException e)
{
errorInfo = "Creat file failure, make a check please.";
dictFile = null;
return false;
}
}
String filePath = pathField.getText() + "\\" + dictNameField.getText() + "." + "tdn";
dictFile = new File(filePath);
if (dictFile.exists())
{
errorInfo = "duplicate file name.";
dictFile = null;
return false;
}
try
{
if (!dictFile.createNewFile())
{
errorInfo = "Creat file failure, make a check please.";
dictFile = null;
return false;
}
} catch (IOException e)
{
errorInfo = "Creat file failure, make a check please.";
dictFile = null;
return false;
}
if (!dictFile.isFile())
{
errorInfo = "Invalid file name or direction name.";
dictFile = null;
return false;
}
return true;
}
public File getDictionaryFile()
{
return dictFile;
}
public String getErrorInfo()
{
return errorInfo;
}
protected JFileChooser createNewDictPathChooser()
{
fileChooserTitle = fileChooser.getDialogTitle();
fileChooserType = fileChooser.getDialogType();
fileChooserSelectionMode = fileChooser.getFileSelectionMode();
fileChooser.setDialogTitle("Choose a directionary...");
fileChooser.setDialogType(JFileChooser.OPEN_DIALOG);
fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
return fileChooser;
}
protected void releaseNewDictPathChooser()
{
fileChooser.setDialogTitle(fileChooserTitle);
fileChooser.setDialogType(fileChooserType);
fileChooser.setFileSelectionMode(fileChooserSelectionMode);
}
}