src/jalview/gui/ChimeraViewFrame.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 jalview.api.FeatureRenderer;
  24 import jalview.bin.Cache;
  25 import jalview.datamodel.AlignmentI;
  26 import jalview.datamodel.PDBEntry;
  27 import jalview.datamodel.SequenceI;
  28 import jalview.ext.rbvi.chimera.ChimeraCommands;
  29 import jalview.ext.rbvi.chimera.JalviewChimeraBinding;
  30 import jalview.gui.StructureViewer.ViewerType;
  31 import jalview.io.DataSourceType;
  32 import jalview.io.StructureFile;
  33 import jalview.structures.models.AAStructureBindingModel;
  34 import jalview.util.BrowserLauncher;
  35 import jalview.util.MessageManager;
  36 import jalview.util.Platform;
  37 import jalview.ws.dbsources.Pdb;
  38
  39 import java.awt.event.ActionEvent;
  40 import java.awt.event.ActionListener;
  41 import java.awt.event.MouseAdapter;
  42 import java.awt.event.MouseEvent;
  43 import java.io.File;
  44 import java.io.FileInputStream;
  45 import java.io.IOException;
  46 import java.io.InputStream;
  47 import java.util.ArrayList;
  48 import java.util.Collections;
  49 import java.util.List;
  50 import java.util.Random;
  51
  52 import javax.swing.JCheckBoxMenuItem;
  53 import javax.swing.JInternalFrame;
  54 import javax.swing.JMenu;
  55 import javax.swing.JMenuItem;
  56 import javax.swing.event.InternalFrameAdapter;
  57 import javax.swing.event.InternalFrameEvent;
  58
  59 /**
  60  * GUI elements for handling an external chimera display
  61  *
  62  * @author jprocter
  63  *
  64  */
  65 public class ChimeraViewFrame extends StructureViewerBase
  66 {
  67   private JalviewChimeraBinding jmb;
  68
  69   private IProgressIndicator progressBar = null;
  70
  71   /*
  72    * Path to Chimera session file. This is set when an open Jalview/Chimera
  73    * session is saved, or on restore from a Jalview project (if it holds the
  74    * filename of any saved Chimera sessions).
  75    */
  76   private String chimeraSessionFile = null;
  77
  78   private Random random = new Random();
  79
  80   private int myWidth = 500;
  81
  82   private int myHeight = 150;
  83
  84   /**
  85    * Initialise menu options.
  86    */
  87   @Override
  88   protected void initMenus()
  89   {
  90     super.initMenus();
  91
  92     viewerActionMenu.setText(MessageManager.getString("label.chimera"));
  93
  94     viewerColour
  95             .setText(MessageManager.getString("label.colour_with_chimera"));
  96     viewerColour.setToolTipText(MessageManager
  97             .getString("label.let_chimera_manage_structure_colours"));
  98
  99     helpItem.setText(MessageManager.getString("label.chimera_help"));
 100     savemenu.setVisible(false); // not yet implemented
 101     viewMenu.add(fitToWindow);
 102
 103     /*
 104      * exchange of Jalview features and Chimera attributes is for now
 105      * an optionally enabled experimental feature
 106      */
 107     if (Desktop.instance.showExperimental())
 108     {
 109       JMenuItem writeFeatures = new JMenuItem(
 110               MessageManager.getString("label.create_chimera_attributes"));
 111       writeFeatures.setToolTipText(MessageManager
 112               .getString("label.create_chimera_attributes_tip"));
 113       writeFeatures.addActionListener(new ActionListener()
 114       {
 115         @Override
 116         public void actionPerformed(ActionEvent e)
 117         {
 118           sendFeaturesToChimera();
 119         }
 120       });
 121       viewerActionMenu.add(writeFeatures);
 122
 123       final JMenu fetchAttributes = new JMenu(
 124               MessageManager.getString("label.fetch_chimera_attributes"));
 125       fetchAttributes.setToolTipText(MessageManager
 126               .getString("label.fetch_chimera_attributes_tip"));
 127       fetchAttributes.addMouseListener(new MouseAdapter()
 128       {
 129
 130         @Override
 131         public void mouseEntered(MouseEvent e)
 132         {
 133           buildAttributesMenu(fetchAttributes);
 134         }
 135       });
 136       viewerActionMenu.add(fetchAttributes);
 137     }
 138   }
 139
 140   /**
 141    * Query Chimera for its residue attribute names and add them as items off the
 142    * attributes menu
 143    *
 144    * @param attributesMenu
 145    */
 146   protected void buildAttributesMenu(JMenu attributesMenu)
 147   {
 148     List<String> atts = jmb.sendChimeraCommand("list resattr", true);
 149     if (atts == null)
 150     {
 151       return;
 152     }
 153     attributesMenu.removeAll();
 154     Collections.sort(atts);
 155     for (String att : atts)
 156     {
 157       final String attName = att.split(" ")[1];
 158
 159       /*
 160        * ignore 'jv_*' attributes, as these are Jalview features that have
 161        * been transferred to residue attributes in Chimera!
 162        */
 163       if (!attName.startsWith(ChimeraCommands.NAMESPACE_PREFIX))
 164       {
 165         JMenuItem menuItem = new JMenuItem(attName);
 166         menuItem.addActionListener(new ActionListener()
 167         {
 168           @Override
 169           public void actionPerformed(ActionEvent e)
 170           {
 171             getChimeraAttributes(attName);
 172           }
 173         });
 174         attributesMenu.add(menuItem);
 175       }
 176     }
 177   }
 178
 179   /**
 180    * Read residues in Chimera with the given attribute name, and set as features
 181    * on the corresponding sequence positions (if any)
 182    *
 183    * @param attName
 184    */
 185   protected void getChimeraAttributes(String attName)
 186   {
 187     jmb.copyStructureAttributesToFeatures(attName, getAlignmentPanel());
 188   }
 189
 190   /**
 191    * Send a command to Chimera to create residue attributes for Jalview features
 192    * <p>
 193    * The syntax is: setattr r <attName> <attValue> <atomSpec>
 194    * <p>
 195    * For example: setattr r jv:chain "Ferredoxin-1, Chloroplastic" #0:94.A
 196    */
 197   protected void sendFeaturesToChimera()
 198   {
 199     int count = jmb.sendFeaturesToViewer(getAlignmentPanel());
 200     statusBar.setText(
 201             MessageManager.formatMessage("label.attributes_set", count));
 202   }
 203
 204   /**
 205    * add a single PDB structure to a new or existing Chimera view
 206    *
 207    * @param pdbentry
 208    * @param seq
 209    * @param chains
 210    * @param ap
 211    */
 212   public ChimeraViewFrame(PDBEntry pdbentry, SequenceI[] seq,
 213           String[] chains, final AlignmentPanel ap)
 214   {
 215     this();
 216     String pdbId = pdbentry.getId();
 217
 218     /*
 219      * If the PDB file is already loaded, the user may just choose to add to an
 220      * existing viewer (or cancel)
 221      */
 222     if (addAlreadyLoadedFile(seq, chains, ap, pdbId))
 223     {
 224       return;
 225     }
 226
 227     /*
 228      * Check if there are other Chimera views involving this alignment and give
 229      * user the option to add and align this molecule to one of them (or cancel)
 230      */
 231     if (addToExistingViewer(pdbentry, seq, chains, ap, pdbId))
 232     {
 233       return;
 234     }
 235
 236     /*
 237      * If the options above are declined or do not apply, show the structure in
 238      * a new viewer
 239      */
 240     openNewChimera(ap, new PDBEntry[] { pdbentry },
 241             new SequenceI[][]
 242             { seq });
 243   }
 244
 245   /**
 246    * Create a helper to manage progress bar display
 247    */
 248   protected void createProgressBar()
 249   {
 250     if (progressBar == null)
 251     {
 252       progressBar = new ProgressBar(statusPanel, statusBar);
 253     }
 254   }
 255
 256   private void openNewChimera(AlignmentPanel ap, PDBEntry[] pdbentrys,
 257           SequenceI[][] seqs)
 258   {
 259     createProgressBar();
 260     jmb = new JalviewChimeraBindingModel(this,
 261             ap.getStructureSelectionManager(), pdbentrys, seqs, null);
 262     addAlignmentPanel(ap);
 263     useAlignmentPanelForColourbyseq(ap);
 264
 265     if (pdbentrys.length > 1)
 266     {
 267       alignAddedStructures = true;
 268       useAlignmentPanelForSuperposition(ap);
 269     }
 270     jmb.setColourBySequence(true);
 271     setSize(myWidth, myHeight);
 272     initMenus();
 273
 274     addingStructures = false;
 275     worker = new Thread(this);
 276     worker.start();
 277
 278     this.addInternalFrameListener(new InternalFrameAdapter()
 279     {
 280       @Override
 281       public void internalFrameClosing(
 282               InternalFrameEvent internalFrameEvent)
 283       {
 284         closeViewer(false);
 285       }
 286     });
 287
 288   }
 289
 290   /**
 291    * Create a new viewer from saved session state data including Chimera session
 292    * file
 293    *
 294    * @param chimeraSessionFile
 295    * @param alignPanel
 296    * @param pdbArray
 297    * @param seqsArray
 298    * @param colourByChimera
 299    * @param colourBySequence
 300    * @param newViewId
 301    */
 302   public ChimeraViewFrame(String chimeraSessionFile,
 303           AlignmentPanel alignPanel, PDBEntry[] pdbArray,
 304           SequenceI[][] seqsArray, boolean colourByChimera,
 305           boolean colourBySequence, String newViewId)
 306   {
 307     this();
 308     setViewId(newViewId);
 309     this.chimeraSessionFile = chimeraSessionFile;
 310     openNewChimera(alignPanel, pdbArray, seqsArray);
 311     if (colourByChimera)
 312     {
 313       jmb.setColourBySequence(false);
 314       seqColour.setSelected(false);
 315       viewerColour.setSelected(true);
 316     }
 317     else if (colourBySequence)
 318     {
 319       jmb.setColourBySequence(true);
 320       seqColour.setSelected(true);
 321       viewerColour.setSelected(false);
 322     }
 323   }
 324
 325   /**
 326    * create a new viewer containing several structures superimposed using the
 327    * given alignPanel.
 328    *
 329    * @param pe
 330    * @param seqs
 331    * @param ap
 332    */
 333   public ChimeraViewFrame(PDBEntry[] pe, SequenceI[][] seqs,
 334           AlignmentPanel ap)
 335   {
 336     this();
 337     openNewChimera(ap, pe, seqs);
 338   }
 339
 340   /**
 341    * Default constructor
 342    */
 343   public ChimeraViewFrame()
 344   {
 345     super();
 346
 347     /*
 348      * closeViewer will decide whether or not to close this frame
 349      * depending on whether user chooses to Cancel or not
 350      */
 351     setDefaultCloseOperation(JInternalFrame.DO_NOTHING_ON_CLOSE);
 352   }
 353
 354   /**
 355    * Returns a list of any Chimera viewers in the desktop. The list is
 356    * restricted to those linked to the given alignment panel if it is not null.
 357    */
 358   @Override
 359   protected List<StructureViewerBase> getViewersFor(AlignmentPanel ap)
 360   {
 361     List<StructureViewerBase> result = new ArrayList<>();
 362     JInternalFrame[] frames = Desktop.instance.getAllFrames();
 363
 364     for (JInternalFrame frame : frames)
 365     {
 366       if (frame instanceof ChimeraViewFrame)
 367       {
 368         if (ap == null || ((StructureViewerBase) frame).isLinkedWith(ap))
 369         {
 370           result.add((StructureViewerBase) frame);
 371         }
 372       }
 373     }
 374     return result;
 375   }
 376
 377   /**
 378    * Launch Chimera. If we have a chimera session file name, send Chimera the
 379    * command to open its saved session file.
 380    */
 381   void initChimera()
 382   {
 383     jmb.setFinishedInit(false);
 384     Desktop.addInternalFrame(this,
 385             jmb.getViewerTitle(getViewerName(), true), getBounds().width,
 386             getBounds().height);
 387
 388     if (!jmb.launchChimera())
 389     {
 390       JvOptionPane.showMessageDialog(Desktop.desktop,
 391               MessageManager.getString("label.chimera_failed"),
 392               MessageManager.getString("label.error_loading_file"),
 393               JvOptionPane.ERROR_MESSAGE);
 394       this.dispose();
 395       return;
 396     }
 397
 398     if (this.chimeraSessionFile != null)
 399     {
 400       boolean opened = jmb.openSession(chimeraSessionFile);
 401       if (!opened)
 402       {
 403         System.err.println("An error occurred opening Chimera session file "
 404                 + chimeraSessionFile);
 405       }
 406     }
 407
 408     jmb.startChimeraListener();
 409   }
 410
 411   /**
 412    * Show only the selected chain(s) in the viewer
 413    */
 414   @Override
 415   void showSelectedChains()
 416   {
 417     List<String> toshow = new ArrayList<>();
 418     for (int i = 0; i < chainMenu.getItemCount(); i++)
 419     {
 420       if (chainMenu.getItem(i) instanceof JCheckBoxMenuItem)
 421       {
 422         JCheckBoxMenuItem item = (JCheckBoxMenuItem) chainMenu.getItem(i);
 423         if (item.isSelected())
 424         {
 425           toshow.add(item.getText());
 426         }
 427       }
 428     }
 429     jmb.showChains(toshow);
 430   }
 431
 432   /**
 433    * Close down this instance of Jalview's Chimera viewer, giving the user the
 434    * option to close the associated Chimera window (process). They may wish to
 435    * keep it open until they have had an opportunity to save any work.
 436    *
 437    * @param closeChimera
 438    *          if true, close any linked Chimera process; if false, prompt first
 439    */
 440   @Override
 441   public void closeViewer(boolean closeChimera)
 442   {
 443     if (jmb != null && jmb.isChimeraRunning())
 444     {
 445       if (!closeChimera)
 446       {
 447         String prompt = MessageManager
 448                 .formatMessage("label.confirm_close_chimera", new Object[]
 449                 { jmb.getViewerTitle(getViewerName(), false) });
 450         prompt = JvSwingUtils.wrapTooltip(true, prompt);
 451         int confirm = JvOptionPane.showConfirmDialog(this, prompt,
 452                 MessageManager.getString("label.close_viewer"),
 453                 JvOptionPane.YES_NO_CANCEL_OPTION);
 454         /*
 455          * abort closure if user hits escape or Cancel
 456          */
 457         if (confirm == JvOptionPane.CANCEL_OPTION
 458                 || confirm == JvOptionPane.CLOSED_OPTION)
 459         {
 460           return;
 461         }
 462         closeChimera = confirm == JvOptionPane.YES_OPTION;
 463       }
 464       jmb.closeViewer(closeChimera);
 465     }
 466     setAlignmentPanel(null);
 467     _aps.clear();
 468     _alignwith.clear();
 469     _colourwith.clear();
 470     // TODO: check for memory leaks where instance isn't finalised because jmb
 471     // holds a reference to the window
 472     jmb = null;
 473     dispose();
 474   }
 475
 476   /**
 477    * Open any newly added PDB structures in Chimera, having first fetched data
 478    * from PDB (if not already saved).
 479    */
 480   @Override
 481   public void run()
 482   {
 483     _started = true;
 484     // todo - record which pdbids were successfully imported.
 485     StringBuilder errormsgs = new StringBuilder(128);
 486     StringBuilder files = new StringBuilder(128);
 487     List<PDBEntry> filePDB = new ArrayList<>();
 488     List<Integer> filePDBpos = new ArrayList<>();
 489     PDBEntry thePdbEntry = null;
 490     StructureFile pdb = null;
 491     try
 492     {
 493       String[] curfiles = jmb.getStructureFiles(); // files currently in viewer
 494       // TODO: replace with reference fetching/transfer code (validate PDBentry
 495       // as a DBRef?)
 496       for (int pi = 0; pi < jmb.getPdbCount(); pi++)
 497       {
 498         String file = null;
 499         thePdbEntry = jmb.getPdbEntry(pi);
 500         if (thePdbEntry.getFile() == null)
 501         {
 502           /*
 503            * Retrieve PDB data, save to file, attach to PDBEntry
 504            */
 505           file = fetchPdbFile(thePdbEntry);
 506           if (file == null)
 507           {
 508             errormsgs.append("'" + thePdbEntry.getId() + "' ");
 509           }
 510         }
 511         else
 512         {
 513           /*
 514            * Got file already - ignore if already loaded in Chimera.
 515            */
 516           file = new File(thePdbEntry.getFile()).getAbsoluteFile()
 517                   .getPath();
 518           if (curfiles != null && curfiles.length > 0)
 519           {
 520             addingStructures = true; // already files loaded.
 521             for (int c = 0; c < curfiles.length; c++)
 522             {
 523               if (curfiles[c].equals(file))
 524               {
 525                 file = null;
 526                 break;
 527               }
 528             }
 529           }
 530         }
 531         if (file != null)
 532         {
 533           filePDB.add(thePdbEntry);
 534           filePDBpos.add(Integer.valueOf(pi));
 535           files.append(" \"" + Platform.escapeString(file) + "\"");
 536         }
 537       }
 538     } catch (OutOfMemoryError oomerror)
 539     {
 540       new OOMWarning("Retrieving PDB files: " + thePdbEntry.getId(),
 541               oomerror);
 542     } catch (Exception ex)
 543     {
 544       ex.printStackTrace();
 545       errormsgs.append(
 546               "When retrieving pdbfiles for '" + thePdbEntry.getId() + "'");
 547     }
 548     if (errormsgs.length() > 0)
 549     {
 550
 551       JvOptionPane.showInternalMessageDialog(Desktop.desktop,
 552               MessageManager.formatMessage(
 553                       "label.pdb_entries_couldnt_be_retrieved", new Object[]
 554                       { errormsgs.toString() }),
 555               MessageManager.getString("label.couldnt_load_file"),
 556               JvOptionPane.ERROR_MESSAGE);
 557     }
 558
 559     if (files.length() > 0)
 560     {
 561       jmb.setFinishedInit(false);
 562       if (!addingStructures)
 563       {
 564         try
 565         {
 566           initChimera();
 567         } catch (Exception ex)
 568         {
 569           Cache.log.error("Couldn't open Chimera viewer!", ex);
 570         }
 571       }
 572       int num = -1;
 573       for (PDBEntry pe : filePDB)
 574       {
 575         num++;
 576         if (pe.getFile() != null)
 577         {
 578           try
 579           {
 580             int pos = filePDBpos.get(num).intValue();
 581             long startTime = startProgressBar(getViewerName() + " "
 582                     + MessageManager.getString("status.opening_file_for")
 583                     + " " + pe.getId());
 584             jmb.openFile(pe);
 585             jmb.addSequence(pos, jmb.getSequence()[pos]);
 586             File fl = new File(pe.getFile());
 587             DataSourceType protocol = DataSourceType.URL;
 588             try
 589             {
 590               if (fl.exists())
 591               {
 592                 protocol = DataSourceType.FILE;
 593               }
 594             } catch (Throwable e)
 595             {
 596             } finally
 597             {
 598               stopProgressBar("", startTime);
 599             }
 600             // Explicitly map to the filename used by Chimera ;
 601
 602             pdb = jmb.getSsm().setMapping(jmb.getSequence()[pos],
 603                     jmb.getChains()[pos], pe.getFile(), protocol,
 604                     progressBar);
 605             stashFoundChains(pdb, pe.getFile());
 606
 607           } catch (OutOfMemoryError oomerror)
 608           {
 609             new OOMWarning(
 610                     "When trying to open and map structures from Chimera!",
 611                     oomerror);
 612           } catch (Exception ex)
 613           {
 614             Cache.log.error(
 615                     "Couldn't open " + pe.getFile() + " in Chimera viewer!",
 616                     ex);
 617           } finally
 618           {
 619             Cache.log.debug("File locations are " + files);
 620           }
 621         }
 622       }
 623
 624       jmb.refreshGUI();
 625       jmb.setFinishedInit(true);
 626       jmb.setLoadingFromArchive(false);
 627
 628       /*
 629        * ensure that any newly discovered features (e.g. RESNUM)
 630        * are added to any open feature settings dialog
 631        */
 632       FeatureRenderer fr = getBinding().getFeatureRenderer(null);
 633       if (fr != null)
 634       {
 635         fr.featuresAdded();
 636       }
 637
 638       // refresh the sequence colours for the new structure(s)
 639       for (AlignmentPanel ap : _colourwith)
 640       {
 641         jmb.updateColours(ap);
 642       }
 643       // do superposition if asked to
 644       if (Cache.getDefault("AUTOSUPERIMPOSE", true) && alignAddedStructures)
 645       {
 646         new Thread(new Runnable()
 647         {
 648           @Override
 649           public void run()
 650           {
 651             alignStructs_withAllAlignPanels();
 652           }
 653         }).start();
 654         alignAddedStructures = false;
 655       }
 656       addingStructures = false;
 657     }
 658     _started = false;
 659     worker = null;
 660   }
 661
 662   /**
 663    * Fetch PDB data and save to a local file. Returns the full path to the file,
 664    * or null if fetch fails. TODO: refactor to common with Jmol ? duplication
 665    *
 666    * @param processingEntry
 667    * @return
 668    * @throws Exception
 669    */
 670
 671   private void stashFoundChains(StructureFile pdb, String file)
 672   {
 673     for (int i = 0; i < pdb.getChains().size(); i++)
 674     {
 675       String chid = new String(
 676               pdb.getId() + ":" + pdb.getChains().elementAt(i).id);
 677       jmb.getChainNames().add(chid);
 678       jmb.getChainFile().put(chid, file);
 679     }
 680   }
 681
 682   private String fetchPdbFile(PDBEntry processingEntry) throws Exception
 683   {
 684     // FIXME: this is duplicated code with Jmol frame ?
 685     String filePath = null;
 686     Pdb pdbclient = new Pdb();
 687     AlignmentI pdbseq = null;
 688     String pdbid = processingEntry.getId();
 689     long handle = System.currentTimeMillis()
 690             + Thread.currentThread().hashCode();
 691
 692     /*
 693      * Write 'fetching PDB' progress on AlignFrame as we are not yet visible
 694      */
 695     String msg = MessageManager.formatMessage("status.fetching_pdb",
 696             new Object[]
 697             { pdbid });
 698     getAlignmentPanel().alignFrame.setProgressBar(msg, handle);
 699     // long hdl = startProgressBar(MessageManager.formatMessage(
 700     // "status.fetching_pdb", new Object[]
 701     // { pdbid }));
 702     try
 703     {
 704       pdbseq = pdbclient.getSequenceRecords(pdbid);
 705     } catch (OutOfMemoryError oomerror)
 706     {
 707       new OOMWarning("Retrieving PDB id " + pdbid, oomerror);
 708     } finally
 709     {
 710       msg = pdbid + " " + MessageManager.getString("label.state_completed");
 711       getAlignmentPanel().alignFrame.setProgressBar(msg, handle);
 712       // stopProgressBar(msg, hdl);
 713     }
 714     /*
 715      * If PDB data were saved and are not invalid (empty alignment), return the
 716      * file path.
 717      */
 718     if (pdbseq != null && pdbseq.getHeight() > 0)
 719     {
 720       // just use the file name from the first sequence's first PDBEntry
 721       filePath = new File(pdbseq.getSequenceAt(0).getAllPDBEntries()
 722               .elementAt(0).getFile()).getAbsolutePath();
 723       processingEntry.setFile(filePath);
 724     }
 725     return filePath;
 726   }
 727
 728   /**
 729    * Convenience method to update the progress bar if there is one. Be sure to
 730    * call stopProgressBar with the returned handle to remove the message.
 731    *
 732    * @param msg
 733    * @param handle
 734    */
 735   public long startProgressBar(String msg)
 736   {
 737     // TODO would rather have startProgress/stopProgress as the
 738     // IProgressIndicator interface
 739     long tm = random.nextLong();
 740     if (progressBar != null)
 741     {
 742       progressBar.setProgressBar(msg, tm);
 743     }
 744     return tm;
 745   }
 746
 747   /**
 748    * End the progress bar with the specified handle, leaving a message (if not
 749    * null) on the status bar
 750    *
 751    * @param msg
 752    * @param handle
 753    */
 754   public void stopProgressBar(String msg, long handle)
 755   {
 756     if (progressBar != null)
 757     {
 758       progressBar.setProgressBar(msg, handle);
 759     }
 760   }
 761
 762   @Override
 763   public void eps_actionPerformed(ActionEvent e)
 764   {
 765     throw new Error(MessageManager
 766             .getString("error.eps_generation_not_implemented"));
 767   }
 768
 769   @Override
 770   public void png_actionPerformed(ActionEvent e)
 771   {
 772     throw new Error(MessageManager
 773             .getString("error.png_generation_not_implemented"));
 774   }
 775
 776   @Override
 777   public void showHelp_actionPerformed(ActionEvent actionEvent)
 778   {
 779     try
 780     {
 781       BrowserLauncher
 782               .openURL("https://www.cgl.ucsf.edu/chimera/docs/UsersGuide");
 783     } catch (IOException ex)
 784     {
 785     }
 786   }
 787
 788   @Override
 789   public AAStructureBindingModel getBinding()
 790   {
 791     return jmb;
 792   }
 793
 794   /**
 795    * Ask Chimera to save its session to the designated file path, or to a
 796    * temporary file if the path is null. Returns the file path if successful,
 797    * else null.
 798    *
 799    * @param filepath
 800    * @see getStateInfo
 801    */
 802   protected String saveSession(String filepath)
 803   {
 804     String pathUsed = filepath;
 805     try
 806     {
 807       if (pathUsed == null)
 808       {
 809         File tempFile = File.createTempFile("chimera", ".py");
 810         tempFile.deleteOnExit();
 811         pathUsed = tempFile.getPath();
 812       }
 813       boolean result = jmb.saveSession(pathUsed);
 814       if (result)
 815       {
 816         this.chimeraSessionFile = pathUsed;
 817         return pathUsed;
 818       }
 819     } catch (IOException e)
 820     {
 821     }
 822     return null;
 823   }
 824
 825   /**
 826    * Returns a string representing the state of the Chimera session. This is
 827    * done by requesting Chimera to save its session to a temporary file, then
 828    * reading the file contents. Returns an empty string on any error.
 829    */
 830   @Override
 831   public String getStateInfo()
 832   {
 833     String sessionFile = saveSession(null);
 834     if (sessionFile == null)
 835     {
 836       return "";
 837     }
 838     InputStream is = null;
 839     try
 840     {
 841       File f = new File(sessionFile);
 842       byte[] bytes = new byte[(int) f.length()];
 843       is = new FileInputStream(sessionFile);
 844       is.read(bytes);
 845       return new String(bytes);
 846     } catch (IOException e)
 847     {
 848       return "";
 849     } finally
 850     {
 851       if (is != null)
 852       {
 853         try
 854         {
 855           is.close();
 856         } catch (IOException e)
 857         {
 858           // ignore
 859         }
 860       }
 861     }
 862   }
 863
 864   @Override
 865   protected void fitToWindow_actionPerformed()
 866   {
 867     jmb.focusView();
 868   }
 869
 870   @Override
 871   public ViewerType getViewerType()
 872   {
 873     return ViewerType.CHIMERA;
 874   }
 875
 876   @Override
 877   protected String getViewerName()
 878   {
 879     return "Chimera";
 880   }
 881
 882   /**
 883    * Sends commands to align structures according to associated alignment(s).
 884    *
 885    * @return
 886    */
 887   @Override
 888   protected String alignStructs_withAllAlignPanels()
 889   {
 890     String reply = super.alignStructs_withAllAlignPanels();
 891     if (reply != null)
 892     {
 893       statusBar.setText("Superposition failed: " + reply);
 894     }
 895     return reply;
 896   }
 897
 898   @Override
 899   protected IProgressIndicator getIProgressIndicator()
 900   {
 901     return progressBar;
 902   }
 903 }