Check hiddenSequence before placing in tmp
[jalview.git] / src / jalview / gui / SeqCanvas.java
1 /*\r
2  * Jalview - A Sequence Alignment Editor and Viewer\r
3  * Copyright (C) 2006 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.image.*;\r
25 \r
26 import javax.swing.*;\r
27 \r
28 \r
29 /**\r
30  * DOCUMENT ME!\r
31  *\r
32  * @author $author$\r
33  * @version $Revision$\r
34  */\r
35 public class SeqCanvas extends JComponent\r
36 {\r
37     final FeatureRenderer fr;\r
38     final SequenceRenderer sr;\r
39     BufferedImage img;\r
40     Graphics2D gg;\r
41     int imgWidth;\r
42     int imgHeight;\r
43     AlignViewport av;\r
44     SearchResults searchResults = null;\r
45     boolean fastPaint = false;\r
46     int LABEL_WEST;\r
47     int LABEL_EAST;\r
48 \r
49 \r
50     int cursorX = 0;\r
51     int cursorY = 0;\r
52 \r
53 \r
54     /**\r
55      * Creates a new SeqCanvas object.\r
56      *\r
57      * @param av DOCUMENT ME!\r
58      */\r
59     public SeqCanvas(AlignViewport av)\r
60     {\r
61         this.av = av;\r
62         fr = new FeatureRenderer(av);\r
63         sr = new SequenceRenderer(av);\r
64         setLayout(new BorderLayout());\r
65         PaintRefresher.Register(this, av.getSequenceSetId());\r
66         setBackground(Color.white);\r
67     }\r
68 \r
69     MCview.PDBCanvas pdbCanvas;\r
70     public SequenceRenderer getSequenceRenderer()\r
71     {\r
72       return sr;\r
73     }\r
74 \r
75     public FeatureRenderer getFeatureRenderer()\r
76     {\r
77       return fr;\r
78     }\r
79 \r
80     public void setPDBCanvas(MCview.PDBCanvas pc)\r
81     {\r
82       pdbCanvas = pc;\r
83     }\r
84 \r
85     public AlignViewport getViewport()\r
86     {\r
87       return av;\r
88     }\r
89 \r
90 \r
91     /**\r
92      * DOCUMENT ME!\r
93      *\r
94      * @param g DOCUMENT ME!\r
95      * @param startx DOCUMENT ME!\r
96      * @param endx DOCUMENT ME!\r
97      * @param ypos DOCUMENT ME!\r
98      */\r
99     void drawNorthScale(Graphics g, int startx, int endx, int ypos)\r
100     {\r
101         int scalestartx = startx - (startx % 10) + 10;\r
102 \r
103         g.setColor(Color.black);\r
104 \r
105         // NORTH SCALE\r
106         for (int i = scalestartx; i < endx; i += 10)\r
107         {\r
108             int value = i;\r
109             if(av.hasHiddenColumns)\r
110                 value = av.getColumnSelection().adjustForHiddenColumns(value);\r
111 \r
112             g.drawString( String.valueOf(value), (i - startx - 1) * av.charWidth,\r
113                 ypos - (av.charHeight / 2));\r
114 \r
115             g.drawLine(((i - startx - 1) * av.charWidth) + (av.charWidth / 2),\r
116                 (ypos + 2) - (av.charHeight / 2),\r
117                 ((i - startx - 1) * av.charWidth) + (av.charWidth / 2), ypos -\r
118                 2);\r
119         }\r
120     }\r
121 \r
122     /**\r
123      * DOCUMENT ME!\r
124      *\r
125      * @param g DOCUMENT ME!\r
126      * @param startx DOCUMENT ME!\r
127      * @param endx DOCUMENT ME!\r
128      * @param ypos DOCUMENT ME!\r
129      */\r
130     void drawWestScale(Graphics g, int startx, int endx, int ypos)\r
131     {\r
132         FontMetrics fm = getFontMetrics(av.getFont());\r
133         ypos += av.charHeight;\r
134 \r
135         if(av.hasHiddenColumns)\r
136         {\r
137           startx = av.getColumnSelection().adjustForHiddenColumns(startx);\r
138           endx = av.getColumnSelection().adjustForHiddenColumns(endx);\r
139         }\r
140 \r
141         int maxwidth = av.alignment.getWidth();\r
142         if (av.hasHiddenColumns)\r
143             maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;\r
144 \r
145         // WEST SCALE\r
146         for (int i = 0; i < av.alignment.getHeight(); i++)\r
147         {\r
148             SequenceI seq = av.alignment.getSequenceAt(i);\r
149             int index = startx;\r
150             int value = -1;\r
151 \r
152             while (index < endx)\r
153             {\r
154                 if (jalview.util.Comparison.isGap(seq.getCharAt(index)))\r
155                 {\r
156                     index++;\r
157 \r
158                     continue;\r
159                 }\r
160 \r
161                 value = av.alignment.getSequenceAt(i).findPosition(index);\r
162 \r
163                 break;\r
164             }\r
165 \r
166             if (value != -1)\r
167             {\r
168                 int x = LABEL_WEST - fm.stringWidth(String.valueOf(value))-av.charWidth/2;\r
169                 g.drawString(value + "", x,\r
170                     (ypos + (i * av.charHeight)) - (av.charHeight / 5));\r
171             }\r
172         }\r
173     }\r
174 \r
175     /**\r
176      * DOCUMENT ME!\r
177      *\r
178      * @param g DOCUMENT ME!\r
179      * @param startx DOCUMENT ME!\r
180      * @param endx DOCUMENT ME!\r
181      * @param ypos DOCUMENT ME!\r
182      */\r
183     void drawEastScale(Graphics g, int startx, int endx, int ypos)\r
184     {\r
185         ypos += av.charHeight;\r
186 \r
187         if(av.hasHiddenColumns)\r
188                 endx = av.getColumnSelection().adjustForHiddenColumns(endx);\r
189 \r
190         SequenceI seq;\r
191         // EAST SCALE\r
192         for (int i = 0; i < av.alignment.getHeight(); i++)\r
193         {\r
194             seq = av.alignment.getSequenceAt(i);\r
195             int index = endx;\r
196             int value = -1;\r
197 \r
198             while (index > startx)\r
199             {\r
200                 if (jalview.util.Comparison.isGap(seq.getCharAt(index)))\r
201                 {\r
202                     index--;\r
203 \r
204                     continue;\r
205                 }\r
206 \r
207                 value = seq.findPosition(index);\r
208 \r
209                 break;\r
210             }\r
211 \r
212             if (value != -1)\r
213             {\r
214                 g.drawString(String.valueOf(value), 0,\r
215                     (ypos + (i * av.charHeight)) - (av.charHeight / 5));\r
216             }\r
217         }\r
218     }\r
219 \r
220     /**\r
221      * DOCUMENT ME!\r
222      *\r
223      * @param horizontal DOCUMENT ME!\r
224      * @param vertical DOCUMENT ME!\r
225      */\r
226     public void fastPaint(int horizontal, int vertical)\r
227     {\r
228         if (gg == null)\r
229         {\r
230             return;\r
231         }\r
232 \r
233 \r
234         fastPaint = true;\r
235 \r
236         gg.copyArea(horizontal * av.charWidth,\r
237                     vertical * av.charHeight,\r
238                     imgWidth,\r
239                     imgHeight,\r
240                     -horizontal * av.charWidth,\r
241                     -vertical * av.charHeight);\r
242 \r
243         int sr = av.startRes;\r
244         int er = av.endRes;\r
245         int ss = av.startSeq;\r
246         int es = av.endSeq;\r
247         int transX = 0;\r
248         int transY = 0;\r
249 \r
250 \r
251         if (horizontal > 0) // scrollbar pulled right, image to the left\r
252         {\r
253             er ++;\r
254             transX = (er - sr - horizontal) * av.charWidth;\r
255             sr = er - horizontal;\r
256         }\r
257         else if (horizontal < 0)\r
258         {\r
259             er = sr - horizontal-1;\r
260         }\r
261         else if (vertical > 0) // scroll down\r
262         {\r
263             ss = es - vertical;\r
264 \r
265             if (ss < av.startSeq)\r
266             { // ie scrolling too fast, more than a page at a time\r
267                 ss = av.startSeq;\r
268             }\r
269             else\r
270             {\r
271                 transY = imgHeight - (vertical * av.charHeight);\r
272             }\r
273         }\r
274         else if (vertical < 0)\r
275         {\r
276             es = ss - vertical;\r
277 \r
278             if (es > av.endSeq)\r
279             {\r
280                 es = av.endSeq;\r
281             }\r
282         }\r
283 \r
284         gg.translate(transX, transY);\r
285         drawPanel(gg, sr, er, ss, es, 0);\r
286         gg.translate(-transX, -transY);\r
287 \r
288         repaint();\r
289     }\r
290 \r
291     /**\r
292      * Definitions of startx and endx (hopefully):\r
293      * SMJS This is what I'm working towards!\r
294      *   startx is the first residue (starting at 0) to display.\r
295      *   endx   is the last residue to display (starting at 0).\r
296      *   starty is the first sequence to display (starting at 0).\r
297      *   endy   is the last sequence to display (starting at 0).\r
298      * NOTE 1: The av limits are set in setFont in this class and\r
299      * in the adjustment listener in SeqPanel when the scrollbars move.\r
300      */\r
301 \r
302     // Set this to false to force a full panel paint\r
303     public void paintComponent(Graphics g)\r
304     {\r
305         super.paintComponent(g);\r
306 \r
307 \r
308 \r
309         if ( img != null && (fastPaint\r
310              || (getVisibleRect().width != g.getClipBounds().width)\r
311              || (getVisibleRect().height != g.getClipBounds().height)))\r
312         {\r
313             g.drawImage(img, 0, 0, this);\r
314             fastPaint = false;\r
315             return;\r
316         }\r
317 \r
318 \r
319         // this draws the whole of the alignment\r
320         imgWidth = getWidth();\r
321         imgHeight = getHeight();\r
322 \r
323         imgWidth -= (imgWidth % av.charWidth);\r
324         imgHeight -= (imgHeight % av.charHeight);\r
325 \r
326         if ((imgWidth < 1) || (imgHeight < 1))\r
327         {\r
328             return;\r
329         }\r
330 \r
331         if (img == null || imgWidth != img.getWidth() || imgHeight != img.getHeight())\r
332         {\r
333           try{\r
334             img = new BufferedImage(imgWidth, imgHeight,\r
335                                     BufferedImage.TYPE_INT_RGB);\r
336             gg = (Graphics2D) img.getGraphics();\r
337             gg.setFont(av.getFont());\r
338           }catch(OutOfMemoryError er)\r
339           {\r
340             System.gc();\r
341             System.out.println(er +" making image, SeqCanvas");\r
342             javax.swing.SwingUtilities.invokeLater(new Runnable()\r
343             {\r
344               public void run()\r
345               {\r
346                 javax.swing.JOptionPane.showInternalMessageDialog(Desktop.\r
347                     desktop,\r
348                     "Out of memory creating alignment image!!"\r
349                     +\r
350                     "\nSee help files for increasing Java Virtual Machine memory."\r
351                     , "Out of memory",\r
352                     javax.swing.JOptionPane.WARNING_MESSAGE);\r
353               }\r
354             });\r
355 \r
356             return;\r
357           }\r
358         }\r
359 \r
360         if (av.antiAlias)\r
361           gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,\r
362                               RenderingHints.VALUE_ANTIALIAS_ON);\r
363 \r
364         gg.setColor(Color.white);\r
365         gg.fillRect(0, 0, imgWidth, imgHeight);\r
366 \r
367 \r
368         if (av.getWrapAlignment())\r
369         {\r
370             drawWrappedPanel(gg, getWidth(), getHeight(), av.startRes);\r
371         }\r
372         else\r
373         {\r
374             drawPanel(gg, av.startRes, av.endRes, av.startSeq, av.endSeq, 0);\r
375         }\r
376 \r
377         g.drawImage(img, 0, 0, this);\r
378 \r
379         if (pdbCanvas != null)\r
380         {\r
381            pdbCanvas.updateSeqColours();\r
382         }\r
383 \r
384     }\r
385 \r
386     /**\r
387      * DOCUMENT ME!\r
388      *\r
389      * @param cwidth DOCUMENT ME!\r
390      *\r
391      * @return DOCUMENT ME!\r
392      */\r
393     public int getWrappedCanvasWidth(int cwidth)\r
394     {\r
395         FontMetrics fm = getFontMetrics(av.getFont());\r
396 \r
397         LABEL_EAST = 0;\r
398         LABEL_WEST = 0;\r
399 \r
400         if (av.scaleRightWrapped)\r
401         {\r
402             LABEL_EAST = fm.stringWidth(getMask());\r
403         }\r
404 \r
405         if (av.scaleLeftWrapped)\r
406         {\r
407             LABEL_WEST = fm.stringWidth(getMask());\r
408         }\r
409 \r
410         return (cwidth - LABEL_EAST - LABEL_WEST) / av.charWidth;\r
411     }\r
412 \r
413 \r
414     /**\r
415      * Generates a string of zeroes.\r
416      * @return String\r
417      */\r
418     String getMask()\r
419     {\r
420       String mask = "00";\r
421       for (int i = av.alignment.getWidth(); i > 0; i /= 10)\r
422       {\r
423         mask += "0";\r
424       }\r
425       return mask;\r
426     }\r
427 \r
428     /**\r
429      * DOCUMENT ME!\r
430      *\r
431      * @param g DOCUMENT ME!\r
432      * @param canvasWidth DOCUMENT ME!\r
433      * @param canvasHeight DOCUMENT ME!\r
434      * @param startRes DOCUMENT ME!\r
435      */\r
436     public void drawWrappedPanel(Graphics g, int canvasWidth, int canvasHeight,\r
437         int startRes)\r
438     {\r
439         AlignmentI al = av.getAlignment();\r
440 \r
441         FontMetrics fm = getFontMetrics(av.getFont());\r
442 \r
443 \r
444         if (av.scaleRightWrapped)\r
445         {\r
446             LABEL_EAST = fm.stringWidth(getMask());\r
447         }\r
448 \r
449 \r
450         if (av.scaleLeftWrapped)\r
451         {\r
452             LABEL_WEST = fm.stringWidth(getMask());\r
453         }\r
454 \r
455         int hgap = av.charHeight;\r
456         if(av.scaleAboveWrapped)\r
457           hgap += av.charHeight;\r
458 \r
459         int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / av.charWidth;\r
460         int cHeight = av.getAlignment().getHeight() * av.charHeight;\r
461 \r
462         av.setWrappedWidth(cWidth);\r
463 \r
464         av.endRes = av.startRes + cWidth;\r
465 \r
466 \r
467         int endx;\r
468         int ypos = hgap;\r
469         int maxwidth = av.alignment.getWidth();\r
470 \r
471         if(av.hasHiddenColumns)\r
472           maxwidth = av.getColumnSelection().findColumnPosition(maxwidth)-1;\r
473 \r
474         while ((ypos <= canvasHeight) && (startRes < maxwidth))\r
475         {\r
476           endx = startRes + cWidth -1;\r
477 \r
478           if (endx > maxwidth)\r
479           {\r
480             endx = maxwidth;\r
481           }\r
482 \r
483             g.setFont(av.getFont());\r
484             g.setColor(Color.black);\r
485 \r
486             if (av.scaleLeftWrapped)\r
487             {\r
488                 drawWestScale(g, startRes, endx, ypos);\r
489             }\r
490 \r
491             if (av.scaleRightWrapped)\r
492             {\r
493                 g.translate(canvasWidth - LABEL_EAST, 0);\r
494                 drawEastScale(g, startRes, endx, ypos);\r
495                 g.translate(-(canvasWidth - LABEL_EAST), 0);\r
496             }\r
497 \r
498             g.translate(LABEL_WEST, 0);\r
499 \r
500             if (av.scaleAboveWrapped)\r
501             {\r
502                 drawNorthScale(g, startRes, endx, ypos);\r
503             }\r
504 \r
505             if (av.hasHiddenColumns && av.showHiddenMarkers)\r
506             {\r
507               g.setColor(Color.blue);\r
508               int res;\r
509               for (int i = 0; i < av.getColumnSelection().getHiddenColumns().size();\r
510                    i++)\r
511               {\r
512                 res = av.getColumnSelection().findHiddenRegionPosition(i) -\r
513                     startRes;\r
514 \r
515                 if (res < 0 || res > endx - startRes)\r
516                   continue;\r
517 \r
518                 gg.fillPolygon(new int[]\r
519                                {res * av.charWidth - av.charHeight / 4,\r
520                                res * av.charWidth + av.charHeight / 4,\r
521                                res * av.charWidth},\r
522                                new int[]\r
523                                {\r
524                                ypos - (av.charHeight / 2),\r
525                                ypos - (av.charHeight / 2),\r
526                                ypos - (av.charHeight / 2) + 8\r
527                 }, 3);\r
528 \r
529               }\r
530             }\r
531 \r
532 \r
533 \r
534             // When printing we have an extra clipped region,\r
535             // the Printable page which we need to account for here\r
536             Shape clip = g.getClip();\r
537 \r
538             if (clip == null)\r
539             {\r
540                 g.setClip(0, 0, cWidth * av.charWidth, canvasHeight);\r
541             }\r
542             else\r
543             {\r
544                 g.setClip(0, (int) clip.getBounds().getY(),\r
545                     cWidth * av.charWidth, (int) clip.getBounds().getHeight());\r
546             }\r
547 \r
548             drawPanel(g, startRes, endx, 0, al.getHeight(), ypos);\r
549 \r
550             if(av.showAnnotation)\r
551             {\r
552               g.translate(0, cHeight + ypos + 3);\r
553               if(annotations==null)\r
554                 annotations = new AnnotationPanel(av);\r
555 \r
556               annotations.drawComponent( (Graphics2D) g, startRes, endx+1);\r
557               g.translate(0, -cHeight - ypos -3);\r
558             }\r
559             g.setClip(clip);\r
560             g.translate(-LABEL_WEST, 0);\r
561 \r
562             ypos += cHeight+getAnnotationHeight()+hgap;\r
563             if(av.showAnnotation)\r
564               ypos -= 3;\r
565 \r
566             startRes += cWidth;\r
567         }\r
568     }\r
569 \r
570     AnnotationPanel annotations;\r
571     int getAnnotationHeight()\r
572     {\r
573       if(!av.showAnnotation)\r
574         return 0;\r
575 \r
576       if(annotations==null)\r
577         annotations = new AnnotationPanel(av);\r
578 \r
579       return annotations.adjustPanelHeight();\r
580     }\r
581 \r
582     /**\r
583      * DOCUMENT ME!\r
584      *\r
585      * @param g1 DOCUMENT ME!\r
586      * @param startRes DOCUMENT ME!\r
587      * @param endRes DOCUMENT ME!\r
588      * @param startSeq DOCUMENT ME!\r
589      * @param endSeq DOCUMENT ME!\r
590      * @param offset DOCUMENT ME!\r
591      */\r
592     void drawPanel(Graphics g1, int startRes, int endRes,\r
593                     int startSeq, int endSeq, int offset)\r
594     {\r
595       if(!av.hasHiddenColumns)\r
596       {\r
597         draw(g1, startRes, endRes, startSeq, endSeq, offset);\r
598       }\r
599       else\r
600       {\r
601         java.util.Vector regions = av.getColumnSelection().getHiddenColumns();\r
602 \r
603         int screenY = 0;\r
604         int blockStart = startRes;\r
605         int blockEnd = endRes;\r
606 \r
607         for (int i = 0; i < regions.size(); i++)\r
608         {\r
609           int[] region = (int[]) regions.elementAt(i);\r
610           int hideStart = region[0];\r
611           int hideEnd = region[1];\r
612 \r
613           if (hideStart <= blockStart)\r
614           {\r
615             blockStart += (hideEnd - hideStart) + 1;\r
616             continue;\r
617           }\r
618 \r
619           blockEnd = hideStart - 1;\r
620 \r
621           g1.translate(screenY * av.charWidth, 0);\r
622 \r
623           draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);\r
624 \r
625           if(av.getShowHiddenMarkers())\r
626           {\r
627             g1.setColor(Color.blue);\r
628 \r
629             g1.drawLine( (blockEnd - blockStart + 1) * av.charWidth - 1,\r
630                         0 + offset,\r
631                         (blockEnd - blockStart + 1) * av.charWidth - 1,\r
632                         (endSeq - startSeq) * av.charHeight + offset);\r
633           }\r
634 \r
635           g1.translate( -screenY * av.charWidth, 0);\r
636           screenY += blockEnd - blockStart + 1;\r
637           blockStart = hideEnd + 1;\r
638         }\r
639 \r
640         if (screenY <= (endRes - startRes))\r
641         {\r
642           blockEnd = blockStart + (endRes - startRes) - screenY;\r
643           g1.translate(screenY * av.charWidth, 0);\r
644           draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);\r
645 \r
646           g1.translate( -screenY * av.charWidth, 0);\r
647         }\r
648       }\r
649 \r
650     }\r
651 \r
652 \r
653 \r
654 \r
655     //int startRes, int endRes, int startSeq, int endSeq, int x, int y,\r
656     // int x1, int x2, int y1, int y2, int startx, int starty,\r
657     void draw(Graphics g,\r
658                    int startRes, int endRes,\r
659                    int startSeq, int endSeq,\r
660                    int offset)\r
661    {\r
662       g.setFont(av.getFont());\r
663       sr.prepare(g, av.renderGaps);\r
664 \r
665       SequenceI nextSeq;\r
666 \r
667         /// First draw the sequences\r
668         /////////////////////////////\r
669         for (int i = startSeq; i < endSeq; i++)\r
670         {\r
671             nextSeq = av.alignment.getSequenceAt(i);\r
672 \r
673             sr.drawSequence(nextSeq, av.alignment.findAllGroups(nextSeq),\r
674                             startRes, endRes,\r
675                             offset + ( (i - startSeq) * av.charHeight));\r
676 \r
677             if (av.showSequenceFeatures)\r
678             {\r
679                 fr.drawSequence(g, nextSeq, startRes, endRes,\r
680                     offset + ((i - startSeq) * av.charHeight));\r
681             }\r
682 \r
683             /// Highlight search Results once all sequences have been drawn\r
684             //////////////////////////////////////////////////////////\r
685             if (searchResults != null)\r
686             {\r
687               int[] visibleResults = searchResults.getResults(nextSeq, startRes, endRes);\r
688               if (visibleResults != null)\r
689                 for (int r = 0; r < visibleResults.length; r += 2)\r
690                 {\r
691                   sr.drawHighlightedText(nextSeq, visibleResults[r],\r
692                                          visibleResults[r + 1],\r
693                                          (visibleResults[r] - startRes) * av.charWidth,\r
694                                          offset + ( (i - startSeq) * av.charHeight));\r
695                 }\r
696             }\r
697 \r
698             if(av.cursorMode && cursorY==i\r
699                && cursorX>=startRes && cursorX<=endRes)\r
700             {\r
701               sr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * av.charWidth,\r
702                             offset + ( (i - startSeq) * av.charHeight));\r
703             }\r
704           }\r
705 \r
706           if(av.getSelectionGroup()!=null || av.alignment.getGroups().size()>0)\r
707             drawGroupsBoundaries(g, startRes, endRes, startSeq, endSeq, offset);\r
708 \r
709    }\r
710 \r
711    void drawGroupsBoundaries(Graphics g1,\r
712                    int startRes, int endRes,\r
713                    int startSeq, int endSeq,\r
714                    int offset)\r
715    {\r
716        Graphics2D g = (Graphics2D)g1;\r
717         //\r
718         /////////////////////////////////////\r
719         // Now outline any areas if necessary\r
720         /////////////////////////////////////\r
721         SequenceGroup group = av.getSelectionGroup();\r
722 \r
723         int sx = -1;\r
724         int sy = -1;\r
725         int ex = -1;\r
726         int groupIndex = -1;\r
727         int visWidth = (endRes - startRes +1) * av.charWidth;\r
728 \r
729         if ((group == null) && (av.alignment.getGroups().size() > 0))\r
730         {\r
731             group = (SequenceGroup) av.alignment.getGroups().elementAt(0);\r
732             groupIndex = 0;\r
733         }\r
734 \r
735 \r
736         if (group != null)\r
737         {\r
738             do\r
739             {\r
740                 int oldY = -1;\r
741                 int i = 0;\r
742                 boolean inGroup = false;\r
743                 int top = -1;\r
744                 int bottom = -1;\r
745 \r
746                 for (i = startSeq; i < endSeq; i++)\r
747                 {\r
748                     sx = (group.getStartRes() - startRes) * av.charWidth;\r
749                     sy = offset + ((i - startSeq) * av.charHeight);\r
750                     ex = (((group.getEndRes() + 1) - group.getStartRes()) * av.charWidth) -\r
751                         1;\r
752 \r
753                     if(sx+ex<0 || sx>visWidth)\r
754                     {\r
755                       continue;\r
756                     }\r
757 \r
758                     if ( (sx <= (endRes-startRes)*av.charWidth) &&\r
759                             group.getSequences(false).\r
760                             contains(av.alignment.getSequenceAt(i)))\r
761                     {\r
762                         if ((bottom == -1) &&\r
763                                 !group.getSequences(false).contains(\r
764                                     av.alignment.getSequenceAt(i + 1)))\r
765                         {\r
766                             bottom = sy + av.charHeight;\r
767                         }\r
768 \r
769                         if (!inGroup)\r
770                         {\r
771                             if (((top == -1) && (i == 0)) ||\r
772                                     !group.getSequences(false).contains(\r
773                                         av.alignment.getSequenceAt(i - 1)))\r
774                             {\r
775                                 top = sy;\r
776                             }\r
777 \r
778                             oldY = sy;\r
779                             inGroup = true;\r
780 \r
781                             if (group == av.getSelectionGroup())\r
782                             {\r
783                                 g.setStroke(new BasicStroke(1,\r
784                                         BasicStroke.CAP_BUTT,\r
785                                         BasicStroke.JOIN_ROUND, 3f,\r
786                                         new float[] { 5f, 3f }, 0f));\r
787                                 g.setColor(Color.RED);\r
788                             }\r
789                             else\r
790                             {\r
791                                 g.setStroke(new BasicStroke());\r
792                                 g.setColor(group.getOutlineColour());\r
793                             }\r
794                         }\r
795                     }\r
796                     else\r
797                     {\r
798                       if (inGroup)\r
799                       {\r
800                         if (sx >= 0 && sx < visWidth)\r
801                           g.drawLine(sx, oldY, sx, sy);\r
802 \r
803                         if (sx + ex < visWidth)\r
804                           g.drawLine(sx + ex, oldY, sx + ex, sy);\r
805 \r
806                         if (sx < 0)\r
807                         {\r
808                           ex += sx;\r
809                           sx = 0;\r
810                         }\r
811 \r
812                         if (sx + ex > visWidth)\r
813                           ex = visWidth;\r
814 \r
815                         else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)\r
816                           ex = (endRes - startRes + 1) * av.charWidth;\r
817 \r
818                         if (top != -1)\r
819                         {\r
820                           g.drawLine(sx, top, sx + ex, top);\r
821                           top = -1;\r
822                         }\r
823 \r
824                         if (bottom != -1)\r
825                         {\r
826                           g.drawLine(sx, bottom, sx + ex, bottom);\r
827                           bottom = -1;\r
828                         }\r
829 \r
830                         inGroup = false;\r
831                         }\r
832                     }\r
833                 }\r
834 \r
835                 if (inGroup)\r
836                 {\r
837                   sy = offset + ( (i - startSeq) * av.charHeight);\r
838                   if (sx >= 0 && sx < visWidth)\r
839                     g.drawLine(sx, oldY, sx, sy);\r
840 \r
841                   if (sx + ex < visWidth)\r
842                     g.drawLine(sx + ex, oldY, sx + ex, sy);\r
843 \r
844                   if (sx < 0)\r
845                   {\r
846                     ex += sx;\r
847                     sx = 0;\r
848                   }\r
849 \r
850                   if (sx + ex > visWidth)\r
851                     ex = visWidth;\r
852                   else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)\r
853                     ex = (endRes - startRes + 1) * av.charWidth;\r
854 \r
855                   if (top != -1)\r
856                   {\r
857                     g.drawLine(sx, top, sx + ex, top);\r
858                     top = -1;\r
859                   }\r
860 \r
861                   if (bottom != -1)\r
862                   {\r
863                     g.drawLine(sx, bottom - 1, sx + ex, bottom - 1);\r
864                     bottom = -1;\r
865                   }\r
866 \r
867                     inGroup = false;\r
868                 }\r
869 \r
870                 groupIndex++;\r
871 \r
872                 g.setStroke(new BasicStroke());\r
873 \r
874                 if (groupIndex >= av.alignment.getGroups().size())\r
875                 {\r
876                     break;\r
877                 }\r
878 \r
879                 group = (SequenceGroup) av.alignment.getGroups().elementAt(groupIndex);\r
880 \r
881 \r
882             }\r
883             while (groupIndex < av.alignment.getGroups().size());\r
884 \r
885         }\r
886 \r
887     }\r
888 \r
889     /**\r
890      * DOCUMENT ME!\r
891      *\r
892      * @param results DOCUMENT ME!\r
893      */\r
894     public void highlightSearchResults(SearchResults results)\r
895     {\r
896         img = null;\r
897 \r
898         searchResults = results;\r
899 \r
900         repaint();\r
901     }\r
902 }\r