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.jws2.JabaParamStore;
  27 import jalview.ws.jws2.JabaPreset;
  28 import jalview.ws.jws2.Jws2Discoverer;
  29 import jalview.ws.jws2.jabaws2.Jws2Instance;
  30 import jalview.ws.params.ArgumentI;
  31 import jalview.ws.params.OptionI;
  32 import jalview.ws.params.ParamDatastoreI;
  33 import jalview.ws.params.ParameterI;
  34 import jalview.ws.params.WsParamSetI;
  35
  36 import java.awt.BorderLayout;
  37 import java.awt.Component;
  38 import java.awt.Dimension;
  39 import java.awt.FlowLayout;
  40 import java.awt.Font;
  41 import java.awt.GridBagConstraints;
  42 import java.awt.GridBagLayout;
  43 import java.awt.GridLayout;
  44 import java.awt.Rectangle;
  45 import java.awt.event.ActionEvent;
  46 import java.awt.event.ActionListener;
  47 import java.awt.event.HierarchyBoundsListener;
  48 import java.awt.event.HierarchyEvent;
  49 import java.awt.event.ItemEvent;
  50 import java.awt.event.ItemListener;
  51 import java.awt.event.WindowEvent;
  52 import java.awt.event.WindowListener;
  53 import java.net.URL;
  54 import java.util.Hashtable;
  55 import java.util.Iterator;
  56 import java.util.List;
  57 import java.util.Vector;
  58
  59 import javax.swing.JButton;
  60 import javax.swing.JComboBox;
  61 import javax.swing.JDialog;
  62 import javax.swing.JFrame;
  63 import javax.swing.JLabel;
  64 import javax.swing.JOptionPane;
  65 import javax.swing.JPanel;
  66 import javax.swing.JScrollPane;
  67 import javax.swing.JSplitPane;
  68 import javax.swing.JTextArea;
  69 import javax.swing.border.TitledBorder;
  70 import javax.swing.event.DocumentEvent;
  71 import javax.swing.event.DocumentListener;
  72
  73 import net.miginfocom.swing.MigLayout;
  74
  75 import compbio.metadata.Argument;
  76 import compbio.metadata.Option;
  77 import compbio.metadata.Parameter;
  78 import compbio.metadata.Preset;
  79 import compbio.metadata.PresetManager;
  80 import compbio.metadata.RunnerConfig;
  81
  82 /**
  83  * job parameter editing/browsing dialog box. User can browse existing settings
  84  * (user + presets + Defaults), and any changes to parameters creates a modified
  85  * user parameter set. LOGIC: If the parameter set is modified, and its name is
  86  * a valid, non-existant user parameter set, then a save button is shown. If the
  87  * parameter set is modified and its name is a valid, extant user parameter set,
  88  * then an update button is shown. If user parameter set's name is edited, and
  89  * old name exists as a writable user parameter set, then rename button is
  90  * shown. If current parameter set is associated with a user defined parameter
  91  * set, then : if set is modifed, a 'revert' button is shown. if set is not
  92  * modified, a 'delete' button is shown.
  93  *
  94  * @author JimP
  95  *
  96  */
  97 public class WsJobParameters extends JPanel implements ItemListener,
  98         ActionListener, DocumentListener, OptsParametersContainerI
  99 {
 100   URL linkImageURL = getClass().getResource("/images/link.gif");
 101
 102   private static final String SVC_DEF = "Defaults"; // this is the null
 103                                                     // parameter set as shown to
 104                                                     // user
 105
 106   /**
 107    * manager for options and parameters.
 108    */
 109   OptsAndParamsPage opanp = new OptsAndParamsPage(this);
 110
 111   /**
 112    * panel containing job options
 113    */
 114   JPanel jobOptions = new JPanel();
 115
 116   /**
 117    * panel containing job parameters
 118    */
 119   JPanel paramList = new JPanel();
 120
 121   JPanel SetNamePanel = new JPanel();
 122
 123   JPanel setDetails = new JPanel();
 124
 125   JSplitPane settingsPanel = new JSplitPane();
 126
 127   JPanel jobPanel = new JPanel();
 128
 129   JScrollPane jobOptionsPane = new JScrollPane();
 130
 131   JButton createpref = new JButton();
 132
 133   JButton deletepref = new JButton();
 134
 135   JButton revertpref = new JButton();
 136
 137   JButton updatepref = new JButton();
 138
 139   JButton startjob = new JButton();
 140
 141   JButton canceljob = new JButton();
 142
 143   JComboBox setName = new JComboBox();
 144
 145   JTextArea setDescr = new JTextArea();
 146
 147   JScrollPane paramPane = new JScrollPane();
 148
 149   // ScrollablePanel optsAndparams = new ScrollablePanel();
 150   JPanel optsAndparams = new JPanel();
 151
 152   RunnerConfig serviceOptions;
 153
 154   ParamDatastoreI paramStore;
 155
 156   private int MAX_OPTWIDTH = 200;
 157
 158   WsJobParameters(Jws2Instance service)
 159   {
 160     this(service, null);
 161   }
 162
 163   public WsJobParameters(Jws2Instance service, WsParamSetI preset)
 164   {
 165     this(null, service, preset, null);
 166   }
 167
 168   /**
 169    *
 170    * @param desktop
 171    *          - if null, create new JFrame outside of desktop
 172    * @param service
 173    * @param preset
 174    */
 175   public WsJobParameters(JFrame parent, Jws2Instance service,
 176           WsParamSetI preset, List<Argument> jobArgset)
 177   {
 178     this(parent, null, service, preset, jobArgset);
 179   }
 180
 181   /**
 182    *
 183    * @param parent
 184    * @param paramStorei
 185    * @param service
 186    * @param preset
 187    * @param jobArgset
 188    */
 189   public WsJobParameters(JFrame parent, ParamDatastoreI paramStorei,
 190           Jws2Instance service, WsParamSetI preset, List<Argument> jobArgset)
 191   {
 192     super();
 193     jbInit();
 194     this.paramStore = paramStorei;
 195     if (paramStore == null)
 196     {
 197       paramStore = service.getParamStore();
 198     }
 199     this.service = service;
 200     // argSetModified(false);
 201     // populate parameter table
 202     initForService(service, preset, jobArgset);
 203     // display in new JFrame attached to parent.
 204     validate();
 205   }
 206
 207   int response = -1;
 208
 209   JDialog frame = null;
 210
 211   /**
 212    * shows a modal dialog containing the parameters.
 213    *
 214    * @return
 215    */
 216   public boolean showRunDialog()
 217   {
 218
 219     frame = new JDialog(Desktop.instance, true);
 220
 221     frame.setTitle(MessageManager.formatMessage("label.edit_params_for",
 222             new String[] { service.getActionText() }));
 223     Rectangle deskr = Desktop.instance.getBounds();
 224     Dimension pref = this.getPreferredSize();
 225     frame.setBounds(new Rectangle(
 226             (int) (deskr.getCenterX() - pref.width / 2), (int) (deskr
 227                     .getCenterY() - pref.height / 2), pref.width,
 228             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       public void run()
 237       {
 238         // jobPanel.setDividerLocation(0.25);
 239
 240       }
 241     });
 242     frame.setVisible(true);
 243
 244     if (response > 0)
 245     {
 246       return true;
 247     }
 248     return false;
 249   }
 250
 251   private void jbInit()
 252   {
 253     this.addHierarchyBoundsListener(new HierarchyBoundsListener()
 254     {
 255
 256       @Override
 257       public void ancestorResized(HierarchyEvent arg0)
 258       {
 259         refreshParamLayout();
 260       }
 261
 262       @Override
 263       public void ancestorMoved(HierarchyEvent arg0)
 264       {
 265         // TODO Auto-generated method stub
 266
 267       }
 268     });
 269     updatepref = JvSwingUtils.makeButton(
 270             MessageManager.getString("action.update"),
 271             MessageManager.getString("label.update_user_parameter_set"),
 272             new ActionListener()
 273             {
 274
 275               public void actionPerformed(ActionEvent e)
 276               {
 277                 update_actionPerformed(e);
 278               }
 279             });
 280     deletepref = JvSwingUtils.makeButton(
 281             MessageManager.getString("action.delete"),
 282             MessageManager.getString("label.delete_user_parameter_set"),
 283             new ActionListener()
 284             {
 285
 286               public void actionPerformed(ActionEvent e)
 287               {
 288                 delete_actionPerformed(e);
 289               }
 290             });
 291     createpref = JvSwingUtils.makeButton(
 292             MessageManager.getString("action.create"),
 293             MessageManager.getString("label.create_user_parameter_set"),
 294             new ActionListener()
 295             {
 296
 297               public void actionPerformed(ActionEvent e)
 298               {
 299                 create_actionPerformed(e);
 300               }
 301             });
 302     revertpref = JvSwingUtils.makeButton(MessageManager
 303             .getString("action.revert"), MessageManager
 304             .getString("label.revert_changes_user_parameter_set"),
 305             new ActionListener()
 306             {
 307
 308               public void actionPerformed(ActionEvent e)
 309               {
 310                 revert_actionPerformed(e);
 311               }
 312             });
 313     startjob = JvSwingUtils.makeButton(
 314             MessageManager.getString("action.start_job"),
 315             MessageManager.getString("label.start_job_current_settings"),
 316             new ActionListener()
 317             {
 318               public void actionPerformed(ActionEvent e)
 319               {
 320                 startjob_actionPerformed(e);
 321               }
 322             });
 323     canceljob = JvSwingUtils.makeButton(
 324             MessageManager.getString("action.cancel_job"),
 325             MessageManager.getString("label.cancel_job_close_dialog"),
 326             new ActionListener()
 327             {
 328               public void actionPerformed(ActionEvent e)
 329               {
 330                 canceljob_actionPerformed(e);
 331               }
 332             });
 333
 334     setDetails.setBorder(new TitledBorder(MessageManager
 335             .getString("label.details")));
 336     setDetails.setLayout(new BorderLayout());
 337     setDescr.setColumns(40);
 338     setDescr.setWrapStyleWord(true);
 339     setDescr.setLineWrap(true);
 340     setDescr.setBackground(getBackground());
 341     setDescr.setEditable(true);
 342     setDescr.getDocument().addDocumentListener(this);
 343     setDescr.setToolTipText(MessageManager
 344             .getString("label.edit_notes_parameter_set"));
 345     JScrollPane setDescrView = new JScrollPane();
 346     setDescrView.getViewport().setView(setDescr);
 347     setName.setEditable(true);
 348     setName.addItemListener(this);
 349     setName.getEditor().addActionListener(this);
 350     JPanel setNameInfo = new JPanel(new FlowLayout(FlowLayout.LEFT));
 351     GridBagLayout gbl = new GridBagLayout();
 352     SetNamePanel.setLayout(gbl);
 353
 354     JLabel setNameLabel = new JLabel(
 355             MessageManager.getString("label.current_parameter_set_name"));
 356     setNameLabel.setFont(new java.awt.Font("Verdana", Font.PLAIN, 10));
 357
 358     setNameInfo.add(setNameLabel);
 359     setNameInfo.add(setName);
 360
 361     // initial button visibility
 362     updatepref.setVisible(false);
 363     deletepref.setVisible(false);
 364     revertpref.setVisible(false);
 365     createpref.setVisible(false);
 366     JPanel setsavebuts = new JPanel();
 367     setsavebuts.setLayout(new FlowLayout(FlowLayout.LEFT)); // GridLayout(1,2));
 368     ((FlowLayout) setsavebuts.getLayout()).setHgap(10);
 369     ((FlowLayout) setsavebuts.getLayout()).setVgap(0);
 370     JPanel spacer = new JPanel();
 371     spacer.setPreferredSize(new Dimension(2, 30));
 372     setsavebuts.add(spacer);
 373     setsavebuts.add(deletepref);
 374     setsavebuts.add(revertpref);
 375     setsavebuts.add(createpref);
 376     setsavebuts.add(updatepref);
 377     // setsavebuts.setSize(new Dimension(150, 30));
 378     JPanel buttonArea = new JPanel(new GridLayout(1, 1));
 379     buttonArea.add(setsavebuts);
 380     SetNamePanel.add(setNameInfo);
 381     GridBagConstraints gbc = new GridBagConstraints();
 382     gbc.gridheight = 2;
 383     gbl.setConstraints(setNameInfo, gbc);
 384     SetNamePanel.add(buttonArea);
 385     gbc = new GridBagConstraints();
 386     gbc.gridx = 0;
 387     gbc.gridy = 2;
 388     gbc.gridheight = 1;
 389     gbl.setConstraints(buttonArea, gbc);
 390     setDetails.add(setDescrView, BorderLayout.CENTER);
 391
 392     // paramPane.setPreferredSize(new Dimension(360, 400));
 393     // paramPane.setPreferredSize(null);
 394     jobOptions.setBorder(new TitledBorder(MessageManager
 395             .getString("label.options")));
 396     jobOptions.setOpaque(true);
 397     paramList.setBorder(new TitledBorder(MessageManager
 398             .getString("label.parameters")));
 399     paramList.setOpaque(true);
 400     JPanel bjo = new JPanel(new BorderLayout()), bjp = new JPanel(
 401             new BorderLayout());
 402     bjo.add(jobOptions, BorderLayout.CENTER);
 403     bjp.add(paramList, BorderLayout.CENTER);
 404     bjp.setOpaque(true);
 405     bjo.setOpaque(true);
 406     // optsAndparams.setScrollableWidth(ScrollableSizeHint.FIT);
 407     // optsAndparams.setScrollableHeight(ScrollableSizeHint.NONE);
 408     // optsAndparams.setLayout(new BorderLayout());
 409     optsAndparams.setLayout(new BorderLayout());
 410     optsAndparams.add(jobOptions, BorderLayout.NORTH);
 411     optsAndparams.add(paramList, BorderLayout.CENTER);
 412     JPanel jp = new JPanel(new BorderLayout());
 413     jp.add(optsAndparams, BorderLayout.CENTER);
 414     paramPane.getViewport().setView(jp);
 415     paramPane.setBorder(null);
 416     setLayout(new BorderLayout());
 417     jobPanel.setPreferredSize(null);
 418     jobPanel.setLayout(new BorderLayout());
 419     jobPanel.add(setDetails, BorderLayout.NORTH);
 420     jobPanel.add(paramPane, BorderLayout.CENTER);
 421     // jobPanel.setOrientation(JSplitPane.VERTICAL_SPLIT);
 422
 423     add(SetNamePanel, BorderLayout.NORTH);
 424     add(jobPanel, BorderLayout.CENTER);
 425
 426     JPanel dialogpanel = new JPanel();
 427     dialogpanel.add(startjob);
 428     dialogpanel.add(canceljob);
 429     // JAL-1580: setMaximumSize() doesn't work, so just size for the worst case:
 430     // check for null is for JUnit usage
 431     final int windowHeight = Desktop.instance == null ? 540
 432             : Desktop.instance.getHeight();
 433     setPreferredSize(new Dimension(540, windowHeight));
 434     add(dialogpanel, BorderLayout.SOUTH);
 435     validate();
 436   }
 437
 438   protected void revert_actionPerformed(ActionEvent e)
 439   {
 440     reInitDialog(lastParmSet);
 441     updateWebServiceMenus();
 442   }
 443
 444   protected void update_actionPerformed(ActionEvent e)
 445   {
 446     if (isUserPreset)
 447     {
 448       String curname = ((String) setName.getSelectedItem()).trim();
 449       _updatePreset(lastParmSet, curname);
 450       lastParmSet = curname;
 451       isUserPreset = true;
 452       initArgSetModified();
 453       syncSetNamesWithStore();
 454     }
 455   }
 456
 457   private void _deleteUserPreset(String lastParmSet2)
 458   {
 459     paramStore.deletePreset(lastParmSet2);
 460   }
 461
 462   protected void delete_actionPerformed(ActionEvent e)
 463   {
 464     if (isUserPreset)
 465     {
 466       // delete current preset's saved entry
 467       _deleteUserPreset(lastParmSet);
 468     }
 469     reInitDialog(null); // service default
 470     updateWebServiceMenus();
 471   }
 472
 473   protected void create_actionPerformed(ActionEvent e)
 474   {
 475     String curname = ((String) setName.getSelectedItem()).trim();
 476     if (curname.length() > 0)
 477     {
 478       _storeCurrentPreset(curname);
 479       lastParmSet = curname;
 480       isUserPreset = true;
 481       reInitDialog(curname);
 482       initArgSetModified();
 483       updateWebServiceMenus();
 484     }
 485     else
 486     {
 487       // TODO: show warning
 488       System.err.println("Invalid name. Not saved.");
 489     }
 490   }
 491
 492   protected void canceljob_actionPerformed(ActionEvent e)
 493   {
 494     response = 0;
 495     if (frame != null)
 496     {
 497       frame.setVisible(false);
 498     }
 499   }
 500
 501   protected void startjob_actionPerformed(ActionEvent e)
 502   {
 503     response = 1;
 504     if (frame != null)
 505     {
 506       frame.setVisible(false);
 507     }
 508   }
 509
 510   Jws2Instance service;
 511
 512   /**
 513    * list of service presets in the gui
 514    */
 515   Hashtable servicePresets = null;
 516
 517   /**
 518    * set if dialog is being set - so handlers will avoid spurious events
 519    */
 520   boolean settingDialog = false;
 521
 522   void initForService(Jws2Instance service, WsParamSetI jabap,
 523           List<Argument> jabajobArgset)
 524   {
 525     WsParamSetI p = null;
 526     List<ArgumentI> jobArgset = null;
 527     settingDialog = true;
 528     { // instantiate the abstract proxy for Jaba objects
 529       jobArgset = jabajobArgset == null ? null : JabaParamStore
 530               .getJwsArgsfromJaba(jabajobArgset);
 531       p = jabap; // (jabap != null) ? paramStore.getPreset(jabap.getName()) :
 532                  // null;
 533     }
 534
 535     Hashtable exnames = new Hashtable();
 536     for (int i = 0, iSize = setName.getItemCount(); i < iSize; i++)
 537     {
 538       exnames.put(setName.getItemAt(i), setName.getItemAt(i));
 539     }
 540     servicePresets = new Hashtable();
 541     // Add the default entry - if not present already.
 542     if (!exnames.contains(SVC_DEF))
 543     {
 544       setName.addItem(SVC_DEF);
 545       exnames.put(SVC_DEF, SVC_DEF);
 546       servicePresets.put(SVC_DEF, SVC_DEF);
 547     }
 548     String curname = (p == null ? "" : p.getName());
 549     for (WsParamSetI pr : paramStore.getPresets())
 550     {
 551       if (!pr.isModifiable())
 552       {
 553         servicePresets.put(pr.getName(), "preset");
 554       }
 555       else
 556       {
 557       }
 558       if (!exnames.contains(pr.getName()))
 559       {
 560         setName.addItem(pr.getName());
 561       }
 562     }
 563     // TODO: if initial jobArgset matches a given user setting or preset then
 564     // should recover setting accordingly
 565     // updateTable(p, jobArgset);
 566     if (p != null)
 567     {
 568       reInitDialog(p.getName());
 569       initArgSetModified();
 570     }
 571     else
 572     {
 573       if (jobArgset != null && jobArgset.size() > 0)
 574       {
 575         curSetName = "Supplied Settings";
 576         isUserPreset = false;
 577         updateTable(p, jobArgset);
 578         setName.setSelectedItem(curSetName);
 579         updateButtonDisplay();
 580       }
 581       else
 582       {
 583         curSetName = null;
 584         reInitDialog(null);
 585       }
 586     }
 587     settingDialog = false;
 588
 589   }
 590
 591   @SuppressWarnings("unchecked")
 592   private void updateTable(WsParamSetI p, List<ArgumentI> jobArgset)
 593   {
 594     boolean setDefaultParams = false;
 595     if (lastParmSet == null)
 596     {
 597       isUserPreset = false;
 598       // First call - so provide Service default settings
 599       setName.setSelectedItem(lastSetName = SVC_DEF);
 600     }
 601     if (p == null && SVC_DEF.equals("" + setName.getSelectedItem()))
 602     {
 603       // indicate that service defaults should be set if available
 604       setDefaultParams = true;
 605     }
 606     // populate table from default parameter set.
 607     List<ArgumentI> args = paramStore.getServiceParameters();
 608
 609     // split to params and required arguments
 610     {
 611       int cw = 0;
 612       boolean optset = false;
 613       for (ArgumentI myarg : args)
 614       {
 615         // Ideally, Argument would implement isRequired !
 616         if (myarg instanceof ParameterI)
 617         {
 618           ParameterI parm = (ParameterI) myarg;
 619           opanp.addParameter(parm).validate();
 620         }
 621         else
 622         {
 623           if (myarg instanceof OptionI)
 624           {
 625             OptionI opt = (OptionI) myarg;
 626             OptionBox ob = opanp.addOption(opt);
 627             ob.resetToDefault(setDefaultParams);
 628             if (MAX_OPTWIDTH < ob.getPreferredSize().width)
 629             {
 630               MAX_OPTWIDTH = ob.getPreferredSize().width;
 631             }
 632             ob.validate();
 633             cw += ob.getPreferredSize().width + 5;
 634           }
 635           else
 636           {
 637             System.err.println("Ignoring unknown service argument type "
 638                     + myarg.getClass().getName());
 639           }
 640         }
 641       }
 642       args = null; // no more args to process.
 643     }
 644     if (p != null)
 645     {
 646       isUserPreset = false;
 647       // initialise setname
 648       setName.setSelectedItem(lastSetName = p.getName());
 649       setDescr.setText(lastDescrText = p.getDescription());
 650       // TODO - URL link
 651       try
 652       {
 653         args = p.getArguments();
 654       } catch (Exception e)
 655       {
 656         e.printStackTrace();
 657       }
 658       // TODO: check if args should be unselected prior to resetting using the
 659       // preset
 660     }
 661
 662     if (jobArgset != null)
 663     {
 664       argSetModified(jobArgset, true);
 665       args = jobArgset;
 666     }
 667     // get setargs from current object
 668     if (args != null)
 669     {
 670       for (ArgumentI arg : args)
 671       {
 672         if (arg instanceof ParameterI)
 673         {
 674           opanp.setParameter((ParameterI) arg);
 675         }
 676         else
 677         {
 678           if (arg instanceof OptionI)
 679           {
 680             // System.out.println("Setting option "
 681             // + System.identityHashCode(arg) + ":" + arg.getName()
 682             // + " with " + arg.getDefaultValue());
 683             opanp.selectOption((OptionI) arg, arg.getValue());
 684           }
 685         }
 686
 687       }
 688     }
 689
 690     refreshParamLayout();
 691     revalidate();
 692   }
 693
 694   private boolean isModified()
 695   {
 696     return modifiedElements.size() > 0;
 697   }
 698
 699   private Hashtable modifiedElements = new Hashtable();
 700
 701   /**
 702    * reset gui and modification state settings
 703    */
 704   private void initArgSetModified()
 705   {
 706     curSetName = null;
 707     modifiedElements.clear();
 708     updateButtonDisplay();
 709   }
 710
 711   private void updateButtonDisplay()
 712   {
 713     boolean _update = false, _create = false, _delete = false, _revert = false;
 714     if (modifiedElements.size() > 0)
 715     {
 716       // set modified
 717       _revert = true;
 718       _update = isUserPreset; // can only update user presets
 719       if (!isUserPreset || modifiedElements.containsKey(setName))
 720       {
 721         // name modified - can create new preset
 722         _create = true;
 723       }
 724     }
 725     else
 726     {
 727       // set unmodified
 728     }
 729     // can still delete a user preset
 730     _delete = isUserPreset;
 731
 732     createpref.setVisible(_create);
 733     updatepref.setVisible(_update);
 734     deletepref.setVisible(_delete);
 735     revertpref.setVisible(_revert);
 736     validate();
 737   }
 738
 739   public void argSetModified(Object modifiedElement, boolean b)
 740   {
 741     if (settingDialog)
 742     {
 743       return;
 744     }
 745     if (!b)
 746     {
 747       modifiedElements.remove(modifiedElement);
 748     }
 749     else
 750     {
 751       if (b && modifiedElement == setName
 752               && modifiedElements.contains(modifiedElement))
 753       {
 754         // HACK! prevents iteration on makeSetNameValid
 755         b = false;
 756       }
 757       modifiedElements.put(modifiedElement, modifiedElement);
 758     }
 759     // set mod status based on presence of elements in table
 760     if (b && modifiedElements.size() > 0)
 761     {
 762       makeSetNameValid(!isUserPreset);
 763       SetNamePanel.revalidate();
 764     }
 765     updateButtonDisplay();
 766   }
 767
 768   private boolean isServicePreset(String selectedItem)
 769   {
 770     return selectedItem.equals(SVC_DEF)
 771             || servicePresets.containsKey(selectedItem);
 772   }
 773
 774   /**
 775    * check if the current set name is a valid set name for saving, if not, then
 776    * fix it.
 777    */
 778   private void makeSetNameValid(boolean newuserset)
 779   {
 780     boolean stn = settingDialog;
 781     boolean renamed = false;
 782     settingDialog = true;
 783     String nm = (curSetName != null ? curSetName : (String) setName
 784             .getSelectedItem());
 785     // check if the name is reserved - if it is, rename it.
 786     if (isServicePreset(nm))
 787     {
 788       nm = "User " + nm;
 789       renamed = true;
 790     }
 791     String tnm = nm;
 792     if (newuserset)
 793     {
 794       int i = 0;
 795       while (paramStore.getPreset(tnm) != null)
 796       {
 797         tnm = nm + " (" + (++i) + ")";
 798         renamed = true;
 799       }
 800       if (i > 0)
 801       {
 802         nm = tnm;
 803       }
 804     }
 805
 806     boolean makeupdate = false;
 807     // sync the gui with the preset database
 808     for (int i = 0, iS = setName.getItemCount(); i < iS; i++)
 809     {
 810       String snm = (String) setName.getItemAt(i);
 811       if (snm.equals(nm))
 812       {
 813         makeupdate = true;
 814         // setName.setSelectedIndex(i);
 815       }
 816     }
 817     if (!makeupdate)
 818     {
 819       setName.addItem(curSetName = nm);
 820       setName.setSelectedItem(curSetName);
 821     }
 822     if (renamed)
 823     {
 824       settingDialog = false; // we need this name change to be registered.
 825       argSetModified(setName, renamed);
 826     }
 827     settingDialog = stn;
 828   }
 829
 830   public void refreshParamLayout()
 831   {
 832     // optsAndparams.setPreferredSize(null);
 833     FlowLayout fl = new FlowLayout(FlowLayout.LEFT);
 834     int sep = fl.getVgap();
 835     boolean fh = true;
 836     int os = 0, s = jobOptions.getBorder().getBorderInsets(jobOptions).bottom
 837             + jobOptions.getBorder().getBorderInsets(jobOptions).top
 838             + 2
 839             * sep;
 840     /**
 841      * final height for viewport
 842      */
 843     int finalh = s;
 844     int panewidth = paramPane.getViewport().getSize().width - 120
 845             - jobOptions.getBorder().getBorderInsets(jobOptions).left
 846             + jobOptions.getBorder().getBorderInsets(jobOptions).right;
 847
 848     int w = 2
 849             * fl.getHgap()
 850             + (MAX_OPTWIDTH > OptsAndParamsPage.PARAM_WIDTH ? MAX_OPTWIDTH
 851                     : OptsAndParamsPage.PARAM_WIDTH);
 852     int hgap = fl.getHgap(), cw = hgap;
 853
 854     if (opanp.getOptSet().size() > 0)
 855     {
 856
 857       jobOptions.setLayout(new MigLayout("", "", ""));
 858       jobOptions.removeAll();
 859
 860       for (OptionBox pbox : opanp.getOptSet().values())
 861       {
 862         pbox.validate();
 863         cw += pbox.getSize().width + hgap;
 864         if (cw + 120 > panewidth)
 865         {
 866           jobOptions.add(pbox, "wrap");
 867           // System.out.println("Wrap on "+pbox.option.getName());
 868           cw = hgap + pbox.getSize().width;
 869           fh = true;
 870         }
 871         else
 872         {
 873           jobOptions.add(pbox);
 874         }
 875         if (fh)
 876         {
 877           finalh += pbox.getSize().height + fl.getVgap();
 878           fh = false;
 879         }
 880       }
 881       jobOptions.revalidate();
 882     }
 883     else
 884     {
 885       jobOptions.setVisible(false);
 886     }
 887
 888     // Now layout the parameters assuming they occupy one column - to calculate
 889     // total height of options+parameters
 890     fl = new FlowLayout(FlowLayout.LEFT);
 891     // helpful hint from
 892     // http://stackoverflow.com/questions/2743177/top-alignment-for-flowlayout
 893     fl.setAlignOnBaseline(true);
 894     if (opanp.getParamSet().size() > 0)
 895     {
 896       paramList.removeAll();
 897       paramList.setLayout(new MigLayout("", "", ""));
 898       fh = true;
 899       for (ParamBox pbox : opanp.getParamSet().values())
 900       {
 901         pbox.validate();
 902         cw += pbox.getSize().width + hgap;
 903         if (cw + 160 > panewidth)
 904         {
 905           paramList.add(pbox, "wrap");
 906           cw = pbox.getSize().width + hgap;
 907           fh = true;
 908         }
 909         else
 910         {
 911           paramList.add(pbox);
 912         }
 913         if (fh)
 914         {
 915           finalh += pbox.getSize().height + fl.getVgap();
 916           fh = false;
 917         }
 918
 919       }
 920       /*
 921        * s = 2 * sep; for (ParamBox pbox : opanp.getParamSet().values()) {
 922        * pbox.validate(); s += sep +
 923        * pbox.getPreferredSize().height+pbox.getBorder
 924        * ().getBorderInsets(pbox).bottom; }
 925        *
 926        * // paramList.setPreferredSize(new Dimension(w, s));
 927        * os+=s+2*sep+paramList
 928        * .getBorder().getBorderInsets(paramList).bottom+paramList
 929        * .getBorder().getBorderInsets(paramList).top;
 930        */
 931       paramList.revalidate();
 932     }
 933     else
 934     {
 935       paramList.setVisible(false);
 936     }
 937     // TODO: waste some time trying to eliminate any unnecessary .validate calls
 938     // here
 939     // System.out.println("Size will be : "+w+","+os);
 940     // optsAndparams.setPreferredSize(null);
 941     // paramPane.getViewport().setView(optsAndparams);
 942     paramPane.getViewport().setAutoscrolls(true);
 943     paramPane.revalidate();
 944     revalidate();
 945   }
 946
 947   /**
 948    * testing method - grab a service and parameter set and show the window
 949    *
 950    * @param args
 951    */
 952   public static void main(String[] args)
 953   {
 954     jalview.ws.jws2.Jws2Discoverer disc = jalview.ws.jws2.Jws2Discoverer
 955             .getDiscoverer();
 956     int p = 0;
 957     if (args.length > 0)
 958     {
 959       Vector<String> services = new Vector<String>();
 960       services.addElement(args[p++]);
 961       Jws2Discoverer.getDiscoverer().setServiceUrls(services);
 962     }
 963     try
 964     {
 965       disc.run();
 966     } catch (Exception e)
 967     {
 968       System.err.println("Aborting. Problem discovering services.");
 969       e.printStackTrace();
 970       return;
 971     }
 972     Jws2Instance lastserv = null;
 973     for (Jws2Instance service : disc.getServices())
 974     {
 975       lastserv = service;
 976       if (p >= args.length || service.serviceType.equalsIgnoreCase(args[p]))
 977       {
 978         if (lastserv != null)
 979         {
 980           List<Preset> prl = null;
 981           Preset pr = null;
 982           if (++p < args.length)
 983           {
 984             PresetManager prman = lastserv.getPresets();
 985             if (prman != null)
 986             {
 987               pr = prman.getPresetByName(args[p]);
 988               if (pr == null)
 989               {
 990                 // just grab the last preset.
 991                 prl = prman.getPresets();
 992               }
 993             }
 994           }
 995           else
 996           {
 997             PresetManager prman = lastserv.getPresets();
 998             if (prman != null)
 999             {
1000               prl = prman.getPresets();
1001             }
1002           }
1003           Iterator<Preset> en = (prl == null) ? null : prl.iterator();
1004           while (en != null && en.hasNext())
1005           {
1006             if (en != null)
1007             {
1008               if (!en.hasNext())
1009               {
1010                 en = prl.iterator();
1011               }
1012               pr = en.next();
1013             }
1014             {
1015               System.out.println("Testing opts dupes for "
1016                       + lastserv.getUri() + " : "
1017                       + lastserv.getActionText() + ":" + pr.getName());
1018               List<Option> rg = lastserv.getRunnerConfig().getOptions();
1019               for (Option o : rg)
1020               {
1021                 try
1022                 {
1023                   Option cpy = jalview.ws.jws2.ParameterUtils.copyOption(o);
1024                 } catch (Exception e)
1025                 {
1026                   System.err.println("Failed to copy " + o.getName());
1027                   e.printStackTrace();
1028                 } catch (Error e)
1029                 {
1030                   System.err.println("Failed to copy " + o.getName());
1031                   e.printStackTrace();
1032                 }
1033               }
1034             }
1035             {
1036               System.out.println("Testing param dupes:");
1037               List<Parameter> rg = lastserv.getRunnerConfig()
1038                       .getParameters();
1039               for (Parameter o : rg)
1040               {
1041                 try
1042                 {
1043                   Parameter cpy = jalview.ws.jws2.ParameterUtils
1044                           .copyParameter(o);
1045                 } catch (Exception e)
1046                 {
1047                   System.err.println("Failed to copy " + o.getName());
1048                   e.printStackTrace();
1049                 } catch (Error e)
1050                 {
1051                   System.err.println("Failed to copy " + o.getName());
1052                   e.printStackTrace();
1053                 }
1054               }
1055             }
1056             {
1057               System.out.println("Testing param write:");
1058               List<String> writeparam = null, readparam = null;
1059               try
1060               {
1061                 writeparam = jalview.ws.jws2.ParameterUtils
1062                         .writeParameterSet(
1063                                 pr.getArguments(lastserv.getRunnerConfig()),
1064                                 " ");
1065                 System.out.println("Testing param read :");
1066                 List<Option> pset = jalview.ws.jws2.ParameterUtils
1067                         .processParameters(writeparam,
1068                                 lastserv.getRunnerConfig(), " ");
1069                 readparam = jalview.ws.jws2.ParameterUtils
1070                         .writeParameterSet(pset, " ");
1071                 Iterator<String> o = pr.getOptions().iterator(), s = writeparam
1072                         .iterator(), t = readparam.iterator();
1073                 boolean failed = false;
1074                 while (s.hasNext() && t.hasNext())
1075                 {
1076                   String on = o.next(), sn = s.next(), st = t.next();
1077                   if (!sn.equals(st))
1078                   {
1079                     System.out.println("Original was " + on
1080                             + " Phase 1 wrote " + sn + "\tPhase 2 wrote "
1081                             + st);
1082                     failed = true;
1083                   }
1084                 }
1085                 if (failed)
1086                 {
1087                   System.out.println("Original parameters:\n"
1088                           + pr.getOptions());
1089                   System.out.println("Wrote parameters in first set:\n"
1090                           + writeparam);
1091                   System.out.println("Wrote parameters in second set:\n"
1092                           + readparam);
1093
1094                 }
1095               } catch (Exception e)
1096               {
1097                 e.printStackTrace();
1098               }
1099             }
1100             WsJobParameters pgui = new WsJobParameters(lastserv,
1101                     new JabaPreset(lastserv, pr));
1102             JFrame jf = new JFrame(MessageManager.formatMessage(
1103                     "label.ws_parameters_for",
1104                     new String[] { lastserv.getActionText() }));
1105             JPanel cont = new JPanel(new BorderLayout());
1106             pgui.validate();
1107             cont.setPreferredSize(pgui.getPreferredSize());
1108             cont.add(pgui, BorderLayout.CENTER);
1109             jf.setLayout(new BorderLayout());
1110             jf.add(cont, BorderLayout.CENTER);
1111             jf.validate();
1112             final Thread thr = Thread.currentThread();
1113             jf.addWindowListener(new WindowListener()
1114             {
1115
1116               public void windowActivated(WindowEvent e)
1117               {
1118                 // TODO Auto-generated method stub
1119
1120               }
1121
1122               public void windowClosed(WindowEvent e)
1123               {
1124               }
1125
1126               public void windowClosing(WindowEvent e)
1127               {
1128                 thr.interrupt();
1129
1130               }
1131
1132               public void windowDeactivated(WindowEvent e)
1133               {
1134                 // TODO Auto-generated method stub
1135
1136               }
1137
1138               public void windowDeiconified(WindowEvent e)
1139               {
1140                 // TODO Auto-generated method stub
1141
1142               }
1143
1144               public void windowIconified(WindowEvent e)
1145               {
1146                 // TODO Auto-generated method stub
1147
1148               }
1149
1150               public void windowOpened(WindowEvent e)
1151               {
1152                 // TODO Auto-generated method stub
1153
1154               }
1155
1156             });
1157             jf.setVisible(true);
1158             boolean inter = false;
1159             while (!inter)
1160             {
1161               try
1162               {
1163                 Thread.sleep(10000);
1164               } catch (Exception e)
1165               {
1166                 inter = true;
1167               }
1168               ;
1169             }
1170             jf.dispose();
1171           }
1172         }
1173       }
1174     }
1175   }
1176
1177   public boolean isServiceDefaults()
1178   {
1179     return (!isModified() && (lastParmSet != null && lastParmSet
1180             .equals(SVC_DEF)));
1181   }
1182
1183   public List<ArgumentI> getJobParams()
1184   {
1185     return opanp.getCurrentSettings();
1186   }
1187
1188   String lastParmSet = null;
1189
1190   /*
1191    * Hashtable<String, Object[]> editedParams = new Hashtable<String,
1192    * Object[]>();
1193    *
1194    * store the given parameters in the user parameter set database.
1195    *
1196    * @param storeSetName - lastParmSet
1197    *
1198    * @param descr - setDescr.getText()
1199    *
1200    * @param jobParams - getJobParams()
1201    *
1202    * private void _storeUserPreset(String storeSetName, String descr,
1203    * List<ArgumentI> jobParams) { // this is a simple hash store. Object[] pset;
1204    * editedParams.put(storeSetName, pset = new Object[3]); pset[0] =
1205    * storeSetName; pset[1] = descr; pset[2] = jobParams; // writeParam("Saving "
1206    * + storeSetName + ": ", jobParams); }
1207    *
1208    * private void writeParam(String nm, List<ArgumentI> params) { for (ArgumentI
1209    * p : params) { System.out.println(nm + ":" + System.identityHashCode(p) +
1210    * " Name: " + p.getName() + " Value: " + p.getDefaultValue()); } }
1211    *
1212    * private Object[] _getUserPreset(String setName) { Object[] pset =
1213    * editedParams.get(setName); // if (pset != null) // writeParam("Retrieving "
1214    * + setName + ": ", (List<Argument>) pset[2]); return pset; }
1215    *
1216    * * remove the given user preset from the preset stash
1217    *
1218    * @param setName
1219    *
1220    * private void _deleteUserPreset(String setName) {
1221    * editedParams.remove(setName); }
1222    */
1223
1224   private void syncSetNamesWithStore()
1225   {
1226     int n = 0;
1227     // remove any set names in the drop down menu that aren't either a reserved
1228     // setting, or a user defined or service preset.
1229     Vector items = new Vector();
1230     while (n < setName.getItemCount())
1231     {
1232       String item = (String) setName.getItemAt(n);
1233       if (!item.equals(SVC_DEF) && !paramStore.presetExists(item))
1234       {
1235         setName.removeItemAt(n);
1236       }
1237       else
1238       {
1239         items.addElement(item);
1240         n++;
1241       }
1242     }
1243     if (!items.contains(SVC_DEF))
1244     {
1245       setName.addItem(SVC_DEF);
1246     }
1247     for (WsParamSetI upn : paramStore.getPresets())
1248     {
1249       if (!items.contains(upn.getName()))
1250       {
1251         setName.addItem(upn.getName());
1252       }
1253     }
1254   }
1255
1256   /**
1257    * true if lastParmSet is a user preset
1258    */
1259   boolean isUserPreset = false;
1260
1261   private void reInitDialog(String nextPreset)
1262   {
1263     settingDialog = true;
1264     // updateTable(null,null); // first reset to defaults
1265     WsParamSetI pset = null;
1266     if (nextPreset != null && nextPreset.length() > 0)
1267     {
1268       pset = paramStore.getPreset(nextPreset);
1269     }
1270     if (pset != null)
1271     {
1272       if (pset.isModifiable())
1273       {
1274         isUserPreset = true;
1275         setDescr.setText(pset.getDescription());
1276         updateTable(null, pset.getArguments());
1277         lastParmSet = nextPreset;
1278       }
1279       else
1280       {
1281         isUserPreset = false;
1282         setDescr.setText("");
1283         // must be a default preset from service
1284         updateTable(pset, null);
1285         lastParmSet = nextPreset;
1286       }
1287     }
1288     else
1289     {
1290       isUserPreset = false;
1291       // Service defaults
1292       setDescr.setText("");
1293       updateTable(null, null);
1294       lastParmSet = SVC_DEF;
1295     }
1296
1297     initArgSetModified();
1298     syncSetNamesWithStore();
1299     setName.setSelectedItem(lastParmSet);
1300     SetNamePanel.validate();
1301     validate();
1302     settingDialog = false;
1303   }
1304
1305   /**
1306    * Rebuild the AlignFrame web service menus (after add/delete of a preset
1307    * option).
1308    */
1309   protected void updateWebServiceMenus()
1310   {
1311     for (AlignFrame alignFrame : Desktop.getAlignFrames())
1312     {
1313       alignFrame.BuildWebServiceMenu();
1314     }
1315   }
1316
1317   String curSetName = null;
1318
1319   public void itemStateChanged(ItemEvent e)
1320   {
1321     if (e.getSource() == setName && e.getStateChange() == e.SELECTED)
1322     {
1323       final String setname = (String) setName.getSelectedItem();
1324       System.out.println("Item state changed for " + setname
1325               + " (handling ? " + !settingDialog + ")");
1326       if (settingDialog)
1327       {
1328         // ignore event
1329         return;
1330       }
1331       if (setname == null)
1332       {
1333         return;
1334       }
1335       javax.swing.SwingUtilities.invokeLater(new Runnable()
1336       {
1337         public void run()
1338         {
1339           doPreferenceComboStateChange(setname);
1340         }
1341       });
1342     }
1343   }
1344
1345   private void doPreferenceComboStateChange(String setname)
1346   {
1347     // user has selected a different item from combo-box
1348     if (isModified())
1349     {
1350       String lsetname = (curSetName != null) ? curSetName : lastParmSet;
1351       if (lsetname.equals(setname))
1352       {
1353         // setname was just edited - so ignore this event.
1354         return;
1355       }
1356       settingDialog = true;
1357       System.out.println("Prompting to save " + lsetname);
1358       if (javax.swing.JOptionPane
1359               .showConfirmDialog(
1360                       this,
1361                       "Parameter set '"
1362                               + lsetname
1363                               + "' is modifed, and your changes will be lost.\nReally change preset ?",
1364                       "Warning: Unsaved Changes",
1365                       javax.swing.JOptionPane.OK_CANCEL_OPTION) != JOptionPane.OK_OPTION)
1366       {
1367         // revert the combobox to the current item
1368         settingDialog = true;
1369         setName.setSelectedItem(lsetname);
1370         settingDialog = false;
1371         // and leave.
1372         return;
1373         // System.out.println("Saving for " + lsetname);
1374         // _storeCurrentPreset(lsetname);
1375
1376       }
1377     }
1378     settingDialog = true;
1379     reInitDialog(setname);
1380     settingDialog = false;
1381
1382   }
1383
1384   private void _renameExistingPreset(String oldName, String curSetName2)
1385   {
1386     paramStore.updatePreset(oldName, curSetName2, setDescr.getText(),
1387             getJobParams());
1388   }
1389
1390   /**
1391    * store current settings as given name. You should then reset gui.
1392    *
1393    * @param curSetName2
1394    */
1395   private void _storeCurrentPreset(String curSetName2)
1396   {
1397     paramStore.storePreset(curSetName2, setDescr.getText(), getJobParams());
1398   }
1399
1400   private void _updatePreset(String lastParmSet2, String curname)
1401   {
1402     paramStore.updatePreset(lastParmSet2, curname, setDescr.getText(),
1403             getJobParams());
1404
1405   }
1406
1407   /**
1408    * last saved name for this user preset
1409    */
1410   String lastSetName = null;
1411
1412   /**
1413    * last saved value of the description text for this user preset
1414    */
1415   String lastDescrText = null;
1416
1417   public void actionPerformed(ActionEvent e)
1418   {
1419     if (e.getSource() instanceof Component)
1420     {
1421       Component src = (Component) e.getSource();
1422       if (src.getParent() == setName)
1423       {
1424         // rename any existing records we know about for this set.
1425         String newname = e.getActionCommand().trim();
1426         String msg = null;
1427         if (isServicePreset(newname))
1428         {
1429           final String oldname = curSetName != null ? curSetName
1430                   : lastParmSet;
1431           final Component ourframe = this;
1432           settingDialog = true;
1433           setName.getEditor().setItem(oldname);
1434           settingDialog = false;
1435           javax.swing.SwingUtilities.invokeLater(new Runnable()
1436           {
1437             public void run()
1438             {
1439               JOptionPane.showMessageDialog(ourframe, MessageManager
1440                       .getString("label.invalid_name_preset_exists"),
1441                       MessageManager.getString("label.invalid_name"),
1442                       JOptionPane.WARNING_MESSAGE);
1443             }
1444           });
1445
1446           return;
1447         }
1448         curSetName = newname;
1449         System.err.println("New name for user setting " + curSetName
1450                 + " (was " + setName.getSelectedItem() + ")");
1451         if (curSetName.equals(setName.getSelectedItem()))
1452         {
1453           curSetName = null;
1454         }
1455         if (curSetName != null)
1456         {
1457           argSetModified(setName, true);
1458           return;
1459         }
1460
1461       }
1462     }
1463   }
1464
1465   private void checkDescrModified()
1466   {
1467     if (!settingDialog)
1468     {
1469
1470       argSetModified(
1471               setDescr,
1472               (lastDescrText == null ? setDescr.getText().trim().length() > 0
1473                       : !setDescr.getText().equals(lastDescrText)));
1474
1475     }
1476   }
1477
1478   public void insertUpdate(DocumentEvent e)
1479   {
1480     checkDescrModified();
1481   }
1482
1483   public void removeUpdate(DocumentEvent e)
1484   {
1485     checkDescrModified();
1486   }
1487
1488   public void changedUpdate(DocumentEvent e)
1489   {
1490     checkDescrModified();
1491   }
1492
1493   /**
1494    *
1495    * @return null or the service preset selected by the user
1496    */
1497   public WsParamSetI getPreset()
1498   {
1499     if (isUserPreset || isModified()
1500             || (lastParmSet != null && lastParmSet.equals(SVC_DEF)))
1501     {
1502       return null;
1503     }
1504     else
1505     {
1506       return paramStore.getPreset(lastParmSet);
1507     }
1508   }
1509 }