src/jalview/gui/OptsAndParamsPage.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.gui;
  22
  23 import jalview.util.MessageManager;
  24 import jalview.ws.params.ArgumentI;
  25 import jalview.ws.params.OptionI;
  26 import jalview.ws.params.ParameterI;
  27 import jalview.ws.params.ValueConstrainI;
  28 import jalview.ws.params.ValueConstrainI.ValueType;
  29 import jalview.ws.params.simple.LogarithmicParameter;
  30
  31 import java.awt.BorderLayout;
  32 import java.awt.Component;
  33 import java.awt.Dimension;
  34 import java.awt.Font;
  35 import java.awt.GridLayout;
  36 import java.awt.Rectangle;
  37 import java.awt.event.ActionEvent;
  38 import java.awt.event.ActionListener;
  39 import java.awt.event.KeyEvent;
  40 import java.awt.event.KeyListener;
  41 import java.awt.event.MouseEvent;
  42 import java.awt.event.MouseListener;
  43 import java.net.URL;
  44 import java.util.ArrayList;
  45 import java.util.List;
  46 import java.util.Map;
  47
  48 import javax.swing.JButton;
  49 import javax.swing.JCheckBox;
  50 import javax.swing.JComboBox;
  51 import javax.swing.JComponent;
  52 import javax.swing.JLabel;
  53 import javax.swing.JMenuItem;
  54 import javax.swing.JPanel;
  55 import javax.swing.JPopupMenu;
  56 import javax.swing.JScrollPane;
  57 import javax.swing.JSlider;
  58 import javax.swing.JTextArea;
  59 import javax.swing.JTextField;
  60 import javax.swing.border.TitledBorder;
  61 import javax.swing.event.ChangeEvent;
  62 import javax.swing.event.ChangeListener;
  63
  64 import net.miginfocom.swing.MigLayout;
  65
  66 /**
  67  * GUI generator/manager for options and parameters. Originally abstracted from
  68  * the WsJobParameters dialog box.
  69  *
  70  * @author jprocter
  71  *
  72  */
  73 public class OptsAndParamsPage
  74 {
  75   /**
  76    * compact or verbose style parameters
  77    */
  78   boolean compact = false;
  79
  80   public class OptionBox extends JPanel
  81           implements MouseListener, ActionListener
  82   {
  83     JCheckBox enabled = new JCheckBox();
  84
  85     final URL finfo;
  86
  87     boolean hasLink = false;
  88
  89     boolean initEnabled = false;
  90
  91     String initVal = null;
  92
  93     OptionI option;
  94
  95     JLabel optlabel = new JLabel();
  96
  97     JComboBox val = new JComboBox();
  98
  99     public OptionBox(OptionI opt)
 100     {
 101       option = opt;
 102       setLayout(new BorderLayout());
 103       enabled.setSelected(opt.isRequired()); // TODO: lock required options
 104       enabled.setFont(new Font("Verdana", Font.PLAIN, 11));
 105       enabled.setText("");
 106       enabled.setText(opt.getName());
 107       enabled.addActionListener(this);
 108       finfo = option.getFurtherDetails();
 109       String desc = opt.getDescription();
 110       if (finfo != null)
 111       {
 112         hasLink = true;
 113
 114         enabled.setToolTipText(JvSwingUtils.wrapTooltip(true,
 115                 ((desc == null || desc.trim().length() == 0)
 116                         ? MessageManager.getString(
 117                                 "label.opt_and_params_further_details")
 118                         : desc) + "<br><img src=\"" + linkImageURL
 119                         + "\"/>"));
 120         enabled.addMouseListener(this);
 121       }
 122       else
 123       {
 124         if (desc != null && desc.trim().length() > 0)
 125         {
 126           enabled.setToolTipText(
 127                   JvSwingUtils.wrapTooltip(true, opt.getDescription()));
 128         }
 129       }
 130       add(enabled, BorderLayout.NORTH);
 131       for (Object str : opt.getPossibleValues())
 132       {
 133         val.addItem(str);
 134       }
 135       val.setSelectedItem(opt.getValue());
 136       if (opt.getPossibleValues().size() > 1)
 137       {
 138         setLayout(new GridLayout(1, 2));
 139         val.addActionListener(this);
 140         add(val, BorderLayout.SOUTH);
 141       }
 142       // TODO: add actionListeners for popup (to open further info),
 143       // and to update list of parameters if an option is enabled
 144       // that takes a value. JBPNote: is this TODO still valid ?
 145       setInitialValue();
 146     }
 147
 148     @Override
 149     public void actionPerformed(ActionEvent e)
 150     {
 151       if (e.getSource() != enabled)
 152       {
 153         enabled.setSelected(true);
 154       }
 155       checkIfModified();
 156     }
 157
 158     private void checkIfModified()
 159     {
 160       boolean notmod = (initEnabled == enabled.isSelected());
 161       if (enabled.isSelected())
 162       {
 163         if (initVal != null)
 164         {
 165           notmod &= initVal.equals(val.getSelectedItem());
 166         }
 167         else
 168         {
 169           // compare against default service setting
 170           notmod &= option.getValue() == null
 171                   || option.getValue().equals(val.getSelectedItem());
 172         }
 173       }
 174       else
 175       {
 176         notmod &= (initVal != null) ? initVal.equals(val.getSelectedItem())
 177                 : val.getSelectedItem() != initVal;
 178       }
 179       poparent.argSetModified(this, !notmod);
 180     }
 181
 182     public OptionI getOptionIfEnabled()
 183     {
 184       if (!enabled.isSelected())
 185       {
 186         return null;
 187       }
 188       OptionI opt = option.copy();
 189       if (opt.getPossibleValues() != null
 190               && opt.getPossibleValues().size() == 1)
 191       {
 192         // Hack to make sure the default value for an enabled option with only
 193         // one value is actually returned
 194         opt.setValue(opt.getPossibleValues().get(0));
 195       }
 196       if (val.getSelectedItem() != null)
 197       {
 198         opt.setValue((String) val.getSelectedItem());
 199       }
 200       else
 201       {
 202         if (option.getValue() != null)
 203         {
 204           opt.setValue(option.getValue());
 205         }
 206       }
 207       return opt;
 208     }
 209
 210     @Override
 211     public void mouseClicked(MouseEvent e)
 212     {
 213       if (e.isPopupTrigger()) // for Windows
 214       {
 215         showUrlPopUp(this, finfo.toString(), e.getX(), e.getY());
 216       }
 217     }
 218
 219     @Override
 220     public void mouseEntered(MouseEvent e)
 221     {
 222       // TODO Auto-generated method stub
 223
 224     }
 225
 226     @Override
 227     public void mouseExited(MouseEvent e)
 228     {
 229       // TODO Auto-generated method stub
 230
 231     }
 232
 233     @Override
 234     public void mousePressed(MouseEvent e)
 235     {
 236       if (e.isPopupTrigger()) // Mac
 237       {
 238         showUrlPopUp(this, finfo.toString(), e.getX(), e.getY());
 239       }
 240     }
 241
 242     @Override
 243     public void mouseReleased(MouseEvent e)
 244     {
 245     }
 246
 247     public void resetToDefault(boolean setDefaultParams)
 248     {
 249       enabled.setSelected(false);
 250       if (option.isRequired()
 251               || (setDefaultParams && option.getValue() != null))
 252       {
 253         // Apply default value
 254         selectOption(option, option.getValue());
 255       }
 256     }
 257
 258     public void setInitialValue()
 259     {
 260       initEnabled = enabled.isSelected();
 261       if (option.getPossibleValues() != null
 262               && option.getPossibleValues().size() > 1)
 263       {
 264         initVal = (String) val.getSelectedItem();
 265       }
 266       else
 267       {
 268         initVal = (initEnabled) ? (String) val.getSelectedItem() : null;
 269       }
 270     }
 271
 272   }
 273
 274   public class ParamBox extends JPanel
 275           implements ChangeListener, ActionListener, MouseListener
 276   {
 277
 278     boolean isLogarithmic;
 279
 280     boolean adjusting = false;
 281
 282     boolean choice = false;
 283
 284     JComboBox choicebox;
 285
 286     JPanel controlPanel = new JPanel();
 287
 288     boolean descisvisible = false;
 289
 290     JScrollPane descPanel = new JScrollPane();
 291
 292     final URL finfo;
 293
 294     boolean integ = false;
 295
 296     Object lastVal;
 297
 298     ParameterI parameter;
 299
 300     final OptsParametersContainerI pmdialogbox;
 301
 302     JPanel settingPanel = new JPanel();
 303
 304     JButton showDesc = new JButton();
 305
 306     JSlider slider = null;
 307
 308     JTextArea string = new JTextArea();
 309
 310     ValueConstrainI validator = null;
 311
 312     JTextField valueField = null;
 313
 314     public ParamBox(final OptsParametersContainerI pmlayout,
 315             ParameterI parm)
 316     {
 317       pmdialogbox = pmlayout;
 318       finfo = parm.getFurtherDetails();
 319       validator = parm.getValidValue();
 320       parameter = parm;
 321       if (validator != null)
 322       {
 323         integ = validator.getType() == ValueType.Integer;
 324       }
 325       else
 326       {
 327         if (parameter.getPossibleValues() != null)
 328         {
 329           choice = true;
 330         }
 331       }
 332       if (parm instanceof LogarithmicParameter)
 333       {
 334         isLogarithmic = true;
 335       }
 336
 337       if (!compact)
 338       {
 339         makeExpanderParam(parm);
 340       }
 341       else
 342       {
 343         makeCompactParam(parm);
 344
 345       }
 346     }
 347
 348     private void makeCompactParam(ParameterI parm)
 349     {
 350       setLayout(new MigLayout("", "[][grow]"));
 351
 352       String ttipText = null;
 353
 354       controlPanel.setLayout(new BorderLayout());
 355
 356       if (parm.getDescription() != null
 357               && parm.getDescription().trim().length() > 0)
 358       {
 359         // Only create description boxes if there actually is a description.
 360         ttipText = (JvSwingUtils.wrapTooltip(true,
 361                 parm.getDescription() + (finfo != null ? "<br><img src=\""
 362                         + linkImageURL + "\"/>"
 363                         + MessageManager.getString(
 364                                 "label.opt_and_params_further_details")
 365                         : "")));
 366       }
 367
 368       JvSwingUtils.mgAddtoLayout(this, ttipText, new JLabel(parm.getName()),
 369               controlPanel, "");
 370       updateControls(parm);
 371       validate();
 372     }
 373
 374     private void makeExpanderParam(ParameterI parm)
 375     {
 376       setPreferredSize(new Dimension(PARAM_WIDTH, PARAM_CLOSEDHEIGHT));
 377       setBorder(new TitledBorder(parm.getName()));
 378       setLayout(null);
 379       showDesc.setFont(new Font("Verdana", Font.PLAIN, 6));
 380       showDesc.setText("+");
 381       string.setFont(new Font("Verdana", Font.PLAIN, 11));
 382       string.setBackground(getBackground());
 383
 384       string.setEditable(false);
 385       descPanel.getViewport().setView(string);
 386
 387       descPanel.setVisible(false);
 388
 389       JPanel firstrow = new JPanel();
 390       firstrow.setLayout(null);
 391       controlPanel.setLayout(new BorderLayout());
 392       controlPanel.setBounds(new Rectangle(39, 10, PARAM_WIDTH - 70,
 393               PARAM_CLOSEDHEIGHT - 50));
 394       firstrow.add(controlPanel);
 395       firstrow.setBounds(new Rectangle(10, 20, PARAM_WIDTH - 30,
 396               PARAM_CLOSEDHEIGHT - 30));
 397
 398       final ParamBox me = this;
 399
 400       if (parm.getDescription() != null
 401               && parm.getDescription().trim().length() > 0)
 402       {
 403         // Only create description boxes if there actually is a description.
 404         if (finfo != null)
 405         {
 406           showDesc.setToolTipText(JvSwingUtils.wrapTooltip(true,
 407                   MessageManager.formatMessage(
 408                           "label.opt_and_params_show_brief_desc_image_link",
 409                           new String[]
 410                           { linkImageURL.toExternalForm() })));
 411           showDesc.addMouseListener(this);
 412         }
 413         else
 414         {
 415           showDesc.setToolTipText(
 416                   JvSwingUtils.wrapTooltip(true, MessageManager.getString(
 417                           "label.opt_and_params_show_brief_desc")));
 418         }
 419         showDesc.addActionListener(new ActionListener()
 420         {
 421
 422           @Override
 423           public void actionPerformed(ActionEvent e)
 424           {
 425             descisvisible = !descisvisible;
 426             descPanel.setVisible(descisvisible);
 427             descPanel.getVerticalScrollBar().setValue(0);
 428             me.setPreferredSize(new Dimension(PARAM_WIDTH,
 429                     (descisvisible) ? PARAM_HEIGHT : PARAM_CLOSEDHEIGHT));
 430             me.validate();
 431             pmdialogbox.refreshParamLayout();
 432           }
 433         });
 434         string.setWrapStyleWord(true);
 435         string.setLineWrap(true);
 436         string.setColumns(32);
 437         string.setText(parm.getDescription());
 438         showDesc.setBounds(new Rectangle(10, 10, 16, 16));
 439         firstrow.add(showDesc);
 440       }
 441       add(firstrow);
 442       validator = parm.getValidValue();
 443       parameter = parm;
 444       if (validator != null)
 445       {
 446         integ = validator.getType() == ValueType.Integer;
 447       }
 448       else
 449       {
 450         if (parameter.getPossibleValues() != null)
 451         {
 452           choice = true;
 453         }
 454       }
 455       updateControls(parm);
 456       descPanel.setBounds(new Rectangle(10, PARAM_CLOSEDHEIGHT,
 457               PARAM_WIDTH - 20, PARAM_HEIGHT - PARAM_CLOSEDHEIGHT - 5));
 458       add(descPanel);
 459       validate();
 460     }
 461
 462     @Override
 463     public void actionPerformed(ActionEvent e)
 464     {
 465       if (adjusting)
 466       {
 467         return;
 468       }
 469       if (!choice)
 470       {
 471         updateSliderFromValueField();
 472       }
 473       checkIfModified();
 474     }
 475
 476     private void checkIfModified()
 477     {
 478       Object cstate = updateSliderFromValueField();
 479       boolean notmod = false;
 480       if (cstate.getClass() == lastVal.getClass())
 481       {
 482         if (cstate instanceof int[])
 483         {
 484           notmod = (((int[]) cstate)[0] == ((int[]) lastVal)[0]);
 485         }
 486         else if (cstate instanceof float[])
 487         {
 488           notmod = (((float[]) cstate)[0] == ((float[]) lastVal)[0]);
 489         }
 490         else if (cstate instanceof String[])
 491         {
 492           notmod = (((String[]) cstate)[0].equals(((String[]) lastVal)[0]));
 493         }
 494       }
 495       pmdialogbox.argSetModified(this, !notmod);
 496     }
 497
 498     @Override
 499     public int getBaseline(int width, int height)
 500     {
 501       return 0;
 502     }
 503
 504     // from
 505     // http://stackoverflow.com/questions/2743177/top-alignment-for-flowlayout
 506     // helpful hint of using the Java 1.6 alignBaseLine property of FlowLayout
 507     @Override
 508     public Component.BaselineResizeBehavior getBaselineResizeBehavior()
 509     {
 510       return Component.BaselineResizeBehavior.CONSTANT_ASCENT;
 511     }
 512
 513     public int getBoxHeight()
 514     {
 515       return (descisvisible ? PARAM_HEIGHT : PARAM_CLOSEDHEIGHT);
 516     }
 517
 518     public ParameterI getParameter()
 519     {
 520       ParameterI prm = parameter.copy();
 521       if (choice)
 522       {
 523         prm.setValue((String) choicebox.getSelectedItem());
 524       }
 525       else
 526       {
 527         prm.setValue(valueField.getText());
 528       }
 529       return prm;
 530     }
 531
 532     public void init()
 533     {
 534       // reset the widget's initial value.
 535       lastVal = null;
 536     }
 537
 538     @Override
 539     public void mouseClicked(MouseEvent e)
 540     {
 541       if (e.isPopupTrigger()) // for Windows
 542       {
 543         showUrlPopUp(this, finfo.toString(), e.getX(), e.getY());
 544       }
 545     }
 546
 547     @Override
 548     public void mouseEntered(MouseEvent e)
 549     {
 550       // TODO Auto-generated method stub
 551
 552     }
 553
 554     @Override
 555     public void mouseExited(MouseEvent e)
 556     {
 557       // TODO Auto-generated method stub
 558
 559     }
 560
 561     @Override
 562     public void mousePressed(MouseEvent e)
 563     {
 564       if (e.isPopupTrigger()) // for Mac
 565       {
 566         showUrlPopUp(this, finfo.toString(), e.getX(), e.getY());
 567       }
 568     }
 569
 570     @Override
 571     public void mouseReleased(MouseEvent e)
 572     {
 573       // TODO Auto-generated method stub
 574
 575     }
 576
 577     @Override
 578     public void stateChanged(ChangeEvent e)
 579     {
 580       if (!adjusting)
 581       {
 582         if (!isLogarithmic)
 583         {
 584           valueField.setText("" + ((integ) ? ("" + slider.getValue())
 585                   : ("" + slider.getValue() / 1000f)));
 586         }
 587         else
 588         {
 589           Double base = ((LogarithmicParameter) parameter).getBase();
 590           Double value = Math.pow(
 591                   base,
 592                   slider.getValue() / 1000000f);
 593           valueField.setText(formatDouble(value));
 594         }
 595         checkIfModified();
 596       }
 597
 598     }
 599
 600     public String formatDouble(Double value)
 601     {
 602       String string = String.format("%3.3f", value);
 603       if (value < 0.001)
 604       {
 605         string = String.format("%3.3e", value);
 606       }
 607       return string;
 608     }
 609
 610     public void updateControls(ParameterI parm)
 611     {
 612       adjusting = true;
 613       boolean init = (choicebox == null && valueField == null);
 614       if (init)
 615       {
 616         if (choice)
 617         {
 618           choicebox = new JComboBox();
 619           choicebox.addActionListener(this);
 620           controlPanel.add(choicebox, BorderLayout.CENTER);
 621         }
 622         else
 623         {
 624           slider = new JSlider();
 625           slider.addChangeListener(this);
 626           valueField = new JTextField();
 627           valueField.addActionListener(this);
 628           valueField.addKeyListener(new KeyListener()
 629           {
 630
 631             @Override
 632             public void keyTyped(KeyEvent e)
 633             {
 634             }
 635
 636             @Override
 637             public void keyReleased(KeyEvent e)
 638             {
 639               if (e.isActionKey())
 640               {
 641                 if (valueField.getText().trim().length() > 0)
 642                 {
 643                   actionPerformed(null);
 644                 }
 645               }
 646             }
 647
 648             @Override
 649             public void keyPressed(KeyEvent e)
 650             {
 651             }
 652           });
 653           valueField.setPreferredSize(new Dimension(60, 25));
 654           controlPanel.add(slider, BorderLayout.WEST);
 655           controlPanel.add(valueField, BorderLayout.EAST);
 656
 657         }
 658       }
 659
 660       if (parm != null)
 661       {
 662         if (choice)
 663         {
 664           if (init)
 665           {
 666             List vals = parm.getPossibleValues();
 667             for (Object val : vals)
 668             {
 669               choicebox.addItem(val);
 670             }
 671           }
 672
 673           if (parm.getValue() != null)
 674           {
 675             choicebox.setSelectedItem(parm.getValue());
 676           }
 677         }
 678         else
 679         {
 680           if (parm instanceof LogarithmicParameter)
 681           {
 682             Double base = ((LogarithmicParameter) parm).getBase();
 683             Double value = Math.pow(base,
 684                     Double.parseDouble(parm.getValue()) / 1000000);
 685             valueField.setText(formatDouble(value));
 686           }
 687           else
 688           {
 689             valueField.setText(parm.getValue());
 690           }
 691         }
 692       }
 693       lastVal = updateSliderFromValueField();
 694       adjusting = false;
 695     }
 696
 697     public Object updateSliderFromValueField()
 698     {
 699       int iVal;
 700       float fVal;
 701       double dVal;
 702       if (validator != null)
 703       {
 704         if (integ)
 705         {
 706           iVal = 0;
 707           try
 708           {
 709             valueField.setText(valueField.getText().trim());
 710             iVal = Integer.valueOf(valueField.getText());
 711             if (validator.getMin() != null
 712                     && validator.getMin().intValue() > iVal)
 713             {
 714               iVal = validator.getMin().intValue();
 715               // TODO: provide visual indication that hard limit was reached for
 716               // this parameter
 717             }
 718             if (validator.getMax() != null
 719                     && validator.getMax().intValue() < iVal)
 720             {
 721               iVal = validator.getMax().intValue();
 722               // TODO: provide visual indication that hard limit was reached for
 723               // this parameter
 724             }
 725           } catch (Exception e)
 726           {
 727           }
 728           ;
 729           // update value field to reflect any bound checking we performed.
 730           valueField.setText("" + iVal);
 731           if (validator.getMin() != null && validator.getMax() != null)
 732           {
 733             slider.getModel().setRangeProperties(iVal, 1,
 734                     validator.getMin().intValue(),
 735                     validator.getMax().intValue() + 1, true);
 736           }
 737           else
 738           {
 739             slider.setVisible(false);
 740           }
 741           return new int[] { iVal };
 742         }
 743         else if (isLogarithmic)
 744         {
 745           double eValue;
 746           dVal = 0d;
 747           try
 748           {
 749             valueField.setText(valueField.getText().trim());
 750             eValue = Double.valueOf(valueField.getText());
 751
 752             dVal = Math.log(eValue) / Math
 753                     .log(((LogarithmicParameter) parameter).getBase())
 754                     * 1000000;
 755
 756             if (validator.getMin() != null
 757                     && validator.getMin().doubleValue() > dVal)
 758             {
 759               dVal = validator.getMin().doubleValue();
 760               // TODO: provide visual indication that hard limit was reached for
 761               // this parameter
 762               // update value field to reflect any bound checking we performed.
 763               valueField.setText("" + formatDouble(eValue));
 764             }
 765             if (validator.getMax() != null
 766                     && validator.getMax().doubleValue() < dVal)
 767             {
 768               dVal = validator.getMax().doubleValue();
 769               // TODO: provide visual indication that hard limit was reached for
 770               // this parameter
 771               // update value field to reflect any bound checking we performed.
 772               valueField.setText("" + formatDouble(eValue));
 773             }
 774           } catch (Exception e)
 775           {
 776           }
 777           ;
 778           if (validator.getMin() != null && validator.getMax() != null)
 779           {
 780             slider.getModel().setRangeProperties((int) (dVal), 1,
 781                     (int) (validator.getMin().doubleValue()),
 782                     1 + (int) (validator.getMax().doubleValue()),
 783                     true);
 784           }
 785           else
 786           {
 787             slider.setVisible(false);
 788           }
 789           return new double[] { dVal };
 790         }
 791         else
 792         {
 793           fVal = 0f;
 794           try
 795           {
 796             valueField.setText(valueField.getText().trim());
 797             fVal = Float.valueOf(valueField.getText());
 798             if (validator.getMin() != null
 799                     && validator.getMin().floatValue() > fVal)
 800             {
 801               fVal = validator.getMin().floatValue();
 802               // TODO: provide visual indication that hard limit was reached for
 803               // this parameter
 804               // update value field to reflect any bound checking we performed.
 805               valueField.setText("" + fVal);
 806             }
 807             if (validator.getMax() != null
 808                     && validator.getMax().floatValue() < fVal)
 809             {
 810               fVal = validator.getMax().floatValue();
 811               // TODO: provide visual indication that hard limit was reached for
 812               // this parameter
 813               // update value field to reflect any bound checking we performed.
 814               valueField.setText("" + fVal);
 815             }
 816           } catch (Exception e)
 817           {
 818           }
 819           ;
 820           if (validator.getMin() != null && validator.getMax() != null)
 821           {
 822             slider.getModel().setRangeProperties((int) (fVal * 1000f), 1,
 823                     (int) (validator.getMin().floatValue() * 1000f),
 824                     1 + (int) (validator.getMax().floatValue() * 1000f),
 825                     true);
 826           }
 827           else
 828           {
 829             slider.setVisible(false);
 830           }
 831           return new float[] { fVal };
 832         }
 833       }
 834       else
 835       {
 836         if (!choice)
 837         {
 838           slider.setVisible(false);
 839           return new String[] { valueField.getText().trim() };
 840         }
 841         else
 842         {
 843           return new String[] { (String) choicebox.getSelectedItem() };
 844         }
 845       }
 846
 847     }
 848   }
 849
 850   public static final int PARAM_WIDTH = 340;
 851
 852   public static final int PARAM_HEIGHT = 150;
 853
 854   public static final int PARAM_CLOSEDHEIGHT = 80;
 855
 856   public OptsAndParamsPage(OptsParametersContainerI paramContainer)
 857   {
 858     this(paramContainer, false);
 859   }
 860
 861   public OptsAndParamsPage(OptsParametersContainerI paramContainer,
 862           boolean compact)
 863   {
 864     poparent = paramContainer;
 865     this.compact = compact;
 866   }
 867
 868   public static void showUrlPopUp(JComponent invoker, final String finfo,
 869           int x, int y)
 870   {
 871
 872     JPopupMenu mnu = new JPopupMenu();
 873     JMenuItem mitem = new JMenuItem(
 874             MessageManager.formatMessage("label.view_params", new String[]
 875             { finfo }));
 876     mitem.addActionListener(new ActionListener()
 877     {
 878
 879       @Override
 880       public void actionPerformed(ActionEvent e)
 881       {
 882         Desktop.showUrl(finfo);
 883
 884       }
 885     });
 886     mnu.add(mitem);
 887     mnu.show(invoker, x, y);
 888   }
 889
 890   URL linkImageURL = getClass().getResource("/images/link.gif");
 891
 892   Map<String, OptionBox> optSet = new java.util.LinkedHashMap<>();
 893
 894   Map<String, ParamBox> paramSet = new java.util.LinkedHashMap<>();
 895
 896   public Map<String, OptionBox> getOptSet()
 897   {
 898     return optSet;
 899   }
 900
 901   public void setOptSet(Map<String, OptionBox> optSet)
 902   {
 903     this.optSet = optSet;
 904   }
 905
 906   public Map<String, ParamBox> getParamSet()
 907   {
 908     return paramSet;
 909   }
 910
 911   public void setParamSet(Map<String, ParamBox> paramSet)
 912   {
 913     this.paramSet = paramSet;
 914   }
 915
 916   OptsParametersContainerI poparent;
 917
 918   OptionBox addOption(OptionI opt)
 919   {
 920     OptionBox cb = optSet.get(opt.getName());
 921     if (cb == null)
 922     {
 923       cb = new OptionBox(opt);
 924       optSet.put(opt.getName(), cb);
 925       // jobOptions.add(cb, FlowLayout.LEFT);
 926     }
 927     return cb;
 928   }
 929
 930   ParamBox addParameter(ParameterI arg)
 931   {
 932     ParamBox pb = paramSet.get(arg.getName());
 933     if (pb == null)
 934     {
 935       pb = new ParamBox(poparent, arg);
 936       paramSet.put(arg.getName(), pb);
 937       // paramList.add(pb);
 938     }
 939     pb.init();
 940     // take the defaults from the parameter
 941     pb.updateControls(arg);
 942     return pb;
 943   }
 944
 945   void selectOption(OptionI option, String string)
 946   {
 947     OptionBox cb = optSet.get(option.getName());
 948     if (cb == null)
 949     {
 950       cb = addOption(option);
 951     }
 952     cb.enabled.setSelected(string != null); // initial state for an option.
 953     if (string != null)
 954     {
 955       if (option.getPossibleValues().contains(string))
 956       {
 957         cb.val.setSelectedItem(string);
 958       }
 959       else
 960       {
 961         throw new Error(MessageManager.formatMessage(
 962                 "error.invalid_value_for_option", new String[]
 963                 { string, option.getName() }));
 964       }
 965
 966     }
 967     if (option.isRequired() && !cb.enabled.isSelected())
 968     {
 969       // TODO: indicate paramset is not valid.. option needs to be selected!
 970     }
 971     cb.setInitialValue();
 972   }
 973
 974   void setParameter(ParameterI arg)
 975   {
 976     ParamBox pb = paramSet.get(arg.getName());
 977     if (pb == null)
 978     {
 979       addParameter(arg);
 980     }
 981     else
 982     {
 983       pb.updateControls(arg);
 984     }
 985
 986   }
 987
 988   /**
 989    * recover options and parameters from GUI
 990    *
 991    * @return
 992    */
 993   public List<ArgumentI> getCurrentSettings()
 994   {
 995     List<ArgumentI> argSet = new ArrayList<>();
 996     for (OptionBox opts : getOptSet().values())
 997     {
 998       OptionI opt = opts.getOptionIfEnabled();
 999       if (opt != null)
1000       {
1001         argSet.add(opt);
1002       }
1003     }
1004     for (ParamBox parambox : getParamSet().values())
1005     {
1006       ParameterI parm = parambox.getParameter();
1007       if (parm != null)
1008       {
1009         argSet.add(parm);
1010       }
1011     }
1012
1013     return argSet;
1014   }
1015
1016 }