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     // parameters dialog in 'expanded' format (help text boxes)
 194     opanp = new OptsAndParamsPage(this, false);
 195     jbInit();
 196     this.paramStore = paramStorei;
 197     if (paramStore == null && service != null)
 198     {
 199       paramStore = service.getParamStore();
 200     }
 201     this.service = service;
 202     initForService(preset, jobArgset);
 203     validate();
 204   }
 205
 206
 207   /**
 208    * Shows a modal dialog containing the parameters and Start or Cancel options.
 209    * Answers true if the job is started, false if cancelled.
 210    *
 211    * @return
 212    */
 213   public CompletionStage<Boolean> showRunDialog()
 214   {
 215     // Should JFrame hahve a parent of getDesktop ?
 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[] { service.getActionText() }));
 222     }
 223     Rectangle deskr = Desktop.getInstance().getBounds();
 224     Dimension pref = this.getPreferredSize();
 225     frame.setBounds(
 226             new Rectangle((int) (deskr.getCenterX() - pref.width / 2),
 227                     (int) (deskr.getCenterY() - pref.height / 2),
 228                     pref.width, pref.height));
 229     frame.setContentPane(this);
 230
 231     // should perhaps recover defaults from user prefs.
 232
 233     frame.validate();
 234     javax.swing.SwingUtilities.invokeLater(new Runnable()
 235     {
 236       @Override
 237       public void run()
 238       {
 239         // jobPanel.setDividerLocation(0.25);
 240
 241       }
 242     });
 243
 244     frame.setVisible(true);
 245
 246     return completionStage;
 247   }
 248
 249   private void jbInit()
 250   {
 251     this.addHierarchyBoundsListener(new HierarchyBoundsListener()
 252     {
 253
 254       @Override
 255       public void ancestorResized(HierarchyEvent arg0)
 256       {
 257         refreshParamLayout();
 258       }
 259
 260       @Override
 261       public void ancestorMoved(HierarchyEvent arg0)
 262       {
 263         // TODO Auto-generated method stub
 264
 265       }
 266     });
 267     updatepref = JvSwingUtils.makeButton(
 268             MessageManager.getString("action.update"),
 269             MessageManager.getString("label.update_user_parameter_set"),
 270             this::update_actionPerformed);
 271     deletepref = JvSwingUtils.makeButton(
 272             MessageManager.getString("action.delete"),
 273             MessageManager.getString("label.delete_user_parameter_set"),
 274             this::delete_actionPerformed);
 275     createpref = JvSwingUtils.makeButton(
 276             MessageManager.getString("action.create"),
 277             MessageManager.getString("label.create_user_parameter_set"),
 278             this::create_actionPerformed);
 279     revertpref = JvSwingUtils.makeButton(
 280             MessageManager.getString("action.revert"),
 281             MessageManager
 282                     .getString("label.revert_changes_user_parameter_set"),
 283             this::revert_actionPerformed);
 284
 285
 286     JPanel setDetails = new JPanel();
 287     setDetails.setBorder(
 288             new TitledBorder(MessageManager.getString("label.details")));
 289     setDetails.setLayout(new BorderLayout());
 290     setDescr.setColumns(40);
 291     setDescr.setWrapStyleWord(true);
 292     setDescr.setLineWrap(true);
 293     setDescr.setBackground(getBackground());
 294     setDescr.setEditable(true);
 295     setDescr.getDocument().addDocumentListener(this);
 296     setDescr.setToolTipText(
 297             MessageManager.getString("label.edit_notes_parameter_set"));
 298     JScrollPane setDescrView = new JScrollPane();
 299     setDescrView.getViewport().setView(setDescr);
 300     setName.setEditable(true);
 301     setName.addItemListener(this);
 302     setName.getEditor().addActionListener(this);
 303     JPanel setNameInfo = new JPanel(new FlowLayout(FlowLayout.LEFT));
 304     GridBagLayout gbl = new GridBagLayout();
 305     setNamePanel.setLayout(gbl);
 306
 307     JLabel setNameLabel = new JLabel(
 308             MessageManager.getString("label.current_parameter_set_name"));
 309     setNameLabel.setFont(new java.awt.Font("Verdana", Font.PLAIN, 10));
 310
 311     setNameInfo.add(setNameLabel);
 312     setNameInfo.add(setName);
 313
 314     // initial button visibility
 315     updatepref.setVisible(false);
 316     deletepref.setVisible(false);
 317     revertpref.setVisible(false);
 318     createpref.setVisible(false);
 319     JPanel setsavebuts = new JPanel();
 320     setsavebuts.setLayout(new FlowLayout(FlowLayout.LEFT, 10, 0)); // GridLayout(1,2));
 321     JPanel spacer = new JPanel();
 322     spacer.setPreferredSize(new Dimension(2, 30));
 323     setsavebuts.add(spacer);
 324     setsavebuts.add(deletepref);
 325     setsavebuts.add(revertpref);
 326     setsavebuts.add(createpref);
 327     setsavebuts.add(updatepref);
 328     // setsavebuts.setSize(new Dimension(150, 30));
 329     JPanel buttonArea = new JPanel(new GridLayout(1, 1));
 330     buttonArea.add(setsavebuts);
 331     setNamePanel.add(setNameInfo);
 332     GridBagConstraints gbc = new GridBagConstraints();
 333     gbc.gridheight = 2;
 334     gbl.setConstraints(setNameInfo, gbc);
 335     setNamePanel.add(buttonArea);
 336     gbc = new GridBagConstraints();
 337     gbc.gridx = 0;
 338     gbc.gridy = 2;
 339     gbc.gridheight = 1;
 340     gbl.setConstraints(buttonArea, gbc);
 341     setDetails.add(setDescrView, BorderLayout.CENTER);
 342
 343     // paramPane.setPreferredSize(new Dimension(360, 400));
 344     // paramPane.setPreferredSize(null);
 345     optionsPanel.setBorder(
 346             new TitledBorder(MessageManager.getString("label.options")));
 347     optionsPanel.setOpaque(true);
 348     paramsPanel.setBorder(
 349             new TitledBorder(MessageManager.getString("label.parameters")));
 350     paramsPanel.setOpaque(true);
 351     // optsAndparams.setScrollableWidth(ScrollableSizeHint.FIT);
 352     // optsAndparams.setScrollableHeight(ScrollableSizeHint.NONE);
 353     // optsAndparams.setLayout(new BorderLayout());
 354     JPanel optsAndparams = new JPanel();
 355     optsAndparams.setLayout(new BorderLayout());
 356     optsAndparams.add(optionsPanel, BorderLayout.NORTH);
 357     optsAndparams.add(paramsPanel, BorderLayout.CENTER);
 358     JPanel jp = new JPanel(new BorderLayout());
 359     jp.add(optsAndparams, BorderLayout.CENTER);
 360     paramPane.getViewport().setView(jp);
 361     paramPane.setBorder(null);
 362     setLayout(new BorderLayout());
 363     JPanel jobPanel = new JPanel();
 364     jobPanel.setPreferredSize(null);
 365     jobPanel.setLayout(new BorderLayout());
 366     jobPanel.add(setDetails, BorderLayout.NORTH);
 367     jobPanel.add(paramPane, BorderLayout.CENTER);
 368     // jobPanel.setOrientation(JSplitPane.VERTICAL_SPLIT);
 369
 370     add(setNamePanel, BorderLayout.NORTH);
 371     add(jobPanel, BorderLayout.CENTER);
 372
 373     JPanel dialogpanel = new JPanel();
 374     dialogpanel.add(startjob);
 375     dialogpanel.add(canceljob);
 376     // JAL-1580: setMaximumSize() doesn't work, so just size for the worst case:
 377     // check for null is for JUnit usage
 378     final int windowHeight = Desktop.getInstance() == null ? DEFAULT_HEIGHT
 379             : Desktop.getInstance().getHeight();
 380     setPreferredSize(new Dimension(540, windowHeight));
 381     add(dialogpanel, BorderLayout.SOUTH);
 382     validate();
 383   }
 384
 385   protected void revert_actionPerformed(ActionEvent e)
 386   {
 387     reInitDialog(lastParmSet);
 388     updateWebServiceMenus();
 389   }
 390
 391   protected void update_actionPerformed(ActionEvent e)
 392   {
 393     if (isUserPreset)
 394     {
 395       String curname = ((String) setName.getSelectedItem()).trim();
 396       _updatePreset(lastParmSet, curname);
 397       lastParmSet = curname;
 398       isUserPreset = true;
 399       initArgSetModified();
 400       syncSetNamesWithStore();
 401     }
 402   }
 403
 404   private void _deleteUserPreset(String lastParmSet2)
 405   {
 406     paramStore.deletePreset(lastParmSet2);
 407   }
 408
 409   protected void delete_actionPerformed(ActionEvent e)
 410   {
 411     if (isUserPreset)
 412     {
 413       // delete current preset's saved entry
 414       _deleteUserPreset(lastParmSet);
 415     }
 416     reInitDialog(null); // service default
 417     updateWebServiceMenus();
 418   }
 419
 420   protected void create_actionPerformed(ActionEvent e)
 421   {
 422     String curname = ((String) setName.getSelectedItem()).trim();
 423     if (curname.length() > 0)
 424     {
 425       _storeCurrentPreset(curname);
 426       lastParmSet = curname;
 427       isUserPreset = true;
 428       reInitDialog(curname);
 429       initArgSetModified();
 430       updateWebServiceMenus();
 431     }
 432     else
 433     {
 434       // TODO: show warning
 435       System.err.println("Invalid name. Not saved.");
 436     }
 437   }
 438
 439   protected void canceljob_actionPerformed(ActionEvent e)
 440   {
 441     startJob = false;
 442     if (frame != null)
 443     {
 444       frame.setVisible(false);
 445     }
 446     completionStage.complete(false);
 447   }
 448
 449   protected void startjob_actionPerformed(ActionEvent e)
 450   {
 451     startJob = true;
 452     if (frame != null)
 453     {
 454       frame.setVisible(false);
 455     }
 456     completionStage.complete(true);
 457   }
 458
 459   void initForService(WsParamSetI paramSet, List<ArgumentI> jobArgset)
 460   {
 461     settingDialog = true;
 462
 463     init(paramSet, jobArgset);
 464
 465   }
 466
 467   void init(WsParamSetI p, List<ArgumentI> jobArgset)
 468   {
 469     Hashtable<String, String> exnames = new Hashtable<>();
 470     for (int i = 0, iSize = setName.getItemCount(); i < iSize; i++)
 471     {
 472       exnames.put(setName.getItemAt(i), setName.getItemAt(i));
 473     }
 474     servicePresets = new Hashtable<>();
 475     // Add the default entry - if not present already.
 476     if (!exnames.contains(SVC_DEF))
 477     {
 478       setName.addItem(SVC_DEF);
 479       exnames.put(SVC_DEF, SVC_DEF);
 480       servicePresets.put(SVC_DEF, SVC_DEF);
 481     }
 482     // String curname = (p == null ? "" : p.getName());
 483     for (WsParamSetI pr : paramStore.getPresets())
 484     {
 485       if (!pr.isModifiable())
 486       {
 487         servicePresets.put(pr.getName(), "preset");
 488       }
 489       else
 490       {
 491       }
 492       if (!exnames.contains(pr.getName()))
 493       {
 494         setName.addItem(pr.getName());
 495       }
 496     }
 497     // TODO: if initial jobArgset matches a given user setting or preset then
 498     // should recover setting accordingly
 499     // updateTable(p, jobArgset);
 500     if (p != null)
 501     {
 502       reInitDialog(p.getName());
 503       initArgSetModified();
 504     }
 505     else
 506     {
 507       if (jobArgset != null && jobArgset.size() > 0)
 508       {
 509         curSetName = "Supplied Settings";
 510         isUserPreset = false;
 511         updateTable(p, jobArgset);
 512         setName.setSelectedItem(curSetName);
 513         updateButtonDisplay();
 514       }
 515       else
 516       {
 517         curSetName = null;
 518         reInitDialog(null);
 519       }
 520     }
 521     settingDialog = false;
 522
 523   }
 524
 525   private void updateTable(WsParamSetI p, List<ArgumentI> jobArgset)
 526   {
 527     boolean setDefaultParams = false;
 528     if (lastParmSet == null)
 529     {
 530       isUserPreset = false;
 531       // First call - so provide Service default settings
 532       setName.setSelectedItem(lastSetName = SVC_DEF);
 533     }
 534     if (p == null && SVC_DEF.equals("" + setName.getSelectedItem()))
 535     {
 536       // indicate that service defaults should be set if available
 537       setDefaultParams = true;
 538     }
 539     // populate table from default parameter set.
 540     List<ArgumentI> args = paramStore.getServiceParameters();
 541
 542     // split to params and required arguments
 543     {
 544       int cw = 0;
 545       boolean optset = false;
 546       for (ArgumentI myarg : args)
 547       {
 548         // Ideally, Argument would implement isRequired !
 549         if (myarg instanceof ParameterI)
 550         {
 551           ParameterI parm = (ParameterI) myarg;
 552           opanp.addParameter(parm).validate();
 553         }
 554         else
 555         {
 556           if (myarg instanceof OptionI)
 557           {
 558             OptionI opt = (OptionI) myarg;
 559             OptionBox ob = opanp.addOption(opt);
 560             ob.resetToDefault(setDefaultParams);
 561             if (maxOptWidth < ob.getPreferredSize().width)
 562             {
 563               maxOptWidth = ob.getPreferredSize().width;
 564             }
 565             ob.validate();
 566             cw += ob.getPreferredSize().width + 5;
 567           }
 568           else
 569           {
 570             System.err.println("Ignoring unknown service argument type "
 571                     + myarg.getClass().getName());
 572           }
 573         }
 574       }
 575       args = null; // no more args to process.
 576     }
 577     if (p != null)
 578     {
 579       isUserPreset = false;
 580       // initialise setname
 581       setName.setSelectedItem(lastSetName = p.getName());
 582       setDescr.setText(lastDescrText = p.getDescription());
 583       // TODO - URL link
 584       try
 585       {
 586         args = p.getArguments();
 587       } catch (Exception e)
 588       {
 589         e.printStackTrace();
 590       }
 591       // TODO: check if args should be unselected prior to resetting using the
 592       // preset
 593     }
 594
 595     if (jobArgset != null)
 596     {
 597       argSetModified(jobArgset, true);
 598       args = jobArgset;
 599     }
 600     // get setargs from current object
 601     if (args != null)
 602     {
 603       for (ArgumentI arg : args)
 604       {
 605         if (arg instanceof ParameterI)
 606         {
 607           opanp.setParameter((ParameterI) arg);
 608         }
 609         else
 610         {
 611           if (arg instanceof OptionI)
 612           {
 613             // System.out.println("Setting option "
 614             // + System.identityHashCode(arg) + ":" + arg.getName()
 615             // + " with " + arg.getDefaultValue());
 616             opanp.selectOption((OptionI) arg, arg.getValue());
 617           }
 618         }
 619
 620       }
 621     }
 622
 623     refreshParamLayout();
 624     revalidate();
 625   }
 626
 627   private boolean isModified()
 628   {
 629     return modifiedElements.size() > 0;
 630   }
 631
 632
 633   /**
 634    * reset gui and modification state settings
 635    */
 636   private void initArgSetModified()
 637   {
 638     curSetName = null;
 639     modifiedElements.clear();
 640     updateButtonDisplay();
 641   }
 642
 643   private void updateButtonDisplay()
 644   {
 645     boolean _update = false, _create = false, _delete = false,
 646             _revert = false;
 647     if (modifiedElements.size() > 0)
 648     {
 649       // set modified
 650       _revert = true;
 651       _update = isUserPreset; // can only update user presets
 652       if (!isUserPreset || modifiedElements.containsKey(setName))
 653       {
 654         // name modified - can create new preset
 655         _create = true;
 656       }
 657     }
 658     else
 659     {
 660       // set unmodified
 661     }
 662     // can still delete a user preset
 663     _delete = isUserPreset;
 664
 665     createpref.setVisible(_create);
 666     updatepref.setVisible(_update);
 667     deletepref.setVisible(_delete);
 668     revertpref.setVisible(_revert);
 669     validate();
 670   }
 671
 672   @Override
 673   public void argSetModified(Object modifiedElement, boolean b)
 674   {
 675     if (settingDialog)
 676     {
 677       return;
 678     }
 679     if (!b)
 680     {
 681       modifiedElements.remove(modifiedElement);
 682     }
 683     else
 684     {
 685       if (b && modifiedElement == setName
 686               && modifiedElements.contains(modifiedElement))
 687       {
 688         // HACK! prevents iteration on makeSetNameValid
 689         b = false;
 690       }
 691       modifiedElements.put(modifiedElement, modifiedElement);
 692     }
 693     // set mod status based on presence of elements in table
 694     if (b && modifiedElements.size() > 0)
 695     {
 696       makeSetNameValid(!isUserPreset);
 697       setNamePanel.revalidate();
 698     }
 699     updateButtonDisplay();
 700   }
 701
 702   private boolean isServicePreset(String selectedItem)
 703   {
 704     return selectedItem.equals(SVC_DEF)
 705             || servicePresets.containsKey(selectedItem);
 706   }
 707
 708   /**
 709    * check if the current set name is a valid set name for saving, if not, then
 710    * fix it.
 711    */
 712   private void makeSetNameValid(boolean newuserset)
 713   {
 714     boolean stn = settingDialog;
 715     boolean renamed = false;
 716     settingDialog = true;
 717     String nm = (curSetName != null ? curSetName
 718             : (String) setName.getSelectedItem());
 719     // check if the name is reserved - if it is, rename it.
 720     if (isServicePreset(nm))
 721     {
 722       nm = "User " + nm;
 723       renamed = true;
 724     }
 725     String tnm = nm;
 726     if (newuserset)
 727     {
 728       int i = 0;
 729       while (paramStore.getPreset(tnm) != null)
 730       {
 731         tnm = nm + " (" + (++i) + ")";
 732         renamed = true;
 733       }
 734       if (i > 0)
 735       {
 736         nm = tnm;
 737       }
 738     }
 739
 740     boolean makeupdate = false;
 741     // sync the gui with the preset database
 742     for (int i = 0, iS = setName.getItemCount(); i < iS; i++)
 743     {
 744       String snm = setName.getItemAt(i);
 745       if (snm.equals(nm))
 746       {
 747         makeupdate = true;
 748         // setName.setSelectedIndex(i);
 749       }
 750     }
 751     if (!makeupdate)
 752     {
 753       setName.addItem(curSetName = nm);
 754       setName.setSelectedItem(curSetName);
 755     }
 756     if (renamed)
 757     {
 758       settingDialog = false; // we need this name change to be registered.
 759       argSetModified(setName, renamed);
 760     }
 761     settingDialog = stn;
 762   }
 763
 764   /**
 765    * Rebuilds the Options and Parameters panels
 766    */
 767   @Override
 768   public void refreshParamLayout()
 769   {
 770     final int rightMargin = 40;
 771     final int availableWidth = paramPane.getViewport().getSize().width
 772             - rightMargin
 773             - optionsPanel.getBorder().getBorderInsets(optionsPanel).left
 774             + optionsPanel.getBorder().getBorderInsets(optionsPanel).right;
 775
 776     if (opanp.getOptSet().size() > 0)
 777     {
 778       int hgap = 5;
 779       int currentWidth = hgap;
 780
 781       /*
 782        * layout constraint 'nogrid' prevents vertical column alignment,
 783        * allowing controls to flow without extra space inserted to align
 784        */
 785       optionsPanel.setLayout(new MigLayout("nogrid", "", ""));
 786       optionsPanel.removeAll();
 787       JPanel lastAdded = null;
 788
 789       /*
 790        * add each control in turn; if adding would overflow the right margin,
 791        * remove and re-add the previous parameter with "wrap" (after)
 792        * in order to start a new row
 793        */
 794       for (OptionBox pbox : opanp.getOptSet().values())
 795       {
 796         pbox.validate();
 797         int boxWidth = pbox.getSize().width;
 798         currentWidth += boxWidth + hgap;
 799         boolean wrapAfterLast = currentWidth > availableWidth
 800                 && lastAdded != null;
 801         // System.out.println(String.format(
 802         // "%s width=%d, paneWidth=%d, currentWidth=%d, wrapAfterLast=%s",
 803         // pbox.toString(), boxWidth, panewidth, currentWidth,
 804         // wrapAfterLast));
 805         if (wrapAfterLast)
 806         {
 807           optionsPanel.remove(lastAdded);
 808           optionsPanel.add(lastAdded, "wrap");
 809           currentWidth = hgap + boxWidth;
 810         }
 811         optionsPanel.add(pbox);
 812         lastAdded = pbox;
 813       }
 814       optionsPanel.revalidate();
 815     }
 816     else
 817     {
 818       optionsPanel.setVisible(false);
 819     }
 820
 821     if (opanp.getParamSet().size() > 0)
 822     {
 823       paramsPanel.removeAll();
 824       paramsPanel.setLayout(new MigLayout("", "", ""));
 825       int hgap = 5;
 826       int currentWidth = hgap;
 827
 828       JPanel lastAdded = null;
 829       for (ParamBox pbox : opanp.getParamSet().values())
 830       {
 831         pbox.validate();
 832         int boxWidth = pbox.getSize().width;
 833         currentWidth += boxWidth + hgap;
 834         boolean wrapAfterLast = currentWidth > availableWidth
 835                 && lastAdded != null;
 836         if (wrapAfterLast)
 837         {
 838           paramsPanel.remove(lastAdded);
 839           paramsPanel.add(lastAdded, "wrap");
 840           currentWidth = pbox.getSize().width + hgap;
 841         }
 842         paramsPanel.add(pbox);
 843         lastAdded = pbox;
 844       }
 845
 846       /*
 847        * s = 2 * sep; for (ParamBox pbox : opanp.getParamSet().values()) {
 848        * pbox.validate(); s += sep +
 849        * pbox.getPreferredSize().height+pbox.getBorder
 850        * ().getBorderInsets(pbox).bottom; }
 851        *
 852        * // paramList.setPreferredSize(new Dimension(w, s));
 853        * os+=s+2*sep+paramList
 854        * .getBorder().getBorderInsets(paramList).bottom+paramList
 855        * .getBorder().getBorderInsets(paramList).top;
 856        */
 857       paramsPanel.revalidate();
 858     }
 859     else
 860     {
 861       paramsPanel.setVisible(false);
 862     }
 863     // TODO: waste some time trying to eliminate any unnecessary .validate calls
 864     // here
 865     // System.out.println("Size will be : "+w+","+os);
 866     // optsAndparams.setPreferredSize(null);
 867     // paramPane.getViewport().setView(optsAndparams);
 868     paramPane.getViewport().setAutoscrolls(true);
 869     paramPane.revalidate();
 870     revalidate();
 871   }
 872
 873
 874   public boolean isServiceDefaults()
 875   {
 876     return (!isModified()
 877             && (lastParmSet != null && lastParmSet.equals(SVC_DEF)));
 878   }
 879
 880   public List<ArgumentI> getJobParams()
 881   {
 882     return opanp.getCurrentSettings();
 883   }
 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 }