Merge branch 'releases/Release_2_11_4_Branch'
[jalview.git] / gui / ScalePanel.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.datamodel.ColumnSelection;
24 import jalview.datamodel.SequenceGroup;
25 import jalview.datamodel.SequenceI;
26 import jalview.util.MessageManager;
27
28 import java.awt.Color;
29 import java.awt.FontMetrics;
30 import java.awt.Graphics;
31 import java.awt.Graphics2D;
32 import java.awt.RenderingHints;
33 import java.awt.event.ActionEvent;
34 import java.awt.event.ActionListener;
35 import java.awt.event.MouseEvent;
36 import java.awt.event.MouseListener;
37 import java.awt.event.MouseMotionListener;
38 import java.util.List;
39
40 import javax.swing.JMenuItem;
41 import javax.swing.JPanel;
42 import javax.swing.JPopupMenu;
43 import javax.swing.ToolTipManager;
44
45 /**
46  * The panel containing the sequence ruler (when not in wrapped mode), and
47  * supports a range of mouse operations to select, hide or reveal columns.
48  */
49 public class ScalePanel extends JPanel implements MouseMotionListener,
50         MouseListener
51 {
52   protected int offy = 4;
53
54   public int width;
55
56   protected AlignViewport av;
57
58   AlignmentPanel ap;
59
60   boolean stretchingGroup = false;
61
62   /*
63    * min, max hold the extent of a mouse drag action
64    */
65   int min;
66
67   int max;
68
69   boolean mouseDragging = false;
70
71   /*
72    * holds a hidden column range when the mouse is over an adjacent column
73    */
74   int[] reveal;
75
76   /**
77    * Constructor
78    * 
79    * @param av
80    * @param ap
81    */
82   public ScalePanel(AlignViewport av, AlignmentPanel ap)
83   {
84     this.av = av;
85     this.ap = ap;
86
87     addMouseListener(this);
88     addMouseMotionListener(this);
89   }
90
91   /**
92    * DOCUMENT ME!
93    * 
94    * @param evt
95    *          DOCUMENT ME!
96    */
97   @Override
98   public void mousePressed(MouseEvent evt)
99   {
100     int x = (evt.getX() / av.getCharWidth()) + av.getStartRes();
101     final int res;
102
103     if (av.hasHiddenColumns())
104     {
105       x = av.getColumnSelection().adjustForHiddenColumns(x);
106     }
107
108     if (x >= av.getAlignment().getWidth())
109     {
110       res = av.getAlignment().getWidth() - 1;
111     }
112     else
113     {
114       res = x;
115     }
116
117     min = res;
118     max = res;
119
120     if (evt.isPopupTrigger())
121     {
122       rightMouseButtonPressed(evt, res);
123     }
124     else
125     {
126       leftMouseButtonPressed(evt, res);
127     }
128   }
129
130   /**
131    * Handles right mouse button press. If pressed in a selected column, opens
132    * context menu for 'Hide Columns'. If pressed on a hidden columns marker,
133    * opens context menu for 'Reveal / Reveal All'. Else does nothing.
134    * 
135    * @param evt
136    * @param res
137    */
138   protected void rightMouseButtonPressed(MouseEvent evt, final int res)
139   {
140     JPopupMenu pop = new JPopupMenu();
141     if (reveal != null)
142     {
143       JMenuItem item = new JMenuItem(
144               MessageManager.getString("label.reveal"));
145       item.addActionListener(new ActionListener()
146       {
147         @Override
148         public void actionPerformed(ActionEvent e)
149         {
150           av.showColumn(reveal[0]);
151           reveal = null;
152           ap.paintAlignment(true);
153           if (ap.overviewPanel != null)
154           {
155             ap.overviewPanel.updateOverviewImage();
156           }
157           av.sendSelection();
158         }
159       });
160       pop.add(item);
161
162       if (av.getColumnSelection().hasHiddenColumns())
163       {
164         item = new JMenuItem(MessageManager.getString("action.reveal_all"));
165         item.addActionListener(new ActionListener()
166         {
167           @Override
168           public void actionPerformed(ActionEvent e)
169           {
170             av.showAllHiddenColumns();
171             reveal = null;
172             ap.paintAlignment(true);
173             if (ap.overviewPanel != null)
174             {
175               ap.overviewPanel.updateOverviewImage();
176             }
177             av.sendSelection();
178           }
179         });
180         pop.add(item);
181       }
182       pop.show(this, evt.getX(), evt.getY());
183     }
184     else if (av.getColumnSelection().contains(res))
185     {
186       JMenuItem item = new JMenuItem(
187               MessageManager.getString("label.hide_columns"));
188       item.addActionListener(new ActionListener()
189       {
190         @Override
191         public void actionPerformed(ActionEvent e)
192         {
193           av.hideColumns(res, res);
194           if (av.getSelectionGroup() != null
195                   && av.getSelectionGroup().getSize() == av.getAlignment()
196                           .getHeight())
197           {
198             av.setSelectionGroup(null);
199           }
200
201           ap.paintAlignment(true);
202           if (ap.overviewPanel != null)
203           {
204             ap.overviewPanel.updateOverviewImage();
205           }
206           av.sendSelection();
207         }
208       });
209       pop.add(item);
210       pop.show(this, evt.getX(), evt.getY());
211     }
212   }
213
214   /**
215    * Handles left mouse button press
216    * 
217    * @param evt
218    * @param res
219    */
220   protected void leftMouseButtonPressed(MouseEvent evt, final int res)
221   {
222     if (!evt.isControlDown() && !evt.isShiftDown())
223     {
224       av.getColumnSelection().clear();
225     }
226
227     av.getColumnSelection().addElement(res);
228     SequenceGroup sg = new SequenceGroup();
229     // try to be as quick as possible
230     SequenceI[] iVec = av.getAlignment().getSequencesArray();
231     for (int i = 0; i < iVec.length; i++)
232     {
233       sg.addSequence(iVec[i], false);
234       iVec[i] = null;
235     }
236     iVec = null;
237     sg.setStartRes(res);
238     sg.setEndRes(res);
239
240     if (evt.isShiftDown())
241     {
242       int min = Math.min(av.getColumnSelection().getMin(), res);
243       int max = Math.max(av.getColumnSelection().getMax(), res);
244       for (int i = min; i < max; i++)
245       {
246         av.getColumnSelection().addElement(i);
247       }
248       sg.setStartRes(min);
249       sg.setEndRes(max);
250     }
251     av.setSelectionGroup(sg);
252     ap.paintAlignment(false);
253     av.sendSelection();
254   }
255
256   /**
257    * DOCUMENT ME!
258    * 
259    * @param evt
260    *          DOCUMENT ME!
261    */
262   @Override
263   public void mouseReleased(MouseEvent evt)
264   {
265     mouseDragging = false;
266
267     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
268
269     if (av.hasHiddenColumns())
270     {
271       res = av.getColumnSelection().adjustForHiddenColumns(res);
272     }
273
274     if (res >= av.getAlignment().getWidth())
275     {
276       res = av.getAlignment().getWidth() - 1;
277     }
278
279     if (!stretchingGroup)
280     {
281       ap.paintAlignment(false);
282
283       return;
284     }
285
286     SequenceGroup sg = av.getSelectionGroup();
287
288     if (sg != null)
289     {
290       if (res > sg.getStartRes())
291       {
292         sg.setEndRes(res);
293       }
294       else if (res < sg.getStartRes())
295       {
296         sg.setStartRes(res);
297       }
298     }
299     stretchingGroup = false;
300     ap.paintAlignment(false);
301     av.sendSelection();
302   }
303
304   /**
305    * DOCUMENT ME!
306    * 
307    * @param evt
308    *          DOCUMENT ME!
309    */
310   @Override
311   public void mouseDragged(MouseEvent evt)
312   {
313     mouseDragging = true;
314
315     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
316     if (res < 0)
317     {
318       res = 0;
319     }
320
321     if (av.hasHiddenColumns())
322     {
323       res = av.getColumnSelection().adjustForHiddenColumns(res);
324     }
325
326     if (res >= av.getAlignment().getWidth())
327     {
328       res = av.getAlignment().getWidth() - 1;
329     }
330
331     if (res < min)
332     {
333       min = res;
334     }
335
336     if (res > max)
337     {
338       max = res;
339     }
340
341     SequenceGroup sg = av.getSelectionGroup();
342
343     if (sg != null)
344     {
345       stretchingGroup = true;
346
347       if (!av.getColumnSelection().contains(res))
348       {
349         av.getColumnSelection().addElement(res);
350       }
351
352       if (res > sg.getStartRes())
353       {
354         sg.setEndRes(res);
355       }
356       if (res < sg.getStartRes())
357       {
358         sg.setStartRes(res);
359       }
360
361       int col;
362       for (int i = min; i <= max; i++)
363       {
364         col = i; // av.getColumnSelection().adjustForHiddenColumns(i);
365
366         if ((col < sg.getStartRes()) || (col > sg.getEndRes()))
367         {
368           av.getColumnSelection().removeElement(col);
369         }
370         else
371         {
372           av.getColumnSelection().addElement(col);
373         }
374       }
375
376       ap.paintAlignment(false);
377     }
378   }
379
380   @Override
381   public void mouseEntered(MouseEvent evt)
382   {
383     if (mouseDragging)
384     {
385       ap.getSeqPanel().scrollCanvas(null);
386     }
387   }
388
389   @Override
390   public void mouseExited(MouseEvent evt)
391   {
392     if (mouseDragging)
393     {
394       ap.getSeqPanel().scrollCanvas(evt);
395     }
396   }
397
398   @Override
399   public void mouseClicked(MouseEvent evt)
400   {
401   }
402
403   @Override
404   public void mouseMoved(MouseEvent evt)
405   {
406     this.setToolTipText(null);
407     reveal = null;
408     if (!av.hasHiddenColumns())
409     {
410       return;
411     }
412
413     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
414
415     res = av.getColumnSelection().adjustForHiddenColumns(res);
416
417     if (av.getColumnSelection().getHiddenColumns() != null)
418     {
419       for (int[] region : av.getColumnSelection().getHiddenColumns())
420       {
421         if (res + 1 == region[0] || res - 1 == region[1])
422         {
423           reveal = region;
424           ToolTipManager.sharedInstance().registerComponent(this);
425           this.setToolTipText(MessageManager
426                   .getString("label.reveal_hidden_columns"));
427           break;
428         }
429       }
430     }
431     repaint();
432   }
433
434   /**
435    * DOCUMENT ME!
436    * 
437    * @param g
438    *          DOCUMENT ME!
439    */
440   @Override
441   public void paintComponent(Graphics g)
442   {
443     drawScale(g, av.getStartRes(), av.getEndRes(), getWidth(), getHeight());
444   }
445
446   // scalewidth will normally be screenwidth,
447   public void drawScale(Graphics g, int startx, int endx, int width,
448           int height)
449   {
450     Graphics2D gg = (Graphics2D) g;
451     gg.setFont(av.getFont());
452
453     if (av.antiAlias)
454     {
455       gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
456               RenderingHints.VALUE_ANTIALIAS_ON);
457     }
458
459     // Fill in the background
460     gg.setColor(Color.white);
461     gg.fillRect(0, 0, width, height);
462     gg.setColor(Color.black);
463
464     // Fill the selected columns
465     ColumnSelection cs = av.getColumnSelection();
466     int avCharWidth = av.getCharWidth(), avCharHeight = av.getCharHeight();
467
468     if (cs != null)
469     {
470       gg.setColor(new Color(220, 0, 0));
471
472       for (int sel : cs.getSelected())
473       {
474         // TODO: JAL-2001 - provide a fast method to list visible selected in a
475         // given range
476
477         if (av.hasHiddenColumns())
478         {
479           if (cs.isVisible(sel))
480           {
481             sel = cs.findColumnPosition(sel);
482           }
483           else
484           {
485             continue;
486           }
487         }
488
489         if ((sel >= startx) && (sel <= endx))
490         {
491           gg.fillRect((sel - startx) * avCharWidth, 0, avCharWidth,
492                   getHeight());
493         }
494       }
495     }
496
497     int widthx = 1 + endx - startx;
498
499     FontMetrics fm = gg.getFontMetrics(av.getFont());
500     int y = avCharHeight, yOf = fm.getDescent();
501     y -= yOf;
502     if (av.hasHiddenColumns())
503     {
504       // draw any hidden column markers
505       gg.setColor(Color.blue);
506       int res;
507       if (av.getShowHiddenMarkers()
508               && av.getColumnSelection().getHiddenColumns() != null)
509       {
510         for (int i = 0; i < av.getColumnSelection().getHiddenColumns()
511                 .size(); i++)
512         {
513           res = av.getColumnSelection().findHiddenRegionPosition(i)
514                   - startx;
515
516           if (res < 0 || res > widthx)
517           {
518             continue;
519           }
520
521           gg.fillPolygon(new int[] {
522               -1 + res * avCharWidth - avCharHeight / 4,
523               -1 + res * avCharWidth + avCharHeight / 4,
524               -1 + res * avCharWidth }, new int[] { y, y, y + 2 * yOf }, 3);
525
526         }
527       }
528     }
529     // Draw the scale numbers
530     gg.setColor(Color.black);
531
532     int maxX = 0;
533     List<Object[]> marks = jalview.renderer.ScaleRenderer.calculateMarks(
534             av, startx, endx);
535
536     for (Object[] mark : marks)
537     {
538       boolean major = Boolean.valueOf((Boolean) mark[0]);
539       int mpos = ((Integer) mark[1]).intValue(); // (i - startx - 1)
540       String mstring = (String) mark[2];
541       if (mstring != null)
542       {
543         if (mpos * avCharWidth > maxX)
544         {
545           gg.drawString(mstring, mpos * avCharWidth, y);
546           maxX = (mpos + 2) * avCharWidth + fm.stringWidth(mstring);
547         }
548       }
549       if (major)
550       {
551         gg.drawLine((mpos * avCharWidth) + (avCharWidth / 2), y + 2,
552                 (mpos * avCharWidth) + (avCharWidth / 2), y + (yOf * 2));
553       }
554       else
555       {
556         gg.drawLine((mpos * avCharWidth) + (avCharWidth / 2), y + yOf,
557                 (mpos * avCharWidth) + (avCharWidth / 2), y + (yOf * 2));
558       }
559     }
560     if (av.hasHiddenColumns())
561     {
562       if (reveal != null && reveal[0] > startx && reveal[0] < endx)
563       {
564         gg.drawString(MessageManager.getString("label.reveal_columns"),
565                 reveal[0] * avCharWidth, 0);
566       }
567     }
568
569   }
570
571 }