src/jalview/ws/jws2/SequenceAnnotationWSClient.java

   1 /**
   2  *
   3  */
   4 package jalview.ws.jws2;
   5
   6 import jalview.api.AlignCalcWorkerI;
   7 import jalview.bin.Cache;
   8 import jalview.gui.AlignFrame;
   9 import jalview.gui.Desktop;
  10 import jalview.gui.JvSwingUtils;
  11 import jalview.ws.jws2.dm.AAConsSettings;
  12 import jalview.ws.jws2.jabaws2.Jws2Instance;
  13 import jalview.ws.params.WsParamSetI;
  14
  15 import java.awt.event.ActionEvent;
  16 import java.awt.event.ActionListener;
  17 import java.util.List;
  18
  19 import javax.swing.JCheckBoxMenuItem;
  20 import javax.swing.JMenu;
  21 import javax.swing.JMenuItem;
  22 import javax.swing.JOptionPane;
  23 import javax.swing.event.MenuEvent;
  24 import javax.swing.event.MenuListener;
  25
  26 /**
  27  * @author jprocter
  28  *
  29  */
  30 public class SequenceAnnotationWSClient extends Jws2Client
  31 {
  32
  33   public static final String AAConsCalcId = "jabaws2.AACons";
  34
  35   /**
  36    * initialise a client so its attachWSMenuEntry method can be called.
  37    */
  38   public SequenceAnnotationWSClient()
  39   {
  40     // TODO Auto-generated constructor stub
  41   }
  42
  43   public SequenceAnnotationWSClient(final Jws2Instance sh,
  44           AlignFrame alignFrame, WsParamSetI preset, boolean editParams)
  45   {
  46     super(alignFrame, preset, null);
  47     initSequenceAnnotationWSClient(sh, alignFrame, preset, editParams);
  48   }
  49
  50   public void initSequenceAnnotationWSClient(final Jws2Instance sh,
  51           AlignFrame alignFrame, WsParamSetI preset, boolean editParams)
  52   {
  53     if (alignFrame.getViewport().getAlignment().isNucleotide())
  54     {
  55       JOptionPane.showMessageDialog(Desktop.desktop, sh.serviceType
  56               + " can only be used\nfor amino acid alignments.",
  57               "Wrong type of sequences!", JOptionPane.WARNING_MESSAGE);
  58       return;
  59
  60     }
  61     if (sh.action.toLowerCase().contains("conservation"))
  62     {
  63       // Build an AACons style client - take alignment, return annotation for
  64       // columns
  65
  66       List<AlignCalcWorkerI> clnts = alignFrame.getViewport()
  67               .getCalcManager()
  68               .getRegisteredWorkersOfClass(AAConsClient.class);
  69       if (clnts == null || clnts.size() == 0)
  70       {
  71         if (!processParams(sh, editParams))
  72         {
  73           return;
  74         }
  75         AAConsClient worker;
  76         alignFrame
  77                 .getViewport()
  78                 .getCalcManager()
  79                 .registerWorker(
  80                         worker = new AAConsClient(sh, alignFrame,
  81                                 this.preset, paramset));
  82         alignFrame.getViewport().getCalcManager().startWorker(worker);
  83
  84       }
  85       else
  86       {
  87         AAConsClient worker = (AAConsClient) clnts.get(0);
  88         if (editParams)
  89         {
  90           paramset = worker.getArguments();
  91           preset = worker.getPreset();
  92         }
  93
  94         if (!processParams(sh, editParams, true))
  95         {
  96           return;
  97         }
  98         // reinstate worker if it was blacklisted (might have happened due to
  99         // invalid parameters)
 100         alignFrame.getViewport().getCalcManager().workerMayRun(worker);
 101         worker.updateParameters(this.preset, paramset);
 102
 103       }
 104     }
 105     if (sh.action.toLowerCase().contains("disorder"))
 106     {
 107       // build IUPred style client. take sequences, returns annotation per
 108       // sequence.
 109       if (!processParams(sh, editParams))
 110       {
 111         return;
 112       }
 113
 114       alignFrame
 115               .getViewport()
 116               .getCalcManager()
 117               .startWorker(
 118                       new AADisorderClient(sh, alignFrame, preset, paramset));
 119     }
 120
 121   }
 122
 123   public SequenceAnnotationWSClient(AAConsSettings fave,
 124           AlignFrame alignFrame, boolean b)
 125   {
 126     super(alignFrame, fave.getPreset(), fave.getJobArgset());
 127     initSequenceAnnotationWSClient(fave.getService(), alignFrame,
 128             fave.getPreset(), b);
 129   }
 130
 131   /*
 132    * (non-Javadoc)
 133    *
 134    * @see jalview.ws.jws2.Jws2Client#attachWSMenuEntry(javax.swing.JMenu,
 135    * jalview.ws.jws2.jabaws2.Jws2Instance, jalview.gui.AlignFrame)
 136    */
 137   public void attachWSMenuEntry(JMenu wsmenu, final Jws2Instance service,
 138           final AlignFrame alignFrame)
 139   {
 140     if (service.serviceType.equals(compbio.ws.client.Services.AAConWS
 141             .toString()))
 142     {
 143       registerAAConsWSInstance(wsmenu, service, alignFrame);
 144       return;
 145     }
 146     boolean hasparams = service.hasParameters();
 147     // Assume name ends in WS
 148     String calcName = service.serviceType.substring(0,
 149             service.serviceType.length() - 2);
 150
 151     JMenuItem aacons = new JMenuItem(calcName + " Defaults");
 152     aacons.addActionListener(new ActionListener()
 153     {
 154
 155       @Override
 156       public void actionPerformed(ActionEvent e)
 157       {
 158         new SequenceAnnotationWSClient(service, alignFrame, null, false);
 159       }
 160     });
 161     wsmenu.add(aacons);
 162     if (hasparams)
 163     {
 164       // only add these menu options if the service has user-modifiable
 165       // arguments
 166       aacons = new JMenuItem("Edit settings and run ...");
 167       aacons.setToolTipText("View and change parameters before running calculation");
 168
 169       aacons.addActionListener(new ActionListener()
 170       {
 171         public void actionPerformed(ActionEvent e)
 172         {
 173           new SequenceAnnotationWSClient(service, alignFrame, null, true);
 174         }
 175       });
 176       wsmenu.add(aacons);
 177       List<WsParamSetI> presets = service.getParamStore().getPresets();
 178       if (presets != null && presets.size() > 0)
 179       {
 180         JMenu presetlist = new JMenu("Run " + calcName + "with preset");
 181
 182         for (final WsParamSetI preset : presets)
 183         {
 184           final JMenuItem methodR = new JMenuItem(preset.getName());
 185           methodR.setToolTipText("<html><p>"
 186                   + JvSwingUtils.wrapTooltip("<strong>"
 187                           + (preset.isModifiable() ? "User Preset"
 188                                   : "Service Preset") + "</strong><br/>"
 189                           + preset.getDescription() + "</p>") + "</html>");
 190           methodR.addActionListener(new ActionListener()
 191           {
 192             public void actionPerformed(ActionEvent e)
 193             {
 194               new SequenceAnnotationWSClient(service, alignFrame, preset,
 195                       false);
 196             }
 197
 198           });
 199           presetlist.add(methodR);
 200         }
 201         wsmenu.add(presetlist);
 202       }
 203
 204     }
 205   }
 206
 207   private final String AAconsToggle = "AACons Calculations",
 208           AAconsToggleTooltip = "When checked, AACons calculations are updated automatically.",
 209           AAeditSettings = "Change AACons Settings...",
 210           AAeditSettingsTooltip = "Modify settings for AACons calculations.";
 211
 212   // private final enableAAConsCalculation(final AlignFrame alignFrame, )
 213   private void registerAAConsWSInstance(final JMenu wsmenu,
 214           final Jws2Instance service, final AlignFrame alignFrame)
 215   {
 216     // register this in the AACons settings set
 217     JCheckBoxMenuItem _aaConsEnabled = null;
 218     for (int i = 0; i < wsmenu.getItemCount(); i++)
 219     {
 220       JMenuItem item = wsmenu.getItem(i);
 221       if (item instanceof JCheckBoxMenuItem
 222               && item.getText().equals(AAconsToggle))
 223       {
 224         _aaConsEnabled = (JCheckBoxMenuItem) item;
 225       }
 226     }
 227     // is there an aaCons worker already present - if so, set it to use the
 228     // given service handle
 229     {
 230       List<AlignCalcWorkerI> aaconsClient = alignFrame.getViewport()
 231               .getCalcManager()
 232               .getRegisteredWorkersOfClass(AAConsClient.class);
 233       if (aaconsClient != null && aaconsClient.size() > 0)
 234       {
 235         AAConsClient worker = (AAConsClient) aaconsClient.get(0);
 236         if (!worker.service.hosturl.equals(service.hosturl))
 237         {
 238          // javax.swing.SwingUtilities.invokeLater(new Runnable()
 239           {
 240          //   @Override
 241          //   public void run()
 242             {
 243               removeCurrentAAConsWorkerFor(alignFrame);
 244               buildCurrentAAConsWorkerFor(alignFrame, service);
 245             }
 246           }//);
 247         }
 248       }
 249     }
 250
 251     // is there a service already registered ? there shouldn't be if we are
 252     // being called correctly
 253     if (_aaConsEnabled == null)
 254     {
 255       final JCheckBoxMenuItem aaConsEnabled = new JCheckBoxMenuItem(
 256               AAconsToggle);
 257       wsmenu.addMenuListener(new MenuListener()
 258       {
 259
 260         @Override
 261         public void menuSelected(MenuEvent arg0)
 262         {
 263           wsmenu.setEnabled(!alignFrame.getViewport().getAlignment()
 264                   .isNucleotide());
 265           List<AlignCalcWorkerI> aaconsClient = alignFrame.getViewport()
 266                   .getCalcManager()
 267                   .getRegisteredWorkersOfClass(AAConsClient.class);
 268           if (aaconsClient != null && aaconsClient.size() > 0)
 269           {
 270             aaConsEnabled.setSelected(true);
 271           }
 272           else
 273           {
 274             aaConsEnabled.setSelected(false);
 275           }
 276         }
 277
 278         @Override
 279         public void menuDeselected(MenuEvent arg0)
 280         {
 281           // TODO Auto-generated method stub
 282
 283         }
 284
 285         @Override
 286         public void menuCanceled(MenuEvent arg0)
 287         {
 288           // TODO Auto-generated method stub
 289
 290         }
 291       });
 292       aaConsEnabled.setToolTipText("<html><p>"
 293               + JvSwingUtils.wrapTooltip(AAconsToggleTooltip + "</p>")
 294               + "</html>");
 295       aaConsEnabled.addActionListener(new ActionListener()
 296       {
 297         @Override
 298         public void actionPerformed(ActionEvent arg0)
 299         {
 300           // aaConsEnabled.setSelected(!aaConsEnabled.isSelected());
 301           List<AlignCalcWorkerI> aaconsClient = alignFrame.getViewport()
 302                   .getCalcManager()
 303                   .getRegisteredWorkersOfClass(AAConsClient.class);
 304           if (aaconsClient != null && aaconsClient.size() > 0)
 305           {
 306             removeCurrentAAConsWorkerFor(alignFrame);
 307           }
 308           else
 309           {
 310             buildCurrentAAConsWorkerFor(alignFrame);
 311
 312           }
 313         }
 314
 315       });
 316       wsmenu.add(aaConsEnabled);
 317       JMenuItem modifyParams = new JMenuItem(AAeditSettings);
 318       modifyParams.setToolTipText("<html><p>"
 319               + JvSwingUtils.wrapTooltip(AAeditSettingsTooltip + "</p>")
 320               + "</html>");
 321       modifyParams.addActionListener(new ActionListener()
 322       {
 323
 324         @Override
 325         public void actionPerformed(ActionEvent arg0)
 326         {
 327           showAAConsAnnotationSettingsFor(alignFrame);
 328         }
 329       });
 330       wsmenu.add(modifyParams);
 331
 332     }
 333   }
 334
 335   private static void showAAConsAnnotationSettingsFor(AlignFrame alignFrame)
 336   {
 337     /*
 338      * preferred settings Whether AACons is automatically recalculated Which
 339      * AACons server to use What parameters to use
 340      */
 341     // could actually do a class search for this too
 342     AAConsSettings fave = (AAConsSettings) alignFrame.getViewport()
 343             .getCalcIdSettingsFor(AAConsCalcId);
 344     if (fave == null)
 345     {
 346       fave = createDefaultAAConsSettings();
 347     }
 348     new SequenceAnnotationWSClient(fave, alignFrame, true);
 349
 350   }
 351
 352   private static void buildCurrentAAConsWorkerFor(AlignFrame alignFrame)
 353   {
 354     buildCurrentAAConsWorkerFor(alignFrame, null);
 355   }
 356
 357   private static void buildCurrentAAConsWorkerFor(AlignFrame alignFrame,
 358           Jws2Instance service)
 359   {
 360     /*
 361      * preferred settings Whether AACons is automatically recalculated Which
 362      * AACons server to use What parameters to use
 363      */
 364     AAConsSettings fave = (AAConsSettings) alignFrame.getViewport()
 365             .getCalcIdSettingsFor(AAConsCalcId);
 366     if (fave == null)
 367     {
 368       fave = createDefaultAAConsSettings(service);
 369     }
 370     else
 371     {
 372       if (service != null
 373               && !fave.getService().hosturl.equals(service.hosturl))
 374       {
 375         Cache.log.debug("Changing AACons service to " + service.hosturl
 376                 + " from " + fave.getService().hosturl);
 377         fave.setService(service);
 378       }
 379     }
 380     new SequenceAnnotationWSClient(fave, alignFrame, false);
 381   }
 382
 383   private static AAConsSettings createDefaultAAConsSettings()
 384   {
 385     return createDefaultAAConsSettings(null);
 386   }
 387
 388   private static AAConsSettings createDefaultAAConsSettings(
 389           Jws2Instance service)
 390   {
 391     if (service != null)
 392     {
 393       if (!service.serviceType.toString().equals(
 394               compbio.ws.client.Services.AAConWS.toString()))
 395       {
 396         Cache.log
 397                 .warn("Ignoring invalid preferred service for AACons calculations (service type was "
 398                         + service.serviceType + ")");
 399         service = null;
 400       }
 401       else
 402       {
 403         // check service is actually in the list of currently avaialable
 404         // services
 405         if (!Jws2Discoverer.getDiscoverer().getServices().contains(service))
 406         {
 407           // it isn't ..
 408           service = null;
 409         }
 410       }
 411     }
 412     if (service == null)
 413     {
 414       // get the default service for AACons
 415       service = Jws2Discoverer.getDiscoverer().getPreferredServiceFor(null,
 416               compbio.ws.client.Services.AAConWS.toString());
 417       /*
 418        * for (Jws2Instance sv : Jws2Discoverer.getDiscoverer().getServices()) {
 419        * if (sv.serviceType.toString().equals(
 420        * compbio.ws.client.Services.AAConWS.toString())) { service = sv; break;
 421        * } }
 422        */
 423     }
 424     if (service == null)
 425     {
 426       // TODO raise dialog box explaining error, and/or open the JABA
 427       // preferences menu.
 428       throw new Error("No AACons service found.");
 429     }
 430     return new AAConsSettings(true, service, null, null);
 431   }
 432
 433   private static void removeCurrentAAConsWorkerFor(AlignFrame alignFrame)
 434   {
 435     alignFrame.getViewport().getCalcManager()
 436             .removeRegisteredWorkersOfClass(AAConsClient.class);
 437     // AAConsClient.removeAAConsAnnotation(alignFrame.alignPanel);
 438
 439   }
 440 }