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    * open a single PDB structure in a new 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
 217     openNewChimera(ap, new PDBEntry[] { pdbentry },
 218             new SequenceI[][]
 219             { seq });
 220   }
 221
 222   /**
 223    * Create a helper to manage progress bar display
 224    */
 225   protected void createProgressBar()
 226   {
 227     if (progressBar == null)
 228     {
 229       progressBar = new ProgressBar(statusPanel, statusBar);
 230     }
 231   }
 232
 233   private void openNewChimera(AlignmentPanel ap, PDBEntry[] pdbentrys,
 234           SequenceI[][] seqs)
 235   {
 236     createProgressBar();
 237     jmb = new JalviewChimeraBindingModel(this,
 238             ap.getStructureSelectionManager(), pdbentrys, seqs, null);
 239     addAlignmentPanel(ap);
 240     useAlignmentPanelForColourbyseq(ap);
 241
 242     if (pdbentrys.length > 1)
 243     {
 244       useAlignmentPanelForSuperposition(ap);
 245     }
 246     jmb.setColourBySequence(true);
 247     setSize(myWidth, myHeight);
 248     initMenus();
 249
 250     addingStructures = false;
 251     worker = new Thread(this);
 252     worker.start();
 253
 254     this.addInternalFrameListener(new InternalFrameAdapter()
 255     {
 256       @Override
 257       public void internalFrameClosing(
 258               InternalFrameEvent internalFrameEvent)
 259       {
 260         closeViewer(false);
 261       }
 262     });
 263
 264   }
 265
 266   /**
 267    * Create a new viewer from saved session state data including Chimera session
 268    * file
 269    *
 270    * @param chimeraSessionFile
 271    * @param alignPanel
 272    * @param pdbArray
 273    * @param seqsArray
 274    * @param colourByChimera
 275    * @param colourBySequence
 276    * @param newViewId
 277    */
 278   public ChimeraViewFrame(String chimeraSessionFile,
 279           AlignmentPanel alignPanel, PDBEntry[] pdbArray,
 280           SequenceI[][] seqsArray, boolean colourByChimera,
 281           boolean colourBySequence, String newViewId)
 282   {
 283     this();
 284     setViewId(newViewId);
 285     this.chimeraSessionFile = chimeraSessionFile;
 286     openNewChimera(alignPanel, pdbArray, seqsArray);
 287     if (colourByChimera)
 288     {
 289       jmb.setColourBySequence(false);
 290       seqColour.setSelected(false);
 291       viewerColour.setSelected(true);
 292     }
 293     else if (colourBySequence)
 294     {
 295       jmb.setColourBySequence(true);
 296       seqColour.setSelected(true);
 297       viewerColour.setSelected(false);
 298     }
 299   }
 300
 301   /**
 302    * create a new viewer containing several structures, optionally superimposed
 303    * using the given alignPanel.
 304    *
 305    * @param pe
 306    * @param seqs
 307    * @param ap
 308    */
 309   public ChimeraViewFrame(PDBEntry[] pe, boolean alignAdded,
 310           SequenceI[][] seqs,
 311           AlignmentPanel ap)
 312   {
 313     this();
 314     setAlignAddedStructures(alignAdded);
 315     openNewChimera(ap, pe, seqs);
 316   }
 317
 318   /**
 319    * Default constructor
 320    */
 321   public ChimeraViewFrame()
 322   {
 323     super();
 324
 325     /*
 326      * closeViewer will decide whether or not to close this frame
 327      * depending on whether user chooses to Cancel or not
 328      */
 329     setDefaultCloseOperation(JInternalFrame.DO_NOTHING_ON_CLOSE);
 330   }
 331
 332   /**
 333    * Launch Chimera. If we have a chimera session file name, send Chimera the
 334    * command to open its saved session file.
 335    */
 336   void initChimera()
 337   {
 338     jmb.setFinishedInit(false);
 339     Desktop.addInternalFrame(this,
 340             jmb.getViewerTitle(getViewerName(), true), getBounds().width,
 341             getBounds().height);
 342
 343     if (!jmb.launchChimera())
 344     {
 345       JvOptionPane.showMessageDialog(Desktop.desktop,
 346               MessageManager.getString("label.chimera_failed"),
 347               MessageManager.getString("label.error_loading_file"),
 348               JvOptionPane.ERROR_MESSAGE);
 349       this.dispose();
 350       return;
 351     }
 352
 353     if (this.chimeraSessionFile != null)
 354     {
 355       boolean opened = jmb.openSession(chimeraSessionFile);
 356       if (!opened)
 357       {
 358         System.err.println("An error occurred opening Chimera session file "
 359                 + chimeraSessionFile);
 360       }
 361     }
 362
 363     jmb.startChimeraListener();
 364   }
 365
 366   /**
 367    * Show only the selected chain(s) in the viewer
 368    */
 369   @Override
 370   void showSelectedChains()
 371   {
 372     List<String> toshow = new ArrayList<>();
 373     for (int i = 0; i < chainMenu.getItemCount(); i++)
 374     {
 375       if (chainMenu.getItem(i) instanceof JCheckBoxMenuItem)
 376       {
 377         JCheckBoxMenuItem item = (JCheckBoxMenuItem) chainMenu.getItem(i);
 378         if (item.isSelected())
 379         {
 380           toshow.add(item.getText());
 381         }
 382       }
 383     }
 384     jmb.showChains(toshow);
 385   }
 386
 387   /**
 388    * Close down this instance of Jalview's Chimera viewer, giving the user the
 389    * option to close the associated Chimera window (process). They may wish to
 390    * keep it open until they have had an opportunity to save any work.
 391    *
 392    * @param closeChimera
 393    *          if true, close any linked Chimera process; if false, prompt first
 394    */
 395   @Override
 396   public void closeViewer(boolean closeChimera)
 397   {
 398     if (jmb != null && jmb.isChimeraRunning())
 399     {
 400       if (!closeChimera)
 401       {
 402         String prompt = MessageManager
 403                 .formatMessage("label.confirm_close_chimera", new Object[]
 404                 { jmb.getViewerTitle(getViewerName(), false) });
 405         prompt = JvSwingUtils.wrapTooltip(true, prompt);
 406         int confirm = JvOptionPane.showConfirmDialog(this, prompt,
 407                 MessageManager.getString("label.close_viewer"),
 408                 JvOptionPane.YES_NO_CANCEL_OPTION);
 409         /*
 410          * abort closure if user hits escape or Cancel
 411          */
 412         if (confirm == JvOptionPane.CANCEL_OPTION
 413                 || confirm == JvOptionPane.CLOSED_OPTION)
 414         {
 415           return;
 416         }
 417         closeChimera = confirm == JvOptionPane.YES_OPTION;
 418       }
 419       jmb.closeViewer(closeChimera);
 420     }
 421     setAlignmentPanel(null);
 422     _aps.clear();
 423     _alignwith.clear();
 424     _colourwith.clear();
 425     // TODO: check for memory leaks where instance isn't finalised because jmb
 426     // holds a reference to the window
 427     jmb = null;
 428     dispose();
 429   }
 430
 431   /**
 432    * Open any newly added PDB structures in Chimera, having first fetched data
 433    * from PDB (if not already saved).
 434    */
 435   @Override
 436   public void run()
 437   {
 438     _started = true;
 439     // todo - record which pdbids were successfully imported.
 440     StringBuilder errormsgs = new StringBuilder(128);
 441     StringBuilder files = new StringBuilder(128);
 442     List<PDBEntry> filePDB = new ArrayList<>();
 443     List<Integer> filePDBpos = new ArrayList<>();
 444     PDBEntry thePdbEntry = null;
 445     StructureFile pdb = null;
 446     try
 447     {
 448       String[] curfiles = jmb.getStructureFiles(); // files currently in viewer
 449       // TODO: replace with reference fetching/transfer code (validate PDBentry
 450       // as a DBRef?)
 451       for (int pi = 0; pi < jmb.getPdbCount(); pi++)
 452       {
 453         String file = null;
 454         thePdbEntry = jmb.getPdbEntry(pi);
 455         if (thePdbEntry.getFile() == null)
 456         {
 457           /*
 458            * Retrieve PDB data, save to file, attach to PDBEntry
 459            */
 460           file = fetchPdbFile(thePdbEntry);
 461           if (file == null)
 462           {
 463             errormsgs.append("'" + thePdbEntry.getId() + "' ");
 464           }
 465         }
 466         else
 467         {
 468           /*
 469            * Got file already - ignore if already loaded in Chimera.
 470            */
 471           file = new File(thePdbEntry.getFile()).getAbsoluteFile()
 472                   .getPath();
 473           if (curfiles != null && curfiles.length > 0)
 474           {
 475             addingStructures = true; // already files loaded.
 476             for (int c = 0; c < curfiles.length; c++)
 477             {
 478               if (curfiles[c].equals(file))
 479               {
 480                 file = null;
 481                 break;
 482               }
 483             }
 484           }
 485         }
 486         if (file != null)
 487         {
 488           filePDB.add(thePdbEntry);
 489           filePDBpos.add(Integer.valueOf(pi));
 490           files.append(" \"" + Platform.escapeString(file) + "\"");
 491         }
 492       }
 493     } catch (OutOfMemoryError oomerror)
 494     {
 495       new OOMWarning("Retrieving PDB files: " + thePdbEntry.getId(),
 496               oomerror);
 497     } catch (Exception ex)
 498     {
 499       ex.printStackTrace();
 500       errormsgs.append(
 501               "When retrieving pdbfiles for '" + thePdbEntry.getId() + "'");
 502     }
 503     if (errormsgs.length() > 0)
 504     {
 505
 506       JvOptionPane.showInternalMessageDialog(Desktop.desktop,
 507               MessageManager.formatMessage(
 508                       "label.pdb_entries_couldnt_be_retrieved", new Object[]
 509                       { errormsgs.toString() }),
 510               MessageManager.getString("label.couldnt_load_file"),
 511               JvOptionPane.ERROR_MESSAGE);
 512     }
 513
 514     if (files.length() > 0)
 515     {
 516       jmb.setFinishedInit(false);
 517       if (!addingStructures)
 518       {
 519         try
 520         {
 521           initChimera();
 522         } catch (Exception ex)
 523         {
 524           Cache.log.error("Couldn't open Chimera viewer!", ex);
 525         }
 526       }
 527       int num = -1;
 528       for (PDBEntry pe : filePDB)
 529       {
 530         num++;
 531         if (pe.getFile() != null)
 532         {
 533           try
 534           {
 535             int pos = filePDBpos.get(num).intValue();
 536             long startTime = startProgressBar(getViewerName() + " "
 537                     + MessageManager.getString("status.opening_file_for")
 538                     + " " + pe.getId());
 539             jmb.openFile(pe);
 540             jmb.addSequence(pos, jmb.getSequence()[pos]);
 541             File fl = new File(pe.getFile());
 542             DataSourceType protocol = DataSourceType.URL;
 543             try
 544             {
 545               if (fl.exists())
 546               {
 547                 protocol = DataSourceType.FILE;
 548               }
 549             } catch (Throwable e)
 550             {
 551             } finally
 552             {
 553               stopProgressBar("", startTime);
 554             }
 555             // Explicitly map to the filename used by Chimera ;
 556
 557             pdb = jmb.getSsm().setMapping(jmb.getSequence()[pos],
 558                     jmb.getChains()[pos], pe.getFile(), protocol,
 559                     progressBar);
 560             stashFoundChains(pdb, pe.getFile());
 561
 562           } catch (OutOfMemoryError oomerror)
 563           {
 564             new OOMWarning(
 565                     "When trying to open and map structures from Chimera!",
 566                     oomerror);
 567           } catch (Exception ex)
 568           {
 569             Cache.log.error(
 570                     "Couldn't open " + pe.getFile() + " in Chimera viewer!",
 571                     ex);
 572           } finally
 573           {
 574             Cache.log.debug("File locations are " + files);
 575           }
 576         }
 577       }
 578
 579       jmb.refreshGUI();
 580       jmb.setFinishedInit(true);
 581       jmb.setLoadingFromArchive(false);
 582
 583       /*
 584        * ensure that any newly discovered features (e.g. RESNUM)
 585        * are added to any open feature settings dialog
 586        */
 587       FeatureRenderer fr = getBinding().getFeatureRenderer(null);
 588       if (fr != null)
 589       {
 590         fr.featuresAdded();
 591       }
 592
 593       // refresh the sequence colours for the new structure(s)
 594       for (AlignmentPanel ap : _colourwith)
 595       {
 596         jmb.updateColours(ap);
 597       }
 598       // do superposition if asked to
 599       if (alignAddedStructures)
 600       {
 601         new Thread(new Runnable()
 602         {
 603           @Override
 604           public void run()
 605           {
 606             alignStructs_withAllAlignPanels();
 607           }
 608         }).start();
 609       }
 610       addingStructures = false;
 611     }
 612     _started = false;
 613     worker = null;
 614   }
 615
 616   /**
 617    * Fetch PDB data and save to a local file. Returns the full path to the file,
 618    * or null if fetch fails. TODO: refactor to common with Jmol ? duplication
 619    *
 620    * @param processingEntry
 621    * @return
 622    * @throws Exception
 623    */
 624
 625   private void stashFoundChains(StructureFile pdb, String file)
 626   {
 627     for (int i = 0; i < pdb.getChains().size(); i++)
 628     {
 629       String chid = new String(
 630               pdb.getId() + ":" + pdb.getChains().elementAt(i).id);
 631       jmb.getChainNames().add(chid);
 632       jmb.getChainFile().put(chid, file);
 633     }
 634   }
 635
 636   private String fetchPdbFile(PDBEntry processingEntry) throws Exception
 637   {
 638     // FIXME: this is duplicated code with Jmol frame ?
 639     String filePath = null;
 640     Pdb pdbclient = new Pdb();
 641     AlignmentI pdbseq = null;
 642     String pdbid = processingEntry.getId();
 643     long handle = System.currentTimeMillis()
 644             + Thread.currentThread().hashCode();
 645
 646     /*
 647      * Write 'fetching PDB' progress on AlignFrame as we are not yet visible
 648      */
 649     String msg = MessageManager.formatMessage("status.fetching_pdb",
 650             new Object[]
 651             { pdbid });
 652     getAlignmentPanel().alignFrame.setProgressBar(msg, handle);
 653     // long hdl = startProgressBar(MessageManager.formatMessage(
 654     // "status.fetching_pdb", new Object[]
 655     // { pdbid }));
 656     try
 657     {
 658       pdbseq = pdbclient.getSequenceRecords(pdbid);
 659     } catch (OutOfMemoryError oomerror)
 660     {
 661       new OOMWarning("Retrieving PDB id " + pdbid, oomerror);
 662     } finally
 663     {
 664       msg = pdbid + " " + MessageManager.getString("label.state_completed");
 665       getAlignmentPanel().alignFrame.setProgressBar(msg, handle);
 666       // stopProgressBar(msg, hdl);
 667     }
 668     /*
 669      * If PDB data were saved and are not invalid (empty alignment), return the
 670      * file path.
 671      */
 672     if (pdbseq != null && pdbseq.getHeight() > 0)
 673     {
 674       // just use the file name from the first sequence's first PDBEntry
 675       filePath = new File(pdbseq.getSequenceAt(0).getAllPDBEntries()
 676               .elementAt(0).getFile()).getAbsolutePath();
 677       processingEntry.setFile(filePath);
 678     }
 679     return filePath;
 680   }
 681
 682   /**
 683    * Convenience method to update the progress bar if there is one. Be sure to
 684    * call stopProgressBar with the returned handle to remove the message.
 685    *
 686    * @param msg
 687    * @param handle
 688    */
 689   public long startProgressBar(String msg)
 690   {
 691     // TODO would rather have startProgress/stopProgress as the
 692     // IProgressIndicator interface
 693     long tm = random.nextLong();
 694     if (progressBar != null)
 695     {
 696       progressBar.setProgressBar(msg, tm);
 697     }
 698     return tm;
 699   }
 700
 701   /**
 702    * End the progress bar with the specified handle, leaving a message (if not
 703    * null) on the status bar
 704    *
 705    * @param msg
 706    * @param handle
 707    */
 708   public void stopProgressBar(String msg, long handle)
 709   {
 710     if (progressBar != null)
 711     {
 712       progressBar.setProgressBar(msg, handle);
 713     }
 714   }
 715
 716   @Override
 717   public void eps_actionPerformed(ActionEvent e)
 718   {
 719     throw new Error(MessageManager
 720             .getString("error.eps_generation_not_implemented"));
 721   }
 722
 723   @Override
 724   public void png_actionPerformed(ActionEvent e)
 725   {
 726     throw new Error(MessageManager
 727             .getString("error.png_generation_not_implemented"));
 728   }
 729
 730   @Override
 731   public void showHelp_actionPerformed(ActionEvent actionEvent)
 732   {
 733     try
 734     {
 735       BrowserLauncher
 736               .openURL("https://www.cgl.ucsf.edu/chimera/docs/UsersGuide");
 737     } catch (IOException ex)
 738     {
 739     }
 740   }
 741
 742   @Override
 743   public AAStructureBindingModel getBinding()
 744   {
 745     return jmb;
 746   }
 747
 748   /**
 749    * Ask Chimera to save its session to the designated file path, or to a
 750    * temporary file if the path is null. Returns the file path if successful,
 751    * else null.
 752    *
 753    * @param filepath
 754    * @see getStateInfo
 755    */
 756   protected String saveSession(String filepath)
 757   {
 758     String pathUsed = filepath;
 759     try
 760     {
 761       if (pathUsed == null)
 762       {
 763         File tempFile = File.createTempFile("chimera", ".py");
 764         tempFile.deleteOnExit();
 765         pathUsed = tempFile.getPath();
 766       }
 767       boolean result = jmb.saveSession(pathUsed);
 768       if (result)
 769       {
 770         this.chimeraSessionFile = pathUsed;
 771         return pathUsed;
 772       }
 773     } catch (IOException e)
 774     {
 775     }
 776     return null;
 777   }
 778
 779   /**
 780    * Returns a string representing the state of the Chimera session. This is
 781    * done by requesting Chimera to save its session to a temporary file, then
 782    * reading the file contents. Returns an empty string on any error.
 783    */
 784   @Override
 785   public String getStateInfo()
 786   {
 787     String sessionFile = saveSession(null);
 788     if (sessionFile == null)
 789     {
 790       return "";
 791     }
 792     InputStream is = null;
 793     try
 794     {
 795       File f = new File(sessionFile);
 796       byte[] bytes = new byte[(int) f.length()];
 797       is = new FileInputStream(sessionFile);
 798       is.read(bytes);
 799       return new String(bytes);
 800     } catch (IOException e)
 801     {
 802       return "";
 803     } finally
 804     {
 805       if (is != null)
 806       {
 807         try
 808         {
 809           is.close();
 810         } catch (IOException e)
 811         {
 812           // ignore
 813         }
 814       }
 815     }
 816   }
 817
 818   @Override
 819   protected void fitToWindow_actionPerformed()
 820   {
 821     jmb.focusView();
 822   }
 823
 824   @Override
 825   public ViewerType getViewerType()
 826   {
 827     return ViewerType.CHIMERA;
 828   }
 829
 830   @Override
 831   protected String getViewerName()
 832   {
 833     return "Chimera";
 834   }
 835
 836   /**
 837    * Sends commands to align structures according to associated alignment(s).
 838    *
 839    * @return
 840    */
 841   @Override
 842   protected String alignStructs_withAllAlignPanels()
 843   {
 844     String reply = super.alignStructs_withAllAlignPanels();
 845     if (reply != null)
 846     {
 847       statusBar.setText("Superposition failed: " + reply);
 848     }
 849     return reply;
 850   }
 851
 852   @Override
 853   protected IProgressIndicator getIProgressIndicator()
 854   {
 855     return progressBar;
 856   }
 857 }