src/jalview/ws2/gui/WebServicesMenuManager.java

   1 package jalview.ws2.gui;
   2
   3 import java.awt.Color;
   4 import java.awt.event.MouseAdapter;
   5 import java.awt.event.MouseEvent;
   6 import java.lang.ref.WeakReference;
   7 import java.net.URL;
   8 import java.util.ArrayList;
   9 import java.util.Collection;
  10 import java.util.Collections;
  11 import java.util.Comparator;
  12 import java.util.HashMap;
  13 import java.util.HashSet;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Objects;
  17 import java.util.TreeMap;
  18 import java.util.concurrent.CompletionStage;
  19
  20 import javax.swing.JCheckBoxMenuItem;
  21 import javax.swing.JLabel;
  22 import javax.swing.JMenu;
  23 import javax.swing.JMenuItem;
  24 import javax.swing.ToolTipManager;
  25 import javax.swing.border.EmptyBorder;
  26
  27 import jalview.gui.AlignFrame;
  28 import jalview.gui.Desktop;
  29 import jalview.gui.JvSwingUtils;
  30 import jalview.gui.WsJobParameters;
  31 import jalview.util.MessageManager;
  32 import jalview.viewmodel.AlignmentViewport;
  33 import jalview.ws.params.ArgumentI;
  34 import jalview.ws.params.ParamDatastoreI;
  35 import jalview.ws.params.WsParamSetI;
  36 import jalview.ws2.actions.alignment.AlignmentAction;
  37 import jalview.ws2.actions.annotation.AnnotationAction;
  38 import jalview.ws2.actions.api.ActionI;
  39 import jalview.ws2.actions.api.TaskI;
  40 import jalview.ws2.api.Credentials;
  41 import jalview.ws2.api.WebService;
  42 import jalview.ws2.client.api.WebServiceProviderI;
  43
  44 import static java.lang.String.format;
  45
  46 public class WebServicesMenuManager
  47 {
  48   private final JMenu menu;
  49
  50   private final AlignFrame frame;
  51
  52   private JMenuItem inProgressItem = new JMenuItem("Service discovery in progress");
  53
  54   private JMenuItem noServicesItem = new JMenuItem("No services available");
  55   {
  56     inProgressItem.setEnabled(false);
  57     inProgressItem.setVisible(false);
  58     noServicesItem.setEnabled(false);
  59   }
  60
  61   private Map<String, WeakReference<TaskI<?>>> interactiveTasks = new HashMap<>();
  62
  63   public WebServicesMenuManager(String name, AlignFrame frame)
  64   {
  65     this.frame = frame;
  66     menu = new JMenu(name);
  67     menu.add(inProgressItem);
  68     menu.add(noServicesItem);
  69   }
  70
  71   public JMenu getMenu()
  72   {
  73     return menu;
  74   }
  75
  76   public void setNoServices(boolean noServices)
  77   {
  78     noServicesItem.setVisible(noServices);
  79   }
  80
  81   public void setInProgress(boolean inProgress)
  82   {
  83     inProgressItem.setVisible(inProgress);
  84   }
  85
  86   public void setServices(WebServiceProviderI services)
  87   {
  88     menu.removeAll();
  89     // services grouped by their category
  90     Map<String, List<WebService<?>>> oneshotServices = new HashMap<>();
  91     Map<String, List<WebService<?>>> interactiveServices = new HashMap<>();
  92     for (WebService<?> service : services.getServices())
  93     {
  94       var map = service.isInteractive() ? interactiveServices : oneshotServices;
  95       map.computeIfAbsent(service.getCategory(), k -> new ArrayList<>())
  96           .add(service);
  97     }
  98     var allKeysSet = new HashSet<>(oneshotServices.keySet());
  99     allKeysSet.addAll(interactiveServices.keySet());
 100     var allKeys = new ArrayList<>(allKeysSet);
 101     allKeys.sort(Comparator.naturalOrder());
 102     for (String category : allKeys)
 103     {
 104       var categoryMenu = new JMenu(category);
 105       var oneshot = oneshotServices.get(category);
 106       if (oneshot != null)
 107         addOneshotEntries(oneshot, categoryMenu);
 108       var interactive = interactiveServices.get(category);
 109       if (interactive != null)
 110       {
 111         if (oneshot != null)
 112           categoryMenu.addSeparator();
 113         addInteractiveEntries(interactive, categoryMenu);
 114       }
 115       menu.add(categoryMenu);
 116     }
 117     menu.add(inProgressItem);
 118     menu.add(noServicesItem);
 119   }
 120
 121   private void addOneshotEntries(List<WebService<?>> services, JMenu menu)
 122   {
 123     // Workaround. Comparator methods not working in j2s
 124     services.sort((ws1, ws2) -> {
 125       var res = ws1.getUrl().toString().compareTo(ws2.getUrl().toString());
 126       if (res == 0)
 127         res = ws1.getName().compareTo(ws2.getName());
 128       return res;
 129     });
 130     URL lastHost = null;
 131     for (WebService<?> service : services)
 132     {
 133       // if new host differs from the last one, add entry separating them
 134       URL host = service.getUrl();
 135       if (!host.equals(lastHost))
 136       {
 137         if (lastHost != null)
 138           menu.addSeparator();
 139         var item = new JMenuItem(host.toString());
 140         item.setForeground(Color.BLUE);
 141         item.addActionListener(e -> Desktop.showUrl(host.toString()));
 142         menu.add(item);
 143         lastHost = host;
 144       }
 145       menu.addSeparator();
 146       // group actions by their subcategory, sorted
 147       var actionsByCategory = new TreeMap<String, List<ActionI<?>>>();
 148       for (ActionI<?> action : service.getActions())
 149       {
 150         actionsByCategory
 151             .computeIfAbsent(
 152                 action.getSubcategory() != null ? action.getSubcategory() : "",
 153                 k -> new ArrayList<>())
 154             .add(action);
 155       }
 156       actionsByCategory.forEach((k, v) -> {
 157         // create submenu named {subcategory} with {service} or use root menu
 158         var atMenu = k.isEmpty() ? menu : new JMenu(String.format("%s with %s", k, service.getName()));
 159         if (atMenu != menu)
 160           menu.add(atMenu); // add only if submenu
 161         // sort actions by name pulling nulls to the front
 162         v.sort(Comparator.comparing(
 163             ActionI::getName, Comparator.nullsFirst(Comparator.naturalOrder())));
 164         for (int i = 0; i < v.size(); i++) {
 165           addEntriesForAction(v.get(i), atMenu, atMenu == menu);
 166         }
 167       });
 168     }
 169   }
 170
 171   private void addEntriesForAction(ActionI<?> action, JMenu menu, boolean isTopLevel)
 172   {
 173     var service = action.getWebService();
 174     String itemName;
 175     if (isTopLevel)
 176     {
 177       itemName = service.getName();
 178       if (action.getName() != null && !action.getName().isEmpty())
 179         itemName += " " + action.getName();
 180     }
 181     else
 182     {
 183       if (action.getName() == null || action.getName().isEmpty())
 184         itemName = "Run";
 185       else
 186         itemName = action.getName();
 187     }
 188     var datastore = service.getParamDatastore();
 189     {
 190       String text = itemName;
 191       if (datastore.hasParameters() || datastore.hasPresets())
 192         text += " with defaults";
 193       JMenuItem item = new JMenuItem(text);
 194       item.addActionListener(e -> {
 195         runAction(action, frame.getCurrentView(), Collections.emptyList(),
 196             Credentials.empty());
 197       });
 198       menu.add(item);
 199     }
 200     if (datastore.hasParameters())
 201     {
 202       JMenuItem item = new JMenuItem("Edit settings and run...");
 203       item.addActionListener(e -> {
 204         openEditParamsDialog(datastore, null, null).thenAccept(args -> {
 205           if (args != null)
 206             runAction(action, frame.getCurrentView(), args, Credentials.empty());
 207         });
 208       });
 209       menu.add(item);
 210     }
 211     var presets = datastore.getPresets();
 212     if (presets != null && presets.size() > 0)
 213     {
 214       final var presetsMenu = new JMenu(MessageManager.formatMessage(
 215           "label.run_with_preset_params", service.getName()));
 216       final int dismissDelay = ToolTipManager.sharedInstance()
 217           .getDismissDelay();
 218       final int QUICK_TOOLTIP = 1500;
 219       for (var preset : presets)
 220       {
 221         var item = new JMenuItem(preset.getName());
 222         item.addMouseListener(new MouseAdapter()
 223         {
 224           @Override
 225           public void mouseEntered(MouseEvent evt)
 226           {
 227             ToolTipManager.sharedInstance().setDismissDelay(QUICK_TOOLTIP);
 228           }
 229
 230           @Override
 231           public void mouseExited(MouseEvent evt)
 232           {
 233             ToolTipManager.sharedInstance().setDismissDelay(dismissDelay);
 234           }
 235         });
 236         String tooltipTitle = MessageManager.getString(
 237             preset.isModifiable() ? "label.user_preset" : "label.service_preset");
 238         String tooltip = String.format("<strong>%s</strong><br/>%s",
 239             tooltipTitle, preset.getDescription());
 240         tooltip = JvSwingUtils.wrapTooltip(true, tooltip);
 241         item.setToolTipText(tooltip);
 242         item.addActionListener(event -> {
 243           runAction(action, frame.getCurrentView(), preset.getArguments(),
 244               Credentials.empty());
 245         });
 246         presetsMenu.add(item);
 247       }
 248       menu.add(presetsMenu);
 249     }
 250   }
 251
 252   private void addInteractiveEntries(List<WebService<?>> services, JMenu menu)
 253   {
 254     Map<String, List<WebService<?>>> byServiceName = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
 255     for (var service : services)
 256     {
 257       byServiceName.computeIfAbsent(service.getName(), k -> new ArrayList<>())
 258           .add(service);
 259     }
 260     for (var entry : byServiceName.entrySet())
 261     {
 262       var group = new InteractiveServiceEntryGroup(entry.getKey(), entry.getValue());
 263       group.appendTo(menu);
 264     }
 265   }
 266
 267   private class InteractiveServiceEntryGroup
 268   {
 269     JLabel serviceLabel;
 270
 271     JMenuItem urlItem = new JMenuItem();
 272
 273     JCheckBoxMenuItem serviceItem = new JCheckBoxMenuItem();
 274
 275     JMenuItem editParamsItem = new JMenuItem("Edit parameters...");
 276
 277     JMenu presetsMenu = new JMenu("Change preset");
 278
 279     JMenu alternativesMenu = new JMenu("Choose action");
 280     {
 281       urlItem.setForeground(Color.BLUE);
 282       urlItem.setVisible(false);
 283       serviceItem.setVisible(false);
 284       editParamsItem.setVisible(false);
 285       presetsMenu.setVisible(false);
 286     }
 287
 288     InteractiveServiceEntryGroup(String name, List<WebService<?>> services)
 289     {
 290       serviceLabel = new JLabel(name);
 291       serviceLabel.setBorder(new EmptyBorder(0, 6, 0, 6));
 292       buildAlternativesMenu(services);
 293     }
 294
 295     private void buildAlternativesMenu(List<WebService<?>> services)
 296     {
 297       var menu = alternativesMenu;
 298       services.sort((ws1, ws2) -> {
 299         var res = ws1.getUrl().toString().compareTo(ws2.getUrl().toString());
 300         if (res == 0)
 301           res = ws1.getName().compareTo(ws2.getName());
 302         return res;
 303       });
 304       URL lastHost = null;
 305       for (var service : services)
 306       {
 307         // Adding url "separator" before each group
 308         URL host = service.getUrl();
 309         if (!host.equals(lastHost))
 310         {
 311           if (lastHost != null)
 312             menu.addSeparator();
 313           var item = new JMenuItem(host.toString());
 314           item.setForeground(Color.BLUE);
 315           item.addActionListener(e -> Desktop.showUrl(host.toString()));
 316           menu.add(item);
 317           lastHost = host;
 318         }
 319         menu.addSeparator();
 320         var actionsByCategory = new TreeMap<String, List<ActionI<?>>>();
 321         for (ActionI<?> action : service.getActions())
 322         {
 323           actionsByCategory
 324               .computeIfAbsent(
 325                   action.getSubcategory() != null ? action.getSubcategory() : "",
 326                   k -> new ArrayList<>())
 327               .add(action);
 328         }
 329         actionsByCategory.forEach((key, actions) -> {
 330           var atMenu = key.isEmpty() ? menu : new JMenu(key + " with " + service.getName());
 331           boolean topLevel = atMenu == menu;
 332           if (!topLevel)
 333             menu.add(atMenu);
 334           actions.sort(Comparator.comparing(
 335               a -> a.getName(),
 336               Comparator.nullsFirst(Comparator.naturalOrder())));
 337           for (ActionI<?> action : actions)
 338           {
 339             var item = new JMenuItem(action.getFullName());
 340             item.addActionListener(e -> setAlternative(action));
 341             atMenu.add(item);
 342           }
 343         });
 344       }
 345     }
 346
 347     private void setAlternative(ActionI<?> action)
 348     {
 349       final var arguments = new ArrayList<ArgumentI>();
 350       final WsParamSetI[] lastPreset = { null };
 351
 352       // update selected url menu item
 353       String url = action.getWebService().getUrl().toString();
 354       urlItem.setText(url);
 355       urlItem.setVisible(true);
 356       for (var l : urlItem.getActionListeners())
 357         urlItem.removeActionListener(l);
 358       urlItem.addActionListener(e -> Desktop.showUrl(url));
 359
 360       // update selected service menu item
 361       serviceItem.setText(action.getFullName());
 362       serviceItem.setVisible(true);
 363       for (var l : serviceItem.getActionListeners())
 364         serviceItem.removeActionListener(l);
 365       WebService<?> service = action.getWebService();
 366       serviceItem.addActionListener(e -> {
 367         if (serviceItem.getState())
 368         {
 369           cancelAndRunInteractive(action, frame.getCurrentView(), arguments,
 370               Credentials.empty());
 371         }
 372         else
 373         {
 374           cancelInteractive(service.getName());
 375         }
 376       });
 377       serviceItem.setSelected(true);
 378
 379       // update edit parameters menu item
 380       var datastore = service.getParamDatastore();
 381       editParamsItem.setVisible(datastore.hasParameters());
 382       for (var l : editParamsItem.getActionListeners())
 383         editParamsItem.removeActionListener(l);
 384       if (datastore.hasParameters())
 385       {
 386         editParamsItem.addActionListener(e -> {
 387           openEditParamsDialog(service.getParamDatastore(), lastPreset[0], arguments)
 388               .thenAccept(args -> {
 389                 if (args != null)
 390                 {
 391                   lastPreset[0] = null;
 392                   arguments.clear();
 393                   arguments.addAll(args);
 394                   cancelAndRunInteractive(action, frame.getCurrentView(),
 395                       arguments, Credentials.empty());
 396                 }
 397               });
 398         });
 399       }
 400
 401       // update presets menu
 402       presetsMenu.removeAll();
 403       presetsMenu.setEnabled(datastore.hasPresets());
 404       if (datastore.hasPresets())
 405       {
 406         for (WsParamSetI preset : datastore.getPresets())
 407         {
 408           var item = new JMenuItem(preset.getName());
 409           item.addActionListener(e -> {
 410             lastPreset[0] = preset;
 411             cancelAndRunInteractive(action, frame.getCurrentView(),
 412                 preset.getArguments(), Credentials.empty());
 413           });
 414           presetsMenu.add(item);
 415         }
 416       }
 417
 418       cancelAndRunInteractive(action, frame.getCurrentView(), arguments,
 419           Credentials.empty());
 420     }
 421
 422     void appendTo(JMenu menu)
 423     {
 424       menu.add(serviceLabel);
 425       menu.add(urlItem);
 426       menu.add(serviceItem);
 427       menu.add(editParamsItem);
 428       menu.add(presetsMenu);
 429       menu.add(alternativesMenu);
 430     }
 431   }
 432
 433   private void cancelInteractive(String wsName)
 434   {
 435     var taskRef = interactiveTasks.get(wsName);
 436     if (taskRef != null && taskRef.get() != null)
 437       taskRef.get().cancel();
 438     interactiveTasks.put(wsName, null);
 439   }
 440
 441   private void cancelAndRunInteractive(ActionI<?> action,
 442       AlignmentViewport viewport, List<ArgumentI> args, Credentials credentials)
 443   {
 444     var wsName = action.getWebService().getName();
 445     cancelInteractive(wsName);
 446     var task = runAction(action, viewport, args, credentials);
 447     interactiveTasks.put(wsName, new WeakReference<>(task));
 448   }
 449
 450   private TaskI<?> runAction(ActionI<?> action, AlignmentViewport viewport,
 451       List<ArgumentI> args, Credentials credentials)
 452   {
 453     // casting and instance checks can be avoided with some effort,
 454     // let them be for now.
 455     if (action instanceof AlignmentAction)
 456     {
 457       // TODO: test if selection contains enough sequences
 458       var _action = (AlignmentAction) action;
 459       var handler = new AlignmentServiceGuiHandler(_action, frame);
 460       return _action.perform(viewport, args, credentials, handler);
 461     }
 462     if (action instanceof AnnotationAction)
 463     {
 464       var _action = (AnnotationAction) action;
 465       var handler = new AnnotationServiceGuiHandler(_action, frame);
 466       return _action.perform(viewport, args, credentials, handler);
 467     }
 468     throw new IllegalArgumentException(
 469         String.format("Illegal action type %s", action.getClass().getName()));
 470   }
 471
 472   private static CompletionStage<List<ArgumentI>> openEditParamsDialog(
 473       ParamDatastoreI paramStore, WsParamSetI preset, List<ArgumentI> arguments)
 474   {
 475     final WsJobParameters jobParams;
 476     if (preset == null && arguments != null && arguments.size() > 0)
 477       jobParams = new WsJobParameters(paramStore, null, arguments);
 478     else
 479       jobParams = new WsJobParameters(paramStore, preset, null);
 480     if (preset != null)
 481       jobParams.setName(MessageManager.getString(
 482           "label.adjusting_parameters_for_calculation"));
 483     var stage = jobParams.showRunDialog();
 484     return stage.thenApply(startJob -> {
 485       if (!startJob)
 486         return null; // null if cancelled
 487       if (jobParams.getPreset() != null)
 488         return jobParams.getPreset().getArguments();
 489       if (jobParams.isServiceDefaults())
 490         return Collections.emptyList();
 491       else
 492         return jobParams.getJobParams();
 493     });
 494   }
 495 }