JAL-2416 remove unused pep, dna alphabets, unused methods, code format
[jalview.git] / src / MCview / AppletPDBCanvas.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 MCview;
22
23 import jalview.analysis.AlignSeq;
24 import jalview.appletgui.AlignmentPanel;
25 import jalview.appletgui.FeatureRenderer;
26 import jalview.appletgui.SequenceRenderer;
27 import jalview.datamodel.PDBEntry;
28 import jalview.datamodel.SequenceI;
29 import jalview.io.DataSourceType;
30 import jalview.io.StructureFile;
31 import jalview.structure.AtomSpec;
32 import jalview.structure.StructureListener;
33 import jalview.structure.StructureMapping;
34 import jalview.structure.StructureSelectionManager;
35 import jalview.util.MessageManager;
36
37 import java.awt.Color;
38 import java.awt.Dimension;
39 import java.awt.Event;
40 import java.awt.Font;
41 import java.awt.Graphics;
42 import java.awt.Image;
43 // JBPNote TODO: This class is quite noisy - needs proper log.info/log.debug
44 import java.awt.Panel;
45 import java.awt.event.KeyAdapter;
46 import java.awt.event.KeyEvent;
47 import java.awt.event.MouseEvent;
48 import java.awt.event.MouseListener;
49 import java.awt.event.MouseMotionListener;
50 import java.io.PrintStream;
51 import java.util.List;
52 import java.util.Vector;
53
54 public class AppletPDBCanvas extends Panel implements MouseListener,
55         MouseMotionListener, StructureListener
56 {
57
58   MCMatrix idmat = new MCMatrix(3, 3);
59
60   MCMatrix objmat = new MCMatrix(3, 3);
61
62   boolean redrawneeded = true;
63
64   int omx = 0;
65
66   int mx = 0;
67
68   int omy = 0;
69
70   int my = 0;
71
72   public StructureFile pdb;
73
74   PDBEntry pdbentry;
75
76   int bsize;
77
78   Image img;
79
80   Graphics ig;
81
82   Dimension prefsize;
83
84   float[] centre = new float[3];
85
86   float[] width = new float[3];
87
88   float maxwidth;
89
90   float scale;
91
92   String inStr;
93
94   String inType;
95
96   boolean bysequence = true;
97
98   boolean depthcue = true;
99
100   boolean wire = false;
101
102   boolean bymolecule = false;
103
104   boolean zbuffer = true;
105
106   boolean dragging;
107
108   int xstart;
109
110   int xend;
111
112   int ystart;
113
114   int yend;
115
116   int xmid;
117
118   int ymid;
119
120   Font font = new Font("Helvetica", Font.PLAIN, 10);
121
122   public SequenceI[] sequence;
123
124   final StringBuffer mappingDetails = new StringBuffer();
125
126   String appletToolTip = null;
127
128   int toolx, tooly;
129
130   PDBChain mainchain;
131
132   Vector<String> highlightRes;
133
134   boolean pdbAction = false;
135
136   Bond highlightBond1, highlightBond2;
137
138   boolean errorLoading = false;
139
140   boolean seqColoursReady = false;
141
142   FeatureRenderer fr;
143
144   AlignmentPanel ap;
145
146   StructureSelectionManager ssm;
147
148   public AppletPDBCanvas(PDBEntry pdbentry, SequenceI[] seq,
149           String[] chains, AlignmentPanel ap, DataSourceType protocol)
150
151   {
152     this.ap = ap;
153     this.pdbentry = pdbentry;
154     this.sequence = seq;
155
156     ssm = StructureSelectionManager
157             .getStructureSelectionManager(ap.av.applet);
158
159     try
160     {
161       pdb = ssm.setMapping(seq, chains, pdbentry.getFile(), protocol);
162
163       if (protocol == DataSourceType.PASTE)
164       {
165         pdbentry.setFile("INLINE" + pdb.getId());
166       }
167
168     } catch (Exception ex)
169     {
170       ex.printStackTrace();
171       return;
172     }
173
174     pdbentry.setId(pdb.getId());
175
176     ssm.addStructureViewerListener(this);
177
178     colourBySequence();
179
180     float max = -10;
181     int maxchain = -1;
182     int pdbstart = 0;
183     int pdbend = 0;
184     int seqstart = 0;
185     int seqend = 0;
186
187     // JUST DEAL WITH ONE SEQUENCE FOR NOW
188     SequenceI sequence = seq[0];
189
190     for (int i = 0; i < pdb.getChains().size(); i++)
191     {
192
193       mappingDetails
194               .append("\n\nPDB Sequence is :\nSequence = "
195                       + pdb.getChains().elementAt(i).sequence
196                               .getSequenceAsString());
197       mappingDetails.append("\nNo of residues = "
198               + pdb.getChains().elementAt(i).residues.size() + "\n\n");
199
200       // Now lets compare the sequences to get
201       // the start and end points.
202       // Align the sequence to the pdb
203       // TODO: DNa/Pep switch
204       AlignSeq as = new AlignSeq(sequence,
205               pdb.getChains().elementAt(i).sequence, pdb.getChains()
206                       .elementAt(i).isNa ? AlignSeq.DNA : AlignSeq.PEP);
207       as.calcScoreMatrix();
208       as.traceAlignment();
209       PrintStream ps = new PrintStream(System.out)
210       {
211         @Override
212         public void print(String x)
213         {
214           mappingDetails.append(x);
215         }
216
217         @Override
218         public void println()
219         {
220           mappingDetails.append("\n");
221         }
222       };
223
224       as.printAlignment(ps);
225
226       if (as.maxscore > max)
227       {
228         max = as.maxscore;
229         maxchain = i;
230
231         pdbstart = as.seq2start;
232         pdbend = as.seq2end;
233         seqstart = as.seq1start + sequence.getStart() - 1;
234         seqend = as.seq1end + sequence.getEnd() - 1;
235       }
236
237       mappingDetails.append("\nPDB start/end " + pdbstart + " " + pdbend);
238       mappingDetails.append("\nSEQ start/end " + seqstart + " " + seqend);
239     }
240
241     mainchain = pdb.getChains().elementAt(maxchain);
242
243     mainchain.pdbstart = pdbstart;
244     mainchain.pdbend = pdbend;
245     mainchain.seqstart = seqstart;
246     mainchain.seqend = seqend;
247     mainchain.isVisible = true;
248     // mainchain.makeExactMapping(maxAlignseq, sequence);
249     // mainchain.transferRESNUMFeatures(sequence, null);
250     this.pdb = pdb;
251     this.prefsize = new Dimension(getSize().width, getSize().height);
252
253     // Initialize the matrices to identity
254     for (int i = 0; i < 3; i++)
255     {
256       for (int j = 0; j < 3; j++)
257       {
258         if (i != j)
259         {
260           idmat.addElement(i, j, 0);
261           objmat.addElement(i, j, 0);
262         }
263         else
264         {
265           idmat.addElement(i, j, 1);
266           objmat.addElement(i, j, 1);
267         }
268       }
269     }
270
271     addMouseMotionListener(this);
272     addMouseListener(this);
273
274     addKeyListener(new KeyAdapter()
275     {
276       @Override
277       public void keyPressed(KeyEvent evt)
278       {
279         doKeyPressed(evt);
280       }
281     });
282
283     findCentre();
284     findWidth();
285
286     setupBonds();
287
288     scale = findScale();
289   }
290
291   Vector<Bond> visiblebonds;
292
293   void setupBonds()
294   {
295     seqColoursReady = false;
296     // Sort the bonds by z coord
297     visiblebonds = new Vector<Bond>();
298
299     for (int ii = 0; ii < pdb.getChains().size(); ii++)
300     {
301       if (pdb.getChains().elementAt(ii).isVisible)
302       {
303         Vector<Bond> tmp = pdb.getChains().elementAt(ii).bonds;
304
305         for (int i = 0; i < tmp.size(); i++)
306         {
307           visiblebonds.addElement(tmp.elementAt(i));
308         }
309       }
310     }
311     seqColoursReady = true;
312     colourBySequence();
313     redrawneeded = true;
314     repaint();
315   }
316
317   public void findWidth()
318   {
319     float[] max = new float[3];
320     float[] min = new float[3];
321
322     max[0] = (float) -1e30;
323     max[1] = (float) -1e30;
324     max[2] = (float) -1e30;
325
326     min[0] = (float) 1e30;
327     min[1] = (float) 1e30;
328     min[2] = (float) 1e30;
329
330     for (int ii = 0; ii < pdb.getChains().size(); ii++)
331     {
332       if (pdb.getChains().elementAt(ii).isVisible)
333       {
334         Vector<Bond> bonds = pdb.getChains().elementAt(ii).bonds;
335
336         for (Bond tmp : bonds)
337         {
338           if (tmp.start[0] >= max[0])
339           {
340             max[0] = tmp.start[0];
341           }
342
343           if (tmp.start[1] >= max[1])
344           {
345             max[1] = tmp.start[1];
346           }
347
348           if (tmp.start[2] >= max[2])
349           {
350             max[2] = tmp.start[2];
351           }
352
353           if (tmp.start[0] <= min[0])
354           {
355             min[0] = tmp.start[0];
356           }
357
358           if (tmp.start[1] <= min[1])
359           {
360             min[1] = tmp.start[1];
361           }
362
363           if (tmp.start[2] <= min[2])
364           {
365             min[2] = tmp.start[2];
366           }
367
368           if (tmp.end[0] >= max[0])
369           {
370             max[0] = tmp.end[0];
371           }
372
373           if (tmp.end[1] >= max[1])
374           {
375             max[1] = tmp.end[1];
376           }
377
378           if (tmp.end[2] >= max[2])
379           {
380             max[2] = tmp.end[2];
381           }
382
383           if (tmp.end[0] <= min[0])
384           {
385             min[0] = tmp.end[0];
386           }
387
388           if (tmp.end[1] <= min[1])
389           {
390             min[1] = tmp.end[1];
391           }
392
393           if (tmp.end[2] <= min[2])
394           {
395             min[2] = tmp.end[2];
396           }
397         }
398       }
399     }
400
401     width[0] = Math.abs(max[0] - min[0]);
402     width[1] = Math.abs(max[1] - min[1]);
403     width[2] = Math.abs(max[2] - min[2]);
404
405     maxwidth = width[0];
406
407     if (width[1] > width[0])
408     {
409       maxwidth = width[1];
410     }
411
412     if (width[2] > width[1])
413     {
414       maxwidth = width[2];
415     }
416
417     // System.out.println("Maxwidth = " + maxwidth);
418   }
419
420   public float findScale()
421   {
422     int dim;
423     int width;
424     int height;
425
426     if (getSize().width != 0)
427     {
428       width = getSize().width;
429       height = getSize().height;
430     }
431     else
432     {
433       width = prefsize.width;
434       height = prefsize.height;
435     }
436
437     if (width < height)
438     {
439       dim = width;
440     }
441     else
442     {
443       dim = height;
444     }
445
446     return (float) (dim / (1.5d * maxwidth));
447   }
448
449   public void findCentre()
450   {
451     float xtot = 0;
452     float ytot = 0;
453     float ztot = 0;
454
455     int bsize = 0;
456
457     // Find centre coordinate
458     for (int ii = 0; ii < pdb.getChains().size(); ii++)
459     {
460       if (pdb.getChains().elementAt(ii).isVisible)
461       {
462         Vector<Bond> bonds = pdb.getChains().elementAt(ii).bonds;
463
464         bsize += bonds.size();
465
466         for (Bond b : bonds)
467         {
468           xtot = xtot + b.start[0] + b.end[0];
469           ytot = ytot + b.start[1] + b.end[1];
470           ztot = ztot + b.start[2] + b.end[2];
471         }
472       }
473     }
474
475     centre[0] = xtot / (2 * (float) bsize);
476     centre[1] = ytot / (2 * (float) bsize);
477     centre[2] = ztot / (2 * (float) bsize);
478   }
479
480   @Override
481   public void paint(Graphics g)
482   {
483
484     if (errorLoading)
485     {
486       g.setColor(Color.white);
487       g.fillRect(0, 0, getSize().width, getSize().height);
488       g.setColor(Color.black);
489       g.setFont(new Font("Verdana", Font.BOLD, 14));
490       g.drawString(
491               MessageManager.getString("label.error_loading_pdb_data"), 50,
492               getSize().height / 2);
493       return;
494     }
495
496     if (!seqColoursReady)
497     {
498       g.setColor(Color.black);
499       g.setFont(new Font("Verdana", Font.BOLD, 14));
500       g.drawString(MessageManager.getString("label.fetching_pdb_data"), 50,
501               getSize().height / 2);
502       return;
503     }
504
505     // Only create the image at the beginning -
506     // this saves much memory usage
507     if ((img == null) || (prefsize.width != getSize().width)
508             || (prefsize.height != getSize().height))
509     {
510
511       try
512       {
513         prefsize.width = getSize().width;
514         prefsize.height = getSize().height;
515
516         scale = findScale();
517         img = createImage(prefsize.width, prefsize.height);
518         ig = img.getGraphics();
519
520         redrawneeded = true;
521       } catch (Exception ex)
522       {
523         ex.printStackTrace();
524       }
525     }
526
527     if (redrawneeded)
528     {
529       drawAll(ig, prefsize.width, prefsize.height);
530       redrawneeded = false;
531     }
532     if (appletToolTip != null)
533     {
534       ig.setColor(Color.red);
535       ig.drawString(appletToolTip, toolx, tooly);
536     }
537
538     g.drawImage(img, 0, 0, this);
539
540     pdbAction = false;
541   }
542
543   public void drawAll(Graphics g, int width, int height)
544   {
545     ig.setColor(Color.black);
546     ig.fillRect(0, 0, width, height);
547     drawScene(ig);
548     drawLabels(ig);
549   }
550
551   public void setColours(jalview.schemes.ColourSchemeI cs)
552   {
553     bysequence = false;
554     pdb.setColours(cs);
555     redrawneeded = true;
556     repaint();
557   }
558
559   // This method has been taken out of PDBChain to allow
560   // Applet and Application specific sequence renderers to be used
561   void colourBySequence()
562   {
563     SequenceRenderer sr = new SequenceRenderer(ap.av);
564
565     StructureMapping[] mapping = ssm.getMapping(pdbentry.getFile());
566
567     boolean showFeatures = false;
568     if (ap.av.isShowSequenceFeatures())
569     {
570       if (fr == null)
571       {
572         fr = new jalview.appletgui.FeatureRenderer(ap.av);
573       }
574
575       fr.transferSettings(ap.getFeatureRenderer());
576
577       showFeatures = true;
578     }
579
580     PDBChain chain;
581     if (bysequence && pdb != null)
582     {
583       for (int ii = 0; ii < pdb.getChains().size(); ii++)
584       {
585         chain = pdb.getChains().elementAt(ii);
586
587         for (int i = 0; i < chain.bonds.size(); i++)
588         {
589           Bond tmp = chain.bonds.elementAt(i);
590           tmp.startCol = Color.lightGray;
591           tmp.endCol = Color.lightGray;
592           if (chain != mainchain)
593           {
594             continue;
595           }
596
597           for (int s = 0; s < sequence.length; s++)
598           {
599             for (int m = 0; m < mapping.length; m++)
600             {
601               if (mapping[m].getSequence() == sequence[s])
602               {
603                 int pos = mapping[m].getSeqPos(tmp.at1.resNumber) - 1;
604                 if (pos > 0)
605                 {
606                   pos = sequence[s].findIndex(pos);
607                   tmp.startCol = sr.getResidueBoxColour(sequence[s], pos);
608                   if (showFeatures)
609                   {
610                     tmp.startCol = fr.findFeatureColour(tmp.startCol,
611                             sequence[s], pos);
612                   }
613                 }
614                 pos = mapping[m].getSeqPos(tmp.at2.resNumber) - 1;
615                 if (pos > 0)
616                 {
617                   pos = sequence[s].findIndex(pos);
618                   tmp.endCol = sr.getResidueBoxColour(sequence[s], pos);
619                   if (showFeatures)
620                   {
621                     tmp.endCol = fr.findFeatureColour(tmp.endCol,
622                             sequence[s], pos);
623                   }
624                 }
625
626               }
627             }
628           }
629         }
630       }
631     }
632   }
633
634   Zsort zsort;
635
636   public void drawScene(Graphics g)
637   {
638     if (zbuffer)
639     {
640       if (zsort == null)
641       {
642         zsort = new Zsort();
643       }
644
645       zsort.sort(visiblebonds);
646     }
647
648     Bond tmpBond = null;
649     for (int i = 0; i < visiblebonds.size(); i++)
650     {
651       tmpBond = visiblebonds.elementAt(i);
652
653       xstart = (int) (((tmpBond.start[0] - centre[0]) * scale) + (getSize().width / 2));
654       ystart = (int) (((centre[1] - tmpBond.start[1]) * scale) + (getSize().height / 2));
655
656       xend = (int) (((tmpBond.end[0] - centre[0]) * scale) + (getSize().width / 2));
657       yend = (int) (((centre[1] - tmpBond.end[1]) * scale) + (getSize().height / 2));
658
659       xmid = (xend + xstart) / 2;
660       ymid = (yend + ystart) / 2;
661
662       if (depthcue && !bymolecule)
663       {
664         if (tmpBond.start[2] < (centre[2] - (maxwidth / 6)))
665         {
666           g.setColor(tmpBond.startCol.darker().darker());
667           drawLine(g, xstart, ystart, xmid, ymid);
668
669           g.setColor(tmpBond.endCol.darker().darker());
670           drawLine(g, xmid, ymid, xend, yend);
671         }
672         else if (tmpBond.start[2] < (centre[2] + (maxwidth / 6)))
673         {
674           g.setColor(tmpBond.startCol.darker());
675           drawLine(g, xstart, ystart, xmid, ymid);
676
677           g.setColor(tmpBond.endCol.darker());
678           drawLine(g, xmid, ymid, xend, yend);
679         }
680         else
681         {
682           g.setColor(tmpBond.startCol);
683           drawLine(g, xstart, ystart, xmid, ymid);
684
685           g.setColor(tmpBond.endCol);
686           drawLine(g, xmid, ymid, xend, yend);
687         }
688
689       }
690       else if (depthcue && bymolecule)
691       {
692         if (tmpBond.start[2] < (centre[2] - (maxwidth / 6)))
693         {
694           g.setColor(Color.green.darker().darker());
695           drawLine(g, xstart, ystart, xend, yend);
696         }
697         else if (tmpBond.start[2] < (centre[2] + (maxwidth / 6)))
698         {
699           g.setColor(Color.green.darker());
700           drawLine(g, xstart, ystart, xend, yend);
701         }
702         else
703         {
704           g.setColor(Color.green);
705           drawLine(g, xstart, ystart, xend, yend);
706         }
707       }
708       else if (!depthcue && !bymolecule)
709       {
710         g.setColor(tmpBond.startCol);
711         drawLine(g, xstart, ystart, xmid, ymid);
712         g.setColor(tmpBond.endCol);
713         drawLine(g, xmid, ymid, xend, yend);
714       }
715       else
716       {
717         drawLine(g, xstart, ystart, xend, yend);
718       }
719
720       if (highlightBond1 != null && highlightBond1 == tmpBond)
721       {
722         g.setColor(Color.white);
723         drawLine(g, xmid, ymid, xend, yend);
724       }
725
726       if (highlightBond2 != null && highlightBond2 == tmpBond)
727       {
728         g.setColor(Color.white);
729         drawLine(g, xstart, ystart, xmid, ymid);
730       }
731
732     }
733   }
734
735   public void drawLine(Graphics g, int x1, int y1, int x2, int y2)
736   {
737     if (!wire)
738     {
739       if (((float) Math.abs(y2 - y1) / (float) Math.abs(x2 - x1)) < 0.5)
740       {
741         g.drawLine(x1, y1, x2, y2);
742         g.drawLine(x1 + 1, y1 + 1, x2 + 1, y2 + 1);
743         g.drawLine(x1, y1 - 1, x2, y2 - 1);
744       }
745       else
746       {
747         g.setColor(g.getColor().brighter());
748         g.drawLine(x1, y1, x2, y2);
749         g.drawLine(x1 + 1, y1, x2 + 1, y2);
750         g.drawLine(x1 - 1, y1, x2 - 1, y2);
751       }
752     }
753     else
754     {
755       g.drawLine(x1, y1, x2, y2);
756     }
757   }
758
759   public Dimension minimumsize()
760   {
761     return prefsize;
762   }
763
764   public Dimension preferredsize()
765   {
766     return prefsize;
767   }
768
769   public void doKeyPressed(KeyEvent evt)
770   {
771     if (evt.getKeyCode() == KeyEvent.VK_UP)
772     {
773       scale = (float) (scale * 1.1);
774       redrawneeded = true;
775       repaint();
776     }
777     else if (evt.getKeyCode() == KeyEvent.VK_DOWN)
778     {
779       scale = (float) (scale * 0.9);
780       redrawneeded = true;
781       repaint();
782     }
783   }
784
785   @Override
786   public void mousePressed(MouseEvent e)
787   {
788     pdbAction = true;
789     Atom fatom = findAtom(e.getX(), e.getY());
790     if (fatom != null)
791     {
792       fatom.isSelected = !fatom.isSelected;
793
794       redrawneeded = true;
795       repaint();
796       if (foundchain != -1)
797       {
798         PDBChain chain = pdb.getChains().elementAt(foundchain);
799         if (chain == mainchain)
800         {
801           if (fatom.alignmentMapping != -1)
802           {
803             if (highlightRes == null)
804             {
805               highlightRes = new Vector<String>();
806             }
807
808             final String atomString = Integer
809                     .toString(fatom.alignmentMapping);
810             if (highlightRes.contains(atomString))
811             {
812               highlightRes.removeElement(atomString);
813             }
814             else
815             {
816               highlightRes.addElement(atomString);
817             }
818           }
819         }
820       }
821
822     }
823     mx = e.getX();
824     my = e.getY();
825     omx = mx;
826     omy = my;
827     dragging = false;
828   }
829
830   @Override
831   public void mouseMoved(MouseEvent e)
832   {
833     pdbAction = true;
834     if (highlightBond1 != null)
835     {
836       highlightBond1.at2.isSelected = false;
837       highlightBond2.at1.isSelected = false;
838       highlightBond1 = null;
839       highlightBond2 = null;
840     }
841
842     Atom fatom = findAtom(e.getX(), e.getY());
843
844     PDBChain chain = null;
845     if (foundchain != -1)
846     {
847       chain = pdb.getChains().elementAt(foundchain);
848       if (chain == mainchain)
849       {
850         mouseOverStructure(fatom.resNumber, chain.id);
851       }
852     }
853
854     if (fatom != null)
855     {
856       toolx = e.getX();
857       tooly = e.getY();
858
859       appletToolTip = chain.id + ":" + fatom.resNumber + " "
860               + fatom.resName;
861       redrawneeded = true;
862       repaint();
863     }
864     else
865     {
866       mouseOverStructure(-1, chain != null ? chain.id : null);
867       appletToolTip = null;
868       redrawneeded = true;
869       repaint();
870     }
871   }
872
873   @Override
874   public void mouseClicked(MouseEvent e)
875   {
876   }
877
878   @Override
879   public void mouseEntered(MouseEvent e)
880   {
881   }
882
883   @Override
884   public void mouseExited(MouseEvent e)
885   {
886   }
887
888   @Override
889   public void mouseDragged(MouseEvent evt)
890   {
891     int x = evt.getX();
892     int y = evt.getY();
893     mx = x;
894     my = y;
895
896     MCMatrix objmat = new MCMatrix(3, 3);
897     objmat.setIdentity();
898
899     if ((evt.getModifiers() & Event.META_MASK) != 0)
900     {
901       objmat.rotatez(((mx - omx)));
902     }
903     else
904     {
905       objmat.rotatex(((omy - my)));
906       objmat.rotatey(((omx - mx)));
907     }
908
909     // Alter the bonds
910     for (PDBChain chain : pdb.getChains())
911     {
912       for (Bond tmpBond : chain.bonds)
913       {
914         // Translate the bond so the centre is 0,0,0
915         tmpBond.translate(-centre[0], -centre[1], -centre[2]);
916
917         // Now apply the rotation matrix
918         tmpBond.start = objmat.vectorMultiply(tmpBond.start);
919         tmpBond.end = objmat.vectorMultiply(tmpBond.end);
920
921         // Now translate back again
922         tmpBond.translate(centre[0], centre[1], centre[2]);
923       }
924     }
925
926     objmat = null;
927
928     omx = mx;
929     omy = my;
930
931     dragging = true;
932
933     redrawneeded = true;
934
935     repaint();
936   }
937
938   @Override
939   public void mouseReleased(MouseEvent evt)
940   {
941     dragging = false;
942     return;
943   }
944
945   void drawLabels(Graphics g)
946   {
947
948     for (PDBChain chain : pdb.getChains())
949     {
950       if (chain.isVisible)
951       {
952         for (Bond tmpBond : chain.bonds)
953         {
954           if (tmpBond.at1.isSelected)
955           {
956             labelAtom(g, tmpBond, 1);
957           }
958
959           if (tmpBond.at2.isSelected)
960           {
961             labelAtom(g, tmpBond, 2);
962           }
963         }
964       }
965     }
966   }
967
968   public void labelAtom(Graphics g, Bond b, int n)
969   {
970     g.setFont(font);
971
972     if (n == 1)
973     {
974       int xstart = (int) (((b.start[0] - centre[0]) * scale) + (getSize().width / 2));
975       int ystart = (int) (((centre[1] - b.start[1]) * scale) + (getSize().height / 2));
976
977       g.setColor(Color.red);
978       g.drawString(b.at1.resName + "-" + b.at1.resNumber, xstart, ystart);
979     }
980
981     if (n == 2)
982     {
983       int xstart = (int) (((b.end[0] - centre[0]) * scale) + (getSize().width / 2));
984       int ystart = (int) (((centre[1] - b.end[1]) * scale) + (getSize().height / 2));
985
986       g.setColor(Color.red);
987       g.drawString(b.at2.resName + "-" + b.at2.resNumber, xstart, ystart);
988     }
989   }
990
991   int foundchain = -1;
992
993   public Atom findAtom(int x, int y)
994   {
995     Atom fatom = null;
996
997     foundchain = -1;
998
999     for (int ii = 0; ii < pdb.getChains().size(); ii++)
1000     {
1001       PDBChain chain = pdb.getChains().elementAt(ii);
1002       int truex;
1003       Bond tmpBond = null;
1004
1005       if (chain.isVisible)
1006       {
1007         Vector<Bond> bonds = pdb.getChains().elementAt(ii).bonds;
1008
1009         for (int i = 0; i < bonds.size(); i++)
1010         {
1011           tmpBond = bonds.elementAt(i);
1012
1013           truex = (int) (((tmpBond.start[0] - centre[0]) * scale) + (getSize().width / 2));
1014
1015           if (Math.abs(truex - x) <= 2)
1016           {
1017             int truey = (int) (((centre[1] - tmpBond.start[1]) * scale) + (getSize().height / 2));
1018
1019             if (Math.abs(truey - y) <= 2)
1020             {
1021               fatom = tmpBond.at1;
1022               foundchain = ii;
1023               break;
1024             }
1025           }
1026         }
1027
1028         // Still here? Maybe its the last bond
1029
1030         truex = (int) (((tmpBond.end[0] - centre[0]) * scale) + (getSize().width / 2));
1031
1032         if (Math.abs(truex - x) <= 2)
1033         {
1034           int truey = (int) (((tmpBond.end[1] - centre[1]) * scale) + (getSize().height / 2));
1035
1036           if (Math.abs(truey - y) <= 2)
1037           {
1038             fatom = tmpBond.at2;
1039             foundchain = ii;
1040             break;
1041           }
1042         }
1043
1044       }
1045
1046       if (fatom != null) // )&& chain.ds != null)
1047       {
1048         chain = pdb.getChains().elementAt(foundchain);
1049       }
1050     }
1051
1052     return fatom;
1053   }
1054
1055   @Override
1056   public void update(Graphics g)
1057   {
1058     paint(g);
1059   }
1060
1061   public void highlightRes(int ii)
1062   {
1063     if (!seqColoursReady)
1064     {
1065       return;
1066     }
1067
1068     if (highlightRes != null && highlightRes.contains((ii - 1) + ""))
1069     {
1070       return;
1071     }
1072
1073     int index = -1;
1074     Bond tmpBond;
1075     for (index = 0; index < mainchain.bonds.size(); index++)
1076     {
1077       tmpBond = mainchain.bonds.elementAt(index);
1078       if (tmpBond.at1.alignmentMapping == ii - 1)
1079       {
1080         if (highlightBond1 != null)
1081         {
1082           highlightBond1.at2.isSelected = false;
1083         }
1084
1085         if (highlightBond2 != null)
1086         {
1087           highlightBond2.at1.isSelected = false;
1088         }
1089
1090         highlightBond1 = null;
1091         highlightBond2 = null;
1092
1093         if (index > 0)
1094         {
1095           highlightBond1 = mainchain.bonds.elementAt(index - 1);
1096           highlightBond1.at2.isSelected = true;
1097         }
1098
1099         if (index != mainchain.bonds.size())
1100         {
1101           highlightBond2 = mainchain.bonds.elementAt(index);
1102           highlightBond2.at1.isSelected = true;
1103         }
1104
1105         break;
1106       }
1107     }
1108
1109     redrawneeded = true;
1110     repaint();
1111   }
1112
1113   public void setAllchainsVisible(boolean b)
1114   {
1115     for (int ii = 0; ii < pdb.getChains().size(); ii++)
1116     {
1117       PDBChain chain = pdb.getChains().elementAt(ii);
1118       chain.isVisible = b;
1119     }
1120     mainchain.isVisible = true;
1121     findCentre();
1122     setupBonds();
1123   }
1124
1125   // ////////////////////////////////
1126   // /StructureListener
1127   @Override
1128   public String[] getPdbFile()
1129   {
1130     return new String[] { pdbentry.getFile() };
1131   }
1132
1133   String lastMessage;
1134
1135   public void mouseOverStructure(int pdbResNum, String chain)
1136   {
1137     if (lastMessage == null || !lastMessage.equals(pdbResNum + chain))
1138     {
1139       ssm.mouseOverStructure(pdbResNum, chain, pdbentry.getFile());
1140     }
1141
1142     lastMessage = pdbResNum + chain;
1143   }
1144
1145   StringBuffer resetLastRes = new StringBuffer();
1146
1147   StringBuffer eval = new StringBuffer();
1148
1149   /**
1150    * Highlight the specified atoms in the structure.
1151    * 
1152    * @param atoms
1153    */
1154   @Override
1155   public void highlightAtoms(List<AtomSpec> atoms)
1156   {
1157     if (!seqColoursReady)
1158     {
1159       return;
1160     }
1161     for (AtomSpec atom : atoms)
1162     {
1163       int atomIndex = atom.getAtomIndex();
1164
1165       if (highlightRes != null
1166               && highlightRes.contains((atomIndex - 1) + ""))
1167       {
1168         continue;
1169       }
1170
1171       highlightAtom(atomIndex);
1172     }
1173
1174     redrawneeded = true;
1175     repaint();
1176   }
1177
1178   /**
1179    * @param atomIndex
1180    */
1181   protected void highlightAtom(int atomIndex)
1182   {
1183     int index = -1;
1184     Bond tmpBond;
1185     for (index = 0; index < mainchain.bonds.size(); index++)
1186     {
1187       tmpBond = mainchain.bonds.elementAt(index);
1188       if (tmpBond.at1.atomIndex == atomIndex)
1189       {
1190         if (highlightBond1 != null)
1191         {
1192           highlightBond1.at2.isSelected = false;
1193         }
1194
1195         if (highlightBond2 != null)
1196         {
1197           highlightBond2.at1.isSelected = false;
1198         }
1199
1200         highlightBond1 = null;
1201         highlightBond2 = null;
1202
1203         if (index > 0)
1204         {
1205           highlightBond1 = mainchain.bonds.elementAt(index - 1);
1206           highlightBond1.at2.isSelected = true;
1207         }
1208
1209         if (index != mainchain.bonds.size())
1210         {
1211           highlightBond2 = mainchain.bonds.elementAt(index);
1212           highlightBond2.at1.isSelected = true;
1213         }
1214
1215         break;
1216       }
1217     }
1218   }
1219
1220   public Color getColour(int atomIndex, int pdbResNum, String chain,
1221           String pdbfile)
1222   {
1223     return Color.white;
1224     // if (!pdbfile.equals(pdbentry.getFile()))
1225     // return null;
1226
1227     // return new Color(viewer.getAtomArgb(atomIndex));
1228   }
1229
1230   @Override
1231   public void updateColours(Object source)
1232   {
1233     colourBySequence();
1234     redrawneeded = true;
1235     repaint();
1236   }
1237
1238   @Override
1239   public void releaseReferences(Object svl)
1240   {
1241     // TODO Auto-generated method stub
1242
1243   }
1244
1245   @Override
1246   public boolean isListeningFor(SequenceI seq)
1247   {
1248     if (sequence != null)
1249     {
1250       for (SequenceI s : sequence)
1251       {
1252         if (s == seq)
1253         {
1254           return true;
1255         }
1256       }
1257     }
1258     return false;
1259   }
1260 }