JAL-3851 remove old interface
[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.Point;
25 import jalview.datamodel.SequenceGroup;
26 import jalview.datamodel.SequenceI;
27 import jalview.datamodel.SequencePoint;
28 import jalview.math.RotatableMatrix;
29 import jalview.math.RotatableMatrix.Axis;
30 import jalview.util.ColorUtils;
31 import jalview.util.MessageManager;
32 import jalview.viewmodel.AlignmentViewport;
33
34 import java.awt.Color;
35 import java.awt.Dimension;
36 import java.awt.Font;
37 import java.awt.Graphics;
38 import java.awt.Graphics2D;
39 import java.awt.Image;
40 import java.awt.RenderingHints;
41 import java.awt.event.InputEvent;
42 import java.awt.event.KeyEvent;
43 import java.awt.event.KeyListener;
44 import java.awt.event.MouseEvent;
45 import java.awt.event.MouseListener;
46 import java.awt.event.MouseMotionListener;
47 import java.awt.event.MouseWheelEvent;
48 import java.awt.event.MouseWheelListener;
49 import java.util.Arrays;
50 import java.util.Iterator;
51 import java.util.List;
52
53 import javax.swing.JPanel;
54 import javax.swing.ToolTipManager;
55
56 /**
57  * Models a Panel on which a set of points, and optionally x/y/z axes, can be
58  * drawn, and rotated or zoomed with the mouse
59  */
60 public class RotatableCanvas extends JPanel implements MouseListener,
61         MouseMotionListener, KeyListener, RotatableCanvasI,
62         MouseWheelListener
63 {
64   private static final float ZOOM_OUT = 0.9f;
65
66   private static final float ZOOM_IN = 1.1f;
67
68   /*
69    * pixels distance within which tooltip shows sequence name
70    */
71   private static final int NEARBY = 3;
72
73   private static final List<String> AXES = Arrays.asList("x", "y", "z");
74
75   private static final Color AXIS_COLOUR = Color.yellow;
76
77   private static final int DIMS = 3;
78
79   boolean drawAxes = true;
80
81   int mouseX;
82
83   int mouseY;
84
85   Image img;
86
87   Graphics ig;
88
89   Dimension prefSize;
90
91   /*
92    * the min-max [x, y, z] values of sequence points when the points
93    * were set on the object, or when the view is reset; 
94    * x and y ranges are not recomputed as points are rotated, as this
95    * would make scaling (zoom) unstable, but z ranges are (for correct
96    * graduated colour brightness based on z-coordinate)
97    */
98   float[] seqMin;
99
100   float[] seqMax;
101
102   /*
103    * a scale factor used in drawing; when equal to 1, the points span
104    * half the available width or height (whichever is less); increase this
105    * factor to zoom in, decrease it to zoom out
106    */
107   private float scaleFactor;
108
109   int npoint;
110
111   /*
112    * sequences and their (x, y, z) PCA dimension values
113    */
114   List<SequencePoint> sequencePoints;
115
116   /*
117    * x, y, z axis end points (PCA dimension values)
118    */
119   private Point[] axisEndPoints;
120
121   // fields for 'select rectangle' (JAL-1124)
122   // int rectx1;
123   // int recty1;
124   // int rectx2;
125   // int recty2;
126
127   AlignmentViewport av;
128
129   AlignmentPanel ap;
130
131   private boolean showLabels;
132
133   private Color bgColour;
134
135   private boolean applyToAllViews;
136
137   /**
138    * Constructor
139    * 
140    * @param panel
141    */
142   public RotatableCanvas(AlignmentPanel panel)
143   {
144     this.av = panel.av;
145     this.ap = panel;
146     setAxisEndPoints(new Point[DIMS]);
147     setShowLabels(false);
148     setApplyToAllViews(false);
149     setBgColour(Color.BLACK);
150     resetAxes();
151
152     ToolTipManager.sharedInstance().registerComponent(this);
153
154     addMouseListener(this);
155     addMouseMotionListener(this);
156     addMouseWheelListener(this);
157   }
158
159   /**
160    * Refreshes the display with labels shown (or not)
161    * 
162    * @param show
163    */
164   public void showLabels(boolean show)
165   {
166     setShowLabels(show);
167     repaint();
168   }
169
170   @Override
171   public void setPoints(List<SequencePoint> points, int np)
172   {
173     this.sequencePoints = points;
174     this.npoint = np;
175     prefSize = getPreferredSize();
176
177     findWidths();
178
179     setScaleFactor(1f);
180   }
181
182   /**
183    * Resets axes to the initial state: x-axis to the right, y-axis up, z-axis to
184    * back (so obscured in a 2-D display)
185    */
186   protected void resetAxes()
187   {
188     getAxisEndPoints()[0] = new Point(1f, 0f, 0f);
189     getAxisEndPoints()[1] = new Point(0f, 1f, 0f);
190     getAxisEndPoints()[2] = new Point(0f, 0f, 1f);
191   }
192
193   /**
194    * Computes and saves the min-max ranges of x/y/z positions of the sequence
195    * points
196    */
197   protected void findWidths()
198   {
199     float[] max = new float[DIMS];
200     float[] min = new float[DIMS];
201     
202     max[0] = -Float.MAX_VALUE;
203     max[1] = -Float.MAX_VALUE;
204     max[2] = -Float.MAX_VALUE;
205     
206     min[0] = Float.MAX_VALUE;
207     min[1] = Float.MAX_VALUE;
208     min[2] = Float.MAX_VALUE;
209     
210     for (SequencePoint sp : sequencePoints)
211     {
212       max[0] = Math.max(max[0], sp.coord.x);
213       max[1] = Math.max(max[1], sp.coord.y);
214       max[2] = Math.max(max[2], sp.coord.z);
215       min[0] = Math.min(min[0], sp.coord.x);
216       min[1] = Math.min(min[1], sp.coord.y);
217       min[2] = Math.min(min[2], sp.coord.z);
218     }
219     
220     seqMin = min;
221     seqMax = max;
222   }
223
224   /**
225    * Answers the preferred size if it has been set, else 400 x 400
226    * 
227    * @return
228    */
229   @Override
230   public Dimension getPreferredSize()
231   {
232     if (prefSize != null)
233     {
234       return prefSize;
235     }
236     else
237     {
238       return new Dimension(400, 400);
239     }
240   }
241
242   /**
243    * Answers the preferred size
244    * 
245    * @return
246    * @see RotatableCanvas#getPreferredSize()
247    */
248   @Override
249   public Dimension getMinimumSize()
250   {
251     return getPreferredSize();
252   }
253
254   /**
255    * Repaints the panel
256    * 
257    * @param g
258    */
259   @Override
260   public void paintComponent(Graphics g1)
261   {
262
263     Graphics2D g = (Graphics2D) g1;
264
265     g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
266             RenderingHints.VALUE_ANTIALIAS_ON);
267     if (sequencePoints == null)
268     {
269       g.setFont(new Font("Verdana", Font.PLAIN, 18));
270       g.drawString(
271               MessageManager.getString("label.calculating_pca") + "....",
272               20, getHeight() / 2);
273     }
274     else
275     {
276       /*
277        * create the image at the beginning or after a resize
278        */
279       boolean resized = prefSize.width != getWidth()
280               || prefSize.height != getHeight();
281       if (img == null || resized)
282       {
283         prefSize.width = getWidth();
284         prefSize.height = getHeight();
285
286         img = createImage(getWidth(), getHeight());
287         ig = img.getGraphics();
288       }
289
290       drawBackground(ig);
291       drawScene(ig);
292
293       if (drawAxes)
294       {
295         drawAxes(ig);
296       }
297
298       g.drawImage(img, 0, 0, this);
299     }
300   }
301
302   /**
303    * Resets the rotation and choice of axes to the initial state (without change
304    * of scale factor)
305    */
306   public void resetView()
307   {
308     img = null;
309     findWidths();
310     resetAxes();
311     repaint();
312   }
313
314   /**
315    * Draws lines for the x, y, z axes
316    * 
317    * @param g
318    */
319   public void drawAxes(Graphics g)
320   {
321     g.setColor(AXIS_COLOUR);
322
323     int midX = getWidth() / 2;
324     int midY = getHeight() / 2;
325     float maxWidth = Math.max(Math.abs(seqMax[0] - seqMin[0]),
326             Math.abs(seqMax[1] - seqMin[1]));
327     int pix = Math.min(getWidth(), getHeight());
328     float scaleBy = pix * getScaleFactor() / (2f * maxWidth);
329
330     for (int i = 0; i < DIMS; i++)
331     {
332       g.drawLine(midX, midY,
333               midX + (int) (getAxisEndPoints()[i].x * scaleBy * seqMax[0]),
334               midY + (int) (getAxisEndPoints()[i].y * scaleBy * seqMax[1]));
335     }
336   }
337
338   /**
339    * Fills the background with the currently configured background colour
340    * 
341    * @param g
342    */
343   public void drawBackground(Graphics g)
344   {
345     g.setColor(getBgColour());
346     g.fillRect(0, 0, prefSize.width, prefSize.height);
347   }
348
349   /**
350    * Draws points (6x6 squares) for the sequences of the PCA, and labels
351    * (sequence names) if configured to do so. The sequence points colours are
352    * taken from the sequence ids in the alignment (converting black to white).
353    * Sequences 'at the back' (z-coordinate is negative) are shaded slightly
354    * darker to help give a 3-D sensation.
355    * 
356    * @param g
357    */
358   public void drawScene(Graphics g1)
359   {
360     Graphics2D g = (Graphics2D) g1;
361
362     g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
363             RenderingHints.VALUE_ANTIALIAS_ON);
364     int pix = Math.min(getWidth(), getHeight());
365     float xWidth = Math.abs(seqMax[0] - seqMin[0]);
366     float yWidth = Math.abs(seqMax[1] - seqMin[1]);
367     float maxWidth = Math.max(xWidth, yWidth);
368     float scaleBy = pix * getScaleFactor() / (2f * maxWidth);
369
370     float[] centre = getCentre();
371
372     for (int i = 0; i < npoint; i++)
373     {
374       /*
375        * sequence point colour as sequence id, but
376        * gray if sequence is currently selected
377        */
378       SequencePoint sp = sequencePoints.get(i);
379       Color sequenceColour = getSequencePointColour(sp);
380       g.setColor(sequenceColour);
381
382       int halfwidth = getWidth() / 2;
383       int halfheight = getHeight() / 2;
384       int x = (int) ((sp.coord.x - centre[0]) * scaleBy) + halfwidth;
385       int y = (int) ((sp.coord.y - centre[1]) * scaleBy) + halfheight;
386       g.fillRect(x - 3, y - 3, 6, 6);
387
388       if (isShowLabels())
389       {
390         g.setColor(Color.red);
391         g.drawString(sp.getSequence().getName(), x - 3, y - 4);
392       }
393     }
394     if (isShowLabels())
395     {
396       g.setColor(AXIS_COLOUR);
397       int midX = getWidth() / 2;
398       int midY = getHeight() / 2;
399       Iterator<String> axes = AXES.iterator();
400       for (Point p : getAxisEndPoints())
401       {
402         int x = midX + (int) (p.x * scaleBy * seqMax[0]);
403         int y = midY + (int) (p.y * scaleBy * seqMax[1]);
404         g.drawString(axes.next(), x - 3, y - 4);
405       }
406     }
407     // //Now the rectangle
408     // if (rectx2 != -1 && recty2 != -1) {
409     // g.setColor(Color.white);
410     //
411     // g.drawRect(rectx1,recty1,rectx2-rectx1,recty2-recty1);
412     // }
413   }
414
415   /**
416    * Determines the colour to use when drawing a sequence point. The colour is
417    * taken from the sequence id, with black converted to white, and then
418    * graduated from darker (at the back) to brighter (at the front) based on the
419    * z-axis coordinate of the point.
420    * 
421    * @param sp
422    * @return
423    */
424   protected Color getSequencePointColour(SequencePoint sp)
425   {
426     SequenceI sequence = sp.getSequence();
427     Color sequenceColour = av.getSequenceColour(sequence);
428     if (sequenceColour == Color.black)
429     {
430       sequenceColour = Color.white;
431     }
432     if (av.getSelectionGroup() != null)
433     {
434       if (av.getSelectionGroup().getSequences(null).contains(sequence))
435       {
436         sequenceColour = Color.gray;
437       }
438     }
439
440     /*
441      * graduate brighter for point in front of centre, darker if behind centre
442      */
443     float zCentre = (seqMin[2] + seqMax[2]) / 2f;
444     if (sp.coord.z > zCentre)
445     {
446       sequenceColour = ColorUtils.getGraduatedColour(sp.coord.z, 0,
447               sequenceColour, seqMax[2], sequenceColour.brighter());
448     }
449     else if (sp.coord.z < zCentre)
450     {
451       sequenceColour = ColorUtils.getGraduatedColour(sp.coord.z, seqMin[2],
452               sequenceColour.darker(), 0, sequenceColour);
453     }
454
455     return sequenceColour;
456   }
457
458   @Override
459   public void keyTyped(KeyEvent evt)
460   {
461   }
462
463   @Override
464   public void keyReleased(KeyEvent evt)
465   {
466   }
467
468   /**
469    * Responds to up or down arrow key by zooming in or out, respectively
470    * 
471    * @param evt
472    */
473   @Override
474   public void keyPressed(KeyEvent evt)
475   {
476     int keyCode = evt.getKeyCode();
477     boolean shiftDown = evt.isShiftDown();
478
479     if (keyCode == KeyEvent.VK_UP)
480     {
481       if (shiftDown)
482       {
483         rotate(0f, -1f);
484       }
485       else
486       {
487         zoom(ZOOM_IN);
488       }
489     }
490     else if (keyCode == KeyEvent.VK_DOWN)
491     {
492       if (shiftDown)
493       {
494         rotate(0f, 1f);
495       }
496       else
497       {
498         zoom(ZOOM_OUT);
499       }
500     }
501     else if (shiftDown && keyCode == KeyEvent.VK_LEFT)
502     {
503       rotate(1f, 0f);
504     }
505     else if (shiftDown && keyCode == KeyEvent.VK_RIGHT)
506     {
507       rotate(-1f, 0f);
508     }
509     else if (evt.getKeyChar() == 's')
510     {
511       // Cache.log.warn("DEBUG: Rectangle selection");
512       // todo not yet enabled as rectx2, recty2 are always -1
513       // need to set them in mouseDragged; JAL-1124
514       // if ((rectx2 != -1) && (recty2 != -1))
515       // {
516       // rectSelect(rectx1, recty1, rectx2, recty2);
517       // }
518     }
519
520     repaint();
521   }
522
523   @Override
524   public void zoom(float factor)
525   {
526     if (factor > 0f)
527     {
528       setScaleFactor(getScaleFactor() * factor);
529     }
530   }
531
532   @Override
533   public void mouseClicked(MouseEvent evt)
534   {
535   }
536
537   @Override
538   public void mouseEntered(MouseEvent evt)
539   {
540   }
541
542   @Override
543   public void mouseExited(MouseEvent evt)
544   {
545   }
546
547   @Override
548   public void mouseReleased(MouseEvent evt)
549   {
550   }
551
552   /**
553    * If the mouse press is at (within 2 pixels of) a sequence point, toggles
554    * (adds or removes) the corresponding sequence as a member of the viewport
555    * selection group. This supports configuring a group in the alignment by
556    * clicking on points in the PCA display.
557    */
558   @Override
559   public void mousePressed(MouseEvent evt)
560   {
561     int x = evt.getX();
562     int y = evt.getY();
563
564     mouseX = x;
565     mouseY = y;
566
567     // rectx1 = x;
568     // recty1 = y;
569     // rectx2 = -1;
570     // recty2 = -1;
571
572     SequenceI found = findSequenceAtPoint(x, y);
573
574     if (found != null)
575     {
576       AlignmentPanel[] aps = getAssociatedPanels();
577
578       for (int a = 0; a < aps.length; a++)
579       {
580         if (aps[a].av.getSelectionGroup() != null)
581         {
582           aps[a].av.getSelectionGroup().addOrRemove(found, true);
583         }
584         else
585         {
586           aps[a].av.setSelectionGroup(new SequenceGroup());
587           aps[a].av.getSelectionGroup().addOrRemove(found, true);
588           aps[a].av.getSelectionGroup()
589                   .setEndRes(aps[a].av.getAlignment().getWidth() - 1);
590         }
591       }
592       PaintRefresher.Refresh(this, av.getSequenceSetId());
593       // canonical selection is sent to other listeners
594       av.sendSelection();
595     }
596
597     repaint();
598   }
599
600   /**
601    * Sets the tooltip to the name of the sequence within 2 pixels of the mouse
602    * position, or clears the tooltip if none found
603    */
604   @Override
605   public void mouseMoved(MouseEvent evt)
606   {
607     SequenceI found = findSequenceAtPoint(evt.getX(), evt.getY());
608
609     this.setToolTipText(found == null ? null : found.getName());
610   }
611
612   /**
613    * Action handler for a mouse drag. Rotates the display around the X axis (for
614    * up/down mouse movement) and/or the Y axis (for left/right mouse movement).
615    * 
616    * @param evt
617    */
618   @Override
619   public void mouseDragged(MouseEvent evt)
620   {
621     int xPos = evt.getX();
622     int yPos = evt.getY();
623
624     if (xPos == mouseX && yPos == mouseY)
625     {
626       return;
627     }
628
629     int xDelta = xPos - mouseX;
630     int yDelta = yPos - mouseY;
631
632     // Check if this is a rectangle drawing drag
633     if ((evt.getModifiersEx() & InputEvent.BUTTON2_DOWN_MASK) != 0)
634     {
635       // rectx2 = evt.getX();
636       // recty2 = evt.getY();
637     }
638     else
639     {
640       rotate(xDelta, yDelta);
641
642       mouseX = xPos;
643       mouseY = yPos;
644
645       // findWidths();
646
647       repaint();
648     }
649   }
650
651   @Override
652   public void rotate(float x, float y)
653   {
654     if (x == 0f && y == 0f)
655     {
656       return;
657     }
658
659     /*
660      * get the identity transformation...
661      */
662     RotatableMatrix rotmat = new RotatableMatrix();
663
664     /*
665      * rotate around the X axis for change in Y
666      * (mouse movement up/down); note we are equating a
667      * number of pixels with degrees of rotation here!
668      */
669     if (y != 0)
670     {
671       rotmat.rotate(y, Axis.X);
672     }
673
674     /*
675      * rotate around the Y axis for change in X
676      * (mouse movement left/right)
677      */
678     if (x != 0)
679     {
680       rotmat.rotate(x, Axis.Y);
681     }
682
683     /*
684      * apply the composite transformation to sequence points;
685      * update z min-max range (affects colour graduation), but not
686      * x or y min-max (as this would affect axis scaling)
687      */
688     float[] centre = getCentre();
689     float zMin = Float.MAX_VALUE;
690     float zMax = -Float.MAX_VALUE;
691
692     for (int i = 0; i < npoint; i++)
693     {
694       SequencePoint sp = sequencePoints.get(i);
695       sp.translate(-centre[0], -centre[1], -centre[2]);
696
697       // Now apply the rotation matrix
698       sp.coord = rotmat.vectorMultiply(sp.coord);
699
700       // Now translate back again
701       sp.translate(centre[0], centre[1], centre[2]);
702       
703       zMin = Math.min(zMin, sp.coord.z);
704       zMax = Math.max(zMax, sp.coord.z);
705     }
706
707     seqMin[2] = zMin;
708     seqMax[2] = zMax;
709
710     /*
711      * rotate the x/y/z axis positions
712      */
713     for (int i = 0; i < DIMS; i++)
714     {
715       getAxisEndPoints()[i] = rotmat.vectorMultiply(getAxisEndPoints()[i]);
716     }
717   }
718
719   /**
720    * Answers the x/y/z coordinates that are midway between the maximum and
721    * minimum sequence point values
722    * 
723    * @return
724    */
725   private float[] getCentre()
726   {
727     float xCentre = (seqMin[0] + seqMax[0]) / 2f;
728     float yCentre = (seqMin[1] + seqMax[1]) / 2f;
729     float zCentre = (seqMin[2] + seqMax[2]) / 2f;
730
731     return new float[] { xCentre, yCentre, zCentre };
732   }
733
734   /**
735    * Adds any sequences whose displayed points are within the given rectangle to
736    * the viewport's current selection. Intended for key 's' after dragging to
737    * select a region of the PCA.
738    * 
739    * @param x1
740    * @param y1
741    * @param x2
742    * @param y2
743    */
744   protected void rectSelect(int x1, int y1, int x2, int y2)
745   {
746     float[] centre = getCentre();
747
748     for (int i = 0; i < npoint; i++)
749     {
750       SequencePoint sp = sequencePoints.get(i);
751       int tmp1 = (int) (((sp.coord.x - centre[0]) * getScaleFactor())
752               + (getWidth() / 2.0));
753       int tmp2 = (int) (((sp.coord.y - centre[1]) * getScaleFactor())
754               + (getHeight() / 2.0));
755
756       if ((tmp1 > x1) && (tmp1 < x2) && (tmp2 > y1) && (tmp2 < y2))
757       {
758         if (av != null)
759         {
760           SequenceI sequence = sp.getSequence();
761           if (!av.getSelectionGroup().getSequences(null)
762                   .contains(sequence))
763           {
764             av.getSelectionGroup().addSequence(sequence, true);
765           }
766         }
767       }
768     }
769   }
770
771   /**
772    * Answers the first sequence found whose point on the display is within 2
773    * pixels of the given coordinates, or null if none is found
774    * 
775    * @param x
776    * @param y
777    * 
778    * @return
779    */
780   protected SequenceI findSequenceAtPoint(int x, int y)
781   {
782     int halfwidth = getWidth() / 2;
783     int halfheight = getHeight() / 2;
784
785     int found = -1;
786     int pix = Math.min(getWidth(), getHeight());
787     float xWidth = Math.abs(seqMax[0] - seqMin[0]);
788     float yWidth = Math.abs(seqMax[1] - seqMin[1]);
789     float maxWidth = Math.max(xWidth, yWidth);
790     float scaleBy = pix * getScaleFactor() / (2f * maxWidth);
791
792     float[] centre = getCentre();
793
794     for (int i = 0; i < npoint; i++)
795     {
796       SequencePoint sp = sequencePoints.get(i);
797       int px = (int) ((sp.coord.x - centre[0]) * scaleBy)
798               + halfwidth;
799       int py = (int) ((sp.coord.y - centre[1]) * scaleBy)
800               + halfheight;
801
802       if ((Math.abs(px - x) < NEARBY) && (Math.abs(py - y) < NEARBY))
803       {
804         found = i;
805         break;
806       }
807     }
808
809     if (found != -1)
810     {
811       return sequencePoints.get(found).getSequence();
812     }
813     else
814     {
815       return null;
816     }
817   }
818
819   /**
820    * Answers the panel the PCA is associated with (all panels for this alignment
821    * if 'associate with all panels' is selected).
822    * 
823    * @return
824    */
825   AlignmentPanel[] getAssociatedPanels()
826   {
827     if (isApplyToAllViews())
828     {
829       return PaintRefresher.getAssociatedPanels(av.getSequenceSetId());
830     }
831     else
832     {
833       return new AlignmentPanel[] { ap };
834     }
835   }
836
837   public Color getBackgroundColour()
838   {
839     return getBgColour();
840   }
841
842   /**
843    * Zooms in or out in response to mouse wheel movement
844    */
845   @Override
846   public void mouseWheelMoved(MouseWheelEvent e)
847   {
848     double wheelRotation = e.getPreciseWheelRotation();
849     if (wheelRotation > 0)
850     {
851       zoom(ZOOM_IN);
852       repaint();
853     }
854     else if (wheelRotation < 0)
855     {
856       zoom(ZOOM_OUT);
857       repaint();
858     }
859   }
860
861   /**
862    * Answers the sequence point minimum [x, y, z] values. Note these are derived
863    * when sequence points are set, but x and y values are not updated on
864    * rotation (because this would result in changes to scaling).
865    * 
866    * @return
867    */
868   public float[] getSeqMin()
869   {
870     return seqMin;
871   }
872
873   /**
874    * Answers the sequence point maximum [x, y, z] values. Note these are derived
875    * when sequence points are set, but x and y values are not updated on
876    * rotation (because this would result in changes to scaling).
877    * 
878    * @return
879    */
880   public float[] getSeqMax()
881   {
882     return seqMax;
883   }
884
885   /**
886    * Sets the minimum and maximum [x, y, z] positions for sequence points. For
887    * use when restoring a saved PCA from state data.
888    * 
889    * @param min
890    * @param max
891    */
892   public void setSeqMinMax(float[] min, float[] max)
893   {
894     seqMin = min;
895     seqMax = max;
896   }
897
898   public float getScaleFactor()
899   {
900     return scaleFactor;
901   }
902
903   public void setScaleFactor(float scaleFactor)
904   {
905     this.scaleFactor = scaleFactor;
906   }
907
908   public boolean isShowLabels()
909   {
910     return showLabels;
911   }
912
913   public void setShowLabels(boolean showLabels)
914   {
915     this.showLabels = showLabels;
916   }
917
918   public boolean isApplyToAllViews()
919   {
920     return applyToAllViews;
921   }
922
923   public void setApplyToAllViews(boolean applyToAllViews)
924   {
925     this.applyToAllViews = applyToAllViews;
926   }
927
928   public Point[] getAxisEndPoints()
929   {
930     return axisEndPoints;
931   }
932
933   public void setAxisEndPoints(Point[] axisEndPoints)
934   {
935     this.axisEndPoints = axisEndPoints;
936   }
937
938   public Color getBgColour()
939   {
940     return bgColour;
941   }
942
943   public void setBgColour(Color bgColour)
944   {
945     this.bgColour = bgColour;
946   }
947 }