();
}
if (progressBars.get(new Long(id)) != null)
{
JPanel panel = progressBars.remove(new Long(id));
if (progressBarHandlers.contains(new Long(id)))
{
progressBarHandlers.remove(new Long(id));
}
removeProgressPanel(panel);
}
else
{
progressBars.put(new Long(id), addProgressPanel(message));
}
}
/*
* (non-Javadoc)
*
* @see jalview.gui.IProgressIndicator#registerHandler(long,
* jalview.gui.IProgressIndicatorHandler)
*/
@Override
public void registerHandler(final long id,
final IProgressIndicatorHandler handler)
{
if (progressBarHandlers == null
|| !progressBars.containsKey(new Long(id)))
{
throw new Error(
MessageManager
.getString("error.call_setprogressbar_before_registering_handler"));
}
progressBarHandlers.put(new Long(id), handler);
final JPanel progressPanel = progressBars.get(new Long(id));
if (handler.canCancel())
{
JButton cancel = new JButton(
MessageManager.getString("action.cancel"));
final IProgressIndicator us = this;
cancel.addActionListener(new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
handler.cancelActivity(id);
us.setProgressBar(MessageManager.formatMessage(
"label.cancelled_params",
new Object[] { ((JLabel) progressPanel.getComponent(0))
.getText() }), id);
}
});
progressPanel.add(cancel, BorderLayout.EAST);
}
}
/**
*
* @return true if any progress bars are still active
*/
@Override
public boolean operationInProgress()
{
if (progressBars != null && progressBars.size() > 0)
{
return true;
}
return false;
}
/**
* This will return the first AlignFrame holding the given viewport instance.
* It will break if there are more than one AlignFrames viewing a particular
* av.
*
* @param viewport
* @return alignFrame for viewport
*/
public static AlignFrame getAlignFrameFor(AlignViewportI viewport)
{
if (desktop != null)
{
AlignmentPanel[] aps = getAlignmentPanels(viewport.getSequenceSetId());
for (int panel = 0; aps != null && panel < aps.length; panel++)
{
if (aps[panel] != null && aps[panel].av == viewport)
{
return aps[panel].alignFrame;
}
}
}
return null;
}
public VamsasApplication getVamsasApplication()
{
return v_client;
}
/**
* flag set if jalview GUI is being operated programmatically
*/
private boolean inBatchMode = false;
/**
* check if jalview GUI is being operated programmatically
*
* @return inBatchMode
*/
public boolean isInBatchMode()
{
return inBatchMode;
}
/**
* set flag if jalview GUI is being operated programmatically
*
* @param inBatchMode
*/
public void setInBatchMode(boolean inBatchMode)
{
this.inBatchMode = inBatchMode;
}
public void startServiceDiscovery()
{
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))
{
if (jalview.ws.jws2.Jws2Discoverer.getDiscoverer().isRunning())
{
jalview.ws.jws2.Jws2Discoverer.getDiscoverer().setAborted(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("" + ermsg +
* " It may be that you have invalid JABA URLs in your web service preferences,"
* + " or mis-configured HTTP proxy settings. " +
* "Check the Connections and Web services tab of the"
* +
* " Tools->Preferences dialog box to change them. |
"
* ), true, true, "Web Service Configuration Problem", 450,
* 400);
*
* jd.waitForInput();
*/
JOptionPane
.showConfirmDialog(
Desktop.desktop,
new JLabel(
""
+ "It may be that you have invalid JABA URLs
in your web service preferences,"
+ "
or as a command-line argument, or mis-configured HTTP proxy settings.
"
+ "Check the Connections and Web services tab
of the"
+ " Tools->Preferences dialog box to change them.
"),
"Web Service Configuration Problem",
JOptionPane.DEFAULT_OPTION,
JOptionPane.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)
{
JOptionPane.showInternalMessageDialog(Desktop.desktop,
MessageManager
.getString("label.web_browser_not_found_unix"),
MessageManager.getString("label.web_browser_not_found"),
JOptionPane.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 files,
List 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");
evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
for (Object file : (List) t
.getTransferData(DataFlavor.javaFileListFlavor))
{
files.add(((File)file).toString());
protocols.add(FormatAdapter.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
evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
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(FormatAdapter.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(FormatAdapter.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(FormatAdapter.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());
evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
Object df = t.getTransferData(fl);
if (df != null)
{
Cache.log.debug("Retrieves: " + df);
}
else
{
Cache.log.debug("Retrieved nothing");
}
}
}
}
}
}
}