JAL-1632 add score model params to PCAModel and PCA constructors
[jalview.git] / src / jalview / gui / StructureViewerBase.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.bin.Cache;
24 import jalview.datamodel.Alignment;
25 import jalview.datamodel.AlignmentI;
26 import jalview.datamodel.ColumnSelection;
27 import jalview.datamodel.PDBEntry;
28 import jalview.datamodel.SequenceI;
29 import jalview.gui.StructureViewer.ViewerType;
30 import jalview.gui.ViewSelectionMenu.ViewSetProvider;
31 import jalview.io.DataSourceType;
32 import jalview.io.JalviewFileChooser;
33 import jalview.io.JalviewFileView;
34 import jalview.jbgui.GStructureViewer;
35 import jalview.schemes.ColourSchemeI;
36 import jalview.schemes.ColourSchemes;
37 import jalview.structures.models.AAStructureBindingModel;
38 import jalview.util.MessageManager;
39
40 import java.awt.Color;
41 import java.awt.Component;
42 import java.awt.event.ActionEvent;
43 import java.awt.event.ActionListener;
44 import java.awt.event.ItemEvent;
45 import java.awt.event.ItemListener;
46 import java.io.BufferedReader;
47 import java.io.File;
48 import java.io.FileOutputStream;
49 import java.io.FileReader;
50 import java.io.IOException;
51 import java.io.PrintWriter;
52 import java.util.ArrayList;
53 import java.util.List;
54 import java.util.Vector;
55
56 import javax.swing.ButtonGroup;
57 import javax.swing.JCheckBoxMenuItem;
58 import javax.swing.JColorChooser;
59 import javax.swing.JMenu;
60 import javax.swing.JMenuItem;
61 import javax.swing.JRadioButtonMenuItem;
62 import javax.swing.event.MenuEvent;
63 import javax.swing.event.MenuListener;
64
65 /**
66  * Base class with common functionality for JMol, Chimera or other structure
67  * viewers.
68  * 
69  * @author gmcarstairs
70  *
71  */
72 public abstract class StructureViewerBase extends GStructureViewer
73         implements Runnable, ViewSetProvider
74 {
75   /*
76    * names for colour options (additional to Jalview colour schemes)
77    */
78   enum ViewerColour
79   {
80     BySequence, ByChain, ChargeCysteine, ByViewer
81   }
82
83   /**
84    * list of sequenceSet ids associated with the view
85    */
86   protected List<String> _aps = new ArrayList<String>();
87
88   /**
89    * list of alignment panels to use for superposition
90    */
91   protected Vector<AlignmentPanel> _alignwith = new Vector<AlignmentPanel>();
92
93   /**
94    * list of alignment panels that are used for colouring structures by aligned
95    * sequences
96    */
97   protected Vector<AlignmentPanel> _colourwith = new Vector<AlignmentPanel>();
98
99   private String viewId = null;
100
101   private AlignmentPanel ap;
102
103   protected boolean alignAddedStructures = false;
104
105   protected boolean _started = false;
106
107   protected boolean addingStructures = false;
108
109   protected Thread worker = null;
110
111   protected boolean allChainsSelected = false;
112
113   /**
114    * Default constructor
115    */
116   public StructureViewerBase()
117   {
118     super();
119   }
120   /**
121    * 
122    * @param ap2
123    * @return true if this Jmol instance is linked with the given alignPanel
124    */
125   public boolean isLinkedWith(AlignmentPanel ap2)
126   {
127     return _aps.contains(ap2.av.getSequenceSetId());
128   }
129
130   public boolean isUsedforaligment(AlignmentPanel ap2)
131   {
132
133     return (_alignwith != null) && _alignwith.contains(ap2);
134   }
135
136   public boolean isUsedforcolourby(AlignmentPanel ap2)
137   {
138     return (_colourwith != null) && _colourwith.contains(ap2);
139   }
140
141   /**
142    * 
143    * @return TRUE if the view is NOT being coloured by the alignment colours.
144    */
145   public boolean isColouredByViewer()
146   {
147     return !getBinding().isColourBySequence();
148   }
149
150   public String getViewId()
151   {
152     if (viewId == null)
153     {
154       viewId = System.currentTimeMillis() + "." + this.hashCode();
155     }
156     return viewId;
157   }
158
159   protected void setViewId(String viewId)
160   {
161     this.viewId = viewId;
162   }
163
164   public abstract String getStateInfo();
165
166   protected void buildActionMenu()
167   {
168     if (_alignwith == null)
169     {
170       _alignwith = new Vector<AlignmentPanel>();
171     }
172     if (_alignwith.size() == 0 && ap != null)
173     {
174       _alignwith.add(ap);
175     }
176     ;
177     for (Component c : viewerActionMenu.getMenuComponents())
178     {
179       if (c != alignStructs)
180       {
181         viewerActionMenu.remove((JMenuItem) c);
182       }
183     }
184   }
185
186   public AlignmentPanel getAlignmentPanel()
187   {
188     return ap;
189   }
190
191   protected void setAlignmentPanel(AlignmentPanel alp)
192   {
193     this.ap = alp;
194   }
195
196   @Override
197   public AlignmentPanel[] getAllAlignmentPanels()
198   {
199     AlignmentPanel[] t, list = new AlignmentPanel[0];
200     for (String setid : _aps)
201     {
202       AlignmentPanel[] panels = PaintRefresher.getAssociatedPanels(setid);
203       if (panels != null)
204       {
205         t = new AlignmentPanel[list.length + panels.length];
206         System.arraycopy(list, 0, t, 0, list.length);
207         System.arraycopy(panels, 0, t, list.length, panels.length);
208         list = t;
209       }
210     }
211
212     return list;
213   }
214
215   /**
216    * set the primary alignmentPanel reference and add another alignPanel to the
217    * list of ones to use for colouring and aligning
218    * 
219    * @param nap
220    */
221   public void addAlignmentPanel(AlignmentPanel nap)
222   {
223     if (getAlignmentPanel() == null)
224     {
225       setAlignmentPanel(nap);
226     }
227     if (!_aps.contains(nap.av.getSequenceSetId()))
228     {
229       _aps.add(nap.av.getSequenceSetId());
230     }
231   }
232
233   /**
234    * remove any references held to the given alignment panel
235    * 
236    * @param nap
237    */
238   public void removeAlignmentPanel(AlignmentPanel nap)
239   {
240     try
241     {
242       _alignwith.remove(nap);
243       _colourwith.remove(nap);
244       if (getAlignmentPanel() == nap)
245       {
246         setAlignmentPanel(null);
247         for (AlignmentPanel aps : getAllAlignmentPanels())
248         {
249           if (aps != nap)
250           {
251             setAlignmentPanel(aps);
252             break;
253           }
254         }
255       }
256     } catch (Exception ex)
257     {
258     }
259     if (getAlignmentPanel() != null)
260     {
261       buildActionMenu();
262     }
263   }
264
265   public void useAlignmentPanelForSuperposition(AlignmentPanel nap)
266   {
267     addAlignmentPanel(nap);
268     if (!_alignwith.contains(nap))
269     {
270       _alignwith.add(nap);
271     }
272   }
273
274   public void excludeAlignmentPanelForSuperposition(AlignmentPanel nap)
275   {
276     if (_alignwith.contains(nap))
277     {
278       _alignwith.remove(nap);
279     }
280   }
281
282   public void useAlignmentPanelForColourbyseq(AlignmentPanel nap,
283           boolean enableColourBySeq)
284   {
285     useAlignmentPanelForColourbyseq(nap);
286     getBinding().setColourBySequence(enableColourBySeq);
287     seqColour.setSelected(enableColourBySeq);
288     viewerColour.setSelected(!enableColourBySeq);
289   }
290
291   public void useAlignmentPanelForColourbyseq(AlignmentPanel nap)
292   {
293     addAlignmentPanel(nap);
294     if (!_colourwith.contains(nap))
295     {
296       _colourwith.add(nap);
297     }
298   }
299
300   public void excludeAlignmentPanelForColourbyseq(AlignmentPanel nap)
301   {
302     if (_colourwith.contains(nap))
303     {
304       _colourwith.remove(nap);
305     }
306   }
307
308   public abstract ViewerType getViewerType();
309
310   /**
311    * add a new structure (with associated sequences and chains) to this viewer,
312    * retrieving it if necessary first.
313    * 
314    * @param pdbentry
315    * @param seqs
316    * @param chains
317    * @param align
318    *          if true, new structure(s) will be aligned using associated
319    *          alignment
320    * @param alignFrame
321    */
322   protected void addStructure(final PDBEntry pdbentry,
323           final SequenceI[] seqs, final String[] chains,
324           final boolean align, final IProgressIndicator alignFrame)
325   {
326     if (pdbentry.getFile() == null)
327     {
328       if (worker != null && worker.isAlive())
329       {
330         // a retrieval is in progress, wait around and add ourselves to the
331         // queue.
332         new Thread(new Runnable()
333         {
334           @Override
335           public void run()
336           {
337             while (worker != null && worker.isAlive() && _started)
338             {
339               try
340               {
341                 Thread.sleep(100 + ((int) Math.random() * 100));
342
343               } catch (Exception e)
344               {
345               }
346             }
347             // and call ourselves again.
348             addStructure(pdbentry, seqs, chains, align, alignFrame);
349           }
350         }).start();
351         return;
352       }
353     }
354     // otherwise, start adding the structure.
355     getBinding().addSequenceAndChain(new PDBEntry[] { pdbentry },
356             new SequenceI[][] { seqs }, new String[][] { chains });
357     addingStructures = true;
358     _started = false;
359     alignAddedStructures = align;
360     worker = new Thread(this);
361     worker.start();
362     return;
363   }
364
365   /**
366    * Presents a dialog with the option to add an align a structure to an
367    * existing structure view
368    * 
369    * @param pdbId
370    * @param view
371    * @return YES, NO or CANCEL JvOptionPane code
372    */
373   protected int chooseAlignStructureToViewer(String pdbId,
374           StructureViewerBase view)
375   {
376     int option = JvOptionPane.showInternalConfirmDialog(Desktop.desktop,
377             MessageManager.formatMessage("label.add_pdbentry_to_view",
378                     new Object[] { pdbId, view.getTitle() }),
379             MessageManager
380                     .getString("label.align_to_existing_structure_view"),
381             JvOptionPane.YES_NO_CANCEL_OPTION);
382     return option;
383   }
384
385   protected boolean hasPdbId(String pdbId)
386   {
387     return getBinding().hasPdbId(pdbId);
388   }
389
390   protected abstract List<StructureViewerBase> getViewersFor(
391           AlignmentPanel alp);
392
393   /**
394    * Check for any existing views involving this alignment and give user the
395    * option to add and align this molecule to one of them
396    * 
397    * @param pdbentry
398    * @param seq
399    * @param chains
400    * @param apanel
401    * @param pdbId
402    * @return true if user adds to a view, or cancels entirely, else false
403    */
404   protected boolean addToExistingViewer(PDBEntry pdbentry, SequenceI[] seq,
405           String[] chains, final AlignmentPanel apanel, String pdbId)
406   {
407     for (StructureViewerBase view : getViewersFor(apanel))
408     {
409       // TODO: highlight the view somehow
410       /*
411        * JAL-1742 exclude view with this structure already mapped (don't offer
412        * to align chain B to chain A of the same structure)
413        */
414       if (view.hasPdbId(pdbId))
415       {
416         continue;
417       }
418       int option = chooseAlignStructureToViewer(pdbId, view);
419       if (option == JvOptionPane.CANCEL_OPTION)
420       {
421         return true;
422       }
423       else if (option == JvOptionPane.YES_OPTION)
424       {
425         view.useAlignmentPanelForSuperposition(apanel);
426         view.addStructure(pdbentry, seq, chains, true, apanel.alignFrame);
427         return true;
428       }
429       else
430       {
431         // NO_OPTION - offer the next viewer if any
432       }
433     }
434
435     /*
436      * nothing offered and selected
437      */
438     return false;
439   }
440
441   /**
442    * Adds mappings for the given sequences to an already opened PDB structure,
443    * and updates any viewers that have the PDB file
444    * 
445    * @param seq
446    * @param chains
447    * @param apanel
448    * @param pdbFilename
449    */
450   protected void addSequenceMappingsToStructure(SequenceI[] seq,
451           String[] chains, final AlignmentPanel apanel, String pdbFilename)
452   {
453     // TODO : Fix multiple seq to one chain issue here.
454     /*
455      * create the mappings
456      */
457     apanel.getStructureSelectionManager().setMapping(seq, chains,
458             pdbFilename, DataSourceType.FILE);
459
460     /*
461      * alert the FeatureRenderer to show new (PDB RESNUM) features
462      */
463     if (apanel.getSeqPanel().seqCanvas.fr != null)
464     {
465       apanel.getSeqPanel().seqCanvas.fr.featuresAdded();
466       apanel.paintAlignment(true);
467     }
468
469     /*
470      * add the sequences to any other viewers (of the same type) for this pdb
471      * file
472      */
473     // JBPNOTE: this looks like a binding routine, rather than a gui routine
474     for (StructureViewerBase viewer : getViewersFor(null))
475     {
476       AAStructureBindingModel bindingModel = viewer.getBinding();
477       for (int pe = 0; pe < bindingModel.getPdbCount(); pe++)
478       {
479         if (bindingModel.getPdbEntry(pe).getFile().equals(pdbFilename))
480         {
481           bindingModel.addSequence(pe, seq);
482           viewer.addAlignmentPanel(apanel);
483           /*
484            * add it to the set of alignments used for colouring structure by
485            * sequence
486            */
487           viewer.useAlignmentPanelForColourbyseq(apanel);
488           viewer.buildActionMenu();
489           apanel.getStructureSelectionManager().sequenceColoursChanged(
490                   apanel);
491           break;
492         }
493       }
494     }
495   }
496
497   /**
498    * Check if the PDB file is already loaded, if so offer to add it to the
499    * existing viewer
500    * 
501    * @param seq
502    * @param chains
503    * @param apanel
504    * @param pdbId
505    * @return true if the user chooses to add to a viewer, or to cancel entirely
506    */
507   protected boolean addAlreadyLoadedFile(SequenceI[] seq, String[] chains,
508           final AlignmentPanel apanel, String pdbId)
509   {
510     boolean finished = false;
511     String alreadyMapped = apanel.getStructureSelectionManager()
512             .alreadyMappedToFile(pdbId);
513
514     if (alreadyMapped != null)
515     {
516       /*
517        * the PDB file is already loaded
518        */
519       int option = JvOptionPane.showInternalConfirmDialog(Desktop.desktop,
520               MessageManager.formatMessage(
521                       "label.pdb_entry_is_already_displayed",
522                       new Object[] { pdbId }), MessageManager
523                       .formatMessage(
524                               "label.map_sequences_to_visible_window",
525                               new Object[] { pdbId }),
526               JvOptionPane.YES_NO_CANCEL_OPTION);
527       if (option == JvOptionPane.CANCEL_OPTION)
528       {
529         finished = true;
530       }
531       else if (option == JvOptionPane.YES_OPTION)
532       {
533         addSequenceMappingsToStructure(seq, chains, apanel, alreadyMapped);
534         finished = true;
535       }
536     }
537     return finished;
538   }
539
540   void setChainMenuItems(List<String> chainNames)
541   {
542     chainMenu.removeAll();
543     if (chainNames == null || chainNames.isEmpty())
544     {
545       return;
546     }
547     JMenuItem menuItem = new JMenuItem(
548             MessageManager.getString("label.all"));
549     menuItem.addActionListener(new ActionListener()
550     {
551       @Override
552       public void actionPerformed(ActionEvent evt)
553       {
554         allChainsSelected = true;
555         for (int i = 0; i < chainMenu.getItemCount(); i++)
556         {
557           if (chainMenu.getItem(i) instanceof JCheckBoxMenuItem)
558           {
559             ((JCheckBoxMenuItem) chainMenu.getItem(i)).setSelected(true);
560           }
561         }
562         showSelectedChains();
563         allChainsSelected = false;
564       }
565     });
566
567     chainMenu.add(menuItem);
568
569     for (String chain : chainNames)
570     {
571       menuItem = new JCheckBoxMenuItem(chain, true);
572       menuItem.addItemListener(new ItemListener()
573       {
574         @Override
575         public void itemStateChanged(ItemEvent evt)
576         {
577           if (!allChainsSelected)
578           {
579             showSelectedChains();
580           }
581         }
582       });
583
584       chainMenu.add(menuItem);
585     }
586   }
587
588   abstract void showSelectedChains();
589
590   /**
591    * Action on selecting one of Jalview's registered colour schemes
592    */
593   @Override
594   public void changeColour_actionPerformed(String colourSchemeName)
595   {
596     AlignmentI al = getAlignmentPanel().av.getAlignment();
597     ColourSchemeI cs = ColourSchemes.getInstance().getColourScheme(
598             colourSchemeName, al, null);
599     getBinding().setJalviewColourScheme(cs);
600   }
601
602   /**
603    * Builds the colour menu
604    */
605   protected void buildColourMenu()
606   {
607     colourMenu.removeAll();
608     AlignmentI al = getAlignmentPanel().av.getAlignment();
609
610     /*
611      * add colour by sequence, by chain, by charge and cysteine
612      */
613     colourMenu.add(seqColour);
614     colourMenu.add(chainColour);
615     colourMenu.add(chargeColour);
616     chargeColour.setEnabled(!al.isNucleotide());
617
618     /*
619      * add all 'simple' (per-residue) colour schemes registered to Jalview
620      */
621     ButtonGroup itemGroup = ColourMenuHelper.addMenuItems(colourMenu, this,
622             al, true);
623
624     /*
625      * add 'colour by viewer' (menu item text is set in subclasses)
626      */
627     viewerColour.setSelected(false);
628     viewerColour.addActionListener(new ActionListener()
629     {
630       @Override
631       public void actionPerformed(ActionEvent actionEvent)
632       {
633         viewerColour_actionPerformed(actionEvent);
634       }
635     });
636     colourMenu.add(viewerColour);
637
638     /*
639      * add 'set background colour'
640      */
641     JMenuItem backGround = new JMenuItem();
642     backGround
643             .setText(MessageManager.getString("action.background_colour"));
644     backGround.addActionListener(new ActionListener()
645     {
646       @Override
647       public void actionPerformed(ActionEvent actionEvent)
648       {
649         background_actionPerformed(actionEvent);
650       }
651     });
652     colourMenu.add(backGround);
653
654     /*
655      * add colour buttons to a group so their selection is
656      * mutually exclusive (background colour is a separate option)
657      */
658     itemGroup.add(seqColour);
659     itemGroup.add(chainColour);
660     itemGroup.add(chargeColour);
661     itemGroup.add(viewerColour);
662   }
663
664   /**
665    * Construct menu items
666    */
667   protected void initMenus()
668   {
669     AAStructureBindingModel binding = getBinding();
670
671     seqColour = new JRadioButtonMenuItem();
672     seqColour.setText(MessageManager.getString("action.by_sequence"));
673     seqColour.setName(ViewerColour.BySequence.name());
674     seqColour.setSelected(binding.isColourBySequence());
675     seqColour.addActionListener(new ActionListener()
676     {
677       @Override
678       public void actionPerformed(ActionEvent actionEvent)
679       {
680         seqColour_actionPerformed(actionEvent);
681       }
682     });
683
684     chainColour = new JRadioButtonMenuItem();
685     chainColour.setText(MessageManager.getString("action.by_chain"));
686     chainColour.setName(ViewerColour.ByChain.name());
687     chainColour.addActionListener(new ActionListener()
688     {
689       @Override
690       public void actionPerformed(ActionEvent actionEvent)
691       {
692         chainColour_actionPerformed(actionEvent);
693       }
694     });
695
696     chargeColour = new JRadioButtonMenuItem();
697     chargeColour.setText(MessageManager.getString("label.charge_cysteine"));
698     chargeColour.setName(ViewerColour.ChargeCysteine.name());
699     chargeColour.addActionListener(new ActionListener()
700     {
701       @Override
702       public void actionPerformed(ActionEvent actionEvent)
703       {
704         chargeColour_actionPerformed(actionEvent);
705       }
706     });
707
708     viewerColour = new JRadioButtonMenuItem();
709     // text is set in overrides of this method
710     viewerColour.setName(ViewerColour.ByViewer.name());
711     viewerColour.setSelected(!binding.isColourBySequence());
712
713     if (_colourwith == null)
714     {
715       _colourwith = new Vector<AlignmentPanel>();
716     }
717     if (_alignwith == null)
718     {
719       _alignwith = new Vector<AlignmentPanel>();
720     }
721
722     ViewSelectionMenu seqColourBy = new ViewSelectionMenu(
723             MessageManager.getString("label.colour_by"), this, _colourwith,
724             new ItemListener()
725             {
726               @Override
727               public void itemStateChanged(ItemEvent e)
728               {
729                 if (!seqColour.isSelected())
730                 {
731                   seqColour.doClick();
732                 }
733                 else
734                 {
735                   // update the Chimera display now.
736                   seqColour_actionPerformed(null);
737                 }
738               }
739             });
740     viewMenu.add(seqColourBy);
741
742     final ItemListener handler = new ItemListener()
743     {
744       @Override
745       public void itemStateChanged(ItemEvent e)
746       {
747         alignStructs.setEnabled(_alignwith.size() > 0);
748         alignStructs.setToolTipText(MessageManager.formatMessage(
749                 "label.align_structures_using_linked_alignment_views",
750                 new String[] { String.valueOf(_alignwith.size()) }));
751       }
752     };
753     JMenu alpanels = new ViewSelectionMenu(
754             MessageManager.getString("label.superpose_with"), this,
755             _alignwith, handler);
756     handler.itemStateChanged(null);
757     viewerActionMenu.add(alpanels);
758     viewerActionMenu.addMenuListener(new MenuListener()
759     {
760       @Override
761       public void menuSelected(MenuEvent e)
762       {
763         handler.itemStateChanged(null);
764       }
765
766       @Override
767       public void menuDeselected(MenuEvent e)
768       {
769       }
770
771       @Override
772       public void menuCanceled(MenuEvent e)
773       {
774       }
775     });
776
777     buildColourMenu();
778   }
779
780   @Override
781   public void setJalviewColourScheme(ColourSchemeI cs) {
782     getBinding().setJalviewColourScheme(cs);
783   }
784   @Override
785   protected void alignStructs_actionPerformed(ActionEvent actionEvent)
786   {
787     alignStructs_withAllAlignPanels();
788   }
789   protected void alignStructs_withAllAlignPanels()
790   {
791     if (getAlignmentPanel() == null)
792     {
793       return;
794     }
795   
796     if (_alignwith.size() == 0)
797     {
798       _alignwith.add(getAlignmentPanel());
799     }
800   
801     try
802     {
803       AlignmentI[] als = new Alignment[_alignwith.size()];
804       ColumnSelection[] alc = new ColumnSelection[_alignwith.size()];
805       int[] alm = new int[_alignwith.size()];
806       int a = 0;
807   
808       for (AlignmentPanel ap : _alignwith)
809       {
810         als[a] = ap.av.getAlignment();
811         alm[a] = -1;
812         alc[a++] = ap.av.getColumnSelection();
813       }
814       getBinding().superposeStructures(als, alm, alc);
815     } catch (Exception e)
816     {
817       StringBuffer sp = new StringBuffer();
818       for (AlignmentPanel ap : _alignwith)
819       {
820         sp.append("'" + ap.alignFrame.getTitle() + "' ");
821       }
822       Cache.log.info("Couldn't align structures with the " + sp.toString()
823               + "associated alignment panels.", e);
824     }
825   }
826   @Override
827   public void background_actionPerformed(ActionEvent actionEvent)
828   {
829     Color col = JColorChooser.showDialog(this,
830             MessageManager.getString("label.select_background_colour"),
831             null);
832     if (col != null)
833     {
834       getBinding().setBackgroundColour(col);
835     }
836   }
837   @Override
838   public void viewerColour_actionPerformed(ActionEvent actionEvent)
839   {
840     if (viewerColour.isSelected())
841     {
842       // disable automatic sequence colouring.
843       getBinding().setColourBySequence(false);
844     }
845   }
846   @Override
847   public void chainColour_actionPerformed(ActionEvent actionEvent)
848   {
849     chainColour.setSelected(true);
850     getBinding().colourByChain();
851   }
852   @Override
853   public void chargeColour_actionPerformed(ActionEvent actionEvent)
854   {
855     chargeColour.setSelected(true);
856     getBinding().colourByCharge();
857   }
858   @Override
859   public void seqColour_actionPerformed(ActionEvent actionEvent)
860   {
861     AAStructureBindingModel binding = getBinding();
862     binding.setColourBySequence(seqColour.isSelected());
863     if (_colourwith == null)
864     {
865       _colourwith = new Vector<AlignmentPanel>();
866     }
867     if (binding.isColourBySequence())
868     {
869       if (!binding.isLoadingFromArchive())
870       {
871         if (_colourwith.size() == 0 && getAlignmentPanel() != null)
872         {
873           // Make the currently displayed alignment panel the associated view
874           _colourwith.add(getAlignmentPanel().alignFrame.alignPanel);
875         }
876       }
877       // Set the colour using the current view for the associated alignframe
878       for (AlignmentPanel ap : _colourwith)
879       {
880         binding.colourBySequence(ap);
881       }
882     }
883   }
884   @Override
885   public void pdbFile_actionPerformed(ActionEvent actionEvent)
886   {
887     JalviewFileChooser chooser = new JalviewFileChooser(
888             Cache.getProperty("LAST_DIRECTORY"));
889   
890     chooser.setFileView(new JalviewFileView());
891     chooser.setDialogTitle(MessageManager.getString("label.save_pdb_file"));
892     chooser.setToolTipText(MessageManager.getString("action.save"));
893   
894     int value = chooser.showSaveDialog(this);
895   
896     if (value == JalviewFileChooser.APPROVE_OPTION)
897     {
898       BufferedReader in = null;
899       try
900       {
901         // TODO: cope with multiple PDB files in view
902         in = new BufferedReader(
903                 new FileReader(getBinding().getPdbFile()[0]));
904         File outFile = chooser.getSelectedFile();
905   
906         PrintWriter out = new PrintWriter(new FileOutputStream(outFile));
907         String data;
908         while ((data = in.readLine()) != null)
909         {
910           if (!(data.indexOf("<PRE>") > -1 || data.indexOf("</PRE>") > -1))
911           {
912             out.println(data);
913           }
914         }
915         out.close();
916       } catch (Exception ex)
917       {
918         ex.printStackTrace();
919       } finally
920       {
921         if (in != null)
922         {
923           try
924           {
925             in.close();
926           } catch (IOException e)
927           {
928             // ignore
929           }
930         }
931       }
932     }
933   }
934   @Override
935   public void viewMapping_actionPerformed(ActionEvent actionEvent)
936   {
937     CutAndPasteTransfer cap = new CutAndPasteTransfer();
938     try
939     {
940       cap.appendText(getBinding().printMappings());
941     } catch (OutOfMemoryError e)
942     {
943       new OOMWarning(
944               "composing sequence-structure alignments for display in text box.",
945               e);
946       cap.dispose();
947       return;
948     }
949     Desktop.addInternalFrame(cap,
950             MessageManager.getString("label.pdb_sequence_mapping"), 550,
951             600);
952   }
953
954   protected abstract String getViewerName();
955   public void updateTitleAndMenus()
956   {
957     AAStructureBindingModel binding = getBinding();
958     if (binding.hasFileLoadingError())
959     {
960       repaint();
961       return;
962     }
963     setChainMenuItems(binding.getChainNames());
964   
965     this.setTitle(binding.getViewerTitle(getViewerName(), true));
966     if (binding.getPdbFile().length > 1 && binding.getSequence().length > 1)
967     {
968       viewerActionMenu.setVisible(true);
969     }
970     if (!binding.isLoadingFromArchive())
971     {
972       seqColour_actionPerformed(null);
973     }
974   }
975 }