+ startServiceDiscovery(false);
+ }
+
+ public void startServiceDiscovery(boolean blocking)
+ {
+ boolean alive = true;
+ Thread t0 = null, t1 = null, t2 = null;
+ // JAL-940 - JALVIEW 1 services are now being EOLed as of JABA 2.1 release
+ if (true)
+ {
+ // todo: changesupport handlers need to be transferred
+ if (discoverer == null)
+ {
+ discoverer = new jalview.ws.jws1.Discoverer();
+ // register PCS handler for desktop.
+ discoverer.addPropertyChangeListener(changeSupport);
+ }
+ // JAL-940 - disabled JWS1 service configuration - always start discoverer
+ // until we phase out completely
+ (t0 = new Thread(discoverer)).start();
+ }
+
+ if (Cache.getDefault("SHOW_JWS2_SERVICES", true))
+ {
+ t2 = jalview.ws.jws2.Jws2Discoverer.getDiscoverer()
+ .startDiscoverer(changeSupport);
+ }
+ Thread t3 = null;
+ {
+ // TODO: do rest service discovery
+ }
+ if (blocking)
+ {
+ while (alive)
+ {
+ try
+ {
+ Thread.sleep(15);
+ } catch (Exception e)
+ {
+ }
+ alive = (t1 != null && t1.isAlive()) || (t2 != null && t2.isAlive())
+ || (t3 != null && t3.isAlive())
+ || (t0 != null && t0.isAlive());
+ }
+ }
+ }
+
+ /**
+ * called to check if the service discovery process completed successfully.
+ *
+ * @param evt
+ */
+ protected void JalviewServicesChanged(PropertyChangeEvent evt)
+ {
+ if (evt.getNewValue() == null || evt.getNewValue() instanceof Vector)
+ {
+ final String ermsg = jalview.ws.jws2.Jws2Discoverer.getDiscoverer()
+ .getErrorMessages();
+ if (ermsg != null)
+ {
+ if (Cache.getDefault("SHOW_WSDISCOVERY_ERRORS", true))
+ {
+ if (serviceChangedDialog == null)
+ {
+ // only run if we aren't already displaying one of these.
+ addDialogThread(serviceChangedDialog = new Runnable()
+ {
+ @Override
+ public void run()
+ {
+
+ /*
+ * JalviewDialog jd =new JalviewDialog() {
+ *
+ * @Override protected void cancelPressed() { // TODO
+ * Auto-generated method stub
+ *
+ * }@Override protected void okPressed() { // TODO
+ * Auto-generated method stub
+ *
+ * }@Override protected void raiseClosed() { // TODO
+ * Auto-generated method stub
+ *
+ * } }; jd.initDialogFrame(new
+ * JLabel("<html><table width=\"450\"><tr><td>" + ermsg +
+ * "<br/>It may be that you have invalid JABA URLs in your web service preferences,"
+ * + " or mis-configured HTTP proxy settings.<br/>" +
+ * "Check the <em>Connections</em> and <em>Web services</em> tab of the"
+ * +
+ * " Tools->Preferences dialog box to change them.</td></tr></table></html>"
+ * ), true, true, "Web Service Configuration Problem", 450,
+ * 400);
+ *
+ * jd.waitForInput();
+ */
+ JvOptionPane.showConfirmDialog(Desktop.desktop,
+ new JLabel("<html><table width=\"450\"><tr><td>"
+ + ermsg + "</td></tr></table>"
+ + "<p>It may be that you have invalid JABA URLs<br/>in your web service preferences,"
+ + "<br>or as a command-line argument, or mis-configured HTTP proxy settings.</p>"
+ + "<p>Check the <em>Connections</em> and <em>Web services</em> tab<br/>of the"
+ + " Tools->Preferences dialog box to change them.</p></html>"),
+ "Web Service Configuration Problem",
+ JvOptionPane.DEFAULT_OPTION,
+ JvOptionPane.ERROR_MESSAGE);
+ serviceChangedDialog = null;
+
+ }
+ });
+ }
+ }
+ else
+ {
+ Cache.log.error(
+ "Errors reported by JABA discovery service. Check web services preferences.\n"
+ + ermsg);
+ }
+ }
+ }
+ }
+
+ private Runnable serviceChangedDialog = null;
+
+ /**
+ * start a thread to open a URL in the configured browser. Pops up a warning
+ * dialog to the user if there is an exception when calling out to the browser
+ * to open the URL.
+ *
+ * @param url
+ */
+ public static void showUrl(final String url)
+ {
+ showUrl(url, Desktop.instance);
+ }
+
+ /**
+ * Like showUrl but allows progress handler to be specified
+ *
+ * @param url
+ * @param progress
+ * (null) or object implementing IProgressIndicator
+ */
+ public static void showUrl(final String url,
+ final IProgressIndicator progress)
+ {
+ new Thread(new Runnable()
+ {
+ @Override
+ public void run()
+ {
+ try
+ {
+ if (progress != null)
+ {
+ progress.setProgressBar(MessageManager
+ .formatMessage("status.opening_params", new Object[]
+ { url }), this.hashCode());
+ }
+ jalview.util.BrowserLauncher.openURL(url);
+ } catch (Exception ex)
+ {
+ JvOptionPane.showInternalMessageDialog(Desktop.desktop,
+ MessageManager
+ .getString("label.web_browser_not_found_unix"),
+ MessageManager.getString("label.web_browser_not_found"),
+ JvOptionPane.WARNING_MESSAGE);
+
+ ex.printStackTrace();
+ }
+ if (progress != null)
+ {
+ progress.setProgressBar(null, this.hashCode());
+ }
+ }
+ }).start();
+ }
+
+ public static WsParamSetManager wsparamManager = null;
+
+ public static ParamManager getUserParameterStore()
+ {
+ if (wsparamManager == null)
+ {
+ wsparamManager = new WsParamSetManager();
+ }
+ return wsparamManager;
+ }
+
+ /**
+ * static hyperlink handler proxy method for use by Jalview's internal windows
+ *
+ * @param e
+ */
+ public static void hyperlinkUpdate(HyperlinkEvent e)
+ {
+ if (e.getEventType() == EventType.ACTIVATED)
+ {
+ String url = null;
+ try
+ {
+ url = e.getURL().toString();
+ Desktop.showUrl(url);
+ } catch (Exception x)
+ {
+ if (url != null)
+ {
+ if (Cache.log != null)
+ {
+ Cache.log.error("Couldn't handle string " + url + " as a URL.");
+ }
+ else
+ {
+ System.err.println(
+ "Couldn't handle string " + url + " as a URL.");
+ }
+ }
+ // ignore any exceptions due to dud links.
+ }
+
+ }
+ }
+
+ /**
+ * single thread that handles display of dialogs to user.
+ */
+ ExecutorService dialogExecutor = Executors.newSingleThreadExecutor();
+
+ /**
+ * flag indicating if dialogExecutor should try to acquire a permit
+ */
+ private volatile boolean dialogPause = true;
+
+ /**
+ * pause the queue
+ */
+ private java.util.concurrent.Semaphore block = new Semaphore(0);
+
+ private static groovy.ui.Console groovyConsole;
+
+ /**
+ * add another dialog thread to the queue
+ *
+ * @param prompter
+ */
+ public void addDialogThread(final Runnable prompter)
+ {
+ dialogExecutor.submit(new Runnable()
+ {
+ @Override
+ public void run()
+ {
+ if (dialogPause)
+ {
+ try
+ {
+ block.acquire();
+ } catch (InterruptedException x)
+ {
+ }
+ ;
+ }
+ if (instance == null)
+ {
+ return;
+ }
+ try
+ {
+ SwingUtilities.invokeAndWait(prompter);
+ } catch (Exception q)
+ {
+ Cache.log.warn("Unexpected Exception in dialog thread.", q);
+ }
+ }
+ });
+ }
+
+ public void startDialogQueue()
+ {
+ // set the flag so we don't pause waiting for another permit and semaphore
+ // the current task to begin
+ dialogPause = false;
+ block.release();
+ }
+
+ @Override
+ protected void snapShotWindow_actionPerformed(ActionEvent e)
+ {
+ invalidate();
+ File of;
+ ImageMaker im = new jalview.util.ImageMaker(
+ this, ImageMaker.TYPE.EPS, "View of Desktop", getWidth(),
+ getHeight(), of = new File("Jalview_snapshot"
+ + System.currentTimeMillis() + ".eps"),
+ "View of desktop", null, 0, false);
+ try
+ {
+ paintAll(im.getGraphics());
+ im.writeImage();
+ } catch (Exception q)
+ {
+ Cache.log.error("Couldn't write snapshot to " + of.getAbsolutePath(),
+ q);
+ return;
+ }
+ Cache.log.info("Successfully written snapshot to file "
+ + of.getAbsolutePath());
+ }
+
+ /**
+ * Explode the views in the given SplitFrame into separate SplitFrame windows.
+ * This respects (remembers) any previous 'exploded geometry' i.e. the size
+ * and location last time the view was expanded (if any). However it does not
+ * remember the split pane divider location - this is set to match the
+ * 'exploding' frame.
+ *
+ * @param sf
+ */
+ public void explodeViews(SplitFrame sf)
+ {
+ AlignFrame oldTopFrame = (AlignFrame) sf.getTopFrame();
+ AlignFrame oldBottomFrame = (AlignFrame) sf.getBottomFrame();
+ List<? extends AlignmentViewPanel> topPanels = oldTopFrame
+ .getAlignPanels();
+ List<? extends AlignmentViewPanel> bottomPanels = oldBottomFrame
+ .getAlignPanels();
+ int viewCount = topPanels.size();
+ if (viewCount < 2)
+ {
+ return;
+ }
+
+ /*
+ * Processing in reverse order works, forwards order leaves the first panels
+ * not visible. I don't know why!
+ */
+ for (int i = viewCount - 1; i >= 0; i--)
+ {
+ /*
+ * Make new top and bottom frames. These take over the respective
+ * AlignmentPanel objects, including their AlignmentViewports, so the
+ * cdna/protein relationships between the viewports is carried over to the
+ * new split frames.
+ *
+ * explodedGeometry holds the (x, y) position of the previously exploded
+ * SplitFrame, and the (width, height) of the AlignFrame component
+ */
+ AlignmentPanel topPanel = (AlignmentPanel) topPanels.get(i);
+ AlignFrame newTopFrame = new AlignFrame(topPanel);
+ newTopFrame.setSize(oldTopFrame.getSize());
+ newTopFrame.setVisible(true);
+ Rectangle geometry = ((AlignViewport) topPanel.getAlignViewport())
+ .getExplodedGeometry();
+ if (geometry != null)
+ {
+ newTopFrame.setSize(geometry.getSize());
+ }
+
+ AlignmentPanel bottomPanel = (AlignmentPanel) bottomPanels.get(i);
+ AlignFrame newBottomFrame = new AlignFrame(bottomPanel);
+ newBottomFrame.setSize(oldBottomFrame.getSize());
+ newBottomFrame.setVisible(true);
+ geometry = ((AlignViewport) bottomPanel.getAlignViewport())
+ .getExplodedGeometry();
+ if (geometry != null)
+ {
+ newBottomFrame.setSize(geometry.getSize());
+ }
+
+ topPanel.av.setGatherViewsHere(false);
+ bottomPanel.av.setGatherViewsHere(false);
+ JInternalFrame splitFrame = new SplitFrame(newTopFrame,
+ newBottomFrame);
+ if (geometry != null)
+ {
+ splitFrame.setLocation(geometry.getLocation());
+ }
+ Desktop.addInternalFrame(splitFrame, sf.getTitle(), -1, -1);
+ }
+
+ /*
+ * Clear references to the panels (now relocated in the new SplitFrames)
+ * before closing the old SplitFrame.
+ */
+ topPanels.clear();
+ bottomPanels.clear();
+ sf.close();
+ }
+
+ /**
+ * Gather expanded split frames, sharing the same pairs of sequence set ids,
+ * back into the given SplitFrame as additional views. Note that the gathered
+ * frames may themselves have multiple views.
+ *
+ * @param source
+ */
+ public void gatherViews(GSplitFrame source)
+ {
+ /*
+ * special handling of explodedGeometry for a view within a SplitFrame: - it
+ * holds the (x, y) position of the enclosing SplitFrame, and the (width,
+ * height) of the AlignFrame component
+ */
+ AlignFrame myTopFrame = (AlignFrame) source.getTopFrame();
+ AlignFrame myBottomFrame = (AlignFrame) source.getBottomFrame();
+ myTopFrame.viewport.setExplodedGeometry(new Rectangle(source.getX(),
+ source.getY(), myTopFrame.getWidth(), myTopFrame.getHeight()));
+ myBottomFrame.viewport
+ .setExplodedGeometry(new Rectangle(source.getX(), source.getY(),
+ myBottomFrame.getWidth(), myBottomFrame.getHeight()));
+ myTopFrame.viewport.setGatherViewsHere(true);
+ myBottomFrame.viewport.setGatherViewsHere(true);
+ String topViewId = myTopFrame.viewport.getSequenceSetId();
+ String bottomViewId = myBottomFrame.viewport.getSequenceSetId();
+
+ JInternalFrame[] frames = desktop.getAllFrames();
+ for (JInternalFrame frame : frames)
+ {
+ if (frame instanceof SplitFrame && frame != source)
+ {
+ SplitFrame sf = (SplitFrame) frame;
+ AlignFrame topFrame = (AlignFrame) sf.getTopFrame();
+ AlignFrame bottomFrame = (AlignFrame) sf.getBottomFrame();
+ boolean gatherThis = false;
+ for (int a = 0; a < topFrame.alignPanels.size(); a++)
+ {
+ AlignmentPanel topPanel = topFrame.alignPanels.get(a);
+ AlignmentPanel bottomPanel = bottomFrame.alignPanels.get(a);
+ if (topViewId.equals(topPanel.av.getSequenceSetId())
+ && bottomViewId.equals(bottomPanel.av.getSequenceSetId()))
+ {
+ gatherThis = true;
+ topPanel.av.setGatherViewsHere(false);
+ bottomPanel.av.setGatherViewsHere(false);
+ topPanel.av.setExplodedGeometry(
+ new Rectangle(sf.getLocation(), topFrame.getSize()));
+ bottomPanel.av.setExplodedGeometry(
+ new Rectangle(sf.getLocation(), bottomFrame.getSize()));
+ myTopFrame.addAlignmentPanel(topPanel, false);
+ myBottomFrame.addAlignmentPanel(bottomPanel, false);
+ }
+ }
+
+ if (gatherThis)
+ {
+ topFrame.getAlignPanels().clear();
+ bottomFrame.getAlignPanels().clear();
+ sf.close();
+ }
+ }
+ }
+
+ /*
+ * The dust settles...give focus to the tab we did this from.
+ */
+ myTopFrame.setDisplayedView(myTopFrame.alignPanel);
+ }
+
+ public static groovy.ui.Console getGroovyConsole()
+ {
+ return groovyConsole;
+ }
+
+ public static void transferFromDropTarget(List<String> files,
+ List<DataSourceType> protocols, DropTargetDropEvent evt,
+ Transferable t) throws Exception
+ {
+
+ DataFlavor uriListFlavor = new DataFlavor(
+ "text/uri-list;class=java.lang.String");
+ if (t.isDataFlavorSupported(DataFlavor.javaFileListFlavor))
+ {
+ // Works on Windows and MacOSX
+ Cache.log.debug("Drop handled as javaFileListFlavor");
+ for (Object file : (List) t
+ .getTransferData(DataFlavor.javaFileListFlavor))
+ {
+ files.add(((File) file).toString());
+ protocols.add(DataSourceType.FILE);
+ }
+ }
+ else
+ {
+ // Unix like behaviour
+ boolean added = false;
+ String data = null;
+ if (t.isDataFlavorSupported(uriListFlavor))
+ {
+ Cache.log.debug("Drop handled as uriListFlavor");
+ // This is used by Unix drag system
+ data = (String) t.getTransferData(uriListFlavor);
+ }
+ if (data == null)
+ {
+ // fallback to text: workaround - on OSX where there's a JVM bug
+ Cache.log.debug("standard URIListFlavor failed. Trying text");
+ // try text fallback
+ data = (String) t.getTransferData(
+ new DataFlavor("text/plain;class=java.lang.String"));
+ if (Cache.log.isDebugEnabled())
+ {
+ Cache.log.debug("fallback returned " + data);
+ }
+ }
+ while (protocols.size() < files.size())
+ {
+ Cache.log.debug("Adding missing FILE protocol for "
+ + files.get(protocols.size()));
+ protocols.add(DataSourceType.FILE);
+ }
+ for (java.util.StringTokenizer st = new java.util.StringTokenizer(
+ data, "\r\n"); st.hasMoreTokens();)
+ {
+ added = true;
+ String s = st.nextToken();
+ if (s.startsWith("#"))
+ {
+ // the line is a comment (as per the RFC 2483)
+ continue;
+ }
+ java.net.URI uri = new java.net.URI(s);
+ if (uri.getScheme().toLowerCase().startsWith("http"))
+ {
+ protocols.add(DataSourceType.URL);
+ files.add(uri.toString());
+ }
+ else
+ {
+ // otherwise preserve old behaviour: catch all for file objects
+ java.io.File file = new java.io.File(uri);
+ protocols.add(DataSourceType.FILE);
+ files.add(file.toString());
+ }
+ }
+ if (Cache.log.isDebugEnabled())
+ {
+ if (data == null || !added)
+ {
+ Cache.log.debug(
+ "Couldn't resolve drop data. Here are the supported flavors:");
+ for (DataFlavor fl : t.getTransferDataFlavors())
+ {
+ Cache.log.debug(
+ "Supported transfer dataflavor: " + fl.toString());
+ Object df = t.getTransferData(fl);
+ if (df != null)
+ {
+ Cache.log.debug("Retrieves: " + df);
+ }
+ else
+ {
+ Cache.log.debug("Retrieved nothing");
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Sets the Preferences property for experimental features to True or False
+ * depending on the state of the controlling menu item
+ */
+ @Override
+ protected void showExperimental_actionPerformed(boolean selected)
+ {
+ Cache.setProperty(EXPERIMENTAL_FEATURES, Boolean.toString(selected));