src/jalview/gui/WsJobParameters.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.gui.OptsAndParamsPage.OptionBox;
  24 import jalview.gui.OptsAndParamsPage.ParamBox;
  25 import jalview.util.MessageManager;
  26 import jalview.ws.api.UIinfo;
  27 import jalview.ws.params.ArgumentI;
  28 import jalview.ws.params.OptionI;
  29 import jalview.ws.params.ParamDatastoreI;
  30 import jalview.ws.params.ParameterI;
  31 import jalview.ws.params.WsParamSetI;
  32
  33 import java.awt.BorderLayout;
  34 import java.awt.Component;
  35 import java.awt.Dimension;
  36 import java.awt.FlowLayout;
  37 import java.awt.Font;
  38 import java.awt.GridBagConstraints;
  39 import java.awt.GridBagLayout;
  40 import java.awt.GridLayout;
  41 import java.awt.Rectangle;
  42 import java.awt.event.ActionEvent;
  43 import java.awt.event.ActionListener;
  44 import java.awt.event.HierarchyBoundsListener;
  45 import java.awt.event.HierarchyEvent;
  46 import java.awt.event.ItemEvent;
  47 import java.awt.event.ItemListener;
  48 import java.util.Hashtable;
  49 import java.util.List;
  50 import java.util.Vector;
  51 import java.util.concurrent.CompletableFuture;
  52 import java.util.concurrent.CompletionStage;
  53
  54 import javax.swing.JButton;
  55 import javax.swing.JComboBox;
  56 import javax.swing.JDialog;
  57 import javax.swing.JFrame;
  58 import javax.swing.JLabel;
  59 import javax.swing.JPanel;
  60 import javax.swing.JScrollPane;
  61 import javax.swing.JTextArea;
  62 import javax.swing.WindowConstants;
  63 import javax.swing.border.TitledBorder;
  64 import javax.swing.event.DocumentEvent;
  65 import javax.swing.event.DocumentListener;
  66
  67 import net.miginfocom.swing.MigLayout;
  68
  69 /**
  70  * job parameter editing/browsing dialog box. User can browse existing settings
  71  * (user + presets + Defaults), and any changes to parameters creates a modified
  72  * user parameter set. LOGIC: If the parameter set is modified, and its name is
  73  * a valid, non-existant user parameter set, then a save button is shown. If the
  74  * parameter set is modified and its name is a valid, extant user parameter set,
  75  * then an update button is shown. If user parameter set's name is edited, and
  76  * old name exists as a writable user parameter set, then rename button is
  77  * shown. If current parameter set is associated with a user defined parameter
  78  * set, then : if set is modifed, a 'revert' button is shown. if set is not
  79  * modified, a 'delete' button is shown.
  80  *
  81  * @author JimP
  82  *
  83  */
  84 public class WsJobParameters extends JPanel implements ItemListener,
  85         ActionListener, DocumentListener, OptsParametersContainerI
  86 {
  87   private static final int PREFERRED_WIDTH = 540;
  88
  89   private static final int DEFAULT_HEIGHT = 640;
  90
  91   // the default parameter set shown to the user
  92   private static final String SVC_DEF = "Defaults";
  93
  94   private int maxOptWidth = 200;
  95
  96   // URL linkImageURL = getClass().getResource("/images/link.gif");
  97
  98   // TODO ABSRACT FROM JABAWS CLASSES
  99
 100   // completion stage representing whether start was clicked
 101   private final CompletableFuture<Boolean> completionStage = new CompletableFuture<>();
 102
 103   /**
 104    * manager for options and parameters.
 105    */
 106   OptsAndParamsPage opanp;
 107
 108   /*
 109    * panel containing job options
 110    */
 111   JPanel optionsPanel = new JPanel();
 112
 113   /*
 114    * panel containing job parameters
 115    */
 116   JPanel paramsPanel = new JPanel();
 117
 118   JPanel setNamePanel = new JPanel();
 119
 120   JButton createpref = new JButton();
 121
 122   JButton deletepref = new JButton();
 123
 124   JButton revertpref = new JButton();
 125
 126   JButton updatepref = new JButton();
 127
 128   JComboBox<String> setName = new JComboBox<>();
 129
 130   JTextArea setDescr = new JTextArea();
 131
 132   JScrollPane paramPane = new JScrollPane();
 133
 134   JButton startjob = JvSwingUtils.makeButton(
 135           MessageManager.getString("action.start_job"),
 136           MessageManager.getString("label.start_job_current_settings"),
 137           this::startjob_actionPerformed);
 138   JButton canceljob = JvSwingUtils.makeButton(
 139           MessageManager.getString("action.cancel_job"),
 140           MessageManager.getString("label.cancel_job_close_dialog"),
 141           this::canceljob_actionPerformed);
 142
 143   ParamDatastoreI paramStore;
 144
 145   // set true when 'Start Job' is clicked
 146   boolean startJob = false;
 147
 148   JFrame frame = null;
 149
 150   UIinfo service;
 151
 152   /*
 153    * list of service presets in the gui
 154    */
 155   Hashtable<String, String> servicePresets = null;
 156
 157   /*
 158    * set if dialog is being set - so handlers will avoid spurious events
 159    */
 160   boolean settingDialog = false;
 161
 162   private Hashtable<Object, Object> modifiedElements = new Hashtable<>();
 163
 164   String lastParmSet = null;
 165
 166   public WsJobParameters(ParamDatastoreI store, WsParamSetI preset,
 167           List<ArgumentI> args)
 168   {
 169     super();
 170
 171     // parameters dialog in 'compact' format (help as tooltips)
 172     opanp = new OptsAndParamsPage(this, true);
 173     jbInit();
 174     this.paramStore = store;
 175     this.service = null;
 176     init(preset, args);
 177     validate();
 178   }
 179
 180   /**
 181    * Constructor given a set of parameters and presets, a service to be invoked,
 182    * and a list of (Jabaws client) arguments
 183    *
 184    * @param paramStorei
 185    * @param service
 186    * @param preset
 187    * @param jobArgset
 188    */
 189   public WsJobParameters(ParamDatastoreI paramStorei, UIinfo service,
 190           WsParamSetI preset, List<ArgumentI> jobArgset)
 191   {
 192     super();
 193
 194     // parameters dialog in 'expanded' format (help text boxes)
 195     opanp = new OptsAndParamsPage(this, false);
 196
 197     jbInit();
 198     this.paramStore = paramStorei;
 199     if (paramStore == null && service != null)
 200     {
 201       paramStore = service.getParamStore();
 202     }
 203     this.service = service;
 204     initForService(preset, jobArgset);
 205     validate();
 206   }
 207
 208   /**
 209    * Shows a modal dialog containing the parameters and Start or Cancel options.
 210    * Answers true if the job is started, false if cancelled.
 211    *
 212    * @return
 213    */
 214   public CompletionStage<Boolean> showRunDialog()
 215   {
 216     frame = new JFrame();
 217     frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
 218     if (service != null)
 219     {
 220       frame.setTitle(MessageManager.formatMessage("label.edit_params_for",
 221               new String[]
 222       { service.getActionText() }));
 223     }
 224     frame.setTitle(MessageManager.formatMessage("label.edit_params_for",
 225             new String[]
 226             { service.getActionText() }));
 227     Rectangle deskr = Desktop.getInstance().getBounds();
 228     Dimension pref = this.getPreferredSize();
 229     frame.setBounds(
 230             new Rectangle((int) (deskr.getCenterX() - pref.width / 2),
 231                     (int) (deskr.getCenterY() - pref.height / 2),
 232                     pref.width, pref.height));
 233     frame.setContentPane(this);
 234
 235     // should perhaps recover defaults from user prefs.
 236
 237     frame.validate();
 238     javax.swing.SwingUtilities.invokeLater(new Runnable()
 239     {
 240       @Override
 241       public void run()
 242       {
 243         // jobPanel.setDividerLocation(0.25);
 244
 245       }
 246     });
 247
 248     frame.setVisible(true);
 249     return completionStage;
 250   }
 251
 252   private void jbInit()
 253   {
 254     this.addHierarchyBoundsListener(new HierarchyBoundsListener()
 255     {
 256
 257       @Override
 258       public void ancestorResized(HierarchyEvent arg0)
 259       {
 260         refreshParamLayout();
 261       }
 262
 263       @Override
 264       public void ancestorMoved(HierarchyEvent arg0)
 265       {
 266         // TODO Auto-generated method stub
 267
 268       }
 269     });
 270     updatepref = JvSwingUtils.makeButton(
 271             MessageManager.getString("action.update"),
 272             MessageManager.getString("label.update_user_parameter_set"),
 273             this::update_actionPerformed);
 274     deletepref = JvSwingUtils.makeButton(
 275             MessageManager.getString("action.delete"),
 276             MessageManager.getString("label.delete_user_parameter_set"),
 277             this::delete_actionPerformed);
 278     createpref = JvSwingUtils.makeButton(
 279             MessageManager.getString("action.create"),
 280             MessageManager.getString("label.create_user_parameter_set"),
 281             this::create_actionPerformed);
 282     revertpref = JvSwingUtils.makeButton(
 283             MessageManager.getString("action.revert"),
 284             MessageManager
 285                     .getString("label.revert_changes_user_parameter_set"),
 286             this::revert_actionPerformed);
 287
 288
 289     JPanel setDetails = new JPanel();
 290     setDetails.setBorder(
 291             new TitledBorder(MessageManager.getString("label.details")));
 292     setDetails.setLayout(new BorderLayout());
 293     setDescr.setColumns(40);
 294     setDescr.setWrapStyleWord(true);
 295     setDescr.setLineWrap(true);
 296     setDescr.setBackground(getBackground());
 297     setDescr.setEditable(true);
 298     setDescr.getDocument().addDocumentListener(this);
 299     setDescr.setToolTipText(
 300             MessageManager.getString("label.edit_notes_parameter_set"));
 301     JScrollPane setDescrView = new JScrollPane();
 302     setDescrView.getViewport().setView(setDescr);
 303     setName.setEditable(true);
 304     setName.addItemListener(this);
 305     setName.getEditor().addActionListener(this);
 306     JPanel setNameInfo = new JPanel(new FlowLayout(FlowLayout.LEFT));
 307     GridBagLayout gbl = new GridBagLayout();
 308     setNamePanel.setLayout(gbl);
 309
 310     JLabel setNameLabel = new JLabel(
 311             MessageManager.getString("label.current_parameter_set_name"));
 312     setNameLabel.setFont(new java.awt.Font("Verdana", Font.PLAIN, 10));
 313
 314     setNameInfo.add(setNameLabel);
 315     setNameInfo.add(setName);
 316
 317     // initial button visibility
 318     updatepref.setVisible(false);
 319     deletepref.setVisible(false);
 320     revertpref.setVisible(false);
 321     createpref.setVisible(false);
 322     JPanel setsavebuts = new JPanel();
 323     setsavebuts.setLayout(new FlowLayout(FlowLayout.LEFT, 10, 0)); // GridLayout(1,2));
 324     JPanel spacer = new JPanel();
 325     spacer.setPreferredSize(new Dimension(2, 30));
 326     setsavebuts.add(spacer);
 327     setsavebuts.add(deletepref);
 328     setsavebuts.add(revertpref);
 329     setsavebuts.add(createpref);
 330     setsavebuts.add(updatepref);
 331     // setsavebuts.setSize(new Dimension(150, 30));
 332     JPanel buttonArea = new JPanel(new GridLayout(1, 1));
 333     buttonArea.add(setsavebuts);
 334     setNamePanel.add(setNameInfo);
 335     GridBagConstraints gbc = new GridBagConstraints();
 336     gbc.gridheight = 2;
 337     gbl.setConstraints(setNameInfo, gbc);
 338     setNamePanel.add(buttonArea);
 339     gbc = new GridBagConstraints();
 340     gbc.gridx = 0;
 341     gbc.gridy = 2;
 342     gbc.gridheight = 1;
 343     gbl.setConstraints(buttonArea, gbc);
 344     setDetails.add(setDescrView, BorderLayout.CENTER);
 345
 346     // paramPane.setPreferredSize(new Dimension(360, 400));
 347     // paramPane.setPreferredSize(null);
 348     optionsPanel.setBorder(
 349             new TitledBorder(MessageManager.getString("label.options")));
 350     optionsPanel.setOpaque(true);
 351     paramsPanel.setBorder(
 352             new TitledBorder(MessageManager.getString("label.parameters")));
 353     paramsPanel.setOpaque(true);
 354     // optsAndparams.setScrollableWidth(ScrollableSizeHint.FIT);
 355     // optsAndparams.setScrollableHeight(ScrollableSizeHint.NONE);
 356     // optsAndparams.setLayout(new BorderLayout());
 357     JPanel optsAndparams = new JPanel();
 358     optsAndparams.setLayout(new BorderLayout());
 359     optsAndparams.add(optionsPanel, BorderLayout.NORTH);
 360     optsAndparams.add(paramsPanel, BorderLayout.CENTER);
 361     JPanel jp = new JPanel(new BorderLayout());
 362     jp.add(optsAndparams, BorderLayout.CENTER);
 363     paramPane.getViewport().setView(jp);
 364     paramPane.setBorder(null);
 365     setLayout(new BorderLayout());
 366
 367     JPanel jobPanel = new JPanel();
 368     jobPanel.setPreferredSize(null);
 369     jobPanel.setLayout(new BorderLayout());
 370     jobPanel.add(setDetails, BorderLayout.NORTH);
 371     jobPanel.add(paramPane, BorderLayout.CENTER);
 372     // jobPanel.setOrientation(JSplitPane.VERTICAL_SPLIT);
 373
 374     add(setNamePanel, BorderLayout.NORTH);
 375     add(jobPanel, BorderLayout.CENTER);
 376
 377     JPanel dialogpanel = new JPanel();
 378     dialogpanel.add(startjob);
 379     dialogpanel.add(canceljob);
 380     // JAL-1580: setMaximumSize() doesn't work, so just size for the worst case:
 381     // check for null is for JUnit usage
 382     final int windowHeight = Desktop.getInstance() == null ? DEFAULT_HEIGHT
 383             : Desktop.getInstance().getHeight();
 384     setPreferredSize(new Dimension(540, windowHeight));
 385     add(dialogpanel, BorderLayout.SOUTH);
 386     validate();
 387   }
 388
 389   protected void revert_actionPerformed(ActionEvent e)
 390   {
 391     reInitDialog(lastParmSet);
 392     updateWebServiceMenus();
 393   }
 394
 395   protected void update_actionPerformed(ActionEvent e)
 396   {
 397     if (isUserPreset)
 398     {
 399       String curname = ((String) setName.getSelectedItem()).trim();
 400       _updatePreset(lastParmSet, curname);
 401       lastParmSet = curname;
 402       isUserPreset = true;
 403       initArgSetModified();
 404       syncSetNamesWithStore();
 405     }
 406   }
 407
 408   private void _deleteUserPreset(String lastParmSet2)
 409   {
 410     paramStore.deletePreset(lastParmSet2);
 411   }
 412
 413   protected void delete_actionPerformed(ActionEvent e)
 414   {
 415     if (isUserPreset)
 416     {
 417       // delete current preset's saved entry
 418       _deleteUserPreset(lastParmSet);
 419     }
 420     reInitDialog(null); // service default
 421     updateWebServiceMenus();
 422   }
 423
 424   protected void create_actionPerformed(ActionEvent e)
 425   {
 426     String curname = ((String) setName.getSelectedItem()).trim();
 427     if (curname.length() > 0)
 428     {
 429       _storeCurrentPreset(curname);
 430       lastParmSet = curname;
 431       isUserPreset = true;
 432       reInitDialog(curname);
 433       initArgSetModified();
 434       updateWebServiceMenus();
 435     }
 436     else
 437     {
 438       // TODO: show warning
 439       System.err.println("Invalid name. Not saved.");
 440     }
 441   }
 442
 443   protected void canceljob_actionPerformed(ActionEvent e)
 444   {
 445     startJob = false;
 446     if (frame != null)
 447     {
 448       frame.setVisible(false);
 449     }
 450     completionStage.complete(false);
 451   }
 452
 453   protected void startjob_actionPerformed(ActionEvent e)
 454   {
 455     startJob = true;
 456     if (frame != null)
 457     {
 458       frame.setVisible(false);
 459     }
 460     completionStage.complete(true);
 461   }
 462
 463   void initForService(WsParamSetI paramSet, List<ArgumentI> jobArgset)
 464   {
 465     settingDialog = true;
 466
 467     init(paramSet, jobArgset);
 468
 469   }
 470
 471   void init(WsParamSetI p, List<ArgumentI> jobArgset)
 472   {
 473     Hashtable<String, String> exnames = new Hashtable<>();
 474     for (int i = 0, iSize = setName.getItemCount(); i < iSize; i++)
 475     {
 476       exnames.put(setName.getItemAt(i), setName.getItemAt(i));
 477     }
 478     servicePresets = new Hashtable<>();
 479     // Add the default entry - if not present already.
 480     if (!exnames.contains(SVC_DEF))
 481     {
 482       setName.addItem(SVC_DEF);
 483       exnames.put(SVC_DEF, SVC_DEF);
 484       servicePresets.put(SVC_DEF, SVC_DEF);
 485     }
 486
 487     // String curname = (p == null ? "" : p.getName());
 488     for (WsParamSetI pr : paramStore.getPresets())
 489     {
 490       if (!pr.isModifiable())
 491       {
 492         servicePresets.put(pr.getName(), "preset");
 493       }
 494       else
 495       {
 496       }
 497       if (!exnames.contains(pr.getName()))
 498       {
 499         setName.addItem(pr.getName());
 500       }
 501     }
 502     // TODO: if initial jobArgset matches a given user setting or preset then
 503     // should recover setting accordingly
 504     // updateTable(p, jobArgset);
 505     if (p != null)
 506     {
 507       reInitDialog(p.getName());
 508       initArgSetModified();
 509     }
 510     else
 511     {
 512       if (jobArgset != null && jobArgset.size() > 0)
 513       {
 514         curSetName = "Supplied Settings";
 515         isUserPreset = false;
 516         updateTable(p, jobArgset);
 517         setName.setSelectedItem(curSetName);
 518         updateButtonDisplay();
 519       }
 520       else
 521       {
 522         curSetName = null;
 523         reInitDialog(null);
 524       }
 525     }
 526     settingDialog = false;
 527   }
 528
 529   private void updateTable(WsParamSetI p, List<ArgumentI> jobArgset)
 530   {
 531     boolean setDefaultParams = false;
 532     if (lastParmSet == null)
 533     {
 534       isUserPreset = false;
 535       // First call - so provide Service default settings
 536       setName.setSelectedItem(lastSetName = SVC_DEF);
 537     }
 538     if (p == null && SVC_DEF.equals("" + setName.getSelectedItem()))
 539     {
 540       // indicate that service defaults should be set if available
 541       setDefaultParams = true;
 542     }
 543     // populate table from default parameter set.
 544     List<ArgumentI> args = paramStore.getServiceParameters();
 545
 546     // split to params and required arguments
 547     {
 548       int cw = 0;
 549       boolean optset = false;
 550       for (ArgumentI myarg : args)
 551       {
 552         // Ideally, Argument would implement isRequired !
 553         if (myarg instanceof ParameterI)
 554         {
 555           ParameterI parm = (ParameterI) myarg;
 556           opanp.addParameter(parm).validate();
 557         }
 558         else
 559         {
 560           if (myarg instanceof OptionI)
 561           {
 562             OptionI opt = (OptionI) myarg;
 563             OptionBox ob = opanp.addOption(opt);
 564             ob.resetToDefault(setDefaultParams);
 565             if (maxOptWidth < ob.getPreferredSize().width)
 566             {
 567               maxOptWidth = ob.getPreferredSize().width;
 568             }
 569             ob.validate();
 570             cw += ob.getPreferredSize().width + 5;
 571           }
 572           else
 573           {
 574             System.err.println("Ignoring unknown service argument type "
 575                     + myarg.getClass().getName());
 576           }
 577         }
 578       }
 579       args = null; // no more args to process.
 580     }
 581     if (p != null)
 582     {
 583       isUserPreset = false;
 584       // initialise setname
 585       setName.setSelectedItem(lastSetName = p.getName());
 586       setDescr.setText(lastDescrText = p.getDescription());
 587       // TODO - URL link
 588       try
 589       {
 590         args = p.getArguments();
 591       } catch (Exception e)
 592       {
 593         e.printStackTrace();
 594       }
 595       // TODO: check if args should be unselected prior to resetting using the
 596       // preset
 597     }
 598
 599     if (jobArgset != null)
 600     {
 601       argSetModified(jobArgset, true);
 602       args = jobArgset;
 603     }
 604     // get setargs from current object
 605     if (args != null)
 606     {
 607       for (ArgumentI arg : args)
 608       {
 609         if (arg instanceof ParameterI)
 610         {
 611           opanp.setParameter((ParameterI) arg);
 612         }
 613         else
 614         {
 615           if (arg instanceof OptionI)
 616           {
 617             // System.out.println("Setting option "
 618             // + System.identityHashCode(arg) + ":" + arg.getName()
 619             // + " with " + arg.getDefaultValue());
 620             opanp.selectOption((OptionI) arg, arg.getValue());
 621           }
 622         }
 623
 624       }
 625     }
 626
 627     refreshParamLayout();
 628     revalidate();
 629   }
 630
 631   private boolean isModified()
 632   {
 633     return modifiedElements.size() > 0;
 634   }
 635
 636   /**
 637    * reset gui and modification state settings
 638    */
 639   private void initArgSetModified()
 640   {
 641     curSetName = null;
 642     modifiedElements.clear();
 643     updateButtonDisplay();
 644   }
 645
 646   private void updateButtonDisplay()
 647   {
 648     boolean _update = false, _create = false, _delete = false,
 649             _revert = false;
 650     if (modifiedElements.size() > 0)
 651     {
 652       // set modified
 653       _revert = true;
 654       _update = isUserPreset; // can only update user presets
 655       if (!isUserPreset || modifiedElements.containsKey(setName))
 656       {
 657         // name modified - can create new preset
 658         _create = true;
 659       }
 660     }
 661     else
 662     {
 663       // set unmodified
 664     }
 665     // can still delete a user preset
 666     _delete = isUserPreset;
 667
 668     createpref.setVisible(_create);
 669     updatepref.setVisible(_update);
 670     deletepref.setVisible(_delete);
 671     revertpref.setVisible(_revert);
 672     validate();
 673   }
 674
 675   @Override
 676   public void argSetModified(Object modifiedElement, boolean b)
 677   {
 678     if (settingDialog)
 679     {
 680       return;
 681     }
 682     if (!b)
 683     {
 684       modifiedElements.remove(modifiedElement);
 685     }
 686     else
 687     {
 688       if (b && modifiedElement == setName
 689               && modifiedElements.contains(modifiedElement))
 690       {
 691         // HACK! prevents iteration on makeSetNameValid
 692         b = false;
 693       }
 694       modifiedElements.put(modifiedElement, modifiedElement);
 695     }
 696     // set mod status based on presence of elements in table
 697     if (b && modifiedElements.size() > 0)
 698     {
 699       makeSetNameValid(!isUserPreset);
 700       setNamePanel.revalidate();
 701     }
 702     updateButtonDisplay();
 703   }
 704
 705   private boolean isServicePreset(String selectedItem)
 706   {
 707     return selectedItem.equals(SVC_DEF)
 708             || servicePresets.containsKey(selectedItem);
 709   }
 710
 711   /**
 712    * check if the current set name is a valid set name for saving, if not, then
 713    * fix it.
 714    */
 715   private void makeSetNameValid(boolean newuserset)
 716   {
 717     boolean stn = settingDialog;
 718     boolean renamed = false;
 719     settingDialog = true;
 720     String nm = (curSetName != null ? curSetName
 721             : (String) setName.getSelectedItem());
 722     // check if the name is reserved - if it is, rename it.
 723     if (isServicePreset(nm))
 724     {
 725       nm = "User " + nm;
 726       renamed = true;
 727     }
 728     String tnm = nm;
 729     if (newuserset)
 730     {
 731       int i = 0;
 732       while (paramStore.getPreset(tnm) != null)
 733       {
 734         tnm = nm + " (" + (++i) + ")";
 735         renamed = true;
 736       }
 737       if (i > 0)
 738       {
 739         nm = tnm;
 740       }
 741     }
 742
 743     boolean makeupdate = false;
 744     // sync the gui with the preset database
 745     for (int i = 0, iS = setName.getItemCount(); i < iS; i++)
 746     {
 747       String snm = setName.getItemAt(i);
 748       if (snm.equals(nm))
 749       {
 750         makeupdate = true;
 751         // setName.setSelectedIndex(i);
 752       }
 753     }
 754     if (!makeupdate)
 755     {
 756       setName.addItem(curSetName = nm);
 757       setName.setSelectedItem(curSetName);
 758     }
 759     if (renamed)
 760     {
 761       settingDialog = false; // we need this name change to be registered.
 762       argSetModified(setName, renamed);
 763     }
 764     settingDialog = stn;
 765   }
 766
 767   /**
 768    * Rebuilds the Options and Parameters panels
 769    */
 770   @Override
 771   public void refreshParamLayout()
 772   {
 773     final int rightMargin = 40;
 774     final int availableWidth = paramPane.getViewport().getSize().width
 775             - rightMargin
 776             - optionsPanel.getBorder().getBorderInsets(optionsPanel).left
 777             + optionsPanel.getBorder().getBorderInsets(optionsPanel).right;
 778
 779     if (opanp.getOptSet().size() > 0)
 780     {
 781       int hgap = 5;
 782       int currentWidth = hgap;
 783
 784       /*
 785        * layout constraint 'nogrid' prevents vertical column alignment,
 786        * allowing controls to flow without extra space inserted to align
 787        */
 788       optionsPanel.setLayout(new MigLayout("nogrid", "", ""));
 789       optionsPanel.removeAll();
 790       JPanel lastAdded = null;
 791
 792       /*
 793        * add each control in turn; if adding would overflow the right margin,
 794        * remove and re-add the previous parameter with "wrap" (after)
 795        * in order to start a new row
 796        */
 797       for (OptionBox pbox : opanp.getOptSet().values())
 798       {
 799         pbox.validate();
 800         int boxWidth = pbox.getSize().width;
 801         currentWidth += boxWidth + hgap;
 802         boolean wrapAfterLast = currentWidth > availableWidth
 803                 && lastAdded != null;
 804         // System.out.println(String.format(
 805         // "%s width=%d, paneWidth=%d, currentWidth=%d, wrapAfterLast=%s",
 806         // pbox.toString(), boxWidth, panewidth, currentWidth,
 807         // wrapAfterLast));
 808         if (wrapAfterLast)
 809         {
 810           optionsPanel.remove(lastAdded);
 811           optionsPanel.add(lastAdded, "wrap");
 812           currentWidth = hgap + boxWidth;
 813         }
 814         optionsPanel.add(pbox);
 815         lastAdded = pbox;
 816       }
 817       optionsPanel.revalidate();
 818     }
 819     else
 820     {
 821       optionsPanel.setVisible(false);
 822     }
 823
 824     if (opanp.getParamSet().size() > 0)
 825     {
 826       paramsPanel.removeAll();
 827       paramsPanel.setLayout(new MigLayout("", "", ""));
 828       int hgap = 5;
 829       int currentWidth = hgap;
 830
 831       JPanel lastAdded = null;
 832       for (ParamBox pbox : opanp.getParamSet().values())
 833       {
 834         pbox.validate();
 835         int boxWidth = pbox.getSize().width;
 836         currentWidth += boxWidth + hgap;
 837         boolean wrapAfterLast = currentWidth > availableWidth
 838                 && lastAdded != null;
 839         if (wrapAfterLast)
 840         {
 841           paramsPanel.remove(lastAdded);
 842           paramsPanel.add(lastAdded, "wrap");
 843           currentWidth = pbox.getSize().width + hgap;
 844         }
 845         paramsPanel.add(pbox);
 846         lastAdded = pbox;
 847       }
 848
 849       /*
 850        * s = 2 * sep; for (ParamBox pbox : opanp.getParamSet().values()) {
 851        * pbox.validate(); s += sep +
 852        * pbox.getPreferredSize().height+pbox.getBorder
 853        * ().getBorderInsets(pbox).bottom; }
 854        *
 855        * // paramList.setPreferredSize(new Dimension(w, s));
 856        * os+=s+2*sep+paramList
 857        * .getBorder().getBorderInsets(paramList).bottom+paramList
 858        * .getBorder().getBorderInsets(paramList).top;
 859        */
 860       paramsPanel.revalidate();
 861     }
 862     else
 863     {
 864       paramsPanel.setVisible(false);
 865     }
 866     // TODO: waste some time trying to eliminate any unnecessary .validate calls
 867     // here
 868     // System.out.println("Size will be : "+w+","+os);
 869     // optsAndparams.setPreferredSize(null);
 870     // paramPane.getViewport().setView(optsAndparams);
 871     paramPane.getViewport().setAutoscrolls(true);
 872     paramPane.revalidate();
 873     revalidate();
 874   }
 875   public boolean isServiceDefaults()
 876   {
 877     return (!isModified()
 878             && (lastParmSet != null && lastParmSet.equals(SVC_DEF)));
 879   }
 880
 881   public List<ArgumentI> getJobParams()
 882   {
 883     return opanp.getCurrentSettings();
 884   }
 885
 886   /*
 887    * Hashtable<String, Object[]> editedParams = new Hashtable<String,
 888    * Object[]>();
 889    *
 890    * store the given parameters in the user parameter set database.
 891    *
 892    * @param storeSetName - lastParmSet
 893    *
 894    * @param descr - setDescr.getText()
 895    *
 896    * @param jobParams - getJobParams()
 897    *
 898    * private void _storeUserPreset(String storeSetName, String descr,
 899    * List<ArgumentI> jobParams) { // this is a simple hash store. Object[] pset;
 900    * editedParams.put(storeSetName, pset = new Object[3]); pset[0] =
 901    * storeSetName; pset[1] = descr; pset[2] = jobParams; // writeParam("Saving "
 902    * + storeSetName + ": ", jobParams); }
 903    *
 904    * private void writeParam(String nm, List<ArgumentI> params) { for (ArgumentI
 905    * p : params) { System.out.println(nm + ":" + System.identityHashCode(p) +
 906    * " Name: " + p.getName() + " Value: " + p.getDefaultValue()); } }
 907    *
 908    * private Object[] _getUserPreset(String setName) { Object[] pset =
 909    * editedParams.get(setName); // if (pset != null) // writeParam("Retrieving "
 910    * + setName + ": ", (List<Argument>) pset[2]); return pset; }
 911    *
 912    * * remove the given user preset from the preset stash
 913    *
 914    * @param setName
 915    *
 916    * private void _deleteUserPreset(String setName) {
 917    * editedParams.remove(setName); }
 918    */
 919
 920   private void syncSetNamesWithStore()
 921   {
 922     int n = 0;
 923     // remove any set names in the drop down menu that aren't either a reserved
 924     // setting, or a user defined or service preset.
 925     Vector<String> items = new Vector<>();
 926     while (n < setName.getItemCount())
 927     {
 928       String item = setName.getItemAt(n);
 929       if (!item.equals(SVC_DEF) && !paramStore.presetExists(item))
 930       {
 931         setName.removeItemAt(n);
 932       }
 933       else
 934       {
 935         items.addElement(item);
 936         n++;
 937       }
 938     }
 939     if (!items.contains(SVC_DEF))
 940     {
 941       setName.addItem(SVC_DEF);
 942     }
 943     for (WsParamSetI upn : paramStore.getPresets())
 944     {
 945       if (!items.contains(upn.getName()))
 946       {
 947         setName.addItem(upn.getName());
 948       }
 949     }
 950   }
 951
 952   /**
 953    * true if lastParmSet is a user preset
 954    */
 955   boolean isUserPreset = false;
 956
 957   private void reInitDialog(String nextPreset)
 958   {
 959     settingDialog = true;
 960     // updateTable(null,null); // first reset to defaults
 961     WsParamSetI pset = null;
 962     if (nextPreset != null && nextPreset.length() > 0)
 963     {
 964       pset = paramStore.getPreset(nextPreset);
 965     }
 966     if (pset != null)
 967     {
 968       if (pset.isModifiable())
 969       {
 970         isUserPreset = true;
 971         setDescr.setText(pset.getDescription());
 972         updateTable(null, pset.getArguments());
 973         lastParmSet = nextPreset;
 974       }
 975       else
 976       {
 977         isUserPreset = false;
 978         setDescr.setText("");
 979         // must be a default preset from service
 980         updateTable(pset, null);
 981         lastParmSet = nextPreset;
 982       }
 983     }
 984     else
 985     {
 986       isUserPreset = false;
 987       // Service defaults
 988       setDescr.setText("");
 989       updateTable(null, null);
 990       lastParmSet = SVC_DEF;
 991     }
 992
 993     initArgSetModified();
 994     syncSetNamesWithStore();
 995     setName.setSelectedItem(lastParmSet);
 996     setNamePanel.validate();
 997     validate();
 998     settingDialog = false;
 999   }
1000
1001   /**
1002    * Rebuild the AlignFrame web service menus (after add/delete of a preset
1003    * option).
1004    */
1005   protected void updateWebServiceMenus()
1006   {
1007     if (Desktop.getInstance() == null)
1008     {
1009       return;
1010     }
1011     for (AlignFrame alignFrame : Desktop.getAlignFrames())
1012     {
1013       alignFrame.buildWebServicesMenu();
1014     }
1015   }
1016
1017   String curSetName = null;
1018
1019   @Override
1020   public void itemStateChanged(ItemEvent e)
1021   {
1022     if (e.getSource() == setName
1023             && e.getStateChange() == ItemEvent.SELECTED)
1024     {
1025       final String setname = (String) setName.getSelectedItem();
1026       // System.out.println("Item state changed for " + setname
1027       // + " (handling ? " + !settingDialog + ")");
1028       if (settingDialog)
1029       {
1030         // ignore event
1031         return;
1032       }
1033       if (setname == null)
1034       {
1035         return;
1036       }
1037       javax.swing.SwingUtilities.invokeLater(new Runnable()
1038       {
1039         @Override
1040         public void run()
1041         {
1042           doPreferenceComboStateChange(setname);
1043         }
1044       });
1045     }
1046   }
1047
1048   private void doPreferenceComboStateChange(String setname)
1049   {
1050     // user has selected a different item from combo-box
1051     if (isModified())
1052     {
1053       String lsetname = (curSetName != null) ? curSetName : lastParmSet;
1054       if (lsetname.equals(setname))
1055       {
1056         // setname was just edited - so ignore this event.
1057         return;
1058       }
1059       settingDialog = true;
1060       System.out.println("Prompting to save " + lsetname);
1061       if (JvOptionPane.showConfirmDialog(this, "Parameter set '" + lsetname
1062               + "' is modifed, and your changes will be lost.\nReally change preset ?",
1063               "Warning: Unsaved Changes",
1064               JvOptionPane.OK_CANCEL_OPTION) != JvOptionPane.OK_OPTION)
1065       {
1066         // revert the combobox to the current item
1067         settingDialog = true;
1068         setName.setSelectedItem(lsetname);
1069         settingDialog = false;
1070         // and leave.
1071         return;
1072         // System.out.println("Saving for " + lsetname);
1073         // _storeCurrentPreset(lsetname);
1074
1075       }
1076     }
1077     settingDialog = true;
1078     reInitDialog(setname);
1079     settingDialog = false;
1080
1081   }
1082
1083   /**
1084    * store current settings as given name. You should then reset gui.
1085    *
1086    * @param curSetName2
1087    */
1088   private void _storeCurrentPreset(String curSetName2)
1089   {
1090     paramStore.storePreset(curSetName2, setDescr.getText(), getJobParams());
1091   }
1092
1093   private void _updatePreset(String lastParmSet2, String curname)
1094   {
1095     paramStore.updatePreset(lastParmSet2, curname, setDescr.getText(),
1096             getJobParams());
1097
1098   }
1099
1100   /**
1101    * last saved name for this user preset
1102    */
1103   String lastSetName = null;
1104
1105   /**
1106    * last saved value of the description text for this user preset
1107    */
1108   String lastDescrText = null;
1109
1110   @Override
1111   public void actionPerformed(ActionEvent e)
1112   {
1113     if (e.getSource() instanceof Component)
1114     {
1115       Component src = (Component) e.getSource();
1116       if (src.getParent() == setName)
1117       {
1118         // rename any existing records we know about for this set.
1119         String newname = e.getActionCommand().trim();
1120         String msg = null;
1121         if (isServicePreset(newname))
1122         {
1123           final String oldname = curSetName != null ? curSetName
1124                   : lastParmSet;
1125           final Component ourframe = this;
1126           settingDialog = true;
1127           setName.getEditor().setItem(oldname);
1128           settingDialog = false;
1129           javax.swing.SwingUtilities.invokeLater(new Runnable()
1130           {
1131             @Override
1132             public void run()
1133             {
1134               JvOptionPane.showMessageDialog(ourframe,
1135                       MessageManager.getString(
1136                               "label.invalid_name_preset_exists"),
1137                       MessageManager.getString("label.invalid_name"),
1138                       JvOptionPane.WARNING_MESSAGE);
1139             }
1140           });
1141
1142           return;
1143         }
1144         curSetName = newname;
1145         System.err.println("New name for user setting " + curSetName
1146                 + " (was " + setName.getSelectedItem() + ")");
1147         if (curSetName.equals(setName.getSelectedItem()))
1148         {
1149           curSetName = null;
1150         }
1151         if (curSetName != null)
1152         {
1153           argSetModified(setName, true);
1154           return;
1155         }
1156
1157       }
1158     }
1159   }
1160
1161   private void checkDescrModified()
1162   {
1163     if (!settingDialog)
1164     {
1165
1166       argSetModified(setDescr,
1167               (lastDescrText == null
1168                       ? setDescr.getText().trim().length() > 0
1169                       : !setDescr.getText().equals(lastDescrText)));
1170
1171     }
1172   }
1173
1174   @Override
1175   public void insertUpdate(DocumentEvent e)
1176   {
1177     checkDescrModified();
1178   }
1179
1180   @Override
1181   public void removeUpdate(DocumentEvent e)
1182   {
1183     checkDescrModified();
1184   }
1185
1186   @Override
1187   public void changedUpdate(DocumentEvent e)
1188   {
1189     checkDescrModified();
1190   }
1191
1192   /**
1193    *
1194    * @return null or the service preset selected by the user
1195    */
1196   public WsParamSetI getPreset()
1197   {
1198     if (isUserPreset || isModified()
1199             || (lastParmSet != null && lastParmSet.equals(SVC_DEF)))
1200     {
1201       return null;
1202     }
1203     else
1204     {
1205       return paramStore.getPreset(lastParmSet);
1206     }
1207   }
1208 }