JAL-2416 allow space in score matrix name
[jalview.git] / src / jalview / gui / RotatableCanvas.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.RotatableCanvasI;
24 import jalview.datamodel.SequenceGroup;
25 import jalview.datamodel.SequenceI;
26 import jalview.datamodel.SequencePoint;
27 import jalview.math.RotatableMatrix;
28 import jalview.util.MessageManager;
29 import jalview.viewmodel.AlignmentViewport;
30
31 import java.awt.Color;
32 import java.awt.Dimension;
33 import java.awt.Font;
34 import java.awt.Graphics;
35 import java.awt.Graphics2D;
36 import java.awt.Image;
37 import java.awt.RenderingHints;
38 import java.awt.event.InputEvent;
39 import java.awt.event.KeyEvent;
40 import java.awt.event.KeyListener;
41 import java.awt.event.MouseEvent;
42 import java.awt.event.MouseListener;
43 import java.awt.event.MouseMotionListener;
44 import java.awt.event.MouseWheelEvent;
45 import java.awt.event.MouseWheelListener;
46 import java.util.Vector;
47
48 import javax.swing.JPanel;
49 import javax.swing.ToolTipManager;
50
51 /**
52  * DOCUMENT ME!
53  * 
54  * @author $author$
55  * @version $Revision$
56  */
57 public class RotatableCanvas extends JPanel implements MouseListener,
58         MouseMotionListener, KeyListener, RotatableCanvasI
59 {
60   RotatableMatrix idmat = new RotatableMatrix(3, 3);
61
62   RotatableMatrix objmat = new RotatableMatrix(3, 3);
63
64   RotatableMatrix rotmat = new RotatableMatrix(3, 3);
65
66   // RubberbandRectangle rubberband;
67   boolean drawAxes = true;
68
69   int omx = 0;
70
71   int mx = 0;
72
73   int omy = 0;
74
75   int my = 0;
76
77   Image img;
78
79   Graphics ig;
80
81   Dimension prefsize;
82
83   float[] centre = new float[3];
84
85   float[] width = new float[3];
86
87   float[] max = new float[3];
88
89   float[] min = new float[3];
90
91   float maxwidth;
92
93   float scale;
94
95   int npoint;
96
97   Vector points;
98
99   float[][] orig;
100
101   float[][] axes;
102
103   int startx;
104
105   int starty;
106
107   int lastx;
108
109   int lasty;
110
111   int rectx1;
112
113   int recty1;
114
115   int rectx2;
116
117   int recty2;
118
119   float scalefactor = 1;
120
121   AlignmentViewport av;
122
123   AlignmentPanel ap;
124
125   boolean showLabels = false;
126
127   Color bgColour = Color.black;
128
129   boolean applyToAllViews = false;
130
131   // Controller controller;
132   public RotatableCanvas(AlignmentPanel ap)
133   {
134     this.av = ap.av;
135     this.ap = ap;
136
137     addMouseWheelListener(new MouseWheelListener()
138     {
139       public void mouseWheelMoved(MouseWheelEvent e)
140       {
141         if (e.getWheelRotation() > 0)
142         {
143           scale = (float) (scale * 1.1);
144           repaint();
145         }
146
147         else
148         {
149           scale = (float) (scale * 0.9);
150           repaint();
151         }
152       }
153     });
154
155   }
156
157   public void showLabels(boolean b)
158   {
159     showLabels = b;
160     repaint();
161   }
162
163   boolean first = true;
164
165   public void setPoints(Vector points, int npoint)
166   {
167     this.points = points;
168     this.npoint = npoint;
169     if (first)
170     {
171       ToolTipManager.sharedInstance().registerComponent(this);
172       ToolTipManager.sharedInstance().setInitialDelay(0);
173       ToolTipManager.sharedInstance().setDismissDelay(10000);
174     }
175     prefsize = getPreferredSize();
176     orig = new float[npoint][3];
177
178     for (int i = 0; i < npoint; i++)
179     {
180       SequencePoint sp = (SequencePoint) points.elementAt(i);
181
182       for (int j = 0; j < 3; j++)
183       {
184         orig[i][j] = sp.coord[j];
185       }
186     }
187
188     // Initialize the matrices to identity
189     for (int i = 0; i < 3; i++)
190     {
191       for (int j = 0; j < 3; j++)
192       {
193         if (i != j)
194         {
195           idmat.addElement(i, j, 0);
196           objmat.addElement(i, j, 0);
197           rotmat.addElement(i, j, 0);
198         }
199         else
200         {
201           idmat.addElement(i, j, 0);
202           objmat.addElement(i, j, 0);
203           rotmat.addElement(i, j, 0);
204         }
205       }
206     }
207
208     axes = new float[3][3];
209     initAxes();
210
211     findCentre();
212     findWidth();
213
214     scale = findScale();
215     if (first)
216     {
217
218       addMouseListener(this);
219
220       addMouseMotionListener(this);
221     }
222     first = false;
223   }
224
225   public void initAxes()
226   {
227     for (int i = 0; i < 3; i++)
228     {
229       for (int j = 0; j < 3; j++)
230       {
231         if (i != j)
232         {
233           axes[i][j] = 0;
234         }
235         else
236         {
237           axes[i][j] = 1;
238         }
239       }
240     }
241   }
242
243   /**
244    * DOCUMENT ME!
245    */
246   public void findWidth()
247   {
248     max = new float[3];
249     min = new float[3];
250
251     max[0] = (float) -1e30;
252     max[1] = (float) -1e30;
253     max[2] = (float) -1e30;
254
255     min[0] = (float) 1e30;
256     min[1] = (float) 1e30;
257     min[2] = (float) 1e30;
258
259     for (int i = 0; i < 3; i++)
260     {
261       for (int j = 0; j < npoint; j++)
262       {
263         SequencePoint sp = (SequencePoint) points.elementAt(j);
264
265         if (sp.coord[i] >= max[i])
266         {
267           max[i] = sp.coord[i];
268         }
269
270         if (sp.coord[i] <= min[i])
271         {
272           min[i] = sp.coord[i];
273         }
274       }
275     }
276
277     // System.out.println("xmax " + max[0] + " min " + min[0]);
278     // System.out.println("ymax " + max[1] + " min " + min[1]);
279     // System.out.println("zmax " + max[2] + " min " + min[2]);
280     width[0] = Math.abs(max[0] - min[0]);
281     width[1] = Math.abs(max[1] - min[1]);
282     width[2] = Math.abs(max[2] - min[2]);
283
284     maxwidth = width[0];
285
286     if (width[1] > width[0])
287     {
288       maxwidth = width[1];
289     }
290
291     if (width[2] > width[1])
292     {
293       maxwidth = width[2];
294     }
295
296     // System.out.println("Maxwidth = " + maxwidth);
297   }
298
299   /**
300    * DOCUMENT ME!
301    * 
302    * @return DOCUMENT ME!
303    */
304   public float findScale()
305   {
306     int dim;
307     int width;
308     int height;
309
310     if (getWidth() != 0)
311     {
312       width = getWidth();
313       height = getHeight();
314     }
315     else
316     {
317       width = prefsize.width;
318       height = prefsize.height;
319     }
320
321     if (width < height)
322     {
323       dim = width;
324     }
325     else
326     {
327       dim = height;
328     }
329
330     return (float) ((dim * scalefactor) / (2 * maxwidth));
331   }
332
333   /**
334    * DOCUMENT ME!
335    */
336   public void findCentre()
337   {
338     // Find centre coordinate
339     findWidth();
340
341     centre[0] = (max[0] + min[0]) / 2;
342     centre[1] = (max[1] + min[1]) / 2;
343     centre[2] = (max[2] + min[2]) / 2;
344
345     // System.out.println("Centre x " + centre[0]);
346     // System.out.println("Centre y " + centre[1]);
347     // System.out.println("Centre z " + centre[2]);
348   }
349
350   /**
351    * DOCUMENT ME!
352    * 
353    * @return DOCUMENT ME!
354    */
355   public Dimension getPreferredSize()
356   {
357     if (prefsize != null)
358     {
359       return prefsize;
360     }
361     else
362     {
363       return new Dimension(400, 400);
364     }
365   }
366
367   /**
368    * DOCUMENT ME!
369    * 
370    * @return DOCUMENT ME!
371    */
372   public Dimension getMinimumSize()
373   {
374     return getPreferredSize();
375   }
376
377   /**
378    * DOCUMENT ME!
379    * 
380    * @param g
381    *          DOCUMENT ME!
382    */
383   public void paintComponent(Graphics g1)
384   {
385
386     Graphics2D g = (Graphics2D) g1;
387
388     g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
389             RenderingHints.VALUE_ANTIALIAS_ON);
390     if (points == null)
391     {
392       g.setFont(new Font("Verdana", Font.PLAIN, 18));
393       g.drawString(MessageManager.getString("label.calculating_pca")
394               + "....", 20, getHeight() / 2);
395     }
396     else
397     {
398       // Only create the image at the beginning -
399       if ((img == null) || (prefsize.width != getWidth())
400               || (prefsize.height != getHeight()))
401       {
402         prefsize.width = getWidth();
403         prefsize.height = getHeight();
404
405         scale = findScale();
406
407         // System.out.println("New scale = " + scale);
408         img = createImage(getWidth(), getHeight());
409         ig = img.getGraphics();
410       }
411
412       drawBackground(ig, bgColour);
413       drawScene(ig);
414
415       if (drawAxes == true)
416       {
417         drawAxes(ig);
418       }
419
420       g.drawImage(img, 0, 0, this);
421     }
422   }
423
424   /**
425    * DOCUMENT ME!
426    * 
427    * @param g
428    *          DOCUMENT ME!
429    */
430   public void drawAxes(Graphics g)
431   {
432
433     g.setColor(Color.yellow);
434
435     for (int i = 0; i < 3; i++)
436     {
437       g.drawLine(getWidth() / 2, getHeight() / 2, (int) ((axes[i][0]
438               * scale * max[0]) + (getWidth() / 2)), (int) ((axes[i][1]
439               * scale * max[1]) + (getHeight() / 2)));
440     }
441   }
442
443   /**
444    * DOCUMENT ME!
445    * 
446    * @param g
447    *          DOCUMENT ME!
448    * @param col
449    *          DOCUMENT ME!
450    */
451   public void drawBackground(Graphics g, Color col)
452   {
453     g.setColor(col);
454     g.fillRect(0, 0, prefsize.width, prefsize.height);
455   }
456
457   /**
458    * DOCUMENT ME!
459    * 
460    * @param g
461    *          DOCUMENT ME!
462    */
463   public void drawScene(Graphics g1)
464   {
465
466     Graphics2D g = (Graphics2D) g1;
467
468     g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
469             RenderingHints.VALUE_ANTIALIAS_ON);
470
471     int halfwidth = getWidth() / 2;
472     int halfheight = getHeight() / 2;
473
474     for (int i = 0; i < npoint; i++)
475     {
476       SequencePoint sp = (SequencePoint) points.elementAt(i);
477       int x = (int) ((float) (sp.coord[0] - centre[0]) * scale) + halfwidth;
478       int y = (int) ((float) (sp.coord[1] - centre[1]) * scale)
479               + halfheight;
480       float z = sp.coord[1] - centre[2];
481
482       if (av.getSequenceColour(sp.sequence) == Color.black)
483       {
484         g.setColor(Color.white);
485       }
486       else
487       {
488         g.setColor(av.getSequenceColour(sp.sequence));
489       }
490
491       if (av.getSelectionGroup() != null)
492       {
493         if (av.getSelectionGroup().getSequences(null)
494                 .contains(((SequencePoint) points.elementAt(i)).sequence))
495         {
496           g.setColor(Color.gray);
497         }
498       }
499
500       if (z < 0)
501       {
502         g.setColor(g.getColor().darker());
503       }
504
505       g.fillRect(x - 3, y - 3, 6, 6);
506       if (showLabels)
507       {
508         g.setColor(Color.red);
509         g.drawString(
510                 ((SequencePoint) points.elementAt(i)).sequence.getName(),
511                 x - 3, y - 4);
512       }
513     }
514
515     // //Now the rectangle
516     // if (rectx2 != -1 && recty2 != -1) {
517     // g.setColor(Color.white);
518     //
519     // g.drawRect(rectx1,recty1,rectx2-rectx1,recty2-recty1);
520     // }
521   }
522
523   /**
524    * DOCUMENT ME!
525    * 
526    * @return DOCUMENT ME!
527    */
528   public Dimension minimumsize()
529   {
530     return prefsize;
531   }
532
533   /**
534    * DOCUMENT ME!
535    * 
536    * @return DOCUMENT ME!
537    */
538   public Dimension preferredsize()
539   {
540     return prefsize;
541   }
542
543   /**
544    * DOCUMENT ME!
545    * 
546    * @param evt
547    *          DOCUMENT ME!
548    */
549   public void keyTyped(KeyEvent evt)
550   {
551   }
552
553   /**
554    * DOCUMENT ME!
555    * 
556    * @param evt
557    *          DOCUMENT ME!
558    */
559   public void keyReleased(KeyEvent evt)
560   {
561   }
562
563   /**
564    * DOCUMENT ME!
565    * 
566    * @param evt
567    *          DOCUMENT ME!
568    */
569   public void keyPressed(KeyEvent evt)
570   {
571     if (evt.getKeyCode() == KeyEvent.VK_UP)
572     {
573       scalefactor = (float) (scalefactor * 1.1);
574       scale = findScale();
575     }
576     else if (evt.getKeyCode() == KeyEvent.VK_DOWN)
577     {
578       scalefactor = (float) (scalefactor * 0.9);
579       scale = findScale();
580     }
581     else if (evt.getKeyChar() == 's')
582     {
583       System.err.println("DEBUG: Rectangle selection"); // log.debug
584
585       if ((rectx2 != -1) && (recty2 != -1))
586       {
587         rectSelect(rectx1, recty1, rectx2, recty2);
588       }
589     }
590
591     repaint();
592   }
593
594   /**
595    * DOCUMENT ME!
596    * 
597    * @param evt
598    *          DOCUMENT ME!
599    */
600   public void mouseClicked(MouseEvent evt)
601   {
602   }
603
604   /**
605    * DOCUMENT ME!
606    * 
607    * @param evt
608    *          DOCUMENT ME!
609    */
610   public void mouseEntered(MouseEvent evt)
611   {
612   }
613
614   /**
615    * DOCUMENT ME!
616    * 
617    * @param evt
618    *          DOCUMENT ME!
619    */
620   public void mouseExited(MouseEvent evt)
621   {
622   }
623
624   /**
625    * DOCUMENT ME!
626    * 
627    * @param evt
628    *          DOCUMENT ME!
629    */
630   public void mouseReleased(MouseEvent evt)
631   {
632   }
633
634   /**
635    * DOCUMENT ME!
636    * 
637    * @param evt
638    *          DOCUMENT ME!
639    */
640   public void mousePressed(MouseEvent evt)
641   {
642     int x = evt.getX();
643     int y = evt.getY();
644
645     mx = x;
646     my = y;
647
648     omx = mx;
649     omy = my;
650
651     startx = x;
652     starty = y;
653
654     rectx1 = x;
655     recty1 = y;
656
657     rectx2 = -1;
658     recty2 = -1;
659
660     SequenceI found = findPoint(x, y);
661
662     if (found != null)
663     {
664       AlignmentPanel[] aps = getAssociatedPanels();
665
666       for (int a = 0; a < aps.length; a++)
667       {
668         if (aps[a].av.getSelectionGroup() != null)
669         {
670           aps[a].av.getSelectionGroup().addOrRemove(found, true);
671         }
672         else
673         {
674           aps[a].av.setSelectionGroup(new SequenceGroup());
675           aps[a].av.getSelectionGroup().addOrRemove(found, true);
676           aps[a].av.getSelectionGroup().setEndRes(
677                   aps[a].av.getAlignment().getWidth() - 1);
678         }
679       }
680       PaintRefresher.Refresh(this, av.getSequenceSetId());
681       // canonical selection is sent to other listeners
682       av.sendSelection();
683     }
684
685     repaint();
686   }
687
688   // private void fireSequenceSelectionEvent(Selection sel) {
689   // controller.handleSequenceSelectionEvent(new
690   // SequenceSelectionEvent(this,sel));
691   // }
692   public void mouseMoved(MouseEvent evt)
693   {
694     SequenceI found = findPoint(evt.getX(), evt.getY());
695
696     if (found != null)
697     {
698       this.setToolTipText(found.getName());
699     }
700     else
701     {
702       this.setToolTipText(null);
703     }
704   }
705
706   /**
707    * DOCUMENT ME!
708    * 
709    * @param evt
710    *          DOCUMENT ME!
711    */
712   public void mouseDragged(MouseEvent evt)
713   {
714     mx = evt.getX();
715     my = evt.getY();
716
717     // Check if this is a rectangle drawing drag
718     if ((evt.getModifiers() & InputEvent.BUTTON2_MASK) != 0)
719     {
720       // rectx2 = evt.getX();
721       // recty2 = evt.getY();
722     }
723     else
724     {
725       rotmat.setIdentity();
726
727       rotmat.rotate((float) (my - omy), 'x');
728       rotmat.rotate((float) (mx - omx), 'y');
729
730       for (int i = 0; i < npoint; i++)
731       {
732         SequencePoint sp = (SequencePoint) points.elementAt(i);
733         sp.coord[0] -= centre[0];
734         sp.coord[1] -= centre[1];
735         sp.coord[2] -= centre[2];
736
737         // Now apply the rotation matrix
738         sp.coord = rotmat.vectorMultiply(sp.coord);
739
740         // Now translate back again
741         sp.coord[0] += centre[0];
742         sp.coord[1] += centre[1];
743         sp.coord[2] += centre[2];
744       }
745
746       for (int i = 0; i < 3; i++)
747       {
748         axes[i] = rotmat.vectorMultiply(axes[i]);
749       }
750
751       omx = mx;
752       omy = my;
753
754       paint(this.getGraphics());
755     }
756   }
757
758   /**
759    * DOCUMENT ME!
760    * 
761    * @param x1
762    *          DOCUMENT ME!
763    * @param y1
764    *          DOCUMENT ME!
765    * @param x2
766    *          DOCUMENT ME!
767    * @param y2
768    *          DOCUMENT ME!
769    */
770   public void rectSelect(int x1, int y1, int x2, int y2)
771   {
772     for (int i = 0; i < npoint; i++)
773     {
774       SequencePoint sp = (SequencePoint) points.elementAt(i);
775       int tmp1 = (int) (((sp.coord[0] - centre[0]) * scale) + ((float) getWidth() / 2.0));
776       int tmp2 = (int) (((sp.coord[1] - centre[1]) * scale) + ((float) getHeight() / 2.0));
777
778       if ((tmp1 > x1) && (tmp1 < x2) && (tmp2 > y1) && (tmp2 < y2))
779       {
780         if (av != null)
781         {
782           if (!av.getSelectionGroup().getSequences(null)
783                   .contains(sp.sequence))
784           {
785             av.getSelectionGroup().addSequence(sp.sequence, true);
786           }
787         }
788       }
789     }
790
791     // if (changedSel) {
792     // fireSequenceSelectionEvent(av.getSelection());
793     // }
794   }
795
796   /**
797    * DOCUMENT ME!
798    * 
799    * @param x
800    *          DOCUMENT ME!
801    * @param y
802    *          DOCUMENT ME!
803    * 
804    * @return DOCUMENT ME!
805    */
806   public SequenceI findPoint(int x, int y)
807   {
808     int halfwidth = getWidth() / 2;
809     int halfheight = getHeight() / 2;
810
811     int found = -1;
812
813     for (int i = 0; i < npoint; i++)
814     {
815       SequencePoint sp = (SequencePoint) points.elementAt(i);
816       int px = (int) ((float) (sp.coord[0] - centre[0]) * scale)
817               + halfwidth;
818       int py = (int) ((float) (sp.coord[1] - centre[1]) * scale)
819               + halfheight;
820
821       if ((Math.abs(px - x) < 3) && (Math.abs(py - y) < 3))
822       {
823         found = i;
824       }
825     }
826
827     if (found != -1)
828     {
829       return ((SequencePoint) points.elementAt(found)).sequence;
830     }
831     else
832     {
833       return null;
834     }
835   }
836
837   AlignmentPanel[] getAssociatedPanels()
838   {
839     if (applyToAllViews)
840     {
841       return PaintRefresher.getAssociatedPanels(av.getSequenceSetId());
842     }
843     else
844     {
845       return new AlignmentPanel[] { ap };
846     }
847   }
848
849   /**
850    * 
851    * @return x,y,z positions of point s (index into points) under current
852    *         transform.
853    */
854   public double[] getPointPosition(int s)
855   {
856     double pts[] = new double[3];
857     float[] p = ((SequencePoint) points.elementAt(s)).coord;
858     pts[0] = p[0];
859     pts[1] = p[1];
860     pts[2] = p[2];
861     return pts;
862   }
863
864 }