Show hide cols and rows
[jalview.git] / src / jalview / gui / AnnotationPanel.java
1 /*\r
2  * Jalview - A Sequence Alignment Editor and Viewer\r
3  * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
4  *\r
5  * This program is free software; you can redistribute it and/or\r
6  * modify it under the terms of the GNU General Public License\r
7  * as published by the Free Software Foundation; either version 2\r
8  * of the License, or (at your option) any later version.\r
9  *\r
10  * This program is distributed in the hope that it will be useful,\r
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
13  * GNU General Public License for more details.\r
14  *\r
15  * You should have received a copy of the GNU General Public License\r
16  * along with this program; if not, write to the Free Software\r
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
18  */\r
19 package jalview.gui;\r
20 \r
21 import jalview.datamodel.*;\r
22 \r
23 import java.awt.*;\r
24 import java.awt.event.*;\r
25 import java.awt.image.*;\r
26 \r
27 import javax.swing.*;\r
28 \r
29 \r
30 /**\r
31  * DOCUMENT ME!\r
32  *\r
33  * @author $author$\r
34  * @version $Revision$\r
35  */\r
36 public class AnnotationPanel extends JPanel implements MouseListener,\r
37     MouseMotionListener, ActionListener, AdjustmentListener\r
38 {\r
39     final String HELIX = "Helix";\r
40     final String SHEET = "Sheet";\r
41     final String LABEL = "Label";\r
42     final String REMOVE = "Remove Annotation";\r
43     final String COLOUR = "Colour";\r
44     final Color HELIX_COLOUR = Color.red.darker();\r
45     final Color SHEET_COLOUR = Color.green.darker().darker();\r
46 \r
47     /** DOCUMENT ME!! */\r
48     AlignViewport av;\r
49     AlignmentPanel ap;\r
50     int activeRow = -1;\r
51     BufferedImage image;\r
52     Graphics2D gg;\r
53     FontMetrics fm;\r
54     int imgWidth = 0;\r
55     boolean fastPaint = false;\r
56 \r
57     //Used For mouse Dragging and resizing graphs\r
58     int graphStretch = -1;\r
59     int graphStretchY = -1;\r
60     int min; //used by mouseDragged to see if user\r
61     int max; //used by mouseDragged to see if user\r
62     boolean mouseDragging = false;\r
63 \r
64     boolean MAC = false;\r
65 \r
66     /**\r
67      * Creates a new AnnotationPanel object.\r
68      *\r
69      * @param ap DOCUMENT ME!\r
70      */\r
71     public AnnotationPanel(AlignmentPanel ap)\r
72     {\r
73 \r
74     if(System.getProperty("os.name").startsWith("Mac"))\r
75       MAC = true;\r
76 \r
77         ToolTipManager.sharedInstance().registerComponent(this);\r
78         ToolTipManager.sharedInstance().setInitialDelay(0);\r
79         ToolTipManager.sharedInstance().setDismissDelay(10000);\r
80         this.ap = ap;\r
81         av = ap.av;\r
82         this.setLayout(null);\r
83         addMouseListener(this);\r
84         addMouseMotionListener(this);\r
85         ap.annotationScroller.getVerticalScrollBar().addAdjustmentListener(this);\r
86     }\r
87 \r
88     public AnnotationPanel(AlignViewport av)\r
89     {\r
90       this.av = av;\r
91     }\r
92 \r
93 \r
94     /**\r
95      * DOCUMENT ME!\r
96      *\r
97      * @param evt DOCUMENT ME!\r
98      */\r
99     public void adjustmentValueChanged(AdjustmentEvent evt)\r
100     {\r
101         ap.alabels.setScrollOffset(-evt.getValue());\r
102     }\r
103 \r
104     /**\r
105      * DOCUMENT ME!\r
106      */\r
107     public int adjustPanelHeight()\r
108     {\r
109         // setHeight of panels\r
110         image = null;\r
111         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();\r
112         int height = 0;\r
113 \r
114         if (aa != null)\r
115         {\r
116             for (int i = 0; i < aa.length; i++)\r
117             {\r
118                 if (!aa[i].visible)\r
119                 {\r
120                     continue;\r
121                 }\r
122 \r
123                 aa[i].height = 0;\r
124 \r
125                 if (aa[i].hasText)\r
126                 {\r
127                     aa[i].height += av.charHeight;\r
128                 }\r
129 \r
130                 if (aa[i].hasIcons)\r
131                 {\r
132                     aa[i].height += 16;\r
133                 }\r
134 \r
135                 if (aa[i].graph>0)\r
136                 {\r
137                     aa[i].height += aa[i].graphHeight;\r
138                 }\r
139 \r
140                 if (aa[i].height == 0)\r
141                 {\r
142                     aa[i].height = 20;\r
143                 }\r
144 \r
145                 height += aa[i].height;\r
146             }\r
147         }\r
148         else\r
149         {\r
150             height = 20;\r
151         }\r
152 \r
153         this.setPreferredSize(new Dimension(1, height));\r
154 \r
155         return height;\r
156     }\r
157 \r
158 \r
159 \r
160     /**\r
161      * DOCUMENT ME!\r
162      *\r
163      * @param evt DOCUMENT ME!\r
164      */\r
165     public void actionPerformed(ActionEvent evt)\r
166     {\r
167         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();\r
168         Annotation[] anot = aa[activeRow].annotations;\r
169 \r
170         if (evt.getActionCommand().equals(REMOVE))\r
171         {\r
172             for (int i = 0; i < av.getColumnSelection().size(); i++)\r
173             {\r
174                 anot[av.getColumnSelection().columnAt(i)] = null;\r
175             }\r
176         }\r
177         else if (evt.getActionCommand().equals(LABEL))\r
178         {\r
179             String label = JOptionPane.showInputDialog(this, "Enter Label ",\r
180                     "Enter label", JOptionPane.QUESTION_MESSAGE);\r
181 \r
182             if (label == null)\r
183             {\r
184                 return;\r
185             }\r
186 \r
187             if ((label.length() > 0) && !aa[activeRow].hasText)\r
188             {\r
189                 aa[activeRow].hasText = true;\r
190             }\r
191 \r
192             for (int i = 0; i < av.getColumnSelection().size(); i++)\r
193             {\r
194                 int index = av.getColumnSelection().columnAt(i);\r
195 \r
196                 if (anot[index] == null)\r
197                 {\r
198                     anot[index] = new Annotation(label, "", ' ', 0);\r
199                 }\r
200 \r
201                 anot[index].displayCharacter = label;\r
202             }\r
203         }\r
204         else if (evt.getActionCommand().equals(COLOUR))\r
205         {\r
206             Color col = JColorChooser.showDialog(this,\r
207                     "Choose foreground colour", Color.black);\r
208 \r
209             for (int i = 0; i < av.getColumnSelection().size(); i++)\r
210             {\r
211                 int index = av.getColumnSelection().columnAt(i);\r
212 \r
213                 if (anot[index] == null)\r
214                 {\r
215                     anot[index] = new Annotation("", "", ' ', 0);\r
216                 }\r
217 \r
218                 anot[index].colour = col;\r
219             }\r
220         }\r
221         else // HELIX OR SHEET\r
222         {\r
223             char type = 0;\r
224             String symbol = "\u03B1";\r
225 \r
226             if (evt.getActionCommand().equals(HELIX))\r
227             {\r
228                 type = 'H';\r
229             }\r
230             else if (evt.getActionCommand().equals(SHEET))\r
231             {\r
232                 type = 'E';\r
233                 symbol = "\u03B2";\r
234             }\r
235 \r
236             if (!aa[activeRow].hasIcons)\r
237             {\r
238                 aa[activeRow].hasIcons = true;\r
239             }\r
240 \r
241             String label = JOptionPane.showInputDialog("Enter a label for the structure?",\r
242                     symbol);\r
243 \r
244             if (label == null)\r
245             {\r
246                 return;\r
247             }\r
248 \r
249             if ((label.length() > 0) && !aa[activeRow].hasText)\r
250             {\r
251                 aa[activeRow].hasText = true;\r
252             }\r
253 \r
254             for (int i = 0; i < av.getColumnSelection().size(); i++)\r
255             {\r
256                 int index = av.getColumnSelection().columnAt(i);\r
257 \r
258                 if (anot[index] == null)\r
259                 {\r
260                     anot[index] = new Annotation(label, "", type, 0);\r
261                 }\r
262 \r
263                 anot[index].secondaryStructure = type;\r
264                 anot[index].displayCharacter = label;\r
265             }\r
266         }\r
267 \r
268         adjustPanelHeight();\r
269         repaint();\r
270 \r
271         return;\r
272     }\r
273 \r
274     /**\r
275      * DOCUMENT ME!\r
276      *\r
277      * @param evt DOCUMENT ME!\r
278      */\r
279     public void mousePressed(MouseEvent evt)\r
280     {\r
281 \r
282 \r
283         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();\r
284         if(aa==null)\r
285           return;\r
286 \r
287 \r
288         int height = 0;\r
289         activeRow = 0;\r
290 \r
291 \r
292         for (int i = 0; i < aa.length; i++)\r
293         {\r
294             if (aa[i].visible)\r
295             {\r
296               height += aa[i].height;\r
297             }\r
298 \r
299             if (evt.getY() < height)\r
300             {\r
301                 if (aa[i].editable)\r
302                 {\r
303                     activeRow = i;\r
304                 }\r
305                 else if(aa[i].graph>0)\r
306                 {\r
307                     //Stretch Graph\r
308                     graphStretch = i;\r
309                     graphStretchY = evt.getY();\r
310                 }\r
311 \r
312                 break;\r
313             }\r
314         }\r
315 \r
316 \r
317         if (SwingUtilities.isRightMouseButton(evt))\r
318         {\r
319             if (av.getColumnSelection() == null)\r
320             {\r
321                 return;\r
322             }\r
323 \r
324             JPopupMenu pop = new JPopupMenu("Structure type");\r
325             JMenuItem item = new JMenuItem(HELIX);\r
326             item.addActionListener(this);\r
327             pop.add(item);\r
328             item = new JMenuItem(SHEET);\r
329             item.addActionListener(this);\r
330             pop.add(item);\r
331             item = new JMenuItem(LABEL);\r
332             item.addActionListener(this);\r
333             pop.add(item);\r
334             item = new JMenuItem(COLOUR);\r
335             item.addActionListener(this);\r
336             pop.add(item);\r
337             item = new JMenuItem(REMOVE);\r
338             item.addActionListener(this);\r
339             pop.add(item);\r
340             pop.show(this, evt.getX(), evt.getY());\r
341 \r
342             return;\r
343         }\r
344 \r
345         if (aa == null)\r
346         {\r
347             return;\r
348         }\r
349 \r
350         int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();\r
351 \r
352         min = res;\r
353         max = res;\r
354 \r
355         if (av.getColumnSelection().contains(res))\r
356           av.getColumnSelection().removeElement(res);\r
357         else\r
358         {\r
359             av.getColumnSelection().addElement(res);\r
360             SequenceGroup sg = new SequenceGroup();\r
361 \r
362             for (int i = 0; i < av.alignment.getSequences().size(); i++)\r
363             {\r
364                 sg.addSequence(av.alignment.getSequenceAt(i), false);\r
365             }\r
366 \r
367             sg.setStartRes(res);\r
368             sg.setEndRes(res);\r
369             av.setSelectionGroup(sg);\r
370         }\r
371 \r
372         ap.repaint();\r
373 \r
374     }\r
375 \r
376     /**\r
377      * DOCUMENT ME!\r
378      *\r
379      * @param evt DOCUMENT ME!\r
380      */\r
381     public void mouseReleased(MouseEvent evt)\r
382     {\r
383       graphStretch = -1;\r
384       graphStretchY = -1;\r
385       mouseDragging = false;\r
386     }\r
387 \r
388     /**\r
389      * DOCUMENT ME!\r
390      *\r
391      * @param evt DOCUMENT ME!\r
392      */\r
393     public void mouseEntered(MouseEvent evt)\r
394     {\r
395       if(mouseDragging)\r
396         ap.seqPanel.scrollCanvas(null);\r
397     }\r
398 \r
399     /**\r
400      * DOCUMENT ME!\r
401      *\r
402      * @param evt DOCUMENT ME!\r
403      */\r
404     public void mouseExited(MouseEvent evt)\r
405     {\r
406       if(mouseDragging)\r
407         ap.seqPanel.scrollCanvas(evt);\r
408     }\r
409 \r
410 \r
411     /**\r
412      * DOCUMENT ME!\r
413      *\r
414      * @param evt DOCUMENT ME!\r
415      */\r
416     public void mouseDragged(MouseEvent evt)\r
417     {\r
418       if(graphStretch>-1)\r
419       {\r
420         av.alignment.getAlignmentAnnotation()[graphStretch].graphHeight += graphStretchY - evt.getY();\r
421         if(av.alignment.getAlignmentAnnotation()[graphStretch].graphHeight <10)\r
422           av.alignment.getAlignmentAnnotation()[graphStretch].graphHeight = 10;\r
423         graphStretchY = evt.getY();\r
424         adjustPanelHeight();\r
425         ap.repaint();\r
426       }\r
427       else\r
428       {\r
429         mouseDragging = true;\r
430 \r
431         int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();\r
432 \r
433         SequenceGroup sg = av.getSelectionGroup();\r
434 \r
435         if (res < min)\r
436         {\r
437             min = res;\r
438         }\r
439 \r
440         if (res > max)\r
441         {\r
442             max = res;\r
443         }\r
444 \r
445         if (sg != null)\r
446         {\r
447             if (!av.getColumnSelection().contains(res))\r
448             {\r
449                 av.getColumnSelection().addElement(res);\r
450             }\r
451 \r
452             if (res > sg.getStartRes())\r
453             {\r
454                 sg.setEndRes(res);\r
455             }\r
456             else if (res < sg.getStartRes())\r
457             {\r
458                 sg.setStartRes(res);\r
459             }\r
460 \r
461             for (int i = min; i <= max; i++)\r
462             {\r
463                 if ((i < sg.getStartRes()) || (i > sg.getEndRes()))\r
464                 {\r
465                     av.getColumnSelection().removeElement(i);\r
466                 }\r
467                 else\r
468                 {\r
469                     av.getColumnSelection().addElement(i);\r
470                 }\r
471             }\r
472 \r
473             ap.repaint();\r
474         }\r
475 \r
476       }\r
477     }\r
478 \r
479     /**\r
480      * DOCUMENT ME!\r
481      *\r
482      * @param evt DOCUMENT ME!\r
483      */\r
484     public void mouseMoved(MouseEvent evt)\r
485     {\r
486         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();\r
487 \r
488         if (aa == null)\r
489         {\r
490             return;\r
491         }\r
492 \r
493         int row = -1;\r
494         int height = 0;\r
495 \r
496         for (int i = 0; i < aa.length; i++)\r
497         {\r
498             if (aa[i].visible)\r
499             {\r
500                 height += aa[i].height;\r
501             }\r
502 \r
503             if (evt.getY() < height)\r
504             {\r
505                 row = i;\r
506 \r
507                 break;\r
508             }\r
509         }\r
510 \r
511         int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();\r
512 \r
513         if(av.hasHiddenColumns)\r
514           res = av.getColumnSelection().adjustForHiddenColumns(res);\r
515 \r
516         if (row > -1 && res<aa[row].annotations.length)\r
517         {\r
518             if(aa[row].graphGroup>-1)\r
519             {\r
520               StringBuffer tip = new StringBuffer("<html>");\r
521               for (int gg = 0; gg < aa.length; gg++)\r
522               {\r
523                 if (aa[gg].graphGroup == aa[row].graphGroup && aa[gg].annotations[res]!=null)\r
524                   tip.append(aa[gg].label+" "+aa[gg].annotations[res].description+"<br>" );\r
525               }\r
526               if(tip.length()!=6)\r
527               {\r
528                 tip.setLength(tip.length() - 4);\r
529                 this.setToolTipText(tip.toString() + "</html>");\r
530               }\r
531             }\r
532             else if(aa[row].annotations[res] != null)\r
533               this.setToolTipText(aa[row].annotations[res].description);\r
534 \r
535             if(aa[row].annotations[res]!=null)\r
536             {\r
537               StringBuffer text = new StringBuffer("Sequence position " +\r
538                                                    (res + 1) + "  " +\r
539                                                    aa[row].annotations[res].description);\r
540 \r
541               ap.alignFrame.statusBar.setText(text.toString());\r
542             }\r
543         }\r
544     }\r
545 \r
546     /**\r
547      * DOCUMENT ME!\r
548      *\r
549      * @param evt DOCUMENT ME!\r
550      */\r
551     public void mouseClicked(MouseEvent evt)\r
552     {\r
553     }\r
554 \r
555     /**\r
556      * DOCUMENT ME!\r
557      *\r
558      * @param g DOCUMENT ME!\r
559      */\r
560     public void paintComponent(Graphics g)\r
561     {\r
562       g.setColor(Color.white);\r
563       g.fillRect(0, 0, getWidth(), getHeight());\r
564 \r
565       if(image!=null)\r
566       {if (fastPaint\r
567             || (getVisibleRect().width != g.getClipBounds().width)\r
568             || (getVisibleRect().height != g.getClipBounds().height))\r
569         {\r
570           g.drawImage(image, 0, 0, this);\r
571           fastPaint = false;\r
572           return;\r
573         }\r
574       }\r
575       imgWidth = (av.endRes - av.startRes + 1) * av.charWidth;\r
576 \r
577       if (image == null || imgWidth != image.getWidth()\r
578           || image.getHeight(this) != getHeight())\r
579       {\r
580         image = new BufferedImage(imgWidth, ap.annotationPanel.getHeight(),\r
581                                   BufferedImage.TYPE_INT_RGB);\r
582         gg = (Graphics2D) image.getGraphics();\r
583 \r
584         if(av.antiAlias)\r
585         gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,\r
586                             RenderingHints.VALUE_ANTIALIAS_ON);\r
587 \r
588         gg.setFont(av.getFont());\r
589         fm = gg.getFontMetrics();\r
590       }\r
591 \r
592 \r
593       drawComponent(gg, av.startRes, av.endRes + 1);\r
594       g.drawImage(image, 0, 0, this);\r
595     }\r
596 \r
597     /**\r
598      * DOCUMENT ME!\r
599      *\r
600      * @param horizontal DOCUMENT ME!\r
601      */\r
602     public void fastPaint(int horizontal)\r
603     {\r
604         if ((horizontal == 0) || gg==null ||\r
605                 (av.alignment.getAlignmentAnnotation() == null) ||\r
606                 (av.alignment.getAlignmentAnnotation().length < 1))\r
607         {\r
608             repaint();\r
609             return;\r
610         }\r
611 \r
612         gg.copyArea(0, 0, imgWidth, getHeight(), -horizontal * av.charWidth, 0);\r
613 \r
614         int sr = av.startRes;\r
615         int er = av.endRes + 1;\r
616         int transX = 0;\r
617 \r
618         if (horizontal > 0) // scrollbar pulled right, image to the left\r
619         {\r
620             transX = (er - sr - horizontal) * av.charWidth;\r
621             sr = er - horizontal;\r
622         }\r
623         else if (horizontal < 0)\r
624         {\r
625             er = sr - horizontal;\r
626         }\r
627 \r
628         gg.translate(transX, 0);\r
629 \r
630         drawComponent(gg, sr, er);\r
631 \r
632         gg.translate(-transX, 0);\r
633 \r
634         fastPaint = true;\r
635 \r
636         repaint();\r
637 \r
638     }\r
639 \r
640     /**\r
641      * DOCUMENT ME!\r
642      *\r
643      * @param g DOCUMENT ME!\r
644      * @param startRes DOCUMENT ME!\r
645      * @param endRes DOCUMENT ME!\r
646      */\r
647     public void drawComponent(Graphics g, int startRes, int endRes)\r
648     {\r
649 \r
650 \r
651       g.setFont(av.getFont());\r
652 \r
653       if (fm == null)\r
654         fm = g.getFontMetrics();\r
655 \r
656 \r
657         g.setColor(Color.white);\r
658         g.fillRect(0, 0, (endRes - startRes) * av.charWidth, getHeight());\r
659 \r
660         if ( (av.alignment.getAlignmentAnnotation() == null) ||\r
661                 (av.alignment.getAlignmentAnnotation().length < 1))\r
662         {\r
663             g.setColor(Color.white);\r
664             g.fillRect(0, 0, getWidth(), getHeight());\r
665             g.setColor(Color.black);\r
666             if(av.validCharWidth)\r
667               g.drawString("Alignment has no annotations", 20, 15);\r
668 \r
669             return;\r
670         }\r
671 \r
672         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();\r
673 \r
674         int x = 0, y = 0;\r
675         int column=0;\r
676         char lastSS;\r
677         int lastSSX;\r
678         int iconOffset = av.charHeight / 2;\r
679         boolean validRes = false;\r
680 \r
681         boolean [] graphGroupDrawn = new boolean[aa.length];\r
682 \r
683 \r
684         //\u03B2 \u03B1\r
685         for (int i = 0; i < aa.length; i++)\r
686         {\r
687             AlignmentAnnotation row = aa[i];\r
688 \r
689             if (!row.visible)\r
690             {\r
691                 continue;\r
692             }\r
693 \r
694             lastSS = ' ';\r
695             lastSSX = 0;\r
696 \r
697             if (row.graph>0)\r
698             {\r
699                 if(row.graphGroup>-1 && graphGroupDrawn[ row.graphGroup ] )\r
700                   continue;\r
701 \r
702                 // this is so that we draw the characters below the graph\r
703                 y += row.height;\r
704 \r
705                 if (row.hasText)\r
706                 {\r
707                     y -= av.charHeight;\r
708                 }\r
709             }\r
710 \r
711             if (row.hasText)\r
712             {\r
713                 iconOffset = av.charHeight / 2;\r
714             }\r
715             else\r
716             {\r
717                 iconOffset = 0;\r
718             }\r
719 \r
720             x = 0;\r
721             while (x < endRes-startRes)\r
722             {\r
723               if (av.hasHiddenColumns)\r
724               {\r
725                 column = av.getColumnSelection().adjustForHiddenColumns(startRes+x);\r
726                 if (column > row.annotations.length-1)\r
727                 {\r
728                   break;\r
729                 }\r
730               }\r
731               else\r
732                 column = startRes+x;\r
733 \r
734 \r
735                 if ((row.annotations.length <= column) ||\r
736                         (row.annotations[column] == null))\r
737                 {\r
738                     validRes = false;\r
739                 }\r
740                 else\r
741                 {\r
742                     validRes = true;\r
743                 }\r
744 \r
745 \r
746                 if (activeRow == i)\r
747                 {\r
748                     g.setColor(Color.red);\r
749 \r
750                     if (av.getColumnSelection() != null)\r
751                     {\r
752                         for (int n = 0; n < av.getColumnSelection().size(); n++)\r
753                         {\r
754                             int v = av.getColumnSelection().columnAt(n);\r
755 \r
756                             if (v == column)\r
757                             {\r
758                                 g.fillRect(x * av.charWidth, y,\r
759                                     av.charWidth, av.charHeight);\r
760                             }\r
761                         }\r
762                     }\r
763                 }\r
764 \r
765                 if (av.validCharWidth && validRes &&\r
766                         (row.annotations[column].displayCharacter.length() > 0))\r
767                 {\r
768 \r
769                     int charOffset = (av.charWidth -\r
770                         fm.charWidth(row.annotations[column].displayCharacter.charAt(\r
771                                 0))) / 2;\r
772                     g.setColor(row.annotations[column].colour);\r
773 \r
774                     if (column == 0 || row.graph>0)\r
775                     {\r
776                         g.drawString(row.annotations[column].displayCharacter,\r
777                                      x*av.charWidth+charOffset,\r
778                             y + iconOffset + 3);\r
779                     }\r
780                     else if (\r
781                         row.annotations[column - 1] == null\r
782                         ||(!row.annotations[column].displayCharacter.equals(\r
783                             row.annotations[column - 1].displayCharacter)\r
784                         ||\r
785                   (row.annotations[column].displayCharacter.length() <2 &&\r
786                    row.annotations[column].secondaryStructure==' ')))\r
787                     {\r
788                         g.drawString(row.annotations[column].displayCharacter,\r
789                                      x*av.charWidth+charOffset,\r
790                                      y + iconOffset + 3);\r
791                     }\r
792                 }\r
793 \r
794                 if (row.hasIcons)\r
795                 {\r
796                     if (!validRes ||\r
797                             (row.annotations[column].secondaryStructure != lastSS))\r
798                     {\r
799                         switch (lastSS)\r
800                         {\r
801                         case 'H':\r
802                             g.setColor(HELIX_COLOUR);\r
803                             if(MAC)\r
804                             {\r
805                               //Off by 1 offset when drawing rects and ovals\r
806                               //to offscreen image on the MAC\r
807                               g.fillRoundRect(lastSSX, y + 4 + iconOffset,\r
808                                               x*av.charWidth - lastSSX, 7, 8, 8);\r
809                               break;\r
810                             }\r
811 \r
812                             int sCol = (lastSSX / av.charWidth) + startRes;\r
813                             int x1 = lastSSX;\r
814                             int x2 = x*av.charWidth;\r
815 \r
816                            if(sCol==0 ||\r
817                               row.annotations[sCol-1]==null ||\r
818                               row.annotations[sCol-1].secondaryStructure!='H')\r
819                            {\r
820                              g.fillArc(lastSSX, y+4+iconOffset, av.charWidth+1, 7, 90,180) ;\r
821                              x1 += av.charWidth/2;\r
822                            }\r
823 \r
824                             if(row.annotations[column]==null ||\r
825                                row.annotations[column].secondaryStructure!='H')\r
826                             {\r
827                               g.fillArc(x*av.charWidth-av.charWidth,\r
828                                         y+4+iconOffset,\r
829                                         av.charWidth,\r
830                                         7, 270,180);\r
831                               x2 -= av.charWidth/2;\r
832                             }\r
833 \r
834                             g.fillRect(x1, y+4+iconOffset, x2-x1+1, 7);\r
835                             break;\r
836 \r
837                         case 'E':\r
838                             g.setColor(SHEET_COLOUR);\r
839                             g.fillRect(lastSSX, y + 4 + iconOffset,\r
840                                 x*av.charWidth - lastSSX - 4, 7);\r
841                             g.fillPolygon(new int[] { x*av.charWidth - 5,\r
842                                           x*av.charWidth - 5,\r
843                                           x*av.charWidth },\r
844                                 new int[]\r
845                                 {\r
846                                     y + iconOffset, y + 14 + iconOffset,\r
847                                     y + 7 + iconOffset\r
848                                 }, 3);\r
849 \r
850                             break;\r
851 \r
852 \r
853                         default:\r
854                             g.setColor(Color.gray);\r
855                             g.fillRect(lastSSX, y + 6 + iconOffset,\r
856                                 x*av.charWidth - lastSSX, 2);\r
857 \r
858                             break;\r
859                         }\r
860 \r
861                         if (validRes)\r
862                         {\r
863                             lastSS = row.annotations[column].secondaryStructure;\r
864                         }\r
865                         else\r
866                         {\r
867                             lastSS = ' ';\r
868                         }\r
869 \r
870                         lastSSX = x*av.charWidth;\r
871                     }\r
872                 }\r
873                 column++;\r
874                 x++;\r
875             }\r
876 \r
877             if(column>=row.annotations.length)\r
878               column = row.annotations.length-1;\r
879 \r
880             x ++;\r
881 \r
882             if (row.hasIcons)\r
883             {\r
884                 switch (lastSS)\r
885                 {\r
886                 case 'H':\r
887                   g.setColor(HELIX_COLOUR);\r
888                   if (MAC)\r
889                   {\r
890                     //Off by 1 offset when drawing rects and ovals\r
891                     //to offscreen image on the MAC\r
892                     g.fillRoundRect(lastSSX, y + 4 + iconOffset,\r
893                                     x*av.charWidth - lastSSX, 7, 8, 8);\r
894                     break;\r
895                   }\r
896 \r
897 \r
898                   int sCol = (lastSSX / av.charWidth) + startRes;\r
899                   int x1 = lastSSX;\r
900                   int x2 = x;\r
901 \r
902                  if(sCol==0 ||\r
903                     row.annotations[sCol-1]==null ||\r
904                     row.annotations[sCol-1].secondaryStructure!='H')\r
905                  {\r
906                    g.fillArc(lastSSX, y+4+iconOffset, av.charWidth+1, 7, 90,180) ;\r
907                    x1 += av.charWidth/2;\r
908                  }\r
909 \r
910                   if(row.annotations[column]==null ||\r
911                      row.annotations[column].secondaryStructure!='H')\r
912                   {\r
913                     g.fillArc(x-av.charWidth, y+4+iconOffset, av.charWidth, 7, 270,180);\r
914                     x2 -= av.charWidth/2;\r
915                   }\r
916 \r
917                   g.fillRect(x1, y+4+iconOffset, x2-x1+1, 7);\r
918 \r
919                     break;\r
920 \r
921                 case 'E':\r
922                     g.setColor(SHEET_COLOUR);\r
923 \r
924                     if (row.annotations[endRes] ==null\r
925                         || row.annotations[endRes].secondaryStructure != 'E')\r
926                     {\r
927                       g.fillRect(lastSSX, y + 4 + iconOffset,\r
928                                  x*av.charWidth - lastSSX - 4, 7);\r
929                       g.fillPolygon(new int[]\r
930                                     {x*av.charWidth - 5,\r
931                                     x*av.charWidth - 5,\r
932                                     x*av.charWidth},\r
933                                     new int[]\r
934                                     {\r
935                                     y + iconOffset, y + 14 + iconOffset,\r
936                                     y + 7 + iconOffset\r
937                       }, 3);\r
938                     }\r
939                     else\r
940                       g.fillRect(lastSSX, y + 4 + iconOffset,\r
941                                  x*av.charWidth - lastSSX, 7);\r
942 \r
943                     break;\r
944 \r
945 \r
946                 default:\r
947                     g.setColor(Color.gray);\r
948                     if(!av.wrapAlignment || endRes==av.endRes)\r
949                       g.fillRect(lastSSX, y + 6 + iconOffset,\r
950                                  x*av.charWidth - lastSSX, 2);\r
951 \r
952                     break;\r
953                 }\r
954             }\r
955 \r
956             if (row.graph>0)\r
957             {\r
958                 if(row.graph == AlignmentAnnotation.LINE_GRAPH )\r
959                 {\r
960                   if(row.graphGroup>-1 && !graphGroupDrawn[row.graphGroup])\r
961                    {\r
962                      float groupmax=-999999, groupmin=9999999;\r
963                      for(int gg=0; gg<aa.length; gg++)\r
964                      {\r
965                        if(aa[gg].graphGroup!=row.graphGroup)\r
966                          continue;\r
967 \r
968                        if(aa[gg]!=row)\r
969                          aa[gg].visible = false;\r
970 \r
971                        if(aa[gg].graphMax>groupmax)\r
972                          groupmax = aa[gg].graphMax;\r
973                        if(aa[gg].graphMin<groupmin)\r
974                          groupmin = aa[gg].graphMin;\r
975                      }\r
976 \r
977                      for (int gg = 0; gg < aa.length; gg++)\r
978                      {\r
979                        if (aa[gg].graphGroup == row.graphGroup)\r
980                        {\r
981                          drawLineGraph(g, aa[gg], startRes, endRes, y,\r
982                                        groupmin, groupmax,\r
983                                        row.graphHeight);\r
984                        }\r
985                      }\r
986 \r
987                      graphGroupDrawn[ row.graphGroup ] = true;\r
988                    }\r
989                    else\r
990                      drawLineGraph(g, row, startRes, endRes,\r
991                                    y, row.graphMin, row.graphMax, row.graphHeight  );\r
992                 }\r
993                 else if(row.graph == AlignmentAnnotation.BAR_GRAPH )\r
994                    drawBarGraph(g, row, startRes, endRes,\r
995                                 row.graphMin, row.graphMax, y);\r
996             }\r
997 \r
998             if (row.graph>0 && row.hasText)\r
999             {\r
1000                 y += av.charHeight;\r
1001             }\r
1002 \r
1003             if (row.graph==0)\r
1004             {\r
1005                 y += aa[i].height;\r
1006             }\r
1007         }\r
1008     }\r
1009 \r
1010     public void drawLineGraph(Graphics g, AlignmentAnnotation aa,\r
1011                               int sRes, int eRes,\r
1012                               int y,\r
1013                               float min, float max,\r
1014                               int graphHeight)\r
1015     {\r
1016       if(sRes>aa.annotations.length)\r
1017         return;\r
1018 \r
1019 \r
1020       int x = 0;\r
1021 \r
1022       //Adjustment for fastpaint to left\r
1023       if(eRes<av.endRes)\r
1024         eRes++;\r
1025 \r
1026       eRes = Math.min(eRes, aa.annotations.length);\r
1027 \r
1028       if(sRes==0)\r
1029       {\r
1030         x++;\r
1031       }\r
1032 \r
1033       int y1=y, y2=y;\r
1034       float range = max - min;\r
1035 \r
1036       ////Draw origin\r
1037       if(min<0)\r
1038         y2 = y - (int)((0-min / range)*graphHeight);\r
1039 \r
1040       g.setColor(Color.gray);\r
1041       g.drawLine(x-av.charWidth,y2,(eRes-sRes+1)*av.charWidth,y2);\r
1042 \r
1043       eRes = Math.min(eRes, aa.annotations.length);\r
1044 \r
1045       int column;\r
1046       int aaMax = aa.annotations.length-1;\r
1047 \r
1048       while( x < eRes - sRes )\r
1049       {\r
1050         column = sRes + x;\r
1051         if(av.hasHiddenColumns)\r
1052         {\r
1053           column = av.getColumnSelection().adjustForHiddenColumns(column);\r
1054         }\r
1055 \r
1056         if (column > aaMax)\r
1057         {\r
1058           break;\r
1059         }\r
1060 \r
1061         if(aa.annotations[column]==null || aa.annotations[column-1]==null)\r
1062         {\r
1063           x++;\r
1064           continue;\r
1065         }\r
1066 \r
1067 \r
1068           g.setColor(aa.annotations[column].colour);\r
1069           y1 = y - (int) (((aa.annotations[column-1].value-min) / range) * graphHeight);\r
1070           y2 = y - (int) (((aa.annotations[column].value-min) / range) * graphHeight);\r
1071 \r
1072           g.drawLine(x*av.charWidth-av.charWidth/2, y1, x*av.charWidth+av.charWidth/2, y2);\r
1073           x ++;\r
1074        }\r
1075 \r
1076        if(aa.threshold!=null)\r
1077        {\r
1078            g.setColor(aa.threshold.colour);\r
1079            Graphics2D g2 = (Graphics2D)g;\r
1080            g2.setStroke(new BasicStroke(1,\r
1081                                          BasicStroke.CAP_SQUARE,\r
1082                                          BasicStroke.JOIN_ROUND, 3f,\r
1083                                          new float[] { 5f, 3f }, 0f));\r
1084 \r
1085            y2 = (int)(y - ((aa.threshold.value-min) / range)*graphHeight);\r
1086            g.drawLine(0,y2,(eRes-sRes)*av.charWidth,y2);\r
1087            g2.setStroke(new BasicStroke());\r
1088       }\r
1089     }\r
1090 \r
1091     public void drawBarGraph(Graphics g, AlignmentAnnotation aa,\r
1092                              int sRes, int eRes,\r
1093                              float min, float max,\r
1094                              int y)\r
1095     {\r
1096       if(sRes>aa.annotations.length)\r
1097         return;\r
1098 \r
1099       eRes = Math.min(eRes, aa.annotations.length);\r
1100 \r
1101       int x=0, y1=y, y2=y;\r
1102 \r
1103       float range = max - min;\r
1104 \r
1105       if(min<0)\r
1106         y2 = y - (int)((0-min / (range))*aa.graphHeight);\r
1107 \r
1108       g.setColor(Color.gray);\r
1109 \r
1110       g.drawLine(x,y2,(eRes-sRes)*av.charWidth,y2);\r
1111 \r
1112       int column;\r
1113       int aaMax = aa.annotations.length-1;\r
1114 \r
1115       while( x < eRes-sRes )\r
1116       {\r
1117         column = sRes + x;\r
1118         if(av.hasHiddenColumns)\r
1119         {\r
1120           column = av.getColumnSelection().adjustForHiddenColumns(column);\r
1121         }\r
1122 \r
1123         if(column > aaMax)\r
1124         {\r
1125             break;\r
1126         }\r
1127 \r
1128         if (aa.annotations[column] == null)\r
1129         {\r
1130           x ++;\r
1131           continue;\r
1132         }\r
1133 \r
1134           g.setColor(aa.annotations[column].colour);\r
1135           y1 = y - (int) (((aa.annotations[column].value-min) / (range)) * aa.graphHeight);\r
1136 \r
1137           if(y1-y2>0)\r
1138             g.fillRect(x*av.charWidth, y2, av.charWidth, y1-y2 );\r
1139           else\r
1140             g.fillRect(x*av.charWidth, y1, av.charWidth, y2-y1 );\r
1141 \r
1142           x ++ ;\r
1143 \r
1144       }\r
1145       if(aa.threshold!=null)\r
1146       {\r
1147           g.setColor(aa.threshold.colour);\r
1148           Graphics2D g2 = (Graphics2D)g;\r
1149           g2.setStroke(new BasicStroke(1,\r
1150                                         BasicStroke.CAP_SQUARE,\r
1151                                         BasicStroke.JOIN_ROUND, 3f,\r
1152                                         new float[] { 5f, 3f }, 0f));\r
1153 \r
1154           y2 = (int)(y - ((aa.threshold.value-min) / range)*aa.graphHeight);\r
1155           g.drawLine(0,y2,(eRes-sRes)*av.charWidth,y2);\r
1156           g2.setStroke(new BasicStroke());\r
1157       }\r
1158     }\r
1159 \r
1160     // used by overview window\r
1161     public void drawGraph(Graphics g, AlignmentAnnotation aa, int width, int y, int sRes, int eRes)\r
1162     {\r
1163       eRes = Math.min(eRes, aa.annotations.length);\r
1164       g.setColor(Color.white);\r
1165       g.fillRect(0, 0, width, y);\r
1166       g.setColor(new Color(0, 0, 180));\r
1167 \r
1168       int x = 0, height;\r
1169 \r
1170       for (int j = sRes; j < eRes; j++)\r
1171       {\r
1172           g.setColor(aa.annotations[j].colour);\r
1173 \r
1174           height = (int) ((aa.annotations[j].value / aa.graphMax) * y);\r
1175           if(height>y)\r
1176             height = y;\r
1177 \r
1178           g.fillRect(x, y - height, av.charWidth, height);\r
1179           x += av.charWidth;\r
1180       }\r
1181     }\r
1182 \r
1183 }\r