src/jalview/gui/WsJobParameters.java

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