src/jalview/gui/Desktop.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ 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 java.awt.BorderLayout;
  24 import java.awt.Color;
  25 import java.awt.Dimension;
  26 import java.awt.FontMetrics;
  27 import java.awt.Graphics;
  28 import java.awt.GridLayout;
  29 import java.awt.Point;
  30 import java.awt.Rectangle;
  31 import java.awt.Toolkit;
  32 import java.awt.Window;
  33 import java.awt.datatransfer.Clipboard;
  34 import java.awt.datatransfer.ClipboardOwner;
  35 import java.awt.datatransfer.DataFlavor;
  36 import java.awt.datatransfer.Transferable;
  37 import java.awt.dnd.DnDConstants;
  38 import java.awt.dnd.DropTargetDragEvent;
  39 import java.awt.dnd.DropTargetDropEvent;
  40 import java.awt.dnd.DropTargetEvent;
  41 import java.awt.dnd.DropTargetListener;
  42 import java.awt.event.ActionEvent;
  43 import java.awt.event.ActionListener;
  44 import java.awt.event.InputEvent;
  45 import java.awt.event.KeyEvent;
  46 import java.awt.event.MouseAdapter;
  47 import java.awt.event.MouseEvent;
  48 import java.awt.event.WindowAdapter;
  49 import java.awt.event.WindowEvent;
  50 import java.beans.PropertyChangeEvent;
  51 import java.beans.PropertyChangeListener;
  52 import java.io.File;
  53 import java.io.FileWriter;
  54 import java.io.IOException;
  55 import java.net.URL;
  56 import java.util.ArrayList;
  57 import java.util.HashMap;
  58 import java.util.Hashtable;
  59 import java.util.List;
  60 import java.util.ListIterator;
  61 import java.util.Vector;
  62 import java.util.concurrent.ExecutorService;
  63 import java.util.concurrent.Executors;
  64 import java.util.concurrent.Semaphore;
  65
  66 import javax.swing.AbstractAction;
  67 import javax.swing.Action;
  68 import javax.swing.ActionMap;
  69 import javax.swing.Box;
  70 import javax.swing.BoxLayout;
  71 import javax.swing.DefaultDesktopManager;
  72 import javax.swing.DesktopManager;
  73 import javax.swing.InputMap;
  74 import javax.swing.JButton;
  75 import javax.swing.JCheckBox;
  76 import javax.swing.JComboBox;
  77 import javax.swing.JComponent;
  78 import javax.swing.JDesktopPane;
  79 import javax.swing.JInternalFrame;
  80 import javax.swing.JLabel;
  81 import javax.swing.JMenuItem;
  82 import javax.swing.JPanel;
  83 import javax.swing.JPopupMenu;
  84 import javax.swing.JProgressBar;
  85 import javax.swing.JTextField;
  86 import javax.swing.KeyStroke;
  87 import javax.swing.SwingUtilities;
  88 import javax.swing.event.HyperlinkEvent;
  89 import javax.swing.event.HyperlinkEvent.EventType;
  90 import javax.swing.event.InternalFrameAdapter;
  91 import javax.swing.event.InternalFrameEvent;
  92
  93 import org.stackoverflowusers.file.WindowsShortcut;
  94
  95 import jalview.api.AlignViewportI;
  96 import jalview.api.AlignmentViewPanel;
  97 import jalview.bin.Cache;
  98 import jalview.bin.Jalview;
  99 import jalview.gui.ImageExporter.ImageWriterI;
 100 import jalview.io.BackupFiles;
 101 import jalview.io.DataSourceType;
 102 import jalview.io.FileFormat;
 103 import jalview.io.FileFormatException;
 104 import jalview.io.FileFormatI;
 105 import jalview.io.FileFormats;
 106 import jalview.io.FileLoader;
 107 import jalview.io.FormatAdapter;
 108 import jalview.io.IdentifyFile;
 109 import jalview.io.JalviewFileChooser;
 110 import jalview.io.JalviewFileView;
 111 import jalview.jbgui.GSplitFrame;
 112 import jalview.jbgui.GStructureViewer;
 113 import jalview.project.Jalview2XML;
 114 import jalview.structure.StructureSelectionManager;
 115 import jalview.urls.IdOrgSettings;
 116 import jalview.util.BrowserLauncher;
 117 import jalview.util.ImageMaker.TYPE;
 118 import jalview.util.MessageManager;
 119 import jalview.util.Platform;
 120 import jalview.util.ShortcutKeyMaskExWrapper;
 121 import jalview.util.UrlConstants;
 122 import jalview.viewmodel.AlignmentViewport;
 123 import jalview.ws.params.ParamManager;
 124 import jalview.ws.utils.UrlDownloadClient;
 125
 126 /**
 127  * Jalview Desktop
 128  *
 129  *
 130  * @author $author$
 131  * @version $Revision: 1.155 $
 132  */
 133 public class Desktop extends jalview.jbgui.GDesktop
 134         implements DropTargetListener, ClipboardOwner, IProgressIndicator,
 135         jalview.api.StructureSelectionManagerProvider
 136 {
 137   private static final String CITATION = "<br><br>Development managed by The Barton Group, University of Dundee, Scotland, UK.<br>"
 138           + "<br><br>For help, see the FAQ at <a href=\"http://www.jalview.org/faq\">www.jalview.org/faq</a> and/or join the jalview-discuss@jalview.org mailing list"
 139           + "<br><br>If  you use Jalview, please cite:"
 140           + "<br>Waterhouse, A.M., Procter, J.B., Martin, D.M.A, Clamp, M. and Barton, G. J. (2009)"
 141           + "<br>Jalview Version 2 - a multiple sequence alignment editor and analysis workbench"
 142           + "<br>Bioinformatics doi: 10.1093/bioinformatics/btp033";
 143
 144   private static final String DEFAULT_AUTHORS = "The Jalview Authors (See AUTHORS file for current list)";
 145
 146   private static int DEFAULT_MIN_WIDTH = 300;
 147
 148   private static int DEFAULT_MIN_HEIGHT = 250;
 149
 150   private static int ALIGN_FRAME_DEFAULT_MIN_WIDTH = 600;
 151
 152   private static int ALIGN_FRAME_DEFAULT_MIN_HEIGHT = 70;
 153
 154   private static final String EXPERIMENTAL_FEATURES = "EXPERIMENTAL_FEATURES";
 155
 156   protected static final String CONFIRM_KEYBOARD_QUIT = "CONFIRM_KEYBOARD_QUIT";
 157
 158   public static HashMap<String, FileWriter> savingFiles = new HashMap<String, FileWriter>();
 159
 160   private JalviewChangeSupport changeSupport = new JalviewChangeSupport();
 161
 162   /**
 163    * news reader - null if it was never started.
 164    */
 165   private BlogReader jvnews = null;
 166
 167   private File projectFile;
 168
 169   /**
 170    * @param listener
 171    * @see jalview.gui.JalviewChangeSupport#addJalviewPropertyChangeListener(java.beans.PropertyChangeListener)
 172    */
 173   public void addJalviewPropertyChangeListener(
 174           PropertyChangeListener listener)
 175   {
 176     changeSupport.addJalviewPropertyChangeListener(listener);
 177   }
 178
 179   /**
 180    * @param propertyName
 181    * @param listener
 182    * @see jalview.gui.JalviewChangeSupport#addJalviewPropertyChangeListener(java.lang.String,
 183    *      java.beans.PropertyChangeListener)
 184    */
 185   public void addJalviewPropertyChangeListener(String propertyName,
 186           PropertyChangeListener listener)
 187   {
 188     changeSupport.addJalviewPropertyChangeListener(propertyName, listener);
 189   }
 190
 191   /**
 192    * @param propertyName
 193    * @param listener
 194    * @see jalview.gui.JalviewChangeSupport#removeJalviewPropertyChangeListener(java.lang.String,
 195    *      java.beans.PropertyChangeListener)
 196    */
 197   public void removeJalviewPropertyChangeListener(String propertyName,
 198           PropertyChangeListener listener)
 199   {
 200     changeSupport.removeJalviewPropertyChangeListener(propertyName,
 201             listener);
 202   }
 203
 204   /** Singleton Desktop instance */
 205   public static Desktop instance;
 206
 207   public static MyDesktopPane desktop;
 208
 209   public static MyDesktopPane getDesktop()
 210   {
 211     // BH 2018 could use currentThread() here as a reference to a
 212     // Hashtable<Thread, MyDesktopPane> in JavaScript
 213     return desktop;
 214   }
 215
 216   static int openFrameCount = 0;
 217
 218   static final int xOffset = 30;
 219
 220   static final int yOffset = 30;
 221
 222   public static jalview.ws.jws1.Discoverer discoverer;
 223
 224   public static Object[] jalviewClipboard;
 225
 226   public static boolean internalCopy = false;
 227
 228   static int fileLoadingCount = 0;
 229
 230   class MyDesktopManager implements DesktopManager
 231   {
 232
 233     private DesktopManager delegate;
 234
 235     public MyDesktopManager(DesktopManager delegate)
 236     {
 237       this.delegate = delegate;
 238     }
 239
 240     @Override
 241     public void activateFrame(JInternalFrame f)
 242     {
 243       try
 244       {
 245         delegate.activateFrame(f);
 246       } catch (NullPointerException npe)
 247       {
 248         Point p = getMousePosition();
 249         instance.showPasteMenu(p.x, p.y);
 250       }
 251     }
 252
 253     @Override
 254     public void beginDraggingFrame(JComponent f)
 255     {
 256       delegate.beginDraggingFrame(f);
 257     }
 258
 259     @Override
 260     public void beginResizingFrame(JComponent f, int direction)
 261     {
 262       delegate.beginResizingFrame(f, direction);
 263     }
 264
 265     @Override
 266     public void closeFrame(JInternalFrame f)
 267     {
 268       delegate.closeFrame(f);
 269     }
 270
 271     @Override
 272     public void deactivateFrame(JInternalFrame f)
 273     {
 274       delegate.deactivateFrame(f);
 275     }
 276
 277     @Override
 278     public void deiconifyFrame(JInternalFrame f)
 279     {
 280       delegate.deiconifyFrame(f);
 281     }
 282
 283     @Override
 284     public void dragFrame(JComponent f, int newX, int newY)
 285     {
 286       if (newY < 0)
 287       {
 288         newY = 0;
 289       }
 290       delegate.dragFrame(f, newX, newY);
 291     }
 292
 293     @Override
 294     public void endDraggingFrame(JComponent f)
 295     {
 296       delegate.endDraggingFrame(f);
 297       desktop.repaint();
 298     }
 299
 300     @Override
 301     public void endResizingFrame(JComponent f)
 302     {
 303       delegate.endResizingFrame(f);
 304       desktop.repaint();
 305     }
 306
 307     @Override
 308     public void iconifyFrame(JInternalFrame f)
 309     {
 310       delegate.iconifyFrame(f);
 311     }
 312
 313     @Override
 314     public void maximizeFrame(JInternalFrame f)
 315     {
 316       delegate.maximizeFrame(f);
 317     }
 318
 319     @Override
 320     public void minimizeFrame(JInternalFrame f)
 321     {
 322       delegate.minimizeFrame(f);
 323     }
 324
 325     @Override
 326     public void openFrame(JInternalFrame f)
 327     {
 328       delegate.openFrame(f);
 329     }
 330
 331     @Override
 332     public void resizeFrame(JComponent f, int newX, int newY, int newWidth,
 333             int newHeight)
 334     {
 335       if (newY < 0)
 336       {
 337         newY = 0;
 338       }
 339       delegate.resizeFrame(f, newX, newY, newWidth, newHeight);
 340     }
 341
 342     @Override
 343     public void setBoundsForFrame(JComponent f, int newX, int newY,
 344             int newWidth, int newHeight)
 345     {
 346       delegate.setBoundsForFrame(f, newX, newY, newWidth, newHeight);
 347     }
 348
 349     // All other methods, simply delegate
 350
 351   }
 352
 353   /**
 354    * Creates a new Desktop object.
 355    */
 356   public Desktop()
 357   {
 358     super();
 359     /**
 360      * A note to implementors. It is ESSENTIAL that any activities that might
 361      * block are spawned off as threads rather than waited for during this
 362      * constructor.
 363      */
 364     instance = this;
 365
 366     doConfigureStructurePrefs();
 367     setTitle("Jalview " + Cache.getProperty("VERSION"));
 368     /*
 369     if (!Platform.isAMac())
 370     {
 371       // this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
 372     }
 373     else
 374     {
 375      this.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
 376     }
 377     */
 378
 379     try
 380     {
 381       APQHandlers.setAPQHandlers(this);
 382     } catch (Throwable t)
 383     {
 384       System.out.println("Error setting APQHandlers: " + t.toString());
 385       // t.printStackTrace();
 386     }
 387
 388     addWindowListener(new WindowAdapter()
 389     {
 390
 391       @Override
 392       public void windowClosing(WindowEvent ev)
 393       {
 394         quit();
 395       }
 396     });
 397
 398     boolean selmemusage = Cache.getDefault("SHOW_MEMUSAGE", false);
 399
 400     boolean showjconsole = Cache.getDefault("SHOW_JAVA_CONSOLE", false);
 401     desktop = new MyDesktopPane(selmemusage);
 402
 403     showMemusage.setSelected(selmemusage);
 404     desktop.setBackground(Color.white);
 405
 406     getContentPane().setLayout(new BorderLayout());
 407     // alternate config - have scrollbars - see notes in JAL-153
 408     // JScrollPane sp = new JScrollPane();
 409     // sp.getViewport().setView(desktop);
 410     // getContentPane().add(sp, BorderLayout.CENTER);
 411
 412     // BH 2018 - just an experiment to try unclipped JInternalFrames.
 413     if (Platform.isJS())
 414     {
 415       getRootPane().putClientProperty("swingjs.overflow.hidden", "false");
 416     }
 417
 418     getContentPane().add(desktop, BorderLayout.CENTER);
 419     desktop.setDragMode(JDesktopPane.OUTLINE_DRAG_MODE);
 420
 421     // This line prevents Windows Look&Feel resizing all new windows to maximum
 422     // if previous window was maximised
 423     desktop.setDesktopManager(new MyDesktopManager(
 424             (Platform.isWindowsAndNotJS() ? new DefaultDesktopManager()
 425                     : Platform.isAMacAndNotJS()
 426                             ? new AquaInternalFrameManager(
 427                                     desktop.getDesktopManager())
 428                             : desktop.getDesktopManager())));
 429
 430     Rectangle dims = getLastKnownDimensions("");
 431     if (dims != null)
 432     {
 433       setBounds(dims);
 434     }
 435     else
 436     {
 437       Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
 438       int xPos = Math.max(5, (screenSize.width - 900) / 2);
 439       int yPos = Math.max(5, (screenSize.height - 650) / 2);
 440       setBounds(xPos, yPos, 900, 650);
 441     }
 442
 443     if (!Platform.isJS())
 444     /**
 445      * Java only
 446      *
 447      * @j2sIgnore
 448      */
 449     {
 450       jconsole = new Console(this, showjconsole);
 451       jconsole.setHeader(Cache.getVersionDetailsForConsole());
 452       showConsole(showjconsole);
 453
 454       showNews.setVisible(false);
 455
 456       experimentalFeatures.setSelected(showExperimental());
 457
 458       getIdentifiersOrgData();
 459
 460       checkURLLinks();
 461
 462       // Spawn a thread that shows the splashscreen
 463
 464       SwingUtilities.invokeLater(new Runnable()
 465       {
 466         @Override
 467         public void run()
 468         {
 469           new SplashScreen(true);
 470         }
 471       });
 472
 473       // Thread off a new instance of the file chooser - this reduces the time
 474       // it
 475       // takes to open it later on.
 476       new Thread(new Runnable()
 477       {
 478         @Override
 479         public void run()
 480         {
 481           Cache.log.debug("Filechooser init thread started.");
 482           String fileFormat = Cache.getProperty("DEFAULT_FILE_FORMAT");
 483           JalviewFileChooser.forRead(Cache.getProperty("LAST_DIRECTORY"),
 484                   fileFormat);
 485           Cache.log.debug("Filechooser init thread finished.");
 486         }
 487       }).start();
 488       // Add the service change listener
 489       changeSupport.addJalviewPropertyChangeListener("services",
 490               new PropertyChangeListener()
 491               {
 492
 493                 @Override
 494                 public void propertyChange(PropertyChangeEvent evt)
 495                 {
 496                   Cache.log.debug("Firing service changed event for "
 497                           + evt.getNewValue());
 498                   JalviewServicesChanged(evt);
 499                 }
 500               });
 501     }
 502
 503     this.setDropTarget(new java.awt.dnd.DropTarget(desktop, this));
 504
 505     this.addWindowListener(new WindowAdapter()
 506     {
 507       @Override
 508       public void windowClosing(WindowEvent evt)
 509       {
 510         quit();
 511       }
 512     });
 513
 514     MouseAdapter ma;
 515     this.addMouseListener(ma = new MouseAdapter()
 516     {
 517       @Override
 518       public void mousePressed(MouseEvent evt)
 519       {
 520         if (evt.isPopupTrigger()) // Mac
 521         {
 522           showPasteMenu(evt.getX(), evt.getY());
 523         }
 524       }
 525
 526       @Override
 527       public void mouseReleased(MouseEvent evt)
 528       {
 529         if (evt.isPopupTrigger()) // Windows
 530         {
 531           showPasteMenu(evt.getX(), evt.getY());
 532         }
 533       }
 534     });
 535     desktop.addMouseListener(ma);
 536
 537   }
 538
 539   /**
 540    * Answers true if user preferences to enable experimental features is True
 541    * (on), else false
 542    *
 543    * @return
 544    */
 545   public boolean showExperimental()
 546   {
 547     String experimental = Cache.getDefault(EXPERIMENTAL_FEATURES,
 548             Boolean.FALSE.toString());
 549     return Boolean.valueOf(experimental).booleanValue();
 550   }
 551
 552   public void doConfigureStructurePrefs()
 553   {
 554     // configure services
 555     StructureSelectionManager ssm = StructureSelectionManager
 556             .getStructureSelectionManager(this);
 557     if (Cache.getDefault(Preferences.ADD_SS_ANN, true))
 558     {
 559       ssm.setAddTempFacAnnot(
 560               Cache.getDefault(Preferences.ADD_TEMPFACT_ANN, true));
 561       ssm.setProcessSecondaryStructure(
 562               Cache.getDefault(Preferences.STRUCT_FROM_PDB, true));
 563       ssm.setSecStructServices(
 564               Cache.getDefault(Preferences.USE_RNAVIEW, true));
 565     }
 566     else
 567     {
 568       ssm.setAddTempFacAnnot(false);
 569       ssm.setProcessSecondaryStructure(false);
 570       ssm.setSecStructServices(false);
 571     }
 572   }
 573
 574   public void checkForNews()
 575   {
 576     final Desktop me = this;
 577     // Thread off the news reader, in case there are connection problems.
 578     new Thread(new Runnable()
 579     {
 580       @Override
 581       public void run()
 582       {
 583         Cache.log.debug("Starting news thread.");
 584         jvnews = new BlogReader(me);
 585         showNews.setVisible(true);
 586         Cache.log.debug("Completed news thread.");
 587       }
 588     }).start();
 589   }
 590
 591   public void getIdentifiersOrgData()
 592   {
 593     // Thread off the identifiers fetcher
 594     new Thread(new Runnable()
 595     {
 596       @Override
 597       public void run()
 598       {
 599         Cache.log.debug("Downloading data from identifiers.org");
 600         try
 601         {
 602           UrlDownloadClient.download(IdOrgSettings.getUrl(),
 603                   IdOrgSettings.getDownloadLocation());
 604         } catch (IOException e)
 605         {
 606           Cache.log.debug("Exception downloading identifiers.org data"
 607                   + e.getMessage());
 608         }
 609       }
 610     }).start();
 611
 612   }
 613
 614   @Override
 615   protected void showNews_actionPerformed(ActionEvent e)
 616   {
 617     showNews(showNews.isSelected());
 618   }
 619
 620   void showNews(boolean visible)
 621   {
 622     Cache.log.debug((visible ? "Showing" : "Hiding") + " news.");
 623     showNews.setSelected(visible);
 624     if (visible && !jvnews.isVisible())
 625     {
 626       new Thread(new Runnable()
 627       {
 628         @Override
 629         public void run()
 630         {
 631           long now = System.currentTimeMillis();
 632           Desktop.instance.setProgressBar(
 633                   MessageManager.getString("status.refreshing_news"), now);
 634           jvnews.refreshNews();
 635           Desktop.instance.setProgressBar(null, now);
 636           jvnews.showNews();
 637         }
 638       }).start();
 639     }
 640   }
 641
 642   /**
 643    * recover the last known dimensions for a jalview window
 644    *
 645    * @param windowName
 646    *          - empty string is desktop, all other windows have unique prefix
 647    * @return null or last known dimensions scaled to current geometry (if last
 648    *         window geom was known)
 649    */
 650   Rectangle getLastKnownDimensions(String windowName)
 651   {
 652     // TODO: lock aspect ratio for scaling desktop Bug #0058199
 653     Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
 654     String x = Cache.getProperty(windowName + "SCREEN_X");
 655     String y = Cache.getProperty(windowName + "SCREEN_Y");
 656     String width = Cache.getProperty(windowName + "SCREEN_WIDTH");
 657     String height = Cache.getProperty(windowName + "SCREEN_HEIGHT");
 658     if ((x != null) && (y != null) && (width != null) && (height != null))
 659     {
 660       int ix = Integer.parseInt(x), iy = Integer.parseInt(y),
 661               iw = Integer.parseInt(width), ih = Integer.parseInt(height);
 662       if (Cache.getProperty("SCREENGEOMETRY_WIDTH") != null)
 663       {
 664         // attempt #1 - try to cope with change in screen geometry - this
 665         // version doesn't preserve original jv aspect ratio.
 666         // take ratio of current screen size vs original screen size.
 667         double sw = ((1f * screenSize.width) / (1f * Integer
 668                 .parseInt(Cache.getProperty("SCREENGEOMETRY_WIDTH"))));
 669         double sh = ((1f * screenSize.height) / (1f * Integer
 670                 .parseInt(Cache.getProperty("SCREENGEOMETRY_HEIGHT"))));
 671         // rescale the bounds depending upon the current screen geometry.
 672         ix = (int) (ix * sw);
 673         iw = (int) (iw * sw);
 674         iy = (int) (iy * sh);
 675         ih = (int) (ih * sh);
 676         while (ix >= screenSize.width)
 677         {
 678           Cache.log.debug(
 679                   "Window geometry location recall error: shifting horizontal to within screenbounds.");
 680           ix -= screenSize.width;
 681         }
 682         while (iy >= screenSize.height)
 683         {
 684           Cache.log.debug(
 685                   "Window geometry location recall error: shifting vertical to within screenbounds.");
 686           iy -= screenSize.height;
 687         }
 688         Cache.log.debug(
 689                 "Got last known dimensions for " + windowName + ": x:" + ix
 690                         + " y:" + iy + " width:" + iw + " height:" + ih);
 691       }
 692       // return dimensions for new instance
 693       return new Rectangle(ix, iy, iw, ih);
 694     }
 695     return null;
 696   }
 697
 698   void showPasteMenu(int x, int y)
 699   {
 700     JPopupMenu popup = new JPopupMenu();
 701     JMenuItem item = new JMenuItem(
 702             MessageManager.getString("label.paste_new_window"));
 703     item.addActionListener(new ActionListener()
 704     {
 705       @Override
 706       public void actionPerformed(ActionEvent evt)
 707       {
 708         paste();
 709       }
 710     });
 711
 712     popup.add(item);
 713     popup.show(this, x, y);
 714   }
 715
 716   public void paste()
 717   {
 718     try
 719     {
 720       Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard();
 721       Transferable contents = c.getContents(this);
 722
 723       if (contents != null)
 724       {
 725         String file = (String) contents
 726                 .getTransferData(DataFlavor.stringFlavor);
 727
 728         FileFormatI format = new IdentifyFile().identify(file,
 729                 DataSourceType.PASTE);
 730
 731         new FileLoader().LoadFile(file, DataSourceType.PASTE, format);
 732
 733       }
 734     } catch (Exception ex)
 735     {
 736       System.out.println(
 737               "Unable to paste alignment from system clipboard:\n" + ex);
 738     }
 739   }
 740
 741   /**
 742    * Adds and opens the given frame to the desktop
 743    *
 744    * @param frame
 745    *          Frame to show
 746    * @param title
 747    *          Visible Title
 748    * @param w
 749    *          width
 750    * @param h
 751    *          height
 752    */
 753   public static synchronized void addInternalFrame(
 754           final JInternalFrame frame, String title, int w, int h)
 755   {
 756     addInternalFrame(frame, title, true, w, h, true, false);
 757   }
 758
 759   /**
 760    * Add an internal frame to the Jalview desktop
 761    *
 762    * @param frame
 763    *          Frame to show
 764    * @param title
 765    *          Visible Title
 766    * @param makeVisible
 767    *          When true, display frame immediately, otherwise, caller must call
 768    *          setVisible themselves.
 769    * @param w
 770    *          width
 771    * @param h
 772    *          height
 773    */
 774   public static synchronized void addInternalFrame(
 775           final JInternalFrame frame, String title, boolean makeVisible,
 776           int w, int h)
 777   {
 778     addInternalFrame(frame, title, makeVisible, w, h, true, false);
 779   }
 780
 781   /**
 782    * Add an internal frame to the Jalview desktop and make it visible
 783    *
 784    * @param frame
 785    *          Frame to show
 786    * @param title
 787    *          Visible Title
 788    * @param w
 789    *          width
 790    * @param h
 791    *          height
 792    * @param resizable
 793    *          Allow resize
 794    */
 795   public static synchronized void addInternalFrame(
 796           final JInternalFrame frame, String title, int w, int h,
 797           boolean resizable)
 798   {
 799     addInternalFrame(frame, title, true, w, h, resizable, false);
 800   }
 801
 802   /**
 803    * Add an internal frame to the Jalview desktop
 804    *
 805    * @param frame
 806    *          Frame to show
 807    * @param title
 808    *          Visible Title
 809    * @param makeVisible
 810    *          When true, display frame immediately, otherwise, caller must call
 811    *          setVisible themselves.
 812    * @param w
 813    *          width
 814    * @param h
 815    *          height
 816    * @param resizable
 817    *          Allow resize
 818    * @param ignoreMinSize
 819    *          Do not set the default minimum size for frame
 820    */
 821   public static synchronized void addInternalFrame(
 822           final JInternalFrame frame, String title, boolean makeVisible,
 823           int w, int h, boolean resizable, boolean ignoreMinSize)
 824   {
 825
 826     // TODO: allow callers to determine X and Y position of frame (eg. via
 827     // bounds object).
 828     // TODO: consider fixing method to update entries in the window submenu with
 829     // the current window title
 830
 831     frame.setTitle(title);
 832     if (frame.getWidth() < 1 || frame.getHeight() < 1)
 833     {
 834       frame.setSize(w, h);
 835     }
 836     // THIS IS A PUBLIC STATIC METHOD, SO IT MAY BE CALLED EVEN IN
 837     // A HEADLESS STATE WHEN NO DESKTOP EXISTS. MUST RETURN
 838     // IF JALVIEW IS RUNNING HEADLESS
 839     // ///////////////////////////////////////////////
 840     if (instance == null || (System.getProperty("java.awt.headless") != null
 841             && System.getProperty("java.awt.headless").equals("true")))
 842     {
 843       return;
 844     }
 845
 846     openFrameCount++;
 847
 848     if (!ignoreMinSize)
 849     {
 850       frame.setMinimumSize(
 851               new Dimension(DEFAULT_MIN_WIDTH, DEFAULT_MIN_HEIGHT));
 852
 853       // Set default dimension for Alignment Frame window.
 854       // The Alignment Frame window could be added from a number of places,
 855       // hence,
 856       // I did this here in order not to miss out on any Alignment frame.
 857       if (frame instanceof AlignFrame)
 858       {
 859         frame.setMinimumSize(new Dimension(ALIGN_FRAME_DEFAULT_MIN_WIDTH,
 860                 ALIGN_FRAME_DEFAULT_MIN_HEIGHT));
 861       }
 862     }
 863
 864     frame.setVisible(makeVisible);
 865     frame.setClosable(true);
 866     frame.setResizable(resizable);
 867     frame.setMaximizable(resizable);
 868     frame.setIconifiable(resizable);
 869     frame.setOpaque(Platform.isJS());
 870
 871     if (frame.getX() < 1 && frame.getY() < 1)
 872     {
 873       frame.setLocation(xOffset * openFrameCount,
 874               yOffset * ((openFrameCount - 1) % 10) + yOffset);
 875     }
 876
 877     /*
 878      * add an entry for the new frame in the Window menu
 879      * (and remove it when the frame is closed)
 880      */
 881     final JMenuItem menuItem = new JMenuItem(title);
 882     frame.addInternalFrameListener(new InternalFrameAdapter()
 883     {
 884       @Override
 885       public void internalFrameActivated(InternalFrameEvent evt)
 886       {
 887         JInternalFrame itf = desktop.getSelectedFrame();
 888         if (itf != null)
 889         {
 890           if (itf instanceof AlignFrame)
 891           {
 892             Jalview.setCurrentAlignFrame((AlignFrame) itf);
 893           }
 894           itf.requestFocus();
 895         }
 896       }
 897
 898       @Override
 899       public void internalFrameClosed(InternalFrameEvent evt)
 900       {
 901         PaintRefresher.RemoveComponent(frame);
 902
 903         /*
 904          * defensive check to prevent frames being
 905          * added half off the window
 906          */
 907         if (openFrameCount > 0)
 908         {
 909           openFrameCount--;
 910         }
 911
 912         /*
 913          * ensure no reference to alignFrame retained by menu item listener
 914          */
 915         if (menuItem.getActionListeners().length > 0)
 916         {
 917           menuItem.removeActionListener(menuItem.getActionListeners()[0]);
 918         }
 919         windowMenu.remove(menuItem);
 920       }
 921     });
 922
 923     menuItem.addActionListener(new ActionListener()
 924     {
 925       @Override
 926       public void actionPerformed(ActionEvent e)
 927       {
 928         try
 929         {
 930           frame.setSelected(true);
 931           frame.setIcon(false);
 932         } catch (java.beans.PropertyVetoException ex)
 933         {
 934           // System.err.println(ex.toString());
 935         }
 936       }
 937     });
 938
 939     setKeyBindings(frame);
 940
 941     desktop.add(frame);
 942
 943     windowMenu.add(menuItem);
 944
 945     frame.toFront();
 946     try
 947     {
 948       frame.setSelected(true);
 949       frame.requestFocus();
 950     } catch (java.beans.PropertyVetoException ve)
 951     {
 952     } catch (java.lang.ClassCastException cex)
 953     {
 954       Cache.log.warn(
 955               "Squashed a possible GUI implementation error. If you can recreate this, please look at http://issues.jalview.org/browse/JAL-869",
 956               cex);
 957     }
 958   }
 959
 960   /**
 961    * Add key bindings to a JInternalFrame so that Ctrl-W and Cmd-W will close
 962    * the window
 963    *
 964    * @param frame
 965    */
 966   private static void setKeyBindings(JInternalFrame frame)
 967   {
 968     @SuppressWarnings("serial")
 969     final Action closeAction = new AbstractAction()
 970     {
 971       @Override
 972       public void actionPerformed(ActionEvent e)
 973       {
 974         frame.dispose();
 975       }
 976     };
 977
 978     /*
 979      * set up key bindings for Ctrl-W and Cmd-W, with the same (Close) action
 980      */
 981     KeyStroke ctrlWKey = KeyStroke.getKeyStroke(KeyEvent.VK_W,
 982             InputEvent.CTRL_DOWN_MASK);
 983     KeyStroke cmdWKey = KeyStroke.getKeyStroke(KeyEvent.VK_W,
 984             ShortcutKeyMaskExWrapper.getMenuShortcutKeyMaskEx());
 985
 986     InputMap inputMap = frame
 987             .getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
 988     String ctrlW = ctrlWKey.toString();
 989     inputMap.put(ctrlWKey, ctrlW);
 990     inputMap.put(cmdWKey, ctrlW);
 991
 992     ActionMap actionMap = frame.getActionMap();
 993     actionMap.put(ctrlW, closeAction);
 994   }
 995
 996   @Override
 997   public void lostOwnership(Clipboard clipboard, Transferable contents)
 998   {
 999     if (!internalCopy)
1000     {
1001       Desktop.jalviewClipboard = null;
1002     }
1003
1004     internalCopy = false;
1005   }
1006
1007   @Override
1008   public void dragEnter(DropTargetDragEvent evt)
1009   {
1010   }
1011
1012   @Override
1013   public void dragExit(DropTargetEvent evt)
1014   {
1015   }
1016
1017   @Override
1018   public void dragOver(DropTargetDragEvent evt)
1019   {
1020   }
1021
1022   @Override
1023   public void dropActionChanged(DropTargetDragEvent evt)
1024   {
1025   }
1026
1027   /**
1028    * DOCUMENT ME!
1029    *
1030    * @param evt
1031    *          DOCUMENT ME!
1032    */
1033   @Override
1034   public void drop(DropTargetDropEvent evt)
1035   {
1036     boolean success = true;
1037     // JAL-1552 - acceptDrop required before getTransferable call for
1038     // Java's Transferable for native dnd
1039     evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
1040     Transferable t = evt.getTransferable();
1041     List<Object> files = new ArrayList<>();
1042     List<DataSourceType> protocols = new ArrayList<>();
1043
1044     try
1045     {
1046       Desktop.transferFromDropTarget(files, protocols, evt, t);
1047     } catch (Exception e)
1048     {
1049       e.printStackTrace();
1050       success = false;
1051     }
1052
1053     if (files != null)
1054     {
1055       try
1056       {
1057         for (int i = 0; i < files.size(); i++)
1058         {
1059           // BH 2018 File or String
1060           Object file = files.get(i);
1061           String fileName = file.toString();
1062           DataSourceType protocol = (protocols == null)
1063                   ? DataSourceType.FILE
1064                   : protocols.get(i);
1065           FileFormatI format = null;
1066
1067           if (fileName.endsWith(".jar"))
1068           {
1069             format = FileFormat.Jalview;
1070
1071           }
1072           else
1073           {
1074             format = new IdentifyFile().identify(file, protocol);
1075           }
1076           if (file instanceof File)
1077           {
1078             Platform.cacheFileData((File) file);
1079           }
1080           new FileLoader().LoadFile(null, file, protocol, format);
1081
1082         }
1083       } catch (Exception ex)
1084       {
1085         success = false;
1086       }
1087     }
1088     evt.dropComplete(success); // need this to ensure input focus is properly
1089                                // transfered to any new windows created
1090   }
1091
1092   /**
1093    * DOCUMENT ME!
1094    *
1095    * @param e
1096    *          DOCUMENT ME!
1097    */
1098   @Override
1099   public void inputLocalFileMenuItem_actionPerformed(AlignViewport viewport)
1100   {
1101     String fileFormat = Cache.getProperty("DEFAULT_FILE_FORMAT");
1102     JalviewFileChooser chooser = JalviewFileChooser.forRead(
1103             Cache.getProperty("LAST_DIRECTORY"), fileFormat,
1104             BackupFiles.getEnabled());
1105
1106     chooser.setFileView(new JalviewFileView());
1107     chooser.setDialogTitle(
1108             MessageManager.getString("label.open_local_file"));
1109     chooser.setToolTipText(MessageManager.getString("action.open"));
1110
1111     chooser.setResponseHandler(0, new Runnable()
1112     {
1113       @Override
1114       public void run()
1115       {
1116         File selectedFile = chooser.getSelectedFile();
1117         Cache.setProperty("LAST_DIRECTORY", selectedFile.getParent());
1118
1119         FileFormatI format = chooser.getSelectedFormat();
1120
1121         /*
1122          * Call IdentifyFile to verify the file contains what its extension implies.
1123          * Skip this step for dynamically added file formats, because
1124          * IdentifyFile does not know how to recognise them.
1125          */
1126         if (FileFormats.getInstance().isIdentifiable(format))
1127         {
1128           try
1129           {
1130             format = new IdentifyFile().identify(selectedFile,
1131                     DataSourceType.FILE);
1132           } catch (FileFormatException e)
1133           {
1134             // format = null; //??
1135           }
1136         }
1137
1138         new FileLoader().LoadFile(viewport, selectedFile,
1139                 DataSourceType.FILE, format);
1140       }
1141     });
1142     chooser.showOpenDialog(this);
1143   }
1144
1145   /**
1146    * Shows a dialog for input of a URL at which to retrieve alignment data
1147    *
1148    * @param viewport
1149    */
1150   @Override
1151   public void inputURLMenuItem_actionPerformed(AlignViewport viewport)
1152   {
1153     // This construct allows us to have a wider textfield
1154     // for viewing
1155     JLabel label = new JLabel(
1156             MessageManager.getString("label.input_file_url"));
1157
1158     JPanel panel = new JPanel(new GridLayout(2, 1));
1159     panel.add(label);
1160
1161     /*
1162      * the URL to fetch is
1163      * Java: an editable combobox with history
1164      * JS: (pending JAL-3038) a plain text field
1165      */
1166     JComponent history;
1167     String urlBase = "http://www.";
1168     if (Platform.isJS())
1169     {
1170       history = new JTextField(urlBase, 35);
1171     }
1172     else
1173     /**
1174      * Java only
1175      *
1176      * @j2sIgnore
1177      */
1178     {
1179       JComboBox<String> asCombo = new JComboBox<>();
1180       asCombo.setPreferredSize(new Dimension(400, 20));
1181       asCombo.setEditable(true);
1182       asCombo.addItem(urlBase);
1183       String historyItems = Cache.getProperty("RECENT_URL");
1184       if (historyItems != null)
1185       {
1186         for (String token : historyItems.split("\\t"))
1187         {
1188           asCombo.addItem(token);
1189         }
1190       }
1191       history = asCombo;
1192     }
1193     panel.add(history);
1194
1195     Object[] options = new Object[] { MessageManager.getString("action.ok"),
1196         MessageManager.getString("action.cancel") };
1197     Runnable action = new Runnable()
1198     {
1199       @Override
1200       public void run()
1201       {
1202         @SuppressWarnings("unchecked")
1203         String url = (history instanceof JTextField
1204                 ? ((JTextField) history).getText()
1205                 : ((JComboBox<String>) history).getSelectedItem()
1206                         .toString());
1207
1208         if (url.toLowerCase().endsWith(".jar"))
1209         {
1210           if (viewport != null)
1211           {
1212             new FileLoader().LoadFile(viewport, url, DataSourceType.URL,
1213                     FileFormat.Jalview);
1214           }
1215           else
1216           {
1217             new FileLoader().LoadFile(url, DataSourceType.URL,
1218                     FileFormat.Jalview);
1219           }
1220         }
1221         else
1222         {
1223           FileFormatI format = null;
1224           try
1225           {
1226             format = new IdentifyFile().identify(url, DataSourceType.URL);
1227           } catch (FileFormatException e)
1228           {
1229             // TODO revise error handling, distinguish between
1230             // URL not found and response not valid
1231           }
1232
1233           if (format == null)
1234           {
1235             String msg = MessageManager
1236                     .formatMessage("label.couldnt_locate", url);
1237             JvOptionPane.showInternalMessageDialog(Desktop.desktop, msg,
1238                     MessageManager.getString("label.url_not_found"),
1239                     JvOptionPane.WARNING_MESSAGE);
1240
1241             return;
1242           }
1243
1244           if (viewport != null)
1245           {
1246             new FileLoader().LoadFile(viewport, url, DataSourceType.URL,
1247                     format);
1248           }
1249           else
1250           {
1251             new FileLoader().LoadFile(url, DataSourceType.URL, format);
1252           }
1253         }
1254       }
1255     };
1256     String dialogOption = MessageManager
1257             .getString("label.input_alignment_from_url");
1258     JvOptionPane.newOptionDialog(desktop).setResponseHandler(0, action)
1259             .showInternalDialog(panel, dialogOption,
1260                     JvOptionPane.YES_NO_CANCEL_OPTION,
1261                     JvOptionPane.PLAIN_MESSAGE, null, options,
1262                     MessageManager.getString("action.ok"));
1263   }
1264
1265   /**
1266    * Opens the CutAndPaste window for the user to paste an alignment in to
1267    *
1268    * @param viewPanel
1269    *          - if not null, the pasted alignment is added to the current
1270    *          alignment; if null, to a new alignment window
1271    */
1272   @Override
1273   public void inputTextboxMenuItem_actionPerformed(
1274           AlignmentViewPanel viewPanel)
1275   {
1276     CutAndPasteTransfer cap = new CutAndPasteTransfer();
1277     cap.setForInput(viewPanel);
1278     Desktop.addInternalFrame(cap,
1279             MessageManager.getString("label.cut_paste_alignmen_file"), true,
1280             600, 500);
1281   }
1282
1283   /*
1284    * Exit the program
1285    */
1286   @Override
1287   public void quit()
1288   {
1289     Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
1290     Cache.setProperty("SCREENGEOMETRY_WIDTH", screen.width + "");
1291     Cache.setProperty("SCREENGEOMETRY_HEIGHT", screen.height + "");
1292     storeLastKnownDimensions("", new Rectangle(getBounds().x, getBounds().y,
1293             getWidth(), getHeight()));
1294
1295     if (jconsole != null)
1296     {
1297       storeLastKnownDimensions("JAVA_CONSOLE_", jconsole.getBounds());
1298       jconsole.stopConsole();
1299     }
1300     if (jvnews != null)
1301     {
1302       storeLastKnownDimensions("JALVIEW_RSS_WINDOW_", jvnews.getBounds());
1303
1304     }
1305     if (dialogExecutor != null)
1306     {
1307       dialogExecutor.shutdownNow();
1308     }
1309     closeAll_actionPerformed(null);
1310
1311     if (groovyConsole != null)
1312     {
1313       // suppress a possible repeat prompt to save script
1314       groovyConsole.setDirty(false);
1315       groovyConsole.exit();
1316     }
1317     System.exit(0);
1318   }
1319
1320   private void storeLastKnownDimensions(String string, Rectangle jc)
1321   {
1322     Cache.log.debug("Storing last known dimensions for " + string + ": x:"
1323             + jc.x + " y:" + jc.y + " width:" + jc.width + " height:"
1324             + jc.height);
1325
1326     Cache.setProperty(string + "SCREEN_X", jc.x + "");
1327     Cache.setProperty(string + "SCREEN_Y", jc.y + "");
1328     Cache.setProperty(string + "SCREEN_WIDTH", jc.width + "");
1329     Cache.setProperty(string + "SCREEN_HEIGHT", jc.height + "");
1330   }
1331
1332   /**
1333    * DOCUMENT ME!
1334    *
1335    * @param e
1336    *          DOCUMENT ME!
1337    */
1338   @Override
1339   public void aboutMenuItem_actionPerformed(ActionEvent e)
1340   {
1341     new Thread(new Runnable()
1342     {
1343       @Override
1344       public void run()
1345       {
1346         new SplashScreen(false);
1347       }
1348     }).start();
1349   }
1350
1351   /**
1352    * Returns the html text for the About screen, including any available version
1353    * number, build details, author details and citation reference, but without
1354    * the enclosing {@code html} tags
1355    *
1356    * @return
1357    */
1358   public String getAboutMessage()
1359   {
1360     StringBuilder message = new StringBuilder(1024);
1361     message.append("<h1><strong>Version: ")
1362             .append(Cache.getProperty("VERSION")).append("</strong></h1>")
1363             .append("<strong>Built: <em>")
1364             .append(Cache.getDefault("BUILD_DATE", "unknown"))
1365             .append("</em> from ").append(Cache.getBuildDetailsForSplash())
1366             .append("</strong>");
1367
1368     String latestVersion = Cache.getDefault("LATEST_VERSION", "Checking");
1369     if (latestVersion.equals("Checking"))
1370     {
1371       // JBP removed this message for 2.11: May be reinstated in future version
1372       // message.append("<br>...Checking latest version...</br>");
1373     }
1374     else if (!latestVersion.equals(Cache.getProperty("VERSION")))
1375     {
1376       boolean red = false;
1377       if (Cache.getProperty("VERSION").toLowerCase()
1378               .indexOf("automated build") == -1)
1379       {
1380         red = true;
1381         // Displayed when code version and jnlp version do not match and code
1382         // version is not a development build
1383         message.append("<div style=\"color: #FF0000;font-style: bold;\">");
1384       }
1385
1386       message.append("<br>!! Version ")
1387               .append(Cache.getDefault("LATEST_VERSION", "..Checking.."))
1388               .append(" is available for download from ")
1389               .append(Cache.getDefault("www.jalview.org",
1390                       "http://www.jalview.org"))
1391               .append(" !!");
1392       if (red)
1393       {
1394         message.append("</div>");
1395       }
1396     }
1397     message.append("<br>Authors:  ");
1398     message.append(Cache.getDefault("AUTHORFNAMES", DEFAULT_AUTHORS));
1399     message.append(CITATION);
1400
1401     return message.toString();
1402   }
1403
1404   /**
1405    * Action on requesting Help documentation
1406    */
1407   @Override
1408   public void documentationMenuItem_actionPerformed()
1409   {
1410     try
1411     {
1412       if (Platform.isJS())
1413       {
1414         BrowserLauncher.openURL("http://www.jalview.org/help.html");
1415       }
1416       else
1417       /**
1418        * Java only
1419        *
1420        * @j2sIgnore
1421        */
1422       {
1423         Help.showHelpWindow();
1424       }
1425     } catch (Exception ex)
1426     {
1427       System.err.println("Error opening help: " + ex.getMessage());
1428     }
1429   }
1430
1431   @Override
1432   public void closeAll_actionPerformed(ActionEvent e)
1433   {
1434     // TODO show a progress bar while closing?
1435     JInternalFrame[] frames = desktop.getAllFrames();
1436     for (int i = 0; i < frames.length; i++)
1437     {
1438       try
1439       {
1440         frames[i].setClosed(true);
1441       } catch (java.beans.PropertyVetoException ex)
1442       {
1443       }
1444     }
1445     Jalview.setCurrentAlignFrame(null);
1446     System.out.println("ALL CLOSED");
1447
1448     /*
1449      * reset state of singleton objects as appropriate (clear down session state
1450      * when all windows are closed)
1451      */
1452     StructureSelectionManager ssm = StructureSelectionManager
1453             .getStructureSelectionManager(this);
1454     if (ssm != null)
1455     {
1456       ssm.resetAll();
1457     }
1458   }
1459
1460   @Override
1461   public void raiseRelated_actionPerformed(ActionEvent e)
1462   {
1463     reorderAssociatedWindows(false, false);
1464   }
1465
1466   @Override
1467   public void minimizeAssociated_actionPerformed(ActionEvent e)
1468   {
1469     reorderAssociatedWindows(true, false);
1470   }
1471
1472   void closeAssociatedWindows()
1473   {
1474     reorderAssociatedWindows(false, true);
1475   }
1476
1477   /*
1478    * (non-Javadoc)
1479    *
1480    * @seejalview.jbgui.GDesktop#garbageCollect_actionPerformed(java.awt.event.
1481    * ActionEvent)
1482    */
1483   @Override
1484   protected void garbageCollect_actionPerformed(ActionEvent e)
1485   {
1486     // We simply collect the garbage
1487     Cache.log.debug("Collecting garbage...");
1488     System.gc();
1489     Cache.log.debug("Finished garbage collection.");
1490   }
1491
1492   /*
1493    * (non-Javadoc)
1494    *
1495    * @see
1496    * jalview.jbgui.GDesktop#showMemusage_actionPerformed(java.awt.event.ActionEvent
1497    * )
1498    */
1499   @Override
1500   protected void showMemusage_actionPerformed(ActionEvent e)
1501   {
1502     desktop.showMemoryUsage(showMemusage.isSelected());
1503   }
1504
1505   /*
1506    * (non-Javadoc)
1507    *
1508    * @see
1509    * jalview.jbgui.GDesktop#showConsole_actionPerformed(java.awt.event.ActionEvent
1510    * )
1511    */
1512   @Override
1513   protected void showConsole_actionPerformed(ActionEvent e)
1514   {
1515     showConsole(showConsole.isSelected());
1516   }
1517
1518   Console jconsole = null;
1519
1520   /**
1521    * control whether the java console is visible or not
1522    *
1523    * @param selected
1524    */
1525   void showConsole(boolean selected)
1526   {
1527     // TODO: decide if we should update properties file
1528     if (jconsole != null) // BH 2018
1529     {
1530       showConsole.setSelected(selected);
1531       Cache.setProperty("SHOW_JAVA_CONSOLE",
1532               Boolean.valueOf(selected).toString());
1533       jconsole.setVisible(selected);
1534     }
1535   }
1536
1537   void reorderAssociatedWindows(boolean minimize, boolean close)
1538   {
1539     JInternalFrame[] frames = desktop.getAllFrames();
1540     if (frames == null || frames.length < 1)
1541     {
1542       return;
1543     }
1544
1545     AlignmentViewport source = null, target = null;
1546     if (frames[0] instanceof AlignFrame)
1547     {
1548       source = ((AlignFrame) frames[0]).getCurrentView();
1549     }
1550     else if (frames[0] instanceof TreePanel)
1551     {
1552       source = ((TreePanel) frames[0]).getViewPort();
1553     }
1554     else if (frames[0] instanceof PCAPanel)
1555     {
1556       source = ((PCAPanel) frames[0]).av;
1557     }
1558     else if (frames[0].getContentPane() instanceof PairwiseAlignPanel)
1559     {
1560       source = ((PairwiseAlignPanel) frames[0].getContentPane()).av;
1561     }
1562
1563     if (source != null)
1564     {
1565       for (int i = 0; i < frames.length; i++)
1566       {
1567         target = null;
1568         if (frames[i] == null)
1569         {
1570           continue;
1571         }
1572         if (frames[i] instanceof AlignFrame)
1573         {
1574           target = ((AlignFrame) frames[i]).getCurrentView();
1575         }
1576         else if (frames[i] instanceof TreePanel)
1577         {
1578           target = ((TreePanel) frames[i]).getViewPort();
1579         }
1580         else if (frames[i] instanceof PCAPanel)
1581         {
1582           target = ((PCAPanel) frames[i]).av;
1583         }
1584         else if (frames[i].getContentPane() instanceof PairwiseAlignPanel)
1585         {
1586           target = ((PairwiseAlignPanel) frames[i].getContentPane()).av;
1587         }
1588
1589         if (source == target)
1590         {
1591           try
1592           {
1593             if (close)
1594             {
1595               frames[i].setClosed(true);
1596             }
1597             else
1598             {
1599               frames[i].setIcon(minimize);
1600               if (!minimize)
1601               {
1602                 frames[i].toFront();
1603               }
1604             }
1605
1606           } catch (java.beans.PropertyVetoException ex)
1607           {
1608           }
1609         }
1610       }
1611     }
1612   }
1613
1614   /**
1615    * DOCUMENT ME!
1616    *
1617    * @param e
1618    *          DOCUMENT ME!
1619    */
1620   @Override
1621   protected void preferences_actionPerformed(ActionEvent e)
1622   {
1623     Preferences.openPreferences();
1624   }
1625
1626   /**
1627    * Prompts the user to choose a file and then saves the Jalview state as a
1628    * Jalview project file
1629    */
1630   @Override
1631   public void saveState_actionPerformed()
1632   {
1633     saveState_actionPerformed(false);
1634   }
1635
1636   public void saveState_actionPerformed(boolean saveAs)
1637   {
1638     java.io.File projectFile = getProjectFile();
1639     // autoSave indicates we already have a file and don't need to ask
1640     boolean autoSave = projectFile != null && !saveAs
1641             && BackupFiles.getEnabled();
1642
1643     // System.out.println("autoSave="+autoSave+", projectFile='"+projectFile+"',
1644     // saveAs="+saveAs+", Backups
1645     // "+(BackupFiles.getEnabled()?"enabled":"disabled"));
1646
1647     boolean approveSave = false;
1648     if (!autoSave)
1649     {
1650       JalviewFileChooser chooser = new JalviewFileChooser("jvp",
1651               "Jalview Project");
1652
1653       chooser.setFileView(new JalviewFileView());
1654       chooser.setDialogTitle(MessageManager.getString("label.save_state"));
1655
1656       int value = chooser.showSaveDialog(this);
1657
1658       if (value == JalviewFileChooser.APPROVE_OPTION)
1659       {
1660         projectFile = chooser.getSelectedFile();
1661         setProjectFile(projectFile);
1662         approveSave = true;
1663       }
1664     }
1665
1666     if (approveSave || autoSave)
1667     {
1668       final Desktop me = this;
1669       final java.io.File chosenFile = projectFile;
1670       new Thread(new Runnable()
1671       {
1672         @Override
1673         public void run()
1674         {
1675           // TODO: refactor to Jalview desktop session controller action.
1676           setProgressBar(MessageManager.formatMessage(
1677                   "label.saving_jalview_project", new Object[]
1678                   { chosenFile.getName() }), chosenFile.hashCode());
1679           Cache.setProperty("LAST_DIRECTORY", chosenFile.getParent());
1680           // TODO catch and handle errors for savestate
1681           // TODO prevent user from messing with the Desktop whilst we're saving
1682           try
1683           {
1684             boolean doBackup = BackupFiles.getEnabled();
1685             BackupFiles backupfiles = doBackup ? new BackupFiles(chosenFile)
1686                     : null;
1687
1688             new Jalview2XML().saveState(
1689                     doBackup ? backupfiles.getTempFile() : chosenFile);
1690
1691             if (doBackup)
1692             {
1693               backupfiles.setWriteSuccess(true);
1694               backupfiles.rollBackupsAndRenameTempFile();
1695             }
1696           } catch (OutOfMemoryError oom)
1697           {
1698             new OOMWarning("Whilst saving current state to "
1699                     + chosenFile.getName(), oom);
1700           } catch (Exception ex)
1701           {
1702             Cache.log.error("Problems whilst trying to save to "
1703                     + chosenFile.getName(), ex);
1704             JvOptionPane.showMessageDialog(me,
1705                     MessageManager.formatMessage(
1706                             "label.error_whilst_saving_current_state_to",
1707                             new Object[]
1708                             { chosenFile.getName() }),
1709                     MessageManager.getString("label.couldnt_save_project"),
1710                     JvOptionPane.WARNING_MESSAGE);
1711           }
1712           setProgressBar(null, chosenFile.hashCode());
1713         }
1714       }).start();
1715     }
1716   }
1717
1718   @Override
1719   public void saveAsState_actionPerformed(ActionEvent e)
1720   {
1721     saveState_actionPerformed(true);
1722   }
1723
1724   private void setProjectFile(File choice)
1725   {
1726     this.projectFile = choice;
1727   }
1728
1729   public File getProjectFile()
1730   {
1731     return this.projectFile;
1732   }
1733
1734   /**
1735    * Shows a file chooser dialog and tries to read in the selected file as a
1736    * Jalview project
1737    */
1738   @Override
1739   public void loadState_actionPerformed()
1740   {
1741     final String[] suffix = new String[] { "jvp", "jar" };
1742     final String[] desc = new String[] { "Jalview Project",
1743         "Jalview Project (old)" };
1744     JalviewFileChooser chooser = new JalviewFileChooser(
1745             Cache.getProperty("LAST_DIRECTORY"), suffix, desc,
1746             "Jalview Project", true, BackupFiles.getEnabled()); // last two
1747                                                                 // booleans:
1748                                                                 // allFiles,
1749     // allowBackupFiles
1750     chooser.setFileView(new JalviewFileView());
1751     chooser.setDialogTitle(MessageManager.getString("label.restore_state"));
1752     chooser.setResponseHandler(0, new Runnable()
1753     {
1754       @Override
1755       public void run()
1756       {
1757         File selectedFile = chooser.getSelectedFile();
1758         setProjectFile(selectedFile);
1759         String choice = selectedFile.getAbsolutePath();
1760         Cache.setProperty("LAST_DIRECTORY", selectedFile.getParent());
1761         new Thread(new Runnable()
1762         {
1763           @Override
1764           public void run()
1765           {
1766             try
1767             {
1768               new Jalview2XML().loadJalviewAlign(selectedFile);
1769             } catch (OutOfMemoryError oom)
1770             {
1771               new OOMWarning("Whilst loading project from " + choice, oom);
1772             } catch (Exception ex)
1773             {
1774               Cache.log.error(
1775                       "Problems whilst loading project from " + choice, ex);
1776               JvOptionPane.showMessageDialog(Desktop.desktop,
1777                       MessageManager.formatMessage(
1778                               "label.error_whilst_loading_project_from",
1779                               new Object[]
1780                               { choice }),
1781                       MessageManager
1782                               .getString("label.couldnt_load_project"),
1783                       JvOptionPane.WARNING_MESSAGE);
1784             }
1785           }
1786         }, "Project Loader").start();
1787       }
1788     });
1789
1790     chooser.showOpenDialog(this);
1791   }
1792
1793   @Override
1794   public void inputSequence_actionPerformed(ActionEvent e)
1795   {
1796     new SequenceFetcher(this);
1797   }
1798
1799   JPanel progressPanel;
1800
1801   ArrayList<JPanel> fileLoadingPanels = new ArrayList<>();
1802
1803   public void startLoading(final Object fileName)
1804   {
1805     if (fileLoadingCount == 0)
1806     {
1807       fileLoadingPanels.add(addProgressPanel(MessageManager
1808               .formatMessage("label.loading_file", new Object[]
1809               { fileName })));
1810     }
1811     fileLoadingCount++;
1812   }
1813
1814   private JPanel addProgressPanel(String string)
1815   {
1816     if (progressPanel == null)
1817     {
1818       progressPanel = new JPanel(new GridLayout(1, 1));
1819       totalProgressCount = 0;
1820       instance.getContentPane().add(progressPanel, BorderLayout.SOUTH);
1821     }
1822     JPanel thisprogress = new JPanel(new BorderLayout(10, 5));
1823     JProgressBar progressBar = new JProgressBar();
1824     progressBar.setIndeterminate(true);
1825
1826     thisprogress.add(new JLabel(string), BorderLayout.WEST);
1827
1828     thisprogress.add(progressBar, BorderLayout.CENTER);
1829     progressPanel.add(thisprogress);
1830     ((GridLayout) progressPanel.getLayout()).setRows(
1831             ((GridLayout) progressPanel.getLayout()).getRows() + 1);
1832     ++totalProgressCount;
1833     instance.validate();
1834     return thisprogress;
1835   }
1836
1837   int totalProgressCount = 0;
1838
1839   private void removeProgressPanel(JPanel progbar)
1840   {
1841     if (progressPanel != null)
1842     {
1843       synchronized (progressPanel)
1844       {
1845         progressPanel.remove(progbar);
1846         GridLayout gl = (GridLayout) progressPanel.getLayout();
1847         gl.setRows(gl.getRows() - 1);
1848         if (--totalProgressCount < 1)
1849         {
1850           this.getContentPane().remove(progressPanel);
1851           progressPanel = null;
1852         }
1853       }
1854     }
1855     validate();
1856   }
1857
1858   public void stopLoading()
1859   {
1860     fileLoadingCount--;
1861     if (fileLoadingCount < 1)
1862     {
1863       while (fileLoadingPanels.size() > 0)
1864       {
1865         removeProgressPanel(fileLoadingPanels.remove(0));
1866       }
1867       fileLoadingPanels.clear();
1868       fileLoadingCount = 0;
1869     }
1870     validate();
1871   }
1872
1873   public static int getViewCount(String alignmentId)
1874   {
1875     AlignmentViewport[] aps = getViewports(alignmentId);
1876     return (aps == null) ? 0 : aps.length;
1877   }
1878
1879   /**
1880    *
1881    * @param alignmentId
1882    *          - if null, all sets are returned
1883    * @return all AlignmentPanels concerning the alignmentId sequence set
1884    */
1885   public static AlignmentPanel[] getAlignmentPanels(String alignmentId)
1886   {
1887     if (Desktop.desktop == null)
1888     {
1889       // no frames created and in headless mode
1890       // TODO: verify that frames are recoverable when in headless mode
1891       return null;
1892     }
1893     List<AlignmentPanel> aps = new ArrayList<>();
1894     AlignFrame[] frames = getAlignFrames();
1895     if (frames == null)
1896     {
1897       return null;
1898     }
1899     for (AlignFrame af : frames)
1900     {
1901       for (AlignmentPanel ap : af.alignPanels)
1902       {
1903         if (alignmentId == null
1904                 || alignmentId.equals(ap.av.getSequenceSetId()))
1905         {
1906           aps.add(ap);
1907         }
1908       }
1909     }
1910     if (aps.size() == 0)
1911     {
1912       return null;
1913     }
1914     AlignmentPanel[] vap = aps.toArray(new AlignmentPanel[aps.size()]);
1915     return vap;
1916   }
1917
1918   /**
1919    * get all the viewports on an alignment.
1920    *
1921    * @param sequenceSetId
1922    *          unique alignment id (may be null - all viewports returned in that
1923    *          case)
1924    * @return all viewports on the alignment bound to sequenceSetId
1925    */
1926   public static AlignmentViewport[] getViewports(String sequenceSetId)
1927   {
1928     List<AlignmentViewport> viewp = new ArrayList<>();
1929     if (desktop != null)
1930     {
1931       AlignFrame[] frames = Desktop.getAlignFrames();
1932
1933       for (AlignFrame afr : frames)
1934       {
1935         if (sequenceSetId == null || afr.getViewport().getSequenceSetId()
1936                 .equals(sequenceSetId))
1937         {
1938           if (afr.alignPanels != null)
1939           {
1940             for (AlignmentPanel ap : afr.alignPanels)
1941             {
1942               if (sequenceSetId == null
1943                       || sequenceSetId.equals(ap.av.getSequenceSetId()))
1944               {
1945                 viewp.add(ap.av);
1946               }
1947             }
1948           }
1949           else
1950           {
1951             viewp.add(afr.getViewport());
1952           }
1953         }
1954       }
1955       if (viewp.size() > 0)
1956       {
1957         return viewp.toArray(new AlignmentViewport[viewp.size()]);
1958       }
1959     }
1960     return null;
1961   }
1962
1963   /**
1964    * Explode the views in the given frame into separate AlignFrame
1965    *
1966    * @param af
1967    */
1968   public static void explodeViews(AlignFrame af)
1969   {
1970     int size = af.alignPanels.size();
1971     if (size < 2)
1972     {
1973       return;
1974     }
1975
1976     // FIXME: ideally should use UI interface API
1977     FeatureSettings viewFeatureSettings = (af.featureSettings != null
1978             && af.featureSettings.isOpen()) ? af.featureSettings : null;
1979     Rectangle fsBounds = af.getFeatureSettingsGeometry();
1980     for (int i = 0; i < size; i++)
1981     {
1982       AlignmentPanel ap = af.alignPanels.get(i);
1983
1984       AlignFrame newaf = new AlignFrame(ap);
1985
1986       // transfer reference for existing feature settings to new alignFrame
1987       if (ap == af.alignPanel)
1988       {
1989         if (viewFeatureSettings != null && viewFeatureSettings.fr.ap == ap)
1990         {
1991           newaf.featureSettings = viewFeatureSettings;
1992         }
1993         newaf.setFeatureSettingsGeometry(fsBounds);
1994       }
1995
1996       /*
1997        * Restore the view's last exploded frame geometry if known. Multiple
1998        * views from one exploded frame share and restore the same (frame)
1999        * position and size.
2000        */
2001       Rectangle geometry = ap.av.getExplodedGeometry();
2002       if (geometry != null)
2003       {
2004         newaf.setBounds(geometry);
2005       }
2006
2007       ap.av.setGatherViewsHere(false);
2008
2009       addInternalFrame(newaf, af.getTitle(), AlignFrame.DEFAULT_WIDTH,
2010               AlignFrame.DEFAULT_HEIGHT);
2011       // and materialise a new feature settings dialog instance for the new
2012       // alignframe
2013       // (closes the old as if 'OK' was pressed)
2014       if (ap == af.alignPanel && newaf.featureSettings != null
2015               && newaf.featureSettings.isOpen()
2016               && af.alignPanel.getAlignViewport().isShowSequenceFeatures())
2017       {
2018         newaf.showFeatureSettingsUI();
2019       }
2020     }
2021
2022     af.featureSettings = null;
2023     af.alignPanels.clear();
2024     af.closeMenuItem_actionPerformed(true);
2025
2026   }
2027
2028   /**
2029    * Gather expanded views (separate AlignFrame's) with the same sequence set
2030    * identifier back in to this frame as additional views, and close the
2031    * expanded views. Note the expanded frames may themselves have multiple
2032    * views. We take the lot.
2033    *
2034    * @param source
2035    */
2036   public void gatherViews(AlignFrame source)
2037   {
2038     source.viewport.setGatherViewsHere(true);
2039     source.viewport.setExplodedGeometry(source.getBounds());
2040     JInternalFrame[] frames = desktop.getAllFrames();
2041     String viewId = source.viewport.getSequenceSetId();
2042     for (int t = 0; t < frames.length; t++)
2043     {
2044       if (frames[t] instanceof AlignFrame && frames[t] != source)
2045       {
2046         AlignFrame af = (AlignFrame) frames[t];
2047         boolean gatherThis = false;
2048         for (int a = 0; a < af.alignPanels.size(); a++)
2049         {
2050           AlignmentPanel ap = af.alignPanels.get(a);
2051           if (viewId.equals(ap.av.getSequenceSetId()))
2052           {
2053             gatherThis = true;
2054             ap.av.setGatherViewsHere(false);
2055             ap.av.setExplodedGeometry(af.getBounds());
2056             source.addAlignmentPanel(ap, false);
2057           }
2058         }
2059
2060         if (gatherThis)
2061         {
2062           if (af.featureSettings != null && af.featureSettings.isOpen())
2063           {
2064             if (source.featureSettings == null)
2065             {
2066               // preserve the feature settings geometry for this frame
2067               source.featureSettings = af.featureSettings;
2068               source.setFeatureSettingsGeometry(
2069                       af.getFeatureSettingsGeometry());
2070             }
2071             else
2072             {
2073               // close it and forget
2074               af.featureSettings.close();
2075             }
2076           }
2077           af.alignPanels.clear();
2078           af.closeMenuItem_actionPerformed(true);
2079         }
2080       }
2081     }
2082
2083     // refresh the feature setting UI for the source frame if it exists
2084     if (source.featureSettings != null && source.featureSettings.isOpen())
2085     {
2086       source.showFeatureSettingsUI();
2087     }
2088   }
2089
2090   public JInternalFrame[] getAllFrames()
2091   {
2092     return desktop.getAllFrames();
2093   }
2094
2095   /**
2096    * Checks the given url to see if it gives a response indicating that the user
2097    * should be informed of a new questionnaire.
2098    *
2099    * @param url
2100    */
2101   public void checkForQuestionnaire(String url)
2102   {
2103     UserQuestionnaireCheck jvq = new UserQuestionnaireCheck(url);
2104     // javax.swing.SwingUtilities.invokeLater(jvq);
2105     new Thread(jvq).start();
2106   }
2107
2108   public void checkURLLinks()
2109   {
2110     // Thread off the URL link checker
2111     addDialogThread(new Runnable()
2112     {
2113       @Override
2114       public void run()
2115       {
2116         if (Cache.getDefault("CHECKURLLINKS", true))
2117         {
2118           // check what the actual links are - if it's just the default don't
2119           // bother with the warning
2120           List<String> links = Preferences.sequenceUrlLinks
2121                   .getLinksForMenu();
2122
2123           // only need to check links if there is one with a
2124           // SEQUENCE_ID which is not the default EMBL_EBI link
2125           ListIterator<String> li = links.listIterator();
2126           boolean check = false;
2127           List<JLabel> urls = new ArrayList<>();
2128           while (li.hasNext())
2129           {
2130             String link = li.next();
2131             if (link.contains(jalview.util.UrlConstants.SEQUENCE_ID)
2132                     && !UrlConstants.isDefaultString(link))
2133             {
2134               check = true;
2135               int barPos = link.indexOf("|");
2136               String urlMsg = barPos == -1 ? link
2137                       : link.substring(0, barPos) + ": "
2138                               + link.substring(barPos + 1);
2139               urls.add(new JLabel(urlMsg));
2140             }
2141           }
2142           if (!check)
2143           {
2144             return;
2145           }
2146
2147           // ask user to check in case URL links use old style tokens
2148           // ($SEQUENCE_ID$ for sequence id _or_ accession id)
2149           JPanel msgPanel = new JPanel();
2150           msgPanel.setLayout(new BoxLayout(msgPanel, BoxLayout.PAGE_AXIS));
2151           msgPanel.add(Box.createVerticalGlue());
2152           JLabel msg = new JLabel(MessageManager
2153                   .getString("label.SEQUENCE_ID_for_DB_ACCESSION1"));
2154           JLabel msg2 = new JLabel(MessageManager
2155                   .getString("label.SEQUENCE_ID_for_DB_ACCESSION2"));
2156           msgPanel.add(msg);
2157           for (JLabel url : urls)
2158           {
2159             msgPanel.add(url);
2160           }
2161           msgPanel.add(msg2);
2162
2163           final JCheckBox jcb = new JCheckBox(
2164                   MessageManager.getString("label.do_not_display_again"));
2165           jcb.addActionListener(new ActionListener()
2166           {
2167             @Override
2168             public void actionPerformed(ActionEvent e)
2169             {
2170               // update Cache settings for "don't show this again"
2171               boolean showWarningAgain = !jcb.isSelected();
2172               Cache.setProperty("CHECKURLLINKS",
2173                       Boolean.valueOf(showWarningAgain).toString());
2174             }
2175           });
2176           msgPanel.add(jcb);
2177
2178           JvOptionPane.showMessageDialog(Desktop.desktop, msgPanel,
2179                   MessageManager
2180                           .getString("label.SEQUENCE_ID_no_longer_used"),
2181                   JvOptionPane.WARNING_MESSAGE);
2182         }
2183       }
2184     });
2185   }
2186
2187   /**
2188    * Proxy class for JDesktopPane which optionally displays the current memory
2189    * usage and highlights the desktop area with a red bar if free memory runs
2190    * low.
2191    *
2192    * @author AMW
2193    */
2194   public class MyDesktopPane extends JDesktopPane implements Runnable
2195   {
2196     private static final float ONE_MB = 1048576f;
2197
2198     boolean showMemoryUsage = false;
2199
2200     Runtime runtime;
2201
2202     java.text.NumberFormat df;
2203
2204     float maxMemory, allocatedMemory, freeMemory, totalFreeMemory,
2205             percentUsage;
2206
2207     public MyDesktopPane(boolean showMemoryUsage)
2208     {
2209       showMemoryUsage(showMemoryUsage);
2210     }
2211
2212     public void showMemoryUsage(boolean showMemory)
2213     {
2214       this.showMemoryUsage = showMemory;
2215       if (showMemory)
2216       {
2217         Thread worker = new Thread(this);
2218         worker.start();
2219       }
2220       repaint();
2221     }
2222
2223     public boolean isShowMemoryUsage()
2224     {
2225       return showMemoryUsage;
2226     }
2227
2228     @Override
2229     public void run()
2230     {
2231       df = java.text.NumberFormat.getNumberInstance();
2232       df.setMaximumFractionDigits(2);
2233       runtime = Runtime.getRuntime();
2234
2235       while (showMemoryUsage)
2236       {
2237         try
2238         {
2239           maxMemory = runtime.maxMemory() / ONE_MB;
2240           allocatedMemory = runtime.totalMemory() / ONE_MB;
2241           freeMemory = runtime.freeMemory() / ONE_MB;
2242           totalFreeMemory = freeMemory + (maxMemory - allocatedMemory);
2243
2244           percentUsage = (totalFreeMemory / maxMemory) * 100;
2245
2246           // if (percentUsage < 20)
2247           {
2248             // border1 = BorderFactory.createMatteBorder(12, 12, 12, 12,
2249             // Color.red);
2250             // instance.set.setBorder(border1);
2251           }
2252           repaint();
2253           // sleep after showing usage
2254           Thread.sleep(3000);
2255         } catch (Exception ex)
2256         {
2257           ex.printStackTrace();
2258         }
2259       }
2260     }
2261
2262     @Override
2263     public void paintComponent(Graphics g)
2264     {
2265       if (showMemoryUsage && g != null && df != null)
2266       {
2267         if (percentUsage < 20)
2268         {
2269           g.setColor(Color.red);
2270         }
2271         FontMetrics fm = g.getFontMetrics();
2272         if (fm != null)
2273         {
2274           g.drawString(MessageManager.formatMessage("label.memory_stats",
2275                   new Object[]
2276                   { df.format(totalFreeMemory), df.format(maxMemory),
2277                       df.format(percentUsage) }),
2278                   10, getHeight() - fm.getHeight());
2279         }
2280       }
2281     }
2282   }
2283
2284   /**
2285    * Accessor method to quickly get all the AlignmentFrames loaded.
2286    *
2287    * @return an array of AlignFrame, or null if none found
2288    */
2289   public static AlignFrame[] getAlignFrames()
2290   {
2291     if (Jalview.isHeadlessMode())
2292     {
2293       // Desktop.desktop is null in headless mode
2294       return new AlignFrame[] { Jalview.currentAlignFrame };
2295     }
2296
2297     JInternalFrame[] frames = Desktop.desktop.getAllFrames();
2298
2299     if (frames == null)
2300     {
2301       return null;
2302     }
2303     List<AlignFrame> avp = new ArrayList<>();
2304     // REVERSE ORDER
2305     for (int i = frames.length - 1; i > -1; i--)
2306     {
2307       if (frames[i] instanceof AlignFrame)
2308       {
2309         avp.add((AlignFrame) frames[i]);
2310       }
2311       else if (frames[i] instanceof SplitFrame)
2312       {
2313         /*
2314          * Also check for a split frame containing an AlignFrame
2315          */
2316         GSplitFrame sf = (GSplitFrame) frames[i];
2317         if (sf.getTopFrame() instanceof AlignFrame)
2318         {
2319           avp.add((AlignFrame) sf.getTopFrame());
2320         }
2321         if (sf.getBottomFrame() instanceof AlignFrame)
2322         {
2323           avp.add((AlignFrame) sf.getBottomFrame());
2324         }
2325       }
2326     }
2327     if (avp.size() == 0)
2328     {
2329       return null;
2330     }
2331     AlignFrame afs[] = avp.toArray(new AlignFrame[avp.size()]);
2332     return afs;
2333   }
2334
2335   /**
2336    * Returns an array of any AppJmol frames in the Desktop (or null if none).
2337    *
2338    * @return
2339    */
2340   public GStructureViewer[] getJmols()
2341   {
2342     JInternalFrame[] frames = Desktop.desktop.getAllFrames();
2343
2344     if (frames == null)
2345     {
2346       return null;
2347     }
2348     List<GStructureViewer> avp = new ArrayList<>();
2349     // REVERSE ORDER
2350     for (int i = frames.length - 1; i > -1; i--)
2351     {
2352       if (frames[i] instanceof AppJmol)
2353       {
2354         GStructureViewer af = (GStructureViewer) frames[i];
2355         avp.add(af);
2356       }
2357     }
2358     if (avp.size() == 0)
2359     {
2360       return null;
2361     }
2362     GStructureViewer afs[] = avp.toArray(new GStructureViewer[avp.size()]);
2363     return afs;
2364   }
2365
2366   /**
2367    * Add Groovy Support to Jalview
2368    */
2369   @Override
2370   public void groovyShell_actionPerformed()
2371   {
2372     try
2373     {
2374       openGroovyConsole();
2375     } catch (Exception ex)
2376     {
2377       Cache.log.error("Groovy Shell Creation failed.", ex);
2378       JvOptionPane.showInternalMessageDialog(Desktop.desktop,
2379
2380               MessageManager.getString("label.couldnt_create_groovy_shell"),
2381               MessageManager.getString("label.groovy_support_failed"),
2382               JvOptionPane.ERROR_MESSAGE);
2383     }
2384   }
2385
2386   /**
2387    * Open the Groovy console
2388    */
2389   void openGroovyConsole()
2390   {
2391     if (groovyConsole == null)
2392     {
2393       groovyConsole = new groovy.ui.Console();
2394       groovyConsole.setVariable("Jalview", this);
2395       groovyConsole.run();
2396
2397       /*
2398        * We allow only one console at a time, so that AlignFrame menu option
2399        * 'Calculate | Run Groovy script' is unambiguous.
2400        * Disable 'Groovy Console', and enable 'Run script', when the console is
2401        * opened, and the reverse when it is closed
2402        */
2403       Window window = (Window) groovyConsole.getFrame();
2404       window.addWindowListener(new WindowAdapter()
2405       {
2406         @Override
2407         public void windowClosed(WindowEvent e)
2408         {
2409           /*
2410            * rebind CMD-Q from Groovy Console to Jalview Quit
2411            */
2412           addQuitHandler();
2413           enableExecuteGroovy(false);
2414         }
2415       });
2416     }
2417
2418     /*
2419      * show Groovy console window (after close and reopen)
2420      */
2421     ((Window) groovyConsole.getFrame()).setVisible(true);
2422
2423     /*
2424      * if we got this far, enable 'Run Groovy' in AlignFrame menus
2425      * and disable opening a second console
2426      */
2427     enableExecuteGroovy(true);
2428   }
2429
2430   /**
2431    * Bind Ctrl/Cmd-Q to Quit - for reset as Groovy Console takes over this
2432    * binding when opened
2433    */
2434   protected void addQuitHandler()
2435   {
2436     getRootPane()
2437             .getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(
2438                     KeyStroke
2439                             .getKeyStroke(KeyEvent.VK_Q,
2440                                     jalview.util.ShortcutKeyMaskExWrapper
2441                                             .getMenuShortcutKeyMaskEx()),
2442                     "Quit");
2443     getRootPane().getActionMap().put("Quit", new AbstractAction()
2444     {
2445       @Override
2446       public void actionPerformed(ActionEvent e)
2447       {
2448         quit();
2449       }
2450     });
2451   }
2452
2453   /**
2454    * Enable or disable 'Run Groovy script' in AlignFrame calculate menus
2455    *
2456    * @param enabled
2457    *          true if Groovy console is open
2458    */
2459   public void enableExecuteGroovy(boolean enabled)
2460   {
2461     /*
2462      * disable opening a second Groovy console
2463      * (or re-enable when the console is closed)
2464      */
2465     groovyShell.setEnabled(!enabled);
2466
2467     AlignFrame[] alignFrames = getAlignFrames();
2468     if (alignFrames != null)
2469     {
2470       for (AlignFrame af : alignFrames)
2471       {
2472         af.setGroovyEnabled(enabled);
2473       }
2474     }
2475   }
2476
2477   /**
2478    * Progress bars managed by the IProgressIndicator method.
2479    */
2480   private Hashtable<Long, JPanel> progressBars;
2481
2482   private Hashtable<Long, IProgressIndicatorHandler> progressBarHandlers;
2483
2484   /*
2485    * (non-Javadoc)
2486    *
2487    * @see jalview.gui.IProgressIndicator#setProgressBar(java.lang.String, long)
2488    */
2489   @Override
2490   public void setProgressBar(String message, long id)
2491   {
2492     // Platform.timeCheck("Desktop " + message, Platform.TIME_MARK);
2493
2494     if (progressBars == null)
2495     {
2496       progressBars = new Hashtable<>();
2497       progressBarHandlers = new Hashtable<>();
2498     }
2499
2500     if (progressBars.get(Long.valueOf(id)) != null)
2501     {
2502       JPanel panel = progressBars.remove(Long.valueOf(id));
2503       if (progressBarHandlers.contains(Long.valueOf(id)))
2504       {
2505         progressBarHandlers.remove(Long.valueOf(id));
2506       }
2507       removeProgressPanel(panel);
2508     }
2509     else
2510     {
2511       progressBars.put(Long.valueOf(id), addProgressPanel(message));
2512     }
2513   }
2514
2515   /*
2516    * (non-Javadoc)
2517    *
2518    * @see jalview.gui.IProgressIndicator#registerHandler(long,
2519    * jalview.gui.IProgressIndicatorHandler)
2520    */
2521   @Override
2522   public void registerHandler(final long id,
2523           final IProgressIndicatorHandler handler)
2524   {
2525     if (progressBarHandlers == null
2526             || !progressBars.containsKey(Long.valueOf(id)))
2527     {
2528       throw new Error(MessageManager.getString(
2529               "error.call_setprogressbar_before_registering_handler"));
2530     }
2531     progressBarHandlers.put(Long.valueOf(id), handler);
2532     final JPanel progressPanel = progressBars.get(Long.valueOf(id));
2533     if (handler.canCancel())
2534     {
2535       JButton cancel = new JButton(
2536               MessageManager.getString("action.cancel"));
2537       final IProgressIndicator us = this;
2538       cancel.addActionListener(new ActionListener()
2539       {
2540
2541         @Override
2542         public void actionPerformed(ActionEvent e)
2543         {
2544           handler.cancelActivity(id);
2545           us.setProgressBar(MessageManager
2546                   .formatMessage("label.cancelled_params", new Object[]
2547                   { ((JLabel) progressPanel.getComponent(0)).getText() }),
2548                   id);
2549         }
2550       });
2551       progressPanel.add(cancel, BorderLayout.EAST);
2552     }
2553   }
2554
2555   /**
2556    *
2557    * @return true if any progress bars are still active
2558    */
2559   @Override
2560   public boolean operationInProgress()
2561   {
2562     if (progressBars != null && progressBars.size() > 0)
2563     {
2564       return true;
2565     }
2566     return false;
2567   }
2568
2569   /**
2570    * This will return the first AlignFrame holding the given viewport instance.
2571    * It will break if there are more than one AlignFrames viewing a particular
2572    * av.
2573    *
2574    * @param viewport
2575    * @return alignFrame for viewport
2576    */
2577   public static AlignFrame getAlignFrameFor(AlignViewportI viewport)
2578   {
2579     if (desktop != null)
2580     {
2581       AlignmentPanel[] aps = getAlignmentPanels(
2582               viewport.getSequenceSetId());
2583       for (int panel = 0; aps != null && panel < aps.length; panel++)
2584       {
2585         if (aps[panel] != null && aps[panel].av == viewport)
2586         {
2587           return aps[panel].alignFrame;
2588         }
2589       }
2590     }
2591     return null;
2592   }
2593
2594   public VamsasApplication getVamsasApplication()
2595   {
2596     // TODO: JAL-3311 remove remaining code from Jalview relating to VAMSAS
2597     return null;
2598
2599   }
2600
2601   /**
2602    * flag set if jalview GUI is being operated programmatically
2603    */
2604   private boolean inBatchMode = false;
2605
2606   /**
2607    * check if jalview GUI is being operated programmatically
2608    *
2609    * @return inBatchMode
2610    */
2611   public boolean isInBatchMode()
2612   {
2613     return inBatchMode;
2614   }
2615
2616   /**
2617    * set flag if jalview GUI is being operated programmatically
2618    *
2619    * @param inBatchMode
2620    */
2621   public void setInBatchMode(boolean inBatchMode)
2622   {
2623     this.inBatchMode = inBatchMode;
2624   }
2625
2626   public void startServiceDiscovery()
2627   {
2628     startServiceDiscovery(false);
2629   }
2630
2631   public void startServiceDiscovery(boolean blocking)
2632   {
2633     boolean alive = true;
2634     Thread t0 = null, t1 = null, t2 = null;
2635     // JAL-940 - JALVIEW 1 services are now being EOLed as of JABA 2.1 release
2636     if (true)
2637     {
2638       // todo: changesupport handlers need to be transferred
2639       if (discoverer == null)
2640       {
2641         discoverer = new jalview.ws.jws1.Discoverer();
2642         // register PCS handler for desktop.
2643         discoverer.addPropertyChangeListener(changeSupport);
2644       }
2645       // JAL-940 - disabled JWS1 service configuration - always start discoverer
2646       // until we phase out completely
2647       (t0 = new Thread(discoverer)).start();
2648     }
2649
2650     if (Cache.getDefault("SHOW_JWS2_SERVICES", true))
2651     {
2652       t2 = jalview.ws.jws2.Jws2Discoverer.getDiscoverer()
2653               .startDiscoverer(changeSupport);
2654     }
2655     Thread t3 = null;
2656     {
2657       // TODO: do rest service discovery
2658     }
2659     if (blocking)
2660     {
2661       while (alive)
2662       {
2663         try
2664         {
2665           Thread.sleep(15);
2666         } catch (Exception e)
2667         {
2668         }
2669         alive = (t1 != null && t1.isAlive()) || (t2 != null && t2.isAlive())
2670                 || (t3 != null && t3.isAlive())
2671                 || (t0 != null && t0.isAlive());
2672       }
2673     }
2674   }
2675
2676   /**
2677    * called to check if the service discovery process completed successfully.
2678    *
2679    * @param evt
2680    */
2681   protected void JalviewServicesChanged(PropertyChangeEvent evt)
2682   {
2683     if (evt.getNewValue() == null || evt.getNewValue() instanceof Vector)
2684     {
2685       final String ermsg = jalview.ws.jws2.Jws2Discoverer.getDiscoverer()
2686               .getErrorMessages();
2687       if (ermsg != null)
2688       {
2689         if (Cache.getDefault("SHOW_WSDISCOVERY_ERRORS", true))
2690         {
2691           if (serviceChangedDialog == null)
2692           {
2693             // only run if we aren't already displaying one of these.
2694             addDialogThread(serviceChangedDialog = new Runnable()
2695             {
2696               @Override
2697               public void run()
2698               {
2699
2700                 /*
2701                  * JalviewDialog jd =new JalviewDialog() {
2702                  *
2703                  * @Override protected void cancelPressed() { // TODO
2704                  * Auto-generated method stub
2705                  *
2706                  * }@Override protected void okPressed() { // TODO
2707                  * Auto-generated method stub
2708                  *
2709                  * }@Override protected void raiseClosed() { // TODO
2710                  * Auto-generated method stub
2711                  *
2712                  * } }; jd.initDialogFrame(new
2713                  * JLabel("<html><table width=\"450\"><tr><td>" + ermsg +
2714                  * "<br/>It may be that you have invalid JABA URLs in your web service preferences,"
2715                  * + " or mis-configured HTTP proxy settings.<br/>" +
2716                  * "Check the <em>Connections</em> and <em>Web services</em> tab of the"
2717                  * +
2718                  * " Tools->Preferences dialog box to change them.</td></tr></table></html>"
2719                  * ), true, true, "Web Service Configuration Problem", 450,
2720                  * 400);
2721                  *
2722                  * jd.waitForInput();
2723                  */
2724                 JvOptionPane.showConfirmDialog(Desktop.desktop,
2725                         new JLabel("<html><table width=\"450\"><tr><td>"
2726                                 + ermsg + "</td></tr></table>"
2727                                 + "<p>It may be that you have invalid JABA URLs<br/>in your web service preferences,"
2728                                 + "<br>or as a command-line argument, or mis-configured HTTP proxy settings.</p>"
2729                                 + "<p>Check the <em>Connections</em> and <em>Web services</em> tab<br/>of the"
2730                                 + " Tools->Preferences dialog box to change them.</p></html>"),
2731                         "Web Service Configuration Problem",
2732                         JvOptionPane.DEFAULT_OPTION,
2733                         JvOptionPane.ERROR_MESSAGE);
2734                 serviceChangedDialog = null;
2735
2736               }
2737             });
2738           }
2739         }
2740         else
2741         {
2742           Cache.log.error(
2743                   "Errors reported by JABA discovery service. Check web services preferences.\n"
2744                           + ermsg);
2745         }
2746       }
2747     }
2748   }
2749
2750   private Runnable serviceChangedDialog = null;
2751
2752   /**
2753    * start a thread to open a URL in the configured browser. Pops up a warning
2754    * dialog to the user if there is an exception when calling out to the browser
2755    * to open the URL.
2756    *
2757    * @param url
2758    */
2759   public static void showUrl(final String url)
2760   {
2761     showUrl(url, Desktop.instance);
2762   }
2763
2764   /**
2765    * Like showUrl but allows progress handler to be specified
2766    *
2767    * @param url
2768    * @param progress
2769    *          (null) or object implementing IProgressIndicator
2770    */
2771   public static void showUrl(final String url,
2772           final IProgressIndicator progress)
2773   {
2774     new Thread(new Runnable()
2775     {
2776       @Override
2777       public void run()
2778       {
2779         try
2780         {
2781           if (progress != null)
2782           {
2783             progress.setProgressBar(MessageManager
2784                     .formatMessage("status.opening_params", new Object[]
2785                     { url }), this.hashCode());
2786           }
2787           jalview.util.BrowserLauncher.openURL(url);
2788         } catch (Exception ex)
2789         {
2790           JvOptionPane.showInternalMessageDialog(Desktop.desktop,
2791                   MessageManager
2792                           .getString("label.web_browser_not_found_unix"),
2793                   MessageManager.getString("label.web_browser_not_found"),
2794                   JvOptionPane.WARNING_MESSAGE);
2795
2796           ex.printStackTrace();
2797         }
2798         if (progress != null)
2799         {
2800           progress.setProgressBar(null, this.hashCode());
2801         }
2802       }
2803     }).start();
2804   }
2805
2806   public static WsParamSetManager wsparamManager = null;
2807
2808   public static ParamManager getUserParameterStore()
2809   {
2810     if (wsparamManager == null)
2811     {
2812       wsparamManager = new WsParamSetManager();
2813     }
2814     return wsparamManager;
2815   }
2816
2817   /**
2818    * static hyperlink handler proxy method for use by Jalview's internal windows
2819    *
2820    * @param e
2821    */
2822   public static void hyperlinkUpdate(HyperlinkEvent e)
2823   {
2824     if (e.getEventType() == EventType.ACTIVATED)
2825     {
2826       String url = null;
2827       try
2828       {
2829         url = e.getURL().toString();
2830         Desktop.showUrl(url);
2831       } catch (Exception x)
2832       {
2833         if (url != null)
2834         {
2835           if (Cache.log != null)
2836           {
2837             Cache.log.error("Couldn't handle string " + url + " as a URL.");
2838           }
2839           else
2840           {
2841             System.err.println(
2842                     "Couldn't handle string " + url + " as a URL.");
2843           }
2844         }
2845         // ignore any exceptions due to dud links.
2846       }
2847
2848     }
2849   }
2850
2851   /**
2852    * single thread that handles display of dialogs to user.
2853    */
2854   ExecutorService dialogExecutor = Executors.newSingleThreadExecutor();
2855
2856   /**
2857    * flag indicating if dialogExecutor should try to acquire a permit
2858    */
2859   private volatile boolean dialogPause = true;
2860
2861   /**
2862    * pause the queue
2863    */
2864   private java.util.concurrent.Semaphore block = new Semaphore(0);
2865
2866   private static groovy.ui.Console groovyConsole;
2867
2868   /**
2869    * add another dialog thread to the queue
2870    *
2871    * @param prompter
2872    */
2873   public void addDialogThread(final Runnable prompter)
2874   {
2875     dialogExecutor.submit(new Runnable()
2876     {
2877       @Override
2878       public void run()
2879       {
2880         if (dialogPause)
2881         {
2882           try
2883           {
2884             block.acquire();
2885           } catch (InterruptedException x)
2886           {
2887           }
2888         }
2889         if (instance == null)
2890         {
2891           return;
2892         }
2893         try
2894         {
2895           SwingUtilities.invokeAndWait(prompter);
2896         } catch (Exception q)
2897         {
2898           Cache.log.warn("Unexpected Exception in dialog thread.", q);
2899         }
2900       }
2901     });
2902   }
2903
2904   public void startDialogQueue()
2905   {
2906     // set the flag so we don't pause waiting for another permit and semaphore
2907     // the current task to begin
2908     dialogPause = false;
2909     block.release();
2910   }
2911
2912   /**
2913    * Outputs an image of the desktop to file in EPS format, after prompting the
2914    * user for choice of Text or Lineart character rendering (unless a preference
2915    * has been set). The file name is generated as
2916    *
2917    * <pre>
2918    * Jalview_snapshot_nnnnn.eps where nnnnn is the current timestamp in milliseconds
2919    * </pre>
2920    */
2921   @Override
2922   protected void snapShotWindow_actionPerformed(ActionEvent e)
2923   {
2924     // currently the menu option to do this is not shown
2925     invalidate();
2926
2927     int width = getWidth();
2928     int height = getHeight();
2929     File of = new File(
2930             "Jalview_snapshot_" + System.currentTimeMillis() + ".eps");
2931     ImageWriterI writer = new ImageWriterI()
2932     {
2933       @Override
2934       public void exportImage(Graphics g) throws Exception
2935       {
2936         paintAll(g);
2937         Cache.log.info("Successfully written snapshot to file "
2938                 + of.getAbsolutePath());
2939       }
2940     };
2941     String title = "View of desktop";
2942     ImageExporter exporter = new ImageExporter(writer, null, TYPE.EPS,
2943             title);
2944     exporter.doExport(of, this, width, height, title);
2945   }
2946
2947   /**
2948    * Explode the views in the given SplitFrame into separate SplitFrame windows.
2949    * This respects (remembers) any previous 'exploded geometry' i.e. the size
2950    * and location last time the view was expanded (if any). However it does not
2951    * remember the split pane divider location - this is set to match the
2952    * 'exploding' frame.
2953    *
2954    * @param sf
2955    */
2956   public void explodeViews(SplitFrame sf)
2957   {
2958     AlignFrame oldTopFrame = (AlignFrame) sf.getTopFrame();
2959     AlignFrame oldBottomFrame = (AlignFrame) sf.getBottomFrame();
2960     List<? extends AlignmentViewPanel> topPanels = oldTopFrame
2961             .getAlignPanels();
2962     List<? extends AlignmentViewPanel> bottomPanels = oldBottomFrame
2963             .getAlignPanels();
2964     int viewCount = topPanels.size();
2965     if (viewCount < 2)
2966     {
2967       return;
2968     }
2969
2970     /*
2971      * Processing in reverse order works, forwards order leaves the first panels
2972      * not visible. I don't know why!
2973      */
2974     for (int i = viewCount - 1; i >= 0; i--)
2975     {
2976       /*
2977        * Make new top and bottom frames. These take over the respective
2978        * AlignmentPanel objects, including their AlignmentViewports, so the
2979        * cdna/protein relationships between the viewports is carried over to the
2980        * new split frames.
2981        *
2982        * explodedGeometry holds the (x, y) position of the previously exploded
2983        * SplitFrame, and the (width, height) of the AlignFrame component
2984        */
2985       AlignmentPanel topPanel = (AlignmentPanel) topPanels.get(i);
2986       AlignFrame newTopFrame = new AlignFrame(topPanel);
2987       newTopFrame.setSize(oldTopFrame.getSize());
2988       newTopFrame.setVisible(true);
2989       Rectangle geometry = ((AlignViewport) topPanel.getAlignViewport())
2990               .getExplodedGeometry();
2991       if (geometry != null)
2992       {
2993         newTopFrame.setSize(geometry.getSize());
2994       }
2995
2996       AlignmentPanel bottomPanel = (AlignmentPanel) bottomPanels.get(i);
2997       AlignFrame newBottomFrame = new AlignFrame(bottomPanel);
2998       newBottomFrame.setSize(oldBottomFrame.getSize());
2999       newBottomFrame.setVisible(true);
3000       geometry = ((AlignViewport) bottomPanel.getAlignViewport())
3001               .getExplodedGeometry();
3002       if (geometry != null)
3003       {
3004         newBottomFrame.setSize(geometry.getSize());
3005       }
3006
3007       topPanel.av.setGatherViewsHere(false);
3008       bottomPanel.av.setGatherViewsHere(false);
3009       JInternalFrame splitFrame = new SplitFrame(newTopFrame,
3010               newBottomFrame);
3011       if (geometry != null)
3012       {
3013         splitFrame.setLocation(geometry.getLocation());
3014       }
3015       Desktop.addInternalFrame(splitFrame, sf.getTitle(), -1, -1);
3016     }
3017
3018     /*
3019      * Clear references to the panels (now relocated in the new SplitFrames)
3020      * before closing the old SplitFrame.
3021      */
3022     topPanels.clear();
3023     bottomPanels.clear();
3024     sf.close();
3025   }
3026
3027   /**
3028    * Gather expanded split frames, sharing the same pairs of sequence set ids,
3029    * back into the given SplitFrame as additional views. Note that the gathered
3030    * frames may themselves have multiple views.
3031    *
3032    * @param source
3033    */
3034   public void gatherViews(GSplitFrame source)
3035   {
3036     /*
3037      * special handling of explodedGeometry for a view within a SplitFrame: - it
3038      * holds the (x, y) position of the enclosing SplitFrame, and the (width,
3039      * height) of the AlignFrame component
3040      */
3041     AlignFrame myTopFrame = (AlignFrame) source.getTopFrame();
3042     AlignFrame myBottomFrame = (AlignFrame) source.getBottomFrame();
3043     myTopFrame.viewport.setExplodedGeometry(new Rectangle(source.getX(),
3044             source.getY(), myTopFrame.getWidth(), myTopFrame.getHeight()));
3045     myBottomFrame.viewport
3046             .setExplodedGeometry(new Rectangle(source.getX(), source.getY(),
3047                     myBottomFrame.getWidth(), myBottomFrame.getHeight()));
3048     myTopFrame.viewport.setGatherViewsHere(true);
3049     myBottomFrame.viewport.setGatherViewsHere(true);
3050     String topViewId = myTopFrame.viewport.getSequenceSetId();
3051     String bottomViewId = myBottomFrame.viewport.getSequenceSetId();
3052
3053     JInternalFrame[] frames = desktop.getAllFrames();
3054     for (JInternalFrame frame : frames)
3055     {
3056       if (frame instanceof SplitFrame && frame != source)
3057       {
3058         SplitFrame sf = (SplitFrame) frame;
3059         AlignFrame topFrame = (AlignFrame) sf.getTopFrame();
3060         AlignFrame bottomFrame = (AlignFrame) sf.getBottomFrame();
3061         boolean gatherThis = false;
3062         for (int a = 0; a < topFrame.alignPanels.size(); a++)
3063         {
3064           AlignmentPanel topPanel = topFrame.alignPanels.get(a);
3065           AlignmentPanel bottomPanel = bottomFrame.alignPanels.get(a);
3066           if (topViewId.equals(topPanel.av.getSequenceSetId())
3067                   && bottomViewId.equals(bottomPanel.av.getSequenceSetId()))
3068           {
3069             gatherThis = true;
3070             topPanel.av.setGatherViewsHere(false);
3071             bottomPanel.av.setGatherViewsHere(false);
3072             topPanel.av.setExplodedGeometry(
3073                     new Rectangle(sf.getLocation(), topFrame.getSize()));
3074             bottomPanel.av.setExplodedGeometry(
3075                     new Rectangle(sf.getLocation(), bottomFrame.getSize()));
3076             myTopFrame.addAlignmentPanel(topPanel, false);
3077             myBottomFrame.addAlignmentPanel(bottomPanel, false);
3078           }
3079         }
3080
3081         if (gatherThis)
3082         {
3083           topFrame.getAlignPanels().clear();
3084           bottomFrame.getAlignPanels().clear();
3085           sf.close();
3086         }
3087       }
3088     }
3089
3090     /*
3091      * The dust settles...give focus to the tab we did this from.
3092      */
3093     myTopFrame.setDisplayedView(myTopFrame.alignPanel);
3094   }
3095
3096   public static groovy.ui.Console getGroovyConsole()
3097   {
3098     return groovyConsole;
3099   }
3100
3101   /**
3102    * handles the payload of a drag and drop event.
3103    *
3104    * TODO refactor to desktop utilities class
3105    *
3106    * @param files
3107    *          - Data source strings extracted from the drop event
3108    * @param protocols
3109    *          - protocol for each data source extracted from the drop event
3110    * @param evt
3111    *          - the drop event
3112    * @param t
3113    *          - the payload from the drop event
3114    * @throws Exception
3115    */
3116   public static void transferFromDropTarget(List<Object> files,
3117           List<DataSourceType> protocols, DropTargetDropEvent evt,
3118           Transferable t) throws Exception
3119   {
3120
3121     // BH 2018 changed List<String> to List<Object> to allow for File from
3122     // SwingJS
3123
3124     // DataFlavor[] flavors = t.getTransferDataFlavors();
3125     // for (int i = 0; i < flavors.length; i++) {
3126     // if (flavors[i].isFlavorJavaFileListType()) {
3127     // evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
3128     // List<File> list = (List<File>) t.getTransferData(flavors[i]);
3129     // for (int j = 0; j < list.size(); j++) {
3130     // File file = (File) list.get(j);
3131     // byte[] data = getDroppedFileBytes(file);
3132     // fileName.setText(file.getName() + " - " + data.length + " " +
3133     // evt.getLocation());
3134     // JTextArea target = (JTextArea) ((DropTarget)
3135     // evt.getSource()).getComponent();
3136     // target.setText(new String(data));
3137     // }
3138     // dtde.dropComplete(true);
3139     // return;
3140     // }
3141     //
3142
3143     DataFlavor uriListFlavor = new DataFlavor(
3144             "text/uri-list;class=java.lang.String"), urlFlavour = null;
3145     try
3146     {
3147       urlFlavour = new DataFlavor(
3148               "application/x-java-url; class=java.net.URL");
3149     } catch (ClassNotFoundException cfe)
3150     {
3151       Cache.log.debug("Couldn't instantiate the URL dataflavor.", cfe);
3152     }
3153
3154     if (urlFlavour != null && t.isDataFlavorSupported(urlFlavour))
3155     {
3156
3157       try
3158       {
3159         java.net.URL url = (URL) t.getTransferData(urlFlavour);
3160         // nb: java 8 osx bug https://bugs.openjdk.java.net/browse/JDK-8156099
3161         // means url may be null.
3162         if (url != null)
3163         {
3164           protocols.add(DataSourceType.URL);
3165           files.add(url.toString());
3166           Cache.log.debug("Drop handled as URL dataflavor "
3167                   + files.get(files.size() - 1));
3168           return;
3169         }
3170         else
3171         {
3172           if (Platform.isAMacAndNotJS())
3173           {
3174             System.err.println(
3175                     "Please ignore plist error - occurs due to problem with java 8 on OSX");
3176           }
3177         }
3178       } catch (Throwable ex)
3179       {
3180         Cache.log.debug("URL drop handler failed.", ex);
3181       }
3182     }
3183     if (t.isDataFlavorSupported(DataFlavor.javaFileListFlavor))
3184     {
3185       // Works on Windows and MacOSX
3186       Cache.log.debug("Drop handled as javaFileListFlavor");
3187       for (Object file : (List) t
3188               .getTransferData(DataFlavor.javaFileListFlavor))
3189       {
3190         files.add(file);
3191         protocols.add(DataSourceType.FILE);
3192       }
3193     }
3194     else
3195     {
3196       // Unix like behaviour
3197       boolean added = false;
3198       String data = null;
3199       if (t.isDataFlavorSupported(uriListFlavor))
3200       {
3201         Cache.log.debug("Drop handled as uriListFlavor");
3202         // This is used by Unix drag system
3203         data = (String) t.getTransferData(uriListFlavor);
3204       }
3205       if (data == null)
3206       {
3207         // fallback to text: workaround - on OSX where there's a JVM bug
3208         Cache.log.debug("standard URIListFlavor failed. Trying text");
3209         // try text fallback
3210         DataFlavor textDf = new DataFlavor(
3211                 "text/plain;class=java.lang.String");
3212         if (t.isDataFlavorSupported(textDf))
3213         {
3214           data = (String) t.getTransferData(textDf);
3215         }
3216
3217         Cache.log.debug("Plain text drop content returned "
3218                 + (data == null ? "Null - failed" : data));
3219
3220       }
3221       if (data != null)
3222       {
3223         while (protocols.size() < files.size())
3224         {
3225           Cache.log.debug("Adding missing FILE protocol for "
3226                   + files.get(protocols.size()));
3227           protocols.add(DataSourceType.FILE);
3228         }
3229         for (java.util.StringTokenizer st = new java.util.StringTokenizer(
3230                 data, "\r\n"); st.hasMoreTokens();)
3231         {
3232           added = true;
3233           String s = st.nextToken();
3234           if (s.startsWith("#"))
3235           {
3236             // the line is a comment (as per the RFC 2483)
3237             continue;
3238           }
3239           java.net.URI uri = new java.net.URI(s);
3240           if (uri.getScheme().toLowerCase().startsWith("http"))
3241           {
3242             protocols.add(DataSourceType.URL);
3243             files.add(uri.toString());
3244           }
3245           else
3246           {
3247             // otherwise preserve old behaviour: catch all for file objects
3248             java.io.File file = new java.io.File(uri);
3249             protocols.add(DataSourceType.FILE);
3250             files.add(file.toString());
3251           }
3252         }
3253       }
3254
3255       if (Cache.log.isDebugEnabled())
3256       {
3257         if (data == null || !added)
3258         {
3259
3260           if (t.getTransferDataFlavors() != null
3261                   && t.getTransferDataFlavors().length > 0)
3262           {
3263             Cache.log.debug(
3264                     "Couldn't resolve drop data. Here are the supported flavors:");
3265             for (DataFlavor fl : t.getTransferDataFlavors())
3266             {
3267               Cache.log.debug(
3268                       "Supported transfer dataflavor: " + fl.toString());
3269               Object df = t.getTransferData(fl);
3270               if (df != null)
3271               {
3272                 Cache.log.debug("Retrieves: " + df);
3273               }
3274               else
3275               {
3276                 Cache.log.debug("Retrieved nothing");
3277               }
3278             }
3279           }
3280           else
3281           {
3282             Cache.log.debug("Couldn't resolve dataflavor for drop: "
3283                     + t.toString());
3284           }
3285         }
3286       }
3287     }
3288     if (Platform.isWindowsAndNotJS())
3289     {
3290       Cache.log.debug("Scanning dropped content for Windows Link Files");
3291
3292       // resolve any .lnk files in the file drop
3293       for (int f = 0; f < files.size(); f++)
3294       {
3295         String source = files.get(f).toString().toLowerCase();
3296         if (protocols.get(f).equals(DataSourceType.FILE)
3297                 && (source.endsWith(".lnk") || source.endsWith(".url")
3298                         || source.endsWith(".site")))
3299         {
3300           try
3301           {
3302             Object obj = files.get(f);
3303             File lf = (obj instanceof File ? (File) obj
3304                     : new File((String) obj));
3305             // process link file to get a URL
3306             Cache.log.debug("Found potential link file: " + lf);
3307             WindowsShortcut wscfile = new WindowsShortcut(lf);
3308             String fullname = wscfile.getRealFilename();
3309             protocols.set(f, FormatAdapter.checkProtocol(fullname));
3310             files.set(f, fullname);
3311             Cache.log.debug("Parsed real filename " + fullname
3312                     + " to extract protocol: " + protocols.get(f));
3313           } catch (Exception ex)
3314           {
3315             Cache.log.error(
3316                     "Couldn't parse " + files.get(f) + " as a link file.",
3317                     ex);
3318           }
3319         }
3320       }
3321     }
3322   }
3323
3324   /**
3325    * Sets the Preferences property for experimental features to True or False
3326    * depending on the state of the controlling menu item
3327    */
3328   @Override
3329   protected void showExperimental_actionPerformed(boolean selected)
3330   {
3331     Cache.setProperty(EXPERIMENTAL_FEATURES, Boolean.toString(selected));
3332   }
3333
3334   /**
3335    * Answers a (possibly empty) list of any structure viewer frames (currently
3336    * for either Jmol or Chimera) which are currently open. This may optionally
3337    * be restricted to viewers of a specified class, or viewers linked to a
3338    * specified alignment panel.
3339    *
3340    * @param apanel
3341    *          if not null, only return viewers linked to this panel
3342    * @param structureViewerClass
3343    *          if not null, only return viewers of this class
3344    * @return
3345    */
3346   public List<StructureViewerBase> getStructureViewers(
3347           AlignmentPanel apanel,
3348           Class<? extends StructureViewerBase> structureViewerClass)
3349   {
3350     List<StructureViewerBase> result = new ArrayList<>();
3351     JInternalFrame[] frames = Desktop.instance.getAllFrames();
3352
3353     for (JInternalFrame frame : frames)
3354     {
3355       if (frame instanceof StructureViewerBase)
3356       {
3357         if (structureViewerClass == null
3358                 || structureViewerClass.isInstance(frame))
3359         {
3360           if (apanel == null
3361                   || ((StructureViewerBase) frame).isLinkedWith(apanel))
3362           {
3363             result.add((StructureViewerBase) frame);
3364           }
3365         }
3366       }
3367     }
3368     return result;
3369   }
3370 }