/*
* 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 optSet = new LinkedHashMap<>();
Map paramSet = new LinkedHashMap<>();
/*
* compact or verbose style parameters
*/
boolean compact = false;
OptsParametersContainerI poparent;
/**
* A class that models a panel rendering a single option (checkbox or choice
* list)
*/
public class OptionBox extends JPanel
implements MouseListener, ActionListener
{
JCheckBox enabled;
final URL finfo;
boolean hasLink = false;
boolean initEnabled = false;
String initVal = null;
OptionI option;
JComboBox val;
/**
* Constructs and adds labels and controls to the panel for one Option
*
* @param opt
*/
public OptionBox(OptionI opt)
{
option = opt;
setLayout(new FlowLayout(FlowLayout.LEFT));
enabled = new JCheckBox(opt.getLabel());
enabled.setSelected(opt.isRequired());
/*
* If option is required, show a label, if optional a checkbox
* (but not for Jabaws pending JWS-126 resolution)
*/
if (opt.isRequired() && !(opt instanceof JabaOption))
{
finfo = null;
add(new JLabel(opt.getLabel()));
}
else
{
finfo = option.getFurtherDetails();
configureCheckbox(opt);
add(enabled);
}
/*
* construct the choice box with possible values,
* or their display names if provided
*/
val = buildComboBox(opt);
val.setSelectedItem(opt.getValue());
/*
* only show the choicebox if there is more than one option,
* or the option is mandatory
*/
if (opt.getPossibleValues().size() > 1 || opt.isRequired())
{
val.addActionListener(this);
add(val);
}
setInitialValue();
}
/**
* Configures the checkbox that controls whether or not the option is
* selected
*
* @param opt
*/
protected void configureCheckbox(OptionI opt)
{
enabled.setFont(new Font("Verdana", Font.PLAIN, 11));
enabled.addActionListener(this);
final String desc = opt.getDescription();
if (finfo != null)
{
hasLink = true;
String description = desc;
if (desc == null || desc.trim().isEmpty())
{
description = MessageManager
.getString("label.opt_and_params_further_details");
}
description = description + " choicebox;
/*
* radio buttons as an alternative to combo box
*/
ButtonGroup buttonGroup;
JPanel controlsPanel = new JPanel();
boolean descriptionIsVisible = false;
JScrollPane descPanel = new JScrollPane();
final URL finfo;
Object lastVal;
ParameterI parameter;
final OptsParametersContainerI pmdialogbox;
JPanel settingPanel = new JPanel();
JSlider slider;
JTextArea descriptionText = new JTextArea();
ValueConstrainI validator;
JTextField valueField;
private String descTooltip;
public ParamBox(final OptsParametersContainerI paramContainer,
ParameterI parm)
{
pmdialogbox = paramContainer;
finfo = parm.getFurtherDetails();
validator = parm.getValidValue();
parameter = parm;
isLogarithmicParameter = parm instanceof LogarithmicParameter;
if (validator != null)
{
ValueType type = validator.getType();
isIntegerParameter = type == ValueType.Integer;
isStringParameter = type == ValueType.String
|| type == ValueType.File;
/*
* ensure slider has an integer range corresponding to
* the min-max range of the parameter
*/
if (validator.getMin() != null && validator.getMax() != null
// && !isIntegerParameter
&& !isStringParameter)
{
double min = validator.getMin().doubleValue();
double max = validator.getMax().doubleValue();
if (isLogarithmicParameter)
{
min = Math.log(min);
max = Math.log(max);
}
sliderScaleFactor = (int) (1000000 / (max - min));
// todo scaleMin, scaleMax could also be final fields
}
}
List possibleValues = parameter.getPossibleValues();
isChoiceParameter = possibleValues != null
&& !possibleValues.isEmpty();
if (compact)
{
addCompactParameter(parm);
}
else
{
addExpandableParam(parm);
}
}
/**
* Adds a 'compact' format parameter, with any help text shown as a tooltip
*
* @param parm
*/
private void addCompactParameter(ParameterI parm)
{
setLayout(new MigLayout("", "[][grow]"));
String ttipText = null;
controlsPanel.setLayout(new BorderLayout());
if (parm.getDescription() != null
&& parm.getDescription().trim().length() > 0)
{
ttipText = (JvSwingUtils.wrapTooltip(true,
parm.getDescription() + (finfo != null ? "
* if a text input, returns the trimmed value
* if a choice list or radio button, returns the selected value
* if a value slider and input field, sets the value of the slider from
* the value in the text field, limiting it to any defined min-max
* range.
*
* Answers the (possibly modified) input value, as a String, Integer, Float
* or Double.
*
* @return
*/
Object updateSliderFromValueField()
{
if (validator == null || isStringParameter)
{
if (isChoiceParameter)
{
if (parameter instanceof RadioChoiceParameter)
{
return buttonGroup.getSelection().getActionCommand();
}
else
{
return getSelectedValue(this.parameter,
choicebox.getSelectedIndex());
}
}
slider.setVisible(false);
return valueField.getText().trim();
}
if (validator.getMin() == null || validator.getMax() == null)
{
slider.setVisible(false);
}
valueField.setText(valueField.getText().trim());
/*
* ensure not outside min-max range
* TODO: provide some visual indicator if limit reached
*/
try
{
valueField.setBackground(Color.WHITE);
double d = Double.parseDouble(valueField.getText());
if (validator.getMin() != null
&& validator.getMin().doubleValue() > d)
{
valueField.setText(formatNumber(validator.getMin()));
}
if (validator.getMax() != null
&& validator.getMax().doubleValue() < d)
{
valueField.setText(formatNumber(validator.getMax()));
}
} catch (NumberFormatException e)
{
valueField.setBackground(Color.yellow);
return Float.NaN;
}
if (isIntegerParameter)
{
int iVal = 0;
try
{
iVal = Integer.valueOf(valueField.getText());
} catch (Exception e)
{
valueField.setBackground(Color.yellow);
return Integer.valueOf(0);
}
if (validator.getMin() != null && validator.getMax() != null)
{
slider.getModel().setRangeProperties(iVal, 1,
validator.getMin().intValue(),
validator.getMax().intValue() + 1, true);
}
else
{
slider.setVisible(false);
}
return Integer.valueOf(iVal);
}
if (isLogarithmicParameter)
{
double dVal = 0d;
try
{
double eValue = Double.valueOf(valueField.getText());
dVal = Math.log(eValue);
} catch (Exception e)
{
// shouldn't be possible here
valueField.setBackground(Color.yellow);
return Double.NaN;
}
if (validator.getMin() != null && validator.getMax() != null)
{
double scaleMin = Math.log(validator.getMin().doubleValue())
* sliderScaleFactor;
double scaleMax = Math.log(validator.getMax().doubleValue())
* sliderScaleFactor;
slider.getModel().setRangeProperties(
(int) (sliderScaleFactor * dVal), 1,
(int) scaleMin, 1 + (int) scaleMax, true);
}
else
{
slider.setVisible(false);
}
return Double.valueOf(dVal);
}
float fVal = 0f;
try
{
fVal = Float.valueOf(valueField.getText());
} catch (Exception e)
{
return Float.valueOf(0f); // shouldn't happen
}
if (validator.getMin() != null && validator.getMax() != null)
{
float scaleMin = validator.getMin().floatValue()
* sliderScaleFactor;
float scaleMax = validator.getMax().floatValue()
* sliderScaleFactor;
slider.getModel().setRangeProperties(
(int) (fVal * sliderScaleFactor), 1, (int) scaleMin,
1 + (int) scaleMax, true);
}
else
{
slider.setVisible(false);
}
return Float.valueOf(fVal);
}
}
/**
* Constructor with the option to show 'compact' format (parameter description
* as tooltip) or 'expanded' format (parameter description in a textbox which
* may be opened or closed). Use compact for simple description text, expanded
* for more wordy or formatted text.
*
* @param paramContainer
*/
public OptsAndParamsPage(OptsParametersContainerI paramContainer,
boolean compact)
{
poparent = paramContainer;
this.compact = compact;
}
public static void showUrlPopUp(JComponent invoker, final String finfo,
int x, int y)
{
JPopupMenu mnu = new JPopupMenu();
JMenuItem mitem = new JMenuItem(
MessageManager.formatMessage("label.view_params", new String[]
{ finfo }));
mitem.addActionListener(new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
Desktop.showUrl(finfo);
}
});
mnu.add(mitem);
mnu.show(invoker, x, y);
}
public Map getOptSet()
{
return optSet;
}
public void setOptSet(Map optSet)
{
this.optSet = optSet;
}
public Map getParamSet()
{
return paramSet;
}
public void setParamSet(Map paramSet)
{
this.paramSet = paramSet;
}
OptionBox addOption(OptionI opt)
{
OptionBox cb = optSet.get(opt.getName());
if (cb == null)
{
cb = new OptionBox(opt);
optSet.put(opt.getName(), cb);
// jobOptions.add(cb, FlowLayout.LEFT);
}
return cb;
}
ParamBox addParameter(ParameterI arg)
{
ParamBox pb = paramSet.get(arg.getName());
if (pb == null)
{
pb = new ParamBox(poparent, arg);
paramSet.put(arg.getName(), pb);
// paramList.add(pb);
}
pb.init();
// take the defaults from the parameter
pb.updateControls(arg);
return pb;
}
void selectOption(OptionI option, String string)
{
OptionBox cb = optSet.get(option.getName());
if (cb == null)
{
cb = addOption(option);
}
cb.enabled.setSelected(string != null); // initial state for an option.
if (string != null)
{
if (option.getPossibleValues().contains(string))
{
cb.val.setSelectedItem(string);
}
else
{
throw new Error(MessageManager.formatMessage(
"error.invalid_value_for_option", new String[]
{ string, option.getName() }));
}
}
if (option.isRequired() && !cb.enabled.isSelected())
{
// TODO: indicate paramset is not valid.. option needs to be selected!
}
cb.setInitialValue();
}
void setParameter(ParameterI arg)
{
ParamBox pb = paramSet.get(arg.getName());
if (pb == null)
{
addParameter(arg);
}
else
{
pb.updateControls(arg);
}
}
/**
* Answers a list of arguments representing all the options and arguments
* selected on the dialog, holding their chosen or input values. Optional
* parameters which were not selected are not included.
*
* @return
*/
public List getCurrentSettings()
{
List argSet = new ArrayList<>();
for (OptionBox opts : getOptSet().values())
{
ArgumentI opt = opts.getSelectedOption();
if (opt != null)
{
argSet.add(opt);
}
}
for (ParamBox parambox : getParamSet().values())
{
ArgumentI parm = parambox.getParameter();
if (parm != null)
{
argSet.add(parm);
}
}
return argSet;
}
/**
* A helper method that constructs and returns a CombBox for choice of the
* possible option values. If display names are provided, then these are added
* as options, otherwise the actual values are added.
*
* @param opt
* @return
*/
protected static JComboBox buildComboBox(OptionI opt)
{
JComboBox cb = null;
List displayNames = opt.getDisplayNames();
if (displayNames != null)
{
List displayNamesObjects = new ArrayList<>();
displayNamesObjects.addAll(displayNames);
cb = JvSwingUtils.buildComboWithTooltips(displayNamesObjects,
opt.getPossibleValues());
}
else
{
cb = new JComboBox<>();
for (String v : opt.getPossibleValues())
{
cb.addItem(v);
}
}
return cb;
}
/**
* Answers the value corresponding to the selected item in the choice combo
* box. Note that this returns the underlying value even if a different
* display name is used in the combo box.
*
* @return
*/
protected static String getSelectedValue(OptionI opt, int sel)
{
List possibleValues = opt.getPossibleValues();
String value = null;
if (possibleValues != null && possibleValues.size() == 1)
{
// Hack to make sure the default value for an enabled option with only
// one value is actually returned even if this.val is not displayed
value = possibleValues.get(0);
}
else if (sel >= 0 && sel < possibleValues.size())
{
value = possibleValues.get(sel);
}
return value;
}
}