/*
* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
* Copyright (C) $$Year-Rel$$ The Jalview Authors
*
* This file is part of Jalview.
*
* Jalview 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 3
* of the License, or (at your option) any later version.
*
* Jalview 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 Jalview. If not, see .
* The Jalview Authors are detailed in the 'AUTHORS' file.
*/
package jalview.gui;
import jalview.gui.OptsAndParamsPage.OptionBox;
import jalview.gui.OptsAndParamsPage.ParamBox;
import jalview.util.MessageManager;
import jalview.ws.api.UIinfo;
import jalview.ws.params.ArgumentI;
import jalview.ws.params.OptionI;
import jalview.ws.params.ParamDatastoreI;
import jalview.ws.params.ParameterI;
import jalview.ws.params.WsParamSetI;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.HierarchyBoundsListener;
import java.awt.event.HierarchyEvent;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.util.Hashtable;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.WindowConstants;
import javax.swing.border.TitledBorder;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import net.miginfocom.swing.MigLayout;
/**
* job parameter editing/browsing dialog box. User can browse existing settings
* (user + presets + Defaults), and any changes to parameters creates a modified
* user parameter set. LOGIC: If the parameter set is modified, and its name is
* a valid, non-existant user parameter set, then a save button is shown. If the
* parameter set is modified and its name is a valid, extant user parameter set,
* then an update button is shown. If user parameter set's name is edited, and
* old name exists as a writable user parameter set, then rename button is
* shown. If current parameter set is associated with a user defined parameter
* set, then : if set is modifed, a 'revert' button is shown. if set is not
* modified, a 'delete' button is shown.
*
* @author JimP
*
*/
public class WsJobParameters extends JPanel implements ItemListener,
ActionListener, DocumentListener, OptsParametersContainerI
{
private static final int PREFERRED_WIDTH = 540;
private static final int DEFAULT_HEIGHT = 640;
// the default parameter set shown to the user
private static final String SVC_DEF = "Defaults";
private int maxOptWidth = 200;
// URL linkImageURL = getClass().getResource("/images/link.gif");
// TODO ABSRACT FROM JABAWS CLASSES
// completion stage representing whether start was clicked
private final CompletableFuture completionStage = new CompletableFuture<>();
/**
* manager for options and parameters.
*/
OptsAndParamsPage opanp;
/*
* panel containing job options
*/
JPanel optionsPanel = new JPanel();
/*
* panel containing job parameters
*/
JPanel paramsPanel = new JPanel();
JPanel setNamePanel = new JPanel();
JButton createpref = new JButton();
JButton deletepref = new JButton();
JButton revertpref = new JButton();
JButton updatepref = new JButton();
JComboBox setName = new JComboBox<>();
JTextArea setDescr = new JTextArea();
JScrollPane paramPane = new JScrollPane();
JButton startjob = JvSwingUtils.makeButton(
MessageManager.getString("action.start_job"),
MessageManager.getString("label.start_job_current_settings"),
this::startjob_actionPerformed);
JButton canceljob = JvSwingUtils.makeButton(
MessageManager.getString("action.cancel_job"),
MessageManager.getString("label.cancel_job_close_dialog"),
this::canceljob_actionPerformed);
ParamDatastoreI paramStore;
// set true when 'Start Job' is clicked
boolean startJob = false;
JFrame frame = null;
UIinfo service;
/*
* list of service presets in the gui
*/
Hashtable servicePresets = null;
/*
* set if dialog is being set - so handlers will avoid spurious events
*/
boolean settingDialog = false;
private Hashtable modifiedElements = new Hashtable<>();
String lastParmSet = null;
public WsJobParameters(ParamDatastoreI store, WsParamSetI preset,
List args)
{
super();
// parameters dialog in 'compact' format (help as tooltips)
opanp = new OptsAndParamsPage(this, true);
jbInit();
this.paramStore = store;
this.service = null;
init(preset, args);
validate();
}
/**
* Constructor given a set of parameters and presets, a service to be invoked,
* and a list of (Jabaws client) arguments
*
* @param paramStorei
* @param service
* @param preset
* @param jobArgset
*/
public WsJobParameters(ParamDatastoreI paramStorei, UIinfo service,
WsParamSetI preset, List jobArgset)
{
super();
// parameters dialog in 'expanded' format (help text boxes)
opanp = new OptsAndParamsPage(this, false);
jbInit();
this.paramStore = paramStorei;
if (paramStore == null && service != null)
{
paramStore = service.getParamStore();
}
this.service = service;
initForService(preset, jobArgset);
validate();
}
/**
* Shows a modal dialog containing the parameters and Start or Cancel options.
* Answers true if the job is started, false if cancelled.
*
* @return
*/
public CompletionStage showRunDialog()
{
frame = new JFrame();
frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
if (service != null)
{
frame.setTitle(MessageManager.formatMessage("label.edit_params_for",
new String[] { service.getActionText() }));
}
Rectangle deskr = Desktop.getInstance().getBounds();
Dimension pref = this.getPreferredSize();
frame.setBounds(
new Rectangle((int) (deskr.getCenterX() - pref.width / 2),
(int) (deskr.getCenterY() - pref.height / 2),
pref.width, pref.height));
frame.setContentPane(this);
// should perhaps recover defaults from user prefs.
frame.validate();
javax.swing.SwingUtilities.invokeLater(new Runnable()
{
@Override
public void run()
{
// jobPanel.setDividerLocation(0.25);
}
});
frame.setVisible(true);
return completionStage;
}
private void jbInit()
{
this.addHierarchyBoundsListener(new HierarchyBoundsListener()
{
@Override
public void ancestorResized(HierarchyEvent arg0)
{
refreshParamLayout();
}
@Override
public void ancestorMoved(HierarchyEvent arg0)
{
// TODO Auto-generated method stub
}
});
updatepref = JvSwingUtils.makeButton(
MessageManager.getString("action.update"),
MessageManager.getString("label.update_user_parameter_set"),
this::update_actionPerformed);
deletepref = JvSwingUtils.makeButton(
MessageManager.getString("action.delete"),
MessageManager.getString("label.delete_user_parameter_set"),
this::delete_actionPerformed);
createpref = JvSwingUtils.makeButton(
MessageManager.getString("action.create"),
MessageManager.getString("label.create_user_parameter_set"),
this::create_actionPerformed);
revertpref = JvSwingUtils.makeButton(
MessageManager.getString("action.revert"),
MessageManager
.getString("label.revert_changes_user_parameter_set"),
this::revert_actionPerformed);
JPanel setDetails = new JPanel();
setDetails.setBorder(
new TitledBorder(MessageManager.getString("label.details")));
setDetails.setLayout(new BorderLayout());
setDescr.setColumns(40);
setDescr.setWrapStyleWord(true);
setDescr.setLineWrap(true);
setDescr.setBackground(getBackground());
setDescr.setEditable(true);
setDescr.getDocument().addDocumentListener(this);
setDescr.setToolTipText(
MessageManager.getString("label.edit_notes_parameter_set"));
JScrollPane setDescrView = new JScrollPane();
setDescrView.getViewport().setView(setDescr);
setName.setEditable(true);
setName.addItemListener(this);
setName.getEditor().addActionListener(this);
JPanel setNameInfo = new JPanel(new FlowLayout(FlowLayout.LEFT));
GridBagLayout gbl = new GridBagLayout();
setNamePanel.setLayout(gbl);
JLabel setNameLabel = new JLabel(
MessageManager.getString("label.current_parameter_set_name"));
setNameLabel.setFont(new java.awt.Font("Verdana", Font.PLAIN, 10));
setNameInfo.add(setNameLabel);
setNameInfo.add(setName);
// initial button visibility
updatepref.setVisible(false);
deletepref.setVisible(false);
revertpref.setVisible(false);
createpref.setVisible(false);
JPanel setsavebuts = new JPanel();
setsavebuts.setLayout(new FlowLayout(FlowLayout.LEFT, 10, 0)); // GridLayout(1,2));
JPanel spacer = new JPanel();
spacer.setPreferredSize(new Dimension(2, 30));
setsavebuts.add(spacer);
setsavebuts.add(deletepref);
setsavebuts.add(revertpref);
setsavebuts.add(createpref);
setsavebuts.add(updatepref);
// setsavebuts.setSize(new Dimension(150, 30));
JPanel buttonArea = new JPanel(new GridLayout(1, 1));
buttonArea.add(setsavebuts);
setNamePanel.add(setNameInfo);
GridBagConstraints gbc = new GridBagConstraints();
gbc.gridheight = 2;
gbl.setConstraints(setNameInfo, gbc);
setNamePanel.add(buttonArea);
gbc = new GridBagConstraints();
gbc.gridx = 0;
gbc.gridy = 2;
gbc.gridheight = 1;
gbl.setConstraints(buttonArea, gbc);
setDetails.add(setDescrView, BorderLayout.CENTER);
// paramPane.setPreferredSize(new Dimension(360, 400));
// paramPane.setPreferredSize(null);
optionsPanel.setBorder(
new TitledBorder(MessageManager.getString("label.options")));
optionsPanel.setOpaque(true);
paramsPanel.setBorder(
new TitledBorder(MessageManager.getString("label.parameters")));
paramsPanel.setOpaque(true);
// optsAndparams.setScrollableWidth(ScrollableSizeHint.FIT);
// optsAndparams.setScrollableHeight(ScrollableSizeHint.NONE);
// optsAndparams.setLayout(new BorderLayout());
JPanel optsAndparams = new JPanel();
optsAndparams.setLayout(new BorderLayout());
optsAndparams.add(optionsPanel, BorderLayout.NORTH);
optsAndparams.add(paramsPanel, BorderLayout.CENTER);
JPanel jp = new JPanel(new BorderLayout());
jp.add(optsAndparams, BorderLayout.CENTER);
paramPane.getViewport().setView(jp);
paramPane.setBorder(null);
setLayout(new BorderLayout());
JPanel jobPanel = new JPanel();
jobPanel.setPreferredSize(null);
jobPanel.setLayout(new BorderLayout());
jobPanel.add(setDetails, BorderLayout.NORTH);
jobPanel.add(paramPane, BorderLayout.CENTER);
// jobPanel.setOrientation(JSplitPane.VERTICAL_SPLIT);
add(setNamePanel, BorderLayout.NORTH);
add(jobPanel, BorderLayout.CENTER);
JPanel dialogpanel = new JPanel();
dialogpanel.add(startjob);
dialogpanel.add(canceljob);
// JAL-1580: setMaximumSize() doesn't work, so just size for the worst case:
// check for null is for JUnit usage
final int windowHeight = Desktop.getInstance() == null ? DEFAULT_HEIGHT
: Desktop.getInstance().getHeight();
setPreferredSize(new Dimension(540, windowHeight));
add(dialogpanel, BorderLayout.SOUTH);
validate();
}
protected void revert_actionPerformed(ActionEvent e)
{
reInitDialog(lastParmSet);
updateWebServiceMenus();
}
protected void update_actionPerformed(ActionEvent e)
{
if (isUserPreset)
{
String curname = ((String) setName.getSelectedItem()).trim();
_updatePreset(lastParmSet, curname);
lastParmSet = curname;
isUserPreset = true;
initArgSetModified();
syncSetNamesWithStore();
}
}
private void _deleteUserPreset(String lastParmSet2)
{
paramStore.deletePreset(lastParmSet2);
}
protected void delete_actionPerformed(ActionEvent e)
{
if (isUserPreset)
{
// delete current preset's saved entry
_deleteUserPreset(lastParmSet);
}
reInitDialog(null); // service default
updateWebServiceMenus();
}
protected void create_actionPerformed(ActionEvent e)
{
String curname = ((String) setName.getSelectedItem()).trim();
if (curname.length() > 0)
{
_storeCurrentPreset(curname);
lastParmSet = curname;
isUserPreset = true;
reInitDialog(curname);
initArgSetModified();
updateWebServiceMenus();
}
else
{
// TODO: show warning
System.err.println("Invalid name. Not saved.");
}
}
protected void canceljob_actionPerformed(ActionEvent e)
{
startJob = false;
if (frame != null)
{
frame.setVisible(false);
}
completionStage.complete(false);
}
protected void startjob_actionPerformed(ActionEvent e)
{
startJob = true;
if (frame != null)
{
frame.setVisible(false);
}
completionStage.complete(true);
}
void initForService(WsParamSetI paramSet, List jobArgset)
{
settingDialog = true;
init(paramSet, jobArgset);
}
void init(WsParamSetI p, List jobArgset)
{
Hashtable exnames = new Hashtable<>();
for (int i = 0, iSize = setName.getItemCount(); i < iSize; i++)
{
exnames.put(setName.getItemAt(i), setName.getItemAt(i));
}
servicePresets = new Hashtable<>();
// Add the default entry - if not present already.
if (!exnames.contains(SVC_DEF))
{
setName.addItem(SVC_DEF);
exnames.put(SVC_DEF, SVC_DEF);
servicePresets.put(SVC_DEF, SVC_DEF);
}
// String curname = (p == null ? "" : p.getName());
for (WsParamSetI pr : paramStore.getPresets())
{
if (!pr.isModifiable())
{
servicePresets.put(pr.getName(), "preset");
}
else
{
}
if (!exnames.contains(pr.getName()))
{
setName.addItem(pr.getName());
}
}
// TODO: if initial jobArgset matches a given user setting or preset then
// should recover setting accordingly
// updateTable(p, jobArgset);
if (p != null)
{
reInitDialog(p.getName());
initArgSetModified();
}
else
{
if (jobArgset != null && jobArgset.size() > 0)
{
curSetName = "Supplied Settings";
isUserPreset = false;
updateTable(p, jobArgset);
setName.setSelectedItem(curSetName);
updateButtonDisplay();
}
else
{
curSetName = null;
reInitDialog(null);
}
}
settingDialog = false;
}
private void updateTable(WsParamSetI p, List jobArgset)
{
boolean setDefaultParams = false;
if (lastParmSet == null)
{
isUserPreset = false;
// First call - so provide Service default settings
setName.setSelectedItem(lastSetName = SVC_DEF);
}
if (p == null && SVC_DEF.equals("" + setName.getSelectedItem()))
{
// indicate that service defaults should be set if available
setDefaultParams = true;
}
// populate table from default parameter set.
List args = paramStore.getServiceParameters();
// split to params and required arguments
{
int cw = 0;
boolean optset = false;
for (ArgumentI myarg : args)
{
// Ideally, Argument would implement isRequired !
if (myarg instanceof ParameterI)
{
ParameterI parm = (ParameterI) myarg;
opanp.addParameter(parm).validate();
}
else
{
if (myarg instanceof OptionI)
{
OptionI opt = (OptionI) myarg;
OptionBox ob = opanp.addOption(opt);
ob.resetToDefault(setDefaultParams);
if (maxOptWidth < ob.getPreferredSize().width)
{
maxOptWidth = ob.getPreferredSize().width;
}
ob.validate();
cw += ob.getPreferredSize().width + 5;
}
else
{
System.err.println("Ignoring unknown service argument type "
+ myarg.getClass().getName());
}
}
}
args = null; // no more args to process.
}
if (p != null)
{
isUserPreset = false;
// initialise setname
setName.setSelectedItem(lastSetName = p.getName());
setDescr.setText(lastDescrText = p.getDescription());
// TODO - URL link
try
{
args = p.getArguments();
} catch (Exception e)
{
e.printStackTrace();
}
// TODO: check if args should be unselected prior to resetting using the
// preset
}
if (jobArgset != null)
{
argSetModified(jobArgset, true);
args = jobArgset;
}
// get setargs from current object
if (args != null)
{
for (ArgumentI arg : args)
{
if (arg instanceof ParameterI)
{
opanp.setParameter((ParameterI) arg);
}
else
{
if (arg instanceof OptionI)
{
// System.out.println("Setting option "
// + System.identityHashCode(arg) + ":" + arg.getName()
// + " with " + arg.getDefaultValue());
opanp.selectOption((OptionI) arg, arg.getValue());
}
}
}
}
refreshParamLayout();
revalidate();
}
private boolean isModified()
{
return modifiedElements.size() > 0;
}
/**
* reset gui and modification state settings
*/
private void initArgSetModified()
{
curSetName = null;
modifiedElements.clear();
updateButtonDisplay();
}
private void updateButtonDisplay()
{
boolean _update = false, _create = false, _delete = false,
_revert = false;
if (modifiedElements.size() > 0)
{
// set modified
_revert = true;
_update = isUserPreset; // can only update user presets
if (!isUserPreset || modifiedElements.containsKey(setName))
{
// name modified - can create new preset
_create = true;
}
}
else
{
// set unmodified
}
// can still delete a user preset
_delete = isUserPreset;
createpref.setVisible(_create);
updatepref.setVisible(_update);
deletepref.setVisible(_delete);
revertpref.setVisible(_revert);
validate();
}
@Override
public void argSetModified(Object modifiedElement, boolean b)
{
if (settingDialog)
{
return;
}
if (!b)
{
modifiedElements.remove(modifiedElement);
}
else
{
if (b && modifiedElement == setName
&& modifiedElements.contains(modifiedElement))
{
// HACK! prevents iteration on makeSetNameValid
b = false;
}
modifiedElements.put(modifiedElement, modifiedElement);
}
// set mod status based on presence of elements in table
if (b && modifiedElements.size() > 0)
{
makeSetNameValid(!isUserPreset);
setNamePanel.revalidate();
}
updateButtonDisplay();
}
private boolean isServicePreset(String selectedItem)
{
return selectedItem.equals(SVC_DEF)
|| servicePresets.containsKey(selectedItem);
}
/**
* check if the current set name is a valid set name for saving, if not, then
* fix it.
*/
private void makeSetNameValid(boolean newuserset)
{
boolean stn = settingDialog;
boolean renamed = false;
settingDialog = true;
String nm = (curSetName != null ? curSetName
: (String) setName.getSelectedItem());
// check if the name is reserved - if it is, rename it.
if (isServicePreset(nm))
{
nm = "User " + nm;
renamed = true;
}
String tnm = nm;
if (newuserset)
{
int i = 0;
while (paramStore.getPreset(tnm) != null)
{
tnm = nm + " (" + (++i) + ")";
renamed = true;
}
if (i > 0)
{
nm = tnm;
}
}
boolean makeupdate = false;
// sync the gui with the preset database
for (int i = 0, iS = setName.getItemCount(); i < iS; i++)
{
String snm = setName.getItemAt(i);
if (snm.equals(nm))
{
makeupdate = true;
// setName.setSelectedIndex(i);
}
}
if (!makeupdate)
{
setName.addItem(curSetName = nm);
setName.setSelectedItem(curSetName);
}
if (renamed)
{
settingDialog = false; // we need this name change to be registered.
argSetModified(setName, renamed);
}
settingDialog = stn;
}
/**
* Rebuilds the Options and Parameters panels
*/
@Override
public void refreshParamLayout()
{
final int rightMargin = 40;
final int availableWidth = paramPane.getViewport().getSize().width
- rightMargin
- optionsPanel.getBorder().getBorderInsets(optionsPanel).left
+ optionsPanel.getBorder().getBorderInsets(optionsPanel).right;
if (opanp.getOptSet().size() > 0)
{
int hgap = 5;
int currentWidth = hgap;
/*
* layout constraint 'nogrid' prevents vertical column alignment,
* allowing controls to flow without extra space inserted to align
*/
optionsPanel.setLayout(new MigLayout("nogrid", "", ""));
optionsPanel.removeAll();
JPanel lastAdded = null;
/*
* add each control in turn; if adding would overflow the right margin,
* remove and re-add the previous parameter with "wrap" (after)
* in order to start a new row
*/
for (OptionBox pbox : opanp.getOptSet().values())
{
pbox.validate();
int boxWidth = pbox.getSize().width;
currentWidth += boxWidth + hgap;
boolean wrapAfterLast = currentWidth > availableWidth
&& lastAdded != null;
// System.out.println(String.format(
// "%s width=%d, paneWidth=%d, currentWidth=%d, wrapAfterLast=%s",
// pbox.toString(), boxWidth, panewidth, currentWidth,
// wrapAfterLast));
if (wrapAfterLast)
{
optionsPanel.remove(lastAdded);
optionsPanel.add(lastAdded, "wrap");
currentWidth = hgap + boxWidth;
}
optionsPanel.add(pbox);
lastAdded = pbox;
}
optionsPanel.revalidate();
}
else
{
optionsPanel.setVisible(false);
}
if (opanp.getParamSet().size() > 0)
{
paramsPanel.removeAll();
paramsPanel.setLayout(new MigLayout("", "", ""));
int hgap = 5;
int currentWidth = hgap;
JPanel lastAdded = null;
for (ParamBox pbox : opanp.getParamSet().values())
{
pbox.validate();
int boxWidth = pbox.getSize().width;
currentWidth += boxWidth + hgap;
boolean wrapAfterLast = currentWidth > availableWidth
&& lastAdded != null;
if (wrapAfterLast)
{
paramsPanel.remove(lastAdded);
paramsPanel.add(lastAdded, "wrap");
currentWidth = pbox.getSize().width + hgap;
}
paramsPanel.add(pbox);
lastAdded = pbox;
}
/*
* s = 2 * sep; for (ParamBox pbox : opanp.getParamSet().values()) {
* pbox.validate(); s += sep +
* pbox.getPreferredSize().height+pbox.getBorder
* ().getBorderInsets(pbox).bottom; }
*
* // paramList.setPreferredSize(new Dimension(w, s));
* os+=s+2*sep+paramList
* .getBorder().getBorderInsets(paramList).bottom+paramList
* .getBorder().getBorderInsets(paramList).top;
*/
paramsPanel.revalidate();
}
else
{
paramsPanel.setVisible(false);
}
// TODO: waste some time trying to eliminate any unnecessary .validate calls
// here
// System.out.println("Size will be : "+w+","+os);
// optsAndparams.setPreferredSize(null);
// paramPane.getViewport().setView(optsAndparams);
paramPane.getViewport().setAutoscrolls(true);
paramPane.revalidate();
revalidate();
}
public boolean isServiceDefaults()
{
return (!isModified()
&& (lastParmSet != null && lastParmSet.equals(SVC_DEF)));
}
public List getJobParams()
{
return opanp.getCurrentSettings();
}
/*
* Hashtable editedParams = new Hashtable();
*
* store the given parameters in the user parameter set database.
*
* @param storeSetName - lastParmSet
*
* @param descr - setDescr.getText()
*
* @param jobParams - getJobParams()
*
* private void _storeUserPreset(String storeSetName, String descr,
* List jobParams) { // this is a simple hash store. Object[] pset;
* editedParams.put(storeSetName, pset = new Object[3]); pset[0] =
* storeSetName; pset[1] = descr; pset[2] = jobParams; // writeParam("Saving "
* + storeSetName + ": ", jobParams); }
*
* private void writeParam(String nm, List params) { for (ArgumentI
* p : params) { System.out.println(nm + ":" + System.identityHashCode(p) +
* " Name: " + p.getName() + " Value: " + p.getDefaultValue()); } }
*
* private Object[] _getUserPreset(String setName) { Object[] pset =
* editedParams.get(setName); // if (pset != null) // writeParam("Retrieving "
* + setName + ": ", (List) pset[2]); return pset; }
*
* * remove the given user preset from the preset stash
*
* @param setName
*
* private void _deleteUserPreset(String setName) {
* editedParams.remove(setName); }
*/
private void syncSetNamesWithStore()
{
int n = 0;
// remove any set names in the drop down menu that aren't either a reserved
// setting, or a user defined or service preset.
Vector items = new Vector<>();
while (n < setName.getItemCount())
{
String item = setName.getItemAt(n);
if (!item.equals(SVC_DEF) && !paramStore.presetExists(item))
{
setName.removeItemAt(n);
}
else
{
items.addElement(item);
n++;
}
}
if (!items.contains(SVC_DEF))
{
setName.addItem(SVC_DEF);
}
for (WsParamSetI upn : paramStore.getPresets())
{
if (!items.contains(upn.getName()))
{
setName.addItem(upn.getName());
}
}
}
/**
* true if lastParmSet is a user preset
*/
boolean isUserPreset = false;
private void reInitDialog(String nextPreset)
{
settingDialog = true;
// updateTable(null,null); // first reset to defaults
WsParamSetI pset = null;
if (nextPreset != null && nextPreset.length() > 0)
{
pset = paramStore.getPreset(nextPreset);
}
if (pset != null)
{
if (pset.isModifiable())
{
isUserPreset = true;
setDescr.setText(pset.getDescription());
updateTable(null, pset.getArguments());
lastParmSet = nextPreset;
}
else
{
isUserPreset = false;
setDescr.setText("");
// must be a default preset from service
updateTable(pset, null);
lastParmSet = nextPreset;
}
}
else
{
isUserPreset = false;
// Service defaults
setDescr.setText("");
updateTable(null, null);
lastParmSet = SVC_DEF;
}
initArgSetModified();
syncSetNamesWithStore();
setName.setSelectedItem(lastParmSet);
setNamePanel.validate();
validate();
settingDialog = false;
}
/**
* Rebuild the AlignFrame web service menus (after add/delete of a preset
* option).
*/
protected void updateWebServiceMenus()
{
if (Desktop.getInstance() == null)
{
return;
}
for (AlignFrame alignFrame : Desktop.getAlignFrames())
{
alignFrame.buildWebServicesMenu();
}
}
String curSetName = null;
@Override
public void itemStateChanged(ItemEvent e)
{
if (e.getSource() == setName
&& e.getStateChange() == ItemEvent.SELECTED)
{
final String setname = (String) setName.getSelectedItem();
// System.out.println("Item state changed for " + setname
// + " (handling ? " + !settingDialog + ")");
if (settingDialog)
{
// ignore event
return;
}
if (setname == null)
{
return;
}
javax.swing.SwingUtilities.invokeLater(new Runnable()
{
@Override
public void run()
{
doPreferenceComboStateChange(setname);
}
});
}
}
private void doPreferenceComboStateChange(String setname)
{
// user has selected a different item from combo-box
if (isModified())
{
String lsetname = (curSetName != null) ? curSetName : lastParmSet;
if (lsetname.equals(setname))
{
// setname was just edited - so ignore this event.
return;
}
settingDialog = true;
System.out.println("Prompting to save " + lsetname);
if (JvOptionPane.showConfirmDialog(this, "Parameter set '" + lsetname
+ "' is modifed, and your changes will be lost.\nReally change preset ?",
"Warning: Unsaved Changes",
JvOptionPane.OK_CANCEL_OPTION) != JvOptionPane.OK_OPTION)
{
// revert the combobox to the current item
settingDialog = true;
setName.setSelectedItem(lsetname);
settingDialog = false;
// and leave.
return;
// System.out.println("Saving for " + lsetname);
// _storeCurrentPreset(lsetname);
}
}
settingDialog = true;
reInitDialog(setname);
settingDialog = false;
}
/**
* store current settings as given name. You should then reset gui.
*
* @param curSetName2
*/
private void _storeCurrentPreset(String curSetName2)
{
paramStore.storePreset(curSetName2, setDescr.getText(), getJobParams());
}
private void _updatePreset(String lastParmSet2, String curname)
{
paramStore.updatePreset(lastParmSet2, curname, setDescr.getText(),
getJobParams());
}
/**
* last saved name for this user preset
*/
String lastSetName = null;
/**
* last saved value of the description text for this user preset
*/
String lastDescrText = null;
@Override
public void actionPerformed(ActionEvent e)
{
if (e.getSource() instanceof Component)
{
Component src = (Component) e.getSource();
if (src.getParent() == setName)
{
// rename any existing records we know about for this set.
String newname = e.getActionCommand().trim();
String msg = null;
if (isServicePreset(newname))
{
final String oldname = curSetName != null ? curSetName
: lastParmSet;
final Component ourframe = this;
settingDialog = true;
setName.getEditor().setItem(oldname);
settingDialog = false;
javax.swing.SwingUtilities.invokeLater(new Runnable()
{
@Override
public void run()
{
JvOptionPane.showMessageDialog(ourframe,
MessageManager.getString(
"label.invalid_name_preset_exists"),
MessageManager.getString("label.invalid_name"),
JvOptionPane.WARNING_MESSAGE);
}
});
return;
}
curSetName = newname;
System.err.println("New name for user setting " + curSetName
+ " (was " + setName.getSelectedItem() + ")");
if (curSetName.equals(setName.getSelectedItem()))
{
curSetName = null;
}
if (curSetName != null)
{
argSetModified(setName, true);
return;
}
}
}
}
private void checkDescrModified()
{
if (!settingDialog)
{
argSetModified(setDescr,
(lastDescrText == null
? setDescr.getText().trim().length() > 0
: !setDescr.getText().equals(lastDescrText)));
}
}
@Override
public void insertUpdate(DocumentEvent e)
{
checkDescrModified();
}
@Override
public void removeUpdate(DocumentEvent e)
{
checkDescrModified();
}
@Override
public void changedUpdate(DocumentEvent e)
{
checkDescrModified();
}
/**
*
* @return null or the service preset selected by the user
*/
public WsParamSetI getPreset()
{
if (isUserPreset || isModified()
|| (lastParmSet != null && lastParmSet.equals(SVC_DEF)))
{
return null;
}
else
{
return paramStore.getPreset(lastParmSet);
}
}
}